Discussion :

[anapurna]

bonjour,
cela me rappel un peu les probabilité et surtout partit denombrement
ne serait ce pas tout simplement un Nombre d'arrangements avec répétitions de 270 éléments neuf à neuf.
ce qui nous donne 270^9 solution potentiels
[Edit] après réflexion il y en a beaucoup moins car j'ai hommi la codécision que le somme ne doit pas dépasser les 270
[Edit2]on sais aussi qu'au delà de 135 nous ne pouvons plus faire d’addition avec les nombres supérieur

sachant que l'addition est transitive on peut déjà réduire le nombre de vérification
pour réduire encore les vérification il faut exclure les répétition de même motif
intuitivement l'utilisation de graphe me parait être une solution

[wiwaxia]

Bonsoir,

Le dénombrement n'est envisageable qu'à la condition impérative de restreindre l'énumération aux listes ordonnées (voir le message du 24/05). Je suis parvenu à programmer le calcul, par un algorithme analogue dans sa partie centrale à celui proposé par Prof et tbc92, mais en usant de restrictions encore plus drastiques.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
 
   FOR ListeA[1]:= 0 TO Lim DO                                             // 1
     IF Test(1, So, Lim) THEN
       FOR ListeA[2]:= ListeA[1] TO Lim DO                                 // 2
         IF Test(2, So, Lim) THEN
           FOR ListeA[3]:= ListeA[2] TO Lim DO                             // 3
             IF Test(3, So, Lim) THEN
               FOR ListeA[4]:= ListeA[3] TO Lim DO                         // 4
                 IF Test(4, So, Lim) THEN
                   FOR ListeA[5]:= ListeA[4] TO Lim DO                     // 5
                     IF Test(5, So, Lim) THEN
                       FOR ListeA[6]:= ListeA[5] TO Lim DO                 // 6
                         IF Test(6, So, Lim) THEN
                           FOR ListeA[7]:= ListeA[6] TO Lim DO             // 7
                             IF Test(7, So, Lim) THEN
                               FOR ListeA[8]:= ListeA[7] TO Lim DO         // 8
                                 IF Test(8, So, Lim) THEN
                                   FOR ListeA[9]:= ListeA[8] TO Lim DO     // 9
                                     BEGIN
                                       Xi:= Mult(ListeF, ListeA);
                                       Nu:= Mu + Xi; Mu:= Nu;
                                       Nu:= Om + 1;  Om:= Nu
                                     END;

Les résultats sont confirmés par des sources externes, mais le calcul devient très lent au-delà de 100. Et bien que l'algorithme fonctionne correctement, je n'en suis pas satisfait en raison de la compression forcenée des instructions, à laquelle j'ai été contraint pour représenter les neuf boucles imbriquées sur une seule page.

[anapurna]

salut

avec un fonction récursive ça devrais donne un truc proche de ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
Function Recurcif(ListeA : ArrOfInt;Ind,Lim,nb,so : Integer;var om,mu : integer)
var
 nu,xi : integer;
begin
  if ind = 1 Then
  begin
    FOR ListeA[ind]:= 0 TO Lim DO                                             // 1
      IF Test(ind, So, Lim) THEN
        Recurcif(ListeA,Ind+1,Lim,so,om,mu)
  end
  else
  if ind = Nb Then
  begin
    FOR ListeA[ind]:= ListeA[ind-1] TO Lim DO                            // NB
    begin 
      // resultat 
      Xi:= Mult(ListeF, ListeA);
      Nu:= Mu + Xi; 
      Mu:= Nu;
      Nu:= Om + 1; 
      Om:= Nu
    end;
  end
  else
    FOR ListeA[ind]:= ListeA[ind-1] TO Lim DO                                 // 2 a NB-1
     IF Test(ind, So, Lim) THEN
       Recurcif(ListeA,Ind+1,Lim,so,om,mu)
end;

[wiwaxia]

C'est effectivement plus élégant; je reprendrai cela à l'occasion.

J'aurais dû préciser que la fonction Test(k, s, L_) modifie aussi la dernière variable (Lim), ce qui restreint justement l'énumération.
Mais cette astuce de programmation me déplaît.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
 FUNCTION Test(k: Byte; s: Word; VAR L_: Word): Boolean;
   VAR i: Byte; Lim, m: Word;
   BEGIN
     m:= s;    FOR i:= 1 TO k DO Dec(m, ListeA[i]); Lim:= m DIV (9 - k);
     L_:= Lim; Test:= (ListeA[k]<=Lim)
   END;

Si cela t'intéresse, voici le texte entier rédigé hâtivement.

[senacle]

J'avais laissé tomber ce sujet pour d'autres activités.

Je vois que des passionnés ont planché dessus

J'essaierai de m'y pencher à nouveau dans quelque temps.