Discussion :

[Fxg]

Ce ne serait pas plus rapide car les accès au Disque Dur sont ce qu'il y a de plus lent.
Il vaut mieux faire tous les calculs en mémoire et ensuite sauvagarder sur le disque.

[Liberator]

Merci, Fxg !

[Roland Chastain]

Il vaut mieux faire tous les calculs en mémoire et ensuite sauvegarder sur le disque.

Fait !

[Liberator]

Roland Chastain, c’est super je suis comblé, merci.

En effet, même si c’est plus long de les enregistrer sur le disque une fois que c’est fait on peut revoir ou retraiter les fichiers sans avoir à les recréer… ce qui, en fait, permet de gagner du temps sur le temps perdu…

[ShaiLeTroll]

Tout dépend SWAP ou pas !
Si l'on stocke un trop grand nombre de permutation provoquant le dépassement de la mémoire physique, cela provoque l'utilisation fichier d'échange et les performances s'écroulent, sujet débattu dans
algorithme combinaisons et test possibilites

[Liberator]

Je vais lire ça. En ce qui me concerne, j'ai constaté que dans le programme proposé plus haut :

Un composant richedit affiche les résultats plus rapidement que la listbox.

Il serait intéressant de savoir pourquoi ( pour moi ).

Essais réussi jusqu'a 11 caractères permutés, ensuite mémoire out !

[Rayek]

Alors bon, le code que j'ai fait et je pense largement optimisable et puis j'ai fait çà en 5mn .

J'ai utilisé des TStringList qui ne sont pas des plus rapide. En passant par des tableaux je pense qu'on gagnerai pas mal en temps de traitement.

Pour le problème de mémoire, c'est peut être du au système récursif de la fonction plus les TStringList créées dynamiquement.

[edam]

pour moi j'avais fais du basic sur SAKHR ;1ére génération des pc en arabe(1984), sans disk dur, sans aucun périférique, si l’aimantation se coupe, je suis foutu

[zano972]

Soir,

Perso je dirais que ça ne peut pas être plus rapide si tu envoyais les résultats sur un DD puisque qu'un accès en RAM restera toujours beaucoup plus rapide qu'un accès DD...

Puisque les résultats sont stockés dans un TStringList, il te suffit à la fin de la procédure (et avant de libérer la variable: LstTmp d'appeler un LstTmp.SavetoFile(nom_de_fichier).

Bonne continuation et A+++

EDIT: désolé je viens de m'apercevoir que cette réponse t'avait déjà été donnée...

[BuzzLeclaire]

Ouah,

Moi ça me rappel mon premier PC, le language est carrément le même

j'avais un APPLE IIe et c'etait du BASIC Applesoft (fait par Microsoft mdr...) identique à cela. Mortel...

C'était exactement l'image qu'ils mettent pour le Apple II+ de 79
http://fr.wikipedia.org/wiki/Apple_II

La je viens de prend 30 ans dans la tête.



quand tu lis çà tu crois réver :
L'Apple II a été remplacé par l'Apple II plus, qui incluait le langage de programmation BASIC Applesoft, signé Microsoft. Il possédait 48 Ko de mémoire, extensible à 64 Ko via une carte langage, et ajoutait l'utilisation d'une arithmétique à virgule flottante dans la ROM

[Liberator]

Je peux toujours utiliser ce code basic, avec mon Note Book 200 sous xp, et il fonctionne très bien, il me sort les 3628800 permutations de 9 N° en un clin d’œil. Exemple ci-dessous :



Le problème, c’est que la fenêtre d’édition ‘exécution’ est minuscule et il n’est pas possible de remonter la liste pour consultation.

J’aurais aimé avoir l’équivalent de ce programme en pascal…je possède une version de turbo pascal 4.0 qui galope aussi vite que le cheval de Zorro et n’affiche pas : ’’mémoire out’’, même avec des permutations importantes...

L’avantage de ces vieilleries, c’est qu’une dizaine de ligne de code faisait des miracles…

[Paul TOTH]

ça se fait aussi très bien en Pascal, mais l'écriture sur la console Windows est assez lente...

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
program permutations;
 
{$APPTYPE CONSOLE}
 
{
50 print chr$(10)
60 if len(f$)=1 then 80
70 d$=d$+left$(f$,1):p=p+1:p$(p)=f$:f$=right$(f$,len(f$)-1):goto 60
80 x=x+1:print d$+f$,x:i=2
90 f$=p$(p):p=p-1:if len(d$)=1 then 110
100 d$=left$(d$,len(d$)-1):goto 120
110 d$=""
120 a(i)=a(i)+1:if a(i)<i then 150
130 a(i)=0:i=i+1:if i>n then print :end
140 goto 90
150 f$=right$(f$,len(f$)-1)+left$(f$,1):goto 60
155 print
160 end
}
 
var
  fs: string;
  ds: string;
  n : Integer;
  a : array of Integer;
  ps: array of string;
  x : Integer;
  p : Integer;
  i : Integer;
begin
  p := 0;
  x := 0;
{
10 cls
20 print
30 input" tapez votre mot ";f$:d$="":n=len(f$):dim a(n):dim p$(n)
}
  Write(' tapez votre mot ');
  ReadLn(fs);
  n := Length(fs) + 1; // 0 basé
  SetLength(a , n);
  SetLength(ps, n);
  repeat
  {
  60 if len(f$)=1 then 80
  70 d$=d$+left$(f$,1):p=p+1:p$(p)=f$:f$=right$(f$,len(f$)-1):goto 60
  }
    while length(fs) <> 1 do
    begin
      ds := ds + fs[1];
      p := p + 1;
      ps[p] := fs;
      Delete(fs, 1, 1);
    end;
  {
  80 x=x+1:print d$+f$,x:i=2
  90 f$=p$(p):p=p-1:if len(d$)=1 then 110
  100 d$=left$(d$,len(d$)-1):goto 120
  110 d$=""
  }
    x := x + 1;
    WriteLn(ds, fs, #9, x);
    i := 2;
    repeat // 90
      fs := ps[p];
      p := p - 1;
      if Length(ds) <> 1 then
        SetLength(ds, Length(ds) - 1)
      else
        ds := '';
  {
  120 a(i)=a(i)+1:if a(i)<i then 150
  }
      a[i] := a[i] + 1;
      if a[i] < i then
        Break;  // goto 150
  {
  130 a(i)=0:i=i+1:if i>n then print :end
  140 goto 90
  }
      a[i] := 0;
      i := i + 1;
      if i > n then
      begin
         WriteLn('Fin');
         ReadLn;
         Exit;
      end;
 
    until False;  // goto 90
  {
  150 f$=right$(f$,len(f$)-1)+left$(f$,1):goto 60
  }
    fs := Copy(fs, 2, MaxInt) + fs[1];
  until False; // goto 60
end.

[Roland Chastain]

ça se fait aussi très bien en Pascal, mais l'écriture sur la console Windows est assez lente...

Chapeau pour le "portage".

Voici mon essai.

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
program Permutations;
 
{ Génère toutes les combinaisons possibles d'un ensemble de caractères,
  à partir d'une chaîne saisie par l'utilisateur. Le résultat est enre-
  gistré dans un fichier texte. }
 
{$IfDef VPascal}
{&PmType Vio}
{$Else}
{$IfNDef Ver70}{$AppType Console}{$EndIf}
{$EndIf}
 
var
  s: string;
  f: text;
 
procedure Permute(var ps: string; const n: integer);
var
  temp: string;
  i, l: integer;
begin
  temp := ps;
  l := Length(temp);
  temp[l - n + 1] := ps[l];
  for i := l - n + 2 to l do temp[i] := ps[i - 1];
  ps := temp;
end;
 
procedure Generateur(var ps: string; const n: integer);
var
  i: integer;
begin
  for i := 1 to n do
  begin
    Permute(ps, n);
    if n = 1 then WriteLn(f, ps)
    else
      Generateur(ps, n - 1);
  end;
end;
 
begin
  Write('?');
  ReadLn(s);
 
  Assign(f, s + '.txt');
  Rewrite(f);
 
  Generateur(s, Length(s));
 
  Close(f);
end.

@Liberator

Compilation testée avec Turbo Pascal 7.0. Si vous utilisez une autre version, il faut modifier en conséquence la mention Ver70 dans les directives de compilation.

[Liberator]

@ Roland Chastain,

J'ai utilisé Delphi 7 : Il écrit les 39 916 800 permutations de 11 caractères en une minute... sur mon petit Note Book 200.

C'est excellent pour moi, je vais tenter 12 caractères soit 479 001 600 permutations…mais sur une machine plus puissante, juste pour voir…

Bravo pour le code, et encore merci !

[Caribensila]

Je ne suis pas programmateur et ne souhaite pas le devenir...

Ca se sent un peu.



Il y a quand même un gros problème conceptuel dans tout ça, et il faudrait sans doute repenser le problème avec un raisonnement plus synthétique :
- qu'est-ce qui peut bien justifier le fait d'écrire, ou de stocker TOUTE la liste en mémoire ?


Il y aura sans aucun doute un traitement (qu'on ignore) qui sera effectué sur cette liste afin de parvenir à un résultat (car je doute fort que cette liste ait de l'intérêt en elle-même).
Il serait donc bien plus pertinent d'effectuer ce traitement au niveau des permutations et de séparer le bon grain de l'ivraie tout de suite, sans devoir stocker puis relire toute la liste.


Si c'est pour faire un moteur d'anagrammes, par exemple, il faudrait comparer chaque résultat au dictionnaire dans la boucle des permutations, ne conserver QUE les mots ayant un sens, et de laisser les autres dans les ténèbres de l'insignifiance.

Au final, gain de temps et d'espace assurés !
Sans compter la satisfaction intellectuelle d'avoir évité de travailler sur du non-sens.

[Liberator]

Certes, il y a du bon sens et de l’ivraie dans ces propos et je comprends parfaitement ce raisonnement qui semble justifié.

Mais il est des cas, où la curiosité sert de moteur et le non-sens de direction.

L’esprit se contentant, parfois, d’un rien pour être satisfait.

Qu’omni soit qui mal y pense.