Pour [latex]4[/latex] chiffres on trouve [latex]a=99[/latex] avec [latex]670[/latex] nombres ayant pour somme [latex]18[/latex] dans l'intervalle [latex][99;\,9999][/latex]

Plus généralement pour [latex]k[/latex] chiffres :

[latex]a=\underbrace{9\ldots 9}_{\frac{k}{2}\,\mathrm{fois}}[/latex] si [latex]k[/latex] est pair.
[latex]a=4\underbrace{9\ldots 9}_{\frac{k-1}{2}\,\mathrm{fois}}[/latex] si [latex]k[/latex] est impair.

Je parle pour " a " d'un entier > 0 à 4 chiffres significatifs, donc ne commençant pas par 0.

@ Scarta: ta 1ère réponse est sur la bonne voie, reste à finaliser.

@ Toufau : parfait

As-tu une justification pour la généralité ?

@ Sydre : très bien !

Même remarque que pour Toufau.


Au fait, personne n'a envisagé la non-unicité du max.....

Ah aussi, si un tableur n'est "qu'une aide au calcul" comme la dernière fois, n lignes suffisent pour sortir le résultat pour n chifres

Ben du dynamique progamming, version Excel

Ligne 1 : 1, suivi de 9*N zéros
Ligne 2
  A2: Sum($A1, A1), on copie A2 jusqu'en J2
  K2: Sum(B1:K1), on copie K2 jusqu'à la 9N+1ème cellule
Lignes suivantes : copie de la ligne 2
Ligne N+1 :
  1ere colonne : 0
  2eme colonne : sum($An,An), copiée jusqu'en Jn
  Kn: Sum(Bn:Jn), on copie Kn jusqu'à la 9N+1ème cellule

Et voilà !


L'équivalent en Excel donc du code suivant

int n = 4, i, j, k;
int[] res = new int[n * 9 + 1];
res[0] = 1;
for (i = 1; i < n; i++)
   for (j = n * 9; j >= 0; j--)
      for (k = 1; k <= 9 && k <= j; k++) res[j] += res[j - k];
for (j = n * 9; j >= 0; j--)
   for (k = 1, res[j] = 0; k <= 9 && k <= j; k++) res[j] += res[j - k];

L'algo en 2 mots : je dispose de N chiffres

- avec 0 chiffre, je peux faire une somme de 0 d'une seule manière, et toutes les autres sommes jusqu'à 9N de zéro manière (je peux pas quoi)

- avec un chiffre de plus, je peux faire une somme S d'autant de manières que je pouvais faire S-9, S-8, S-7, etc... avec un chiffre de moins (puisque j'ajoute ce nouveau chiffre au nombre)

et bien entendu, on répète le processus pour chaque chiffre qu'on ajoute

- la seule particularité, pour le dernier chiffre qu'on ajoute : il ne peut pas être 0.


Et en écrivant ces lignes, je me rends compte qu'on peut faire encore plus simple : plutôt que de forcer le dernier chiffre, on peut forcer le premier
Du coup, l'initialisation du tableau, au lieu d'être t[i] = 1 pour i = 0 et 0 sinon, on met t[i] = 1 pour 1 <= i <= 9 et 0 sinon, et on traite les n-1 chiffres suivants sans cas particulier pour le dernier

long i, j, k;
long n = 4;
long[] res = new long[n * 9 + 1];
for (i = 1; i <= 9; i++) res[i] = 1;
for (i = 1; i < n; i++)
    for (j = n * 9; j >= 0; j--)
        for (k = 1; k <= 9 && k <= j; k++)
            res[j] += res[j - k];