Recopie d'un nombre de lignes espacées

Salut gthe,

une version avec le tri que tu souhaites : les combinaisons dupliquées en fin de tableau.
Pour faire simple, les lignes "pauvres" ou "riches" sont directement réparties dans 2 tableaux distincts ,tMIN et tMAX, avant d'être affichés l'un en-dessous de l'autre.

Est-ce bien cela que tu voulais ?

    If iRep > 0 Then
        Cells.NumberFormat = 0
        tTab = UsedRange.Value
        iMax = WorksheetFunction.Max(UsedRange)
        With Worksheets("COPY")
            .Cells.Delete
            .[A1].Resize(UBound(tTab, 1), UBound(tTab, 2)).Value = tTab
        End With
        For x = 1 To UBound(tTab, 1)
            For y = UBound(tTab, 2) To 1 Step -1
                If tTab(x, y) <> "" Then
                    Cells(x, y).Interior.Color = RGB(215, 215, 215)
                    iOK = IIf(CInt(tTab(x, y)) = iMax, iRep + 1, 1)
                    If iOK = 1 Then ReDim Preserve tMIN(UBound(tTab, 2), lngIdx1 + 1)
                    If iOK > 1 Then ReDim Preserve tMAX(UBound(tTab, 2), lngIdx2 + iOK)
                    For k = IIf(iOK = 1, lngIdx1, lngIdx2) To IIf(iOK = 1, lngIdx1, lngIdx2 + iOK - 1)
                        For w = 1 To y
                            If iOK = 1 Then tMIN(w - 1, k) = tTab(x, w)
                            If iOK > 1 Then tMAX(w - 1, k) = tTab(x, w)
                        Next
                    Next
                    If iOK = 1 Then lngIdx1 = lngIdx1 + 1
                    If iOK > 1 Then lngIdx2 = lngIdx2 + iOK
                    Exit For
                End If
            Next
        Next
        Cells.Delete
        [A1].Resize(lngIdx1, UBound(tTab, 2)) = WorksheetFunction.Transpose(tMIN)
        Range("A" & UsedRange.Rows.Count + 1).Resize(lngIdx2, UBound(tTab, 2)) = WorksheetFunction.Transpose(tMAX)
    End If

A+

Salut Curulis57,

Si j'ai bien compris, ce que tu appelles lignes pauvres et lignes riches, c'est en fonction de celles qui possèdent le nombre final le plus élevé du tableau ? (riche : oui, pauvre : non)

Je viens d'essayer de tester l'algorithme entier que je t'ai expliqué dans le post précédent, mais ça ne marche pas (en fait la première itération fonctionne bien, mais pas les autres).

Je te joins un exemple d'erreur :

Pour ce faire, je t'explique comment j'ai procédé :

je suis parti de la combinaison de départ suivante :

1 1 1

1 1 2

1 2 1

1 2 2

2 1 1

2 1 2

2 2 1

2 2 2

1 1 3

1 2 3

1 3 X

2 1 3

2 2 3

2 3 X

3 X X

et quand j'ai lancé l'itération en rentrant "3", ça m'a effectivement développé 3x supplémentaire les lignes se terminant par 3 (et ça c'est parfait - d'ailleurs j'ai aussi remarqué que les lignes se terminant par le plus grand nombre sont automatiquement remises à la fin du tableau et ça c'est excellent :D)

J'obtiens donc

Mais effectivement, quand j'accole par exemple la combinaison

1 1 1

1 1 2

1 2 X

2 X X

au tableau ci-dessus, j'obtiens ça :

Et là, par exemple, quand je souhaite réaliser une itération par exemple de 3 ici, ça me met "erreur d'exécution 5 argument ou appel de procédure incorrect"

Mais j'ai réfléchi !

Je pense qu'en fait il y a moyen de s'en sortir pour que le programme sache exactement ce qu'il doit développer !

Et dans ce cas la, pas besoin de programmer les 20 variables comme je disais (parce que même en réitérant le processus 20 fois, je serai quand même très rapide, et ça te fera l'économie d'un programme compliqué !)

Pourquoi ne pas, avant chaque phase de duplication et de tri, renseigner les 3 variables suivantes : p et q et r (donc là c'est l'utilisateur qui doit les renseigner) ?

Les lignes seraient donc dupliquées p fois, mais seulement celles qui ont simultanément des cases remplies au moins à partir de la q-ème colonne et dont le chiffre final renseigné est r !

Ce qui donnerait avec l'exemple ci-dessus :

Du coup, vu que le programme sait que nous avons imputé q=4 (puisque c'est à partir de la 4ème colonne que nous avons "rajouté des combinaisons", comme dans mon exemple) et r=2 (parce que nous savons que les lignes contenant des données au moins jusqu'à la 4ème colonne doivent se terminer par le max possible entre la q-ème colonne et la dernière colonne soit "2"), il multipliera les lignes suivantes par p :

(je termine le message après par peur de le perdre)

(suite du message précédent, je n'ai pas pu éditer l'ancien).

Ce sont donc ces lignes là qui seront dupliquées :

(car elles finissent tous par 2, le chiffre le plus grand parmi les colonnes rajoutées c.a.d les colonnes n°4,5 et 6). Et c'est pour ça que q=4 (correspond à la 1ère colonne rajoutée).

Voilà voilà, si tu as des questions n'hésite pas !

;)

Salut gthe,

1 étape à la fois !
Lignes pauvres, lignes riches, oui, c'est bien ça : poétique, non ?

- j'avais bien compris le principe de rajouter des données aux seules lignes riches du traitement précédent.
- j'ai maintenant compris que le prochain iMax sera calculé dans ces colonnes ajoutées ;
- par contre, c'est le calcul de cet ajout via, j'imagine, la macro de H2SO4, que je ne comprends pas encore.

J'ai vu passer dans un fichier un tableau avec tes fameux P, R, truc : c'est cela qu'il faut suivre de traitement en traitement ?
Je suppose que P est fixe jusqu'au terme du calcul : ça me semblerait logique !

Donc, il me faut :
- un de ces tableaux avec explications ;
- comment tu "choisis" la portion de ce développement à ajouter.

Trouve les mots pour expliquer le processus au Béotien mathématique que je suis et je parie que je te fais un truc full automatique.

A+

Salut Curulis57 :)

Désolé, pas mal de dossiers à traiter au travail, je ne suis revenu que maintenant :D

1 étape à la fois !
Lignes pauvres, lignes riches, oui, c'est bien ça : poétique, non ? Pas mal, ça donne un certain style je trouve, je vais adopter cette formulation ;)

- j'avais bien compris le principe de rajouter des données aux seules lignes riches du traitement précédent. ==> exactement. Chaque itération (ou rajout "d'ordre") rajoute aux seules lignes riches, les lignes générées par le programme de h2so4. Si par exemple le programme de h2so4 génère 40 combinaisons (cas pour n=3 et p=3 si je ne dis pas de bêtises) alors chaque ligne riche sera dupliquée 39 fois (pour qu'il y en ait 40 au total). Et donc p vaudra 39.

De cette façon, à chacune de ces lignes riches on aura pu accoler les 40 combinaisons générées par le programme de h2so4.

- j'ai maintenant compris que le prochain iMax sera calculé dans ces colonnes ajoutées ==> si j'ai bien compris l'Imax, oui exactement !
- par contre, c'est le calcul de cet ajout via, j'imagine, la macro de H2SO4, que je ne comprends pas encore => le calcul de cet ajout = l'ajout en lui même ? En fait, ce sont les kⁿ combinaisons auxquelles on a retiré tous les chiffres à droite des valeurs k de toutes les kⁿ combinaisons générées. Par exemple, si k=4 et n=5, la combinaison 34213 sera remplacée par 34XXX et donc la combinaison 34214 aussi par 34XXX (ça c'est l'application R1 de la PJ). Or 34XXX = 34XXX, il n'y aura donc qu'une combinaison 34XXX. (c'est l'application de la R2 de la PJ)

J'ai vu passer dans un fichier un tableau avec tes fameux P, R, truc : c'est cela qu'il faut suivre de traitement en traitement ?

Yes, c'est une proposition de s'en sortir autrement ! Le problème c'est que si on ne fait un tri que par l'unique "dernière" valeur de chaque ligne, le programme n'a pas la "mémoire" des lignes qui viennent d'être copiées. Et c'est vraiment difficile. Donc on peut le "prendre par la main" en lui disant : "si tu trouves des lignes qui continuent d'être remplies à partir de la q-ème colonne, alors tu me recopies p fois que celles qui finissent par le chiffre final maximal entre la q-ème colonne [inclus] et la dernière colonne [inclus] (et on peut noter ce chiffre final "r" (et ce "r" correspond au "k" de la dernière série de combinaisons générée par le programme de h2so4 puisque c'est celles que l'on copie ;) ).

Je suppose que P est fixe jusqu'au terme du calcul : ça me semblerait logique ! ==> Non justement. P ne peut pas être fixe. Du moins il l'est que si on génère toujours le même nombre de combinaisons avec le programme de h2so4 (par exemple, si pour chaque itération on a toujours k=2 et n=2 pour toutes les itérations, si on a toujours k=5 et n=8 pour toutes les itérations, etc...). Mais si par exemple je veux k(1)=7 et n(1)=1 puis k(2)=5 et n(2) = 9 puis k(3)=8 et n(3)=7, etc,... jamais je ne génèrerai le même nombre de combinaisons par le programme de h2so4. Or, c'est bien ce nombre de combinaisons qui détermine le coefficient de duplication (p).

Dans mon exemple que je t'ai détaillé avec les couleurs, p vaut 3 (parce que comme j'ai besoin de 4 lignes disponibles par ligne riche contenant le plus grand nombre final parmi la dernière génération de nombres rajoutés, et que j'en duplique déjà une existante pour chacune d'entre elles, j'en ai bien besoin de 4 [les 4 combinaisons ci-dessous] MOINS une :D

:

2) Ensuite je vais générer une autre série de combinaisons avec les variables k et n par le programme de h2so4 (c'est la deuxième itération) avec les variables k(2) et n(2). Ca me donne pour k(2)=2 et n(2)=3 pris arbitrairement ceci (je les fait figurer en orange) :

1 1 1

1 1 2

1 2 X

2 X X

Donc, il me faut :
- un de ces tableaux avec explications ;
- comment tu "choisis" la portion de ce développement à ajouter.

Trouve les mots pour expliquer le processus au Béotien mathématique que je suis et je parie que je te fais un truc full automatique. ==> Ce serait tellement le rêve ;)

Bon courage et merci encore :D

A+

Salut gthe,

tu es toujours là ?

Je viens peut-être de capter un truc...
Le iRep de chaque itération est en fait le nombre de combinaisons de chaque étape du tableau 'H2SO4' !?
La première étape est l'établissement du rang 1 avec une duplication dépendant déjà du rang 2!?

Là, si j'ai bon, je viens de passer un cap...
Par contre, il y a d'autres flous...
Ces combinaisons peuvent-elles (je pense que oui...) être ajoutées à TOUTE ligne, mêmes d'anciennes pauvres, dont le dernier chiffre correspond au nouvel iMax ?

Sois précis et pédagogue : je vais avoir 8 heures à tuer là-dessus... Tu restes en ligne tard ?

A+

Re !

Généralement, oui je peux rester assez tard (du style entre 0h et 2h selon ma forme ahah :D)

Alors le iRep je ne sais pas ce que c'est, mais s'il s'agit du nombre de répétitions (le nombre de copies), c'est en effet le nombre de combinaison du tableau "h2so4" mais auquel tu retranches 1 (à moins que le coefficient p correspond à ce nombre +1, ça dépend comment tu comptes).

Je dis ça parce qu'il ne faut pas confondre le nombre de fois qu'on copie une combinaison et le nombre de copies de cette combinaison (il y a une différence de 1 car on copie t-1 fois la combinaison pour en avoir t). Mais ça je le rappelle parce que je suis capable de m'embrouiller dessus ahah ;)***

Sinon c'est exactement ça !! La 1ère étape est l'établissement du rang 1 et le nombre de duplications dépend du nombre de combinaisons "h2so4" (moins 1)*** du rang 2 ! [dans ma logique, le nombre de duplication d'une combinaison = le nombre total de cette combinaison - 1]. Mais ça tu vois comme tu veux (si on me demande de définir p=39 ou p=40 alors que le nombre de combinaisons générées par le programme "h2so4" est 40, c'est toi qui voit. Je verrai bien en manipulant le programme comment tu vois le truc. Du moment que c'est toujours la même logique c'est bon ahah :) ]

Tu viens donc de passer un cap ahah :) Regarde de nouveau l'algorithme où j'ai tout mis en couleur, tu vas voir, ça va s'éclaircir :D

Alors par contre attention, ces combinaisons ne s'ajoutent qu'aux lignes les plus riches ! En effet, pense que si à un ordre donné tu n'as pas le chiffre max de cet ordre alors le jeu est perdu et il faut recommencer tout le processus pour gagner (c'est à dire repartir de l'ordre 1). Mais ça on ne l'écrit pas. Ca revient à perdre sa mise de départ et fin du game ! Donc on n'ajoute qu'aux lignes les plus riches et finissant par le nombre final le plus élevé [de la dernière génération] (c'est à dire celles qui permettent de poursuivre le jeu) les combinaisons dépendant du rang suivant !

En gros, tu n'écris la combinaison la plus longue que si tu gagnes à chaque "ordre", c'est-à-dire si à chaque fois tu as réussi à obtenir le chiffre max de l'ordre en question ! (et s'il te reste des "X" devant alors que ça reste ton chiffre max de ton ordre actuel, ça veut dire que tu as gaspillé moins d'essais que le nombre imparti. Et ce nombre, c'est n(x) avec x x, l'ordre :D)

N'hésite pas si tu as besoin d'aide, je vais devoir m'absenter 60 à 75 minutes, mais je reste là après (jusqu'à au moins 0h et peut-être un peu plus :D du style 2h ;) )

Mercii :D

Ok, man,

j'aurais bien fait un jeu de mot très gaulois sur le rang 10 mais, restons pro !
La combinaison H2SO4 du rang 10 doit être distribuée, selon l'espace disponible, comme pour les autres rangs, j'imagine ?

Avec ça, je pense que j'ai tout ce qu'il faut pour délirer la nuit...

Ne m'attends pas : ça peut durer... comme ça peut aller vite, tout dépendra de ma bonne inspiration!

A+

Salut Curulis57,

Les jeux de mots ne me dérangent pas ;)

Par contre je ne comprends la question sur la combinaison du rang 10 ? Elle suit la même règle que les autres, mais contrairement aux combinaisons de rang inférieur, on ne dupliquera pas celles du rang 10 dans le but d'y ajouter les "résultats h2so4" du rang 11 car le rang 10 est le dernier. ;)

T'inquiètes pas, tu as tout ton temps :D

Bon courage :)

Je viens de me rendre compte que je n'ai pas mis un seul smiley depuis le début (mais en fait, c'est parce que d'habitude j'utilise les symboles équivalents - et je viens juste de comprendre qu'il existe les smiley dans les "touches" )

Merci en tout cas

gthe,

une idée qui me traverse l'esprit : parmi toutes les combinaisons H2SO4 possibles, de 1-1 à 10-10, lesquelles sont à éliminer d'office ?

Bon, les xx-1, sûrement, et...

Merci,

A+

Curulis57,

Je ne comprends pas ce tableau, qu'est-ce qu'il signifie ?

Sinon il va falloir que je t'en dise plus pour que tu comprennes bien ce que signifie le "k" et le "n" (les deux paramètres du logiciel de h2so4).

le k signifie la valeur maximale du chiffre d'un ordre donné (parce k peut varier selon les ordres).

le n signifie la valeur maximale du nombre de chiffres qu'il y a dans une combinaison.

En théorie n devrait varier de 1 à 1000 et k de 1 à 10. Mais pour des raisons pratiques on ramènera les cas possibles k de 1 à 10 et n de 1 à 10. (sinon ce sera trop compliqué, et rien que n=27 et k=3 on obtient trop de combinaisons pour Excel ahah...). Tu ne peux donc rien éliminer, il y a bien 100 combinaisons possibles ! (10 x 10).

Ma théorie consiste à chaîner des paris : Voici un exemple que je te traduis en langage Excel. J'aurais peut-être dû faire ça depuis le début, mais écoute bien la suite, ça va tout te débloquer ;)

Soit une chaîne de 2 paliers de paris sportifs (2 ordres donc) :

On considère que l'argent de départ que l'on possède au début de l'arbre est égale à la mise initiale du premier pari, soit 1 euro dans cet exemple (tout ce qu'il y a en bleu, je l'invente car c'est un exemple).

ordre 1 : Je parie 1 euro pour essayer d'obtenir 3 euros à la place. Si je gagne, je rejoue ces 3 euros pour en obtenir 9. Si je gagne, je rejoue ces 9 euros pour en obtenir 27. En revanche, je n'ai pas le droit à l'erreur à ce stade car c'est le seul euro que j'ai parié !

On écrira alors ordre 1 : 1=>3=>9=>27. Il y a 3 épreuves consécutives à réussir (E=3) et k c'est le nombre d'issues possibles. E est le nombre d'épreuves consécutives à réussir à un ordre donné. Comme pour chaque ordre, il faut toujours réussir E paris consécutifs, alors il n'y a que E+1 c'est à dire k possibilités : La règle d'or est que pour passer d'un ordre à l'ordre suivant, il faut toujours finir par réussir E fois d'affilée ! (et k = E+1) Donc tu as le choix ici de (G = Gagner ; P = Perdre) pour chaque "épreuve" (1 épreuve = un pari : on gagne ou on perd) et ici il y a 3 épreuves car tu dois faire 1=>3 puis 3=>9 puis 9=>27 (soit k = E + 1 = 3 + 1 = 4) , et on le voit bien car possibilité 1 : P ; possibilité 2 : GP ; possibilité 3 : GGP et possibilité 4 : GGG*** - et ces 1,2,3 et 4 ce sont les fameux chiffres du programme de h2so4 et ceux que l'on manipule en les dupliquant, collant etc ) alors k vaut 4. Mais c'est que le fait de gagner 3 fois de suite qui te fait passer à l'ordre suivant (car sinon, tu perds tout :( )

***Si je n'inscris jamais de combinaison "PP", "GPP", "PGP", ( = en fait le fait qu'il n'y jamais 2 pertes consécutives ou non dans le même essai), c'est tout simplement parce que perdre revient à recommencer la série d'épreuves ! Donc on ne peut pas perdre "plus d'une fois d'affilée" ici car on aurait plus d'argent :(

Du coup on a pour cet exemple n(1) = 1 et k(1) = 4.

Soit les combinaisons :

1 (perdu : P)

2 (gagné puis perdu : GP)

3 (gagné puis gagné puis perdu : GGP)

4 (gagné puis gagné puis gagné : GGG)

Donc pour rappel, n'oublie jamais que k = E+1. C'est absolument toujours vrai !

Ensuite, si on a 27 euros en poche, on peut passer à l'ordre 2 ! Disons que les épreuves de l'ordre 2 sont les suivantes : je mise 9 euros pour en gagner 27. puis si je gagne, je mise 27 euros pour en gagner 200. Puis que si j'atteins ces 200, je termine l'ordre 2. Mathématiquement on écrira "ordre 2 : 9=>27=>200. Et là, ce qu'il faut bien comprendre, c'est que si je perds dès le début de cet ordre 2, tu es d'accord qu'il me restait 27 euros avant de commencer (les 27 euros de l'ordre 1) : donc si je perds mon premier pari de l'ordre 2, soit un pari de 9 euros, il m'en restera encore 18 pour continuer l'aventure ! Et si je perds, il m'en restera encore 9 ! Par contre là si je reperds, c'est fini il me restera 0, ciao ! Donc 27/9 = 3. J'ai 3 essais pour m'en sortir, et c'est pour ça que dans cet exemple n(2) = 3. Comme là il faut passer de 9 à 27 puis de 27 à 200 (dans cet ordre 3, et toujours consécutivement) alors j'ai 2 épreuves à réussir (E = 2) et donc k = E + 1 = 3. J'ai donc 3 possibilités ! Et ces possibilités sont 1 : P, 2 : GP, 3 : GG***. et ces 1,2 et 3 ce sont les fameux chiffres du programme de h2so4 et ceux que l'on manipule en les dupliquant, collant etc Sauf que comme j'ai 3 essais pour m'en sortir (pour rappel n(2) = 3) alors je peux réussir à faire kⁿ possibilités soit 3³ = 27 (et c'est là qu'interviennent les règles R1 et R2 du programme soumis à h2so4 ! Parce qu'en fait, je ne peux continuer que si je gagne 2 fois d'affilée, c'est-à-dire si je fais "GG" ! Donc toutes les combinaisons ne terminant pas par "3" (c'est-à-dire GG) et soit le chiffre final de cet ordre le plus élevé, elles sont perdantes !

***Si je n'inscris jamais de combinaison "PP", ( = en fait le fait qu'il n'y jamais 2 pertes consécutives ou non dans le même essai), c'est tout simplement parce que perdre revient à recommencer la série d'épreuves !

Par exemple, sur le deuxième ordre qu'on avait noté 9=>27=>200 , si tu perds quand tu joues tes 9 euros pour les transformer en 27, tu ne peux pas faire ensuite l'étape 27=>200. Tu dois bien recommencer l'étape "9=>27". Donc perdre revient à rejouer s'il te reste au moins un essai et donc on doit directement repasser à son essai suivant. Et c'est vrai quel que soit la transition :D

Regarde (là, ci-dessous, je n'ai détaillé que les combinaisons de l'ordre 2, soit le programme h2so4 généré avec k(2) = 3 et n(2) = 3) :

1 (perdu à l'ordre 1... comme j'avais 1 essai à l'ordre 1 et que je l'ai échoué (alors que je devais y arriver 3 fois de suite car il y avait 3 épreuves à cet ordre, même pas besoin de continuer à développer cette combinaison)

2 (gagné puis perdu à l'ordre 1... comme j'avais 1 essai à l'ordre 1 pour tout gagner d'un coup (3 fois de suite), c'est perdu...)

3 (gagné puis gagné puis perdu à l'ordre 1... comme j'avais 1 essai à l'ordre 1 pour tout gagner d'un coup (3 fois de suite), c'est perdu...)

4 | 1 1 1 (ORDRE 1 : j'avais gagné puis gagné puis gagné donc j'ai pu passer à l'ordre 2, soit : P au premier essai, il me reste alors 27-9 = 18 euros puis P au 2ème essai , il me reste alors 18-9 = 9 euros , puis P au 3ème essai, il me reste alors 0 euro. A aucun moment j'ai réussi 3 paris d'affilée : je ne passe pas à l'étape suivante et c'est pour cela que cette combinaison n'est pas développée ! car elle ne se termine pas par l'issue qui me fait passer à l'étape suivante c'est à dire gagner 2 fois d'affilée (GG), qui n'est que la possibilité "3" , soit le "chiffre final" le plus élevé !

4 | 1 1 2 (soit pour l'ordre 2 (donc juste le " | 1 1 2" : P puis P puis GP , et ça suffit pas car j'aurais du gagner 2 fois d'affilée (soit faire absolument au moins un "GG" , noté "3", sur au moins 1 des 3 essais)

A partir de là, tous les commentaires qui suivent chaque combinaison concernent l'ordre 2. Donc c'est pour ça que je ne parle jamais du "4" de l'ordre 1 : dans tous les cas, il fallait bien réussir à faire GGG à l'ordre 1 pour continuer la partie... sinon je perdais mon euro de départ et plus d'argent pour continuer à jouer :(

4 | 1 1 3 (soit pour l'ordre 2 (je nommerai O2 pour "O = Ordre" 2 : P, P, GG : yes j'ai réussi mes 2 épreuves d'affilée (E = 2 donc k = E + 1 = 3 : Je peux passer à l'ordre 3 !

4 | 1 2 1 (soit pour O2 : G GP P => c'est mort car j'ai pas réussi à gagner 2 fois d'affilée sur mes 3 essais)

4 | 1 2 2 (soit pour O2 G GP GP, c'est mort)

4 | 1 2 3 (soit pour O2 G GP GG, yes j'ai réussi en 3 essais !)

4 | 1 3 1 => Alors là à l'O2 j'ai fait P GG (et il y a P en plus, mais en fait non !) Pourquoi ? car "GG" me suffit pour passer à l'ordre suivant ! C'est pour ça que 1 3 1 devient 1 3 X (et que X est une case vide). Cette combinaison pourra être complétée par l'ordre 3 parce qu'elle me fait passer avec mon "GG" ! Et avec même un essai de moins que le nombre imparti, d'où le X ! Et c'est pour ça que la règle R1 du fichier h2so4 existe ! Tous les chiffres à droite du chiffre le plus élevé sont supprimés car c'est déjà gagné même s'il reste des essais ! (puisque pour rappel, le "chiffre final le plus élevé d'un ordre, c'est quand on atteint son objectif c.a.d quand on gagne E fois d'affilée !!!)

4 | 1 3 2 => Même remarque, à l'ordre 2 j'ai fait P GG donc le reste on s'en fiche car j'ai atteint mon objectif : donc 1 3 X

4 | 1 3 3 => O2 : 1 3 X aussi !

Mais... J'ai 3 combinaisons 4 | 1 3 X alors ? YES, elles sont redondantes ! hasta la vista, on supprime les doublons et on garde une seule combinaison de ce nom là ! Et ça, c'est la règle 2 du programme h2so4 !

4 | 2 1 1 => O2 : GP, P, P et pas de GG en 3 essais, ça dégage, on pourra pas dupliquer car pas de suite possible, je suis fauché j'ai plus un rond :(

4 | 2 1 2 => O2 : GP, P, GP et pas de GG en 3 essais, c'est mort pour la suite...

4 | 2 1 3 => (soit pour O2 : GP, P, GG : yes j'ai réussi en 3 essais !)

4 | 2 2 1 => O2 : GP, GP, P et pas de GG en 3 essais, c'est mort pour la suite...

4 | 2 2 2 => O2 : GP, GP, GP et pas de GG en 3 essais, c'est mort pour la suite...

4 | 2 2 3 => O2 : GP, GP, GG, OUF on a réussi en 3 coups ;) On peut passer à l'ordre 3 !

4 | 2 3 1 => O2 : GP, GG et le reste on s'en fiche car on a atteint notre objectif (GG) en deux essais : donc 2 3 X

4 | 2 3 2 => O2 : GP, GG et le reste on s'en fiche car on a atteint notre objectif (GG) en deux essais : donc 2 3 X

4 | 2 3 3 => O2 : GP, GG et le reste on s'en fiche car on a atteint notre objectif (GG) en deux essais : donc 2 3 X

Mais... J'ai 3 combinaisons 4 | 2 3 X alors ? YES, elles sont redondantes ! hasta la vista, on supprime les doublons et on garde une seule combinaison de ce nom là ! Et ça, c'est la règle 2 du programme h2so4 !

4 | 3 1 1 => O2 : GG, et le reste on s'en fiche car on a atteint notre objectif (GG) en un essai ! : donc 3 X X

4 | 3 1 2 => O2 : GG, et le reste on s'en fiche car on a atteint notre objectif (GG) en un essai ! : donc 3 X X

4 | 3 1 3 => O2 : GG, et le reste on s'en fiche car on a atteint notre objectif (GG) en un essai ! : donc 3 X X

4 | 3 2 1 => O2 : GG, et le reste on s'en fiche car on a atteint notre objectif (GG) en un essai ! : donc 3 X X

4 | 3 2 2 => O2 : GG, et le reste on s'en fiche car on a atteint notre objectif (GG) en un essai ! : donc 3 X X

4 | 3 2 3 => O2 : GG, et le reste on s'en fiche car on a atteint notre objectif (GG) en un essai ! : donc 3 X X

4 | 3 3 1 => O2 : GG, et le reste on s'en fiche car on a atteint notre objectif (GG) en un essai ! : donc 3 X X

4 | 3 3 2 => O2 : GG, et le reste on s'en fiche car on a atteint notre objectif (GG) en un essai ! : donc 3 X X

4 | 3 3 3 => O2 : GG, et le reste on s'en fiche car on a atteint notre objectif (GG) en un essai ! : donc 3 X X

Mais... J'ai 9 combinaisons 4 | 3 X X alors ? YES, elles sont redondantes ! hasta la vista, on supprime les doublons et on garde une seule combinaison de ce nom là ! Et ça, c'est la règle 2 du programme h2so4 !

Et c'est pour ça que doutes les combinaisons réalisées depuis l'ordre 1, il ne reste plus que :

1

2

3

4 | 1 1 1

4 | 1 1 2

4 | 1 1 3

4 | 1 2 1

4 | 1 2 2

4 | 1 2 3

4 | 1 3 X

4 | 2 1 1

4 | 2 1 2

4 | 2 1 3

4 | 2 2 1

4 | 2 2 2

4 | 2 2 3

4 | 2 3 X

4 | 3 X X

Et donc effectivement, ce sont bien les combinaisons riches (car l'ordre 2 a pu être passé donc il figure !) et avec le chiffre final le plus élevé (car l'épreuve qui permet de tout gagner consécutivement à l'ordre actuel) qui permettent de poursuivre à l'ordre 3 !

Dernière remarque : pour chaque ordre, on utilise les chiffres "1" "2" "3", jusqu'à "10" parfois. Mais il faut être bien d'accord que pour un ordre donné, c'est la valeur de k qui détermine la signification (en "gagnés et perdus") d'un "chiffre"! En effet, si k=4, on a 4 possibilités (pour E = k-1 = 3 épreuves) : 1 :P, 2 :GP, 3 :GGP ou 4 :GGG (puis réessayer si on a encore n-X essais... avec X le nombre de fois qu'on à déjà fait une combinaison non égale à k). Par contre, si k=10, il y a 10 possibilités (pour 9 épreuves !) soit 1 : P, 2 : GP, 3 : GGP, 4 : GGGP, 5 : GGGGP, 6 : GGGGGP, 7 : GGGGGGP, 8 : GGGGGGGP , 9 : GGGGGGGGP , 10 : GGGGGGGGG. Et comme d'habitude, la règle d'or est que pour passer à l'ordre suivant : il faut réussir E fois d'affilée soit ici dans cet exemple, l'évènement k, soit "10".

==> Donc selon l'ordre, un chiffre identique n'aura pas la même signification au niveau du jeu ! Mais le chiffre le plus élevé d'un ordre signifie qu'on peut passer à l'ordre suivant ! Et c'est la seule condition pour y arriver (c'est à dire réussir "ce chiffre" (ou k) soit E = k-1 paris d'affilée...) :D

Voilà, désolé pour ce looooooong post, mais maintenant je pense que tu comprends l'essence même de tous ces chiffres ;)

Euh... c'est à dire que... je suis désolé de ne rien capter... ce que tu me racontes, c'est du chinois pour moi...
Petite anecdote pour te donner mon niveau en math.
En humanités, un jour, le prof de math s'est tourné vers la classe et a demandé :
- Tout le monde a compris ? Sauf Curulis ? Ok, on continue !

Le tableau, ce sont justement les combinaisons K/n dont il y avait un exemplaire dans un de tes fichiers.
Beaucoup de combinaisons issues de ces chiffres pondent des centaines de milliers de lignes avec la macro de H2SO4 !!
Ma question : jusqu'à combien de lignes penses-tu limiter l'utilisation de ces K/n dans la succession de tes "ordres" ?
Avec 20 lignes riches à dupliquer pour insérer autant de fois, par ex, 50.000 lignes d'une combinaison, on n'ira pas loin...

Ou, alors, j'ai manqué un épisode...

EDIT

Ceci...

pour chaque ordre, on utilise les chiffres "1" "2" "3", jusqu'à "10" parfois

- ce sont les seuls chiffres utilisés comme "n" ?
- et pour les "K" : de combien à combien ?

Bon, ne fais pas comme mon prof de math et explique...

Salut Curulis57,

pas de soucis :D

Je me limite à la limite d'Excel soit 1 048 576 lignes ;)

Pour le tableau k/n, tu pourrais me donner le nom du post et la date et l'heure du post où tu l'as vu ?

Sinon k vaut 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ou 10 et n vaut 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ou 10.

Et je suis bien conscient que je vais avoir des problèmes si je mets k=10 et n=10 pour chaque ordre, mais Excel m'enverra un message d'erreur et je saurai qu'il faut que je me calme sur les valeurs de k et n ou l'ordre maximal auquel je fais mon calcul :D

Salut gthe,

j'ai l'impression que tu n'as jamais calculé le nombre de lignes de certaines combinaisons K/n !!!
Fais tourner la macro de H2SO4 et plonge dans le fond du résultat apprécier le nombre de lignes !

Ex : K7 / n7 = +- 336.000 lignes de combinaisons !
Comment veux-tu faire joujou avec des duplications pareilles ?

Va vraiment falloir mettre ça au clair et mettre des limites!

A+

Salut Curulis 57,

t'inquiètes, même qu'avec k=10 et n=10 sur un unique ordre j'ai 3 922 632 451 combinaisons ! Donc rien que là on enfonce les limites Excel

Mais si tu veux j'ai vendu un tableau allant de k=1 à 10 et n=1 à 10 :) Donc je sais en connaissance de cause qu'on enfoncera les limites Excel ;)

T'inquiètes :)

Salut gthe,

on n'est pas sur la même longueur d'onde, je pense...
Laissons ce point de côté pour l'instant.

Je suis sur le point de réussir le full automatique : il reste un ajustement d'affichage et je t'envoie ça.

A+

Salut Curulis57,

Si si j'ai bien compris : si je tente certaines combinaisons, le programme ne marchera pas et c'est pour ça que tu souhaitais le restreindre ! Mais au contraire, je préfère qu'il y ait trop de combinaisons possibles que pas assez, donc même si la combinaison k=10 et n=10 ne fonctionne pas, je souhaiterais quand même que l'utilisateur ait la possibilité de "rentrer" cette combinaison, même s'il se prend un "Error" dans la face :) Histoire qu'il comprend que bibi ne doit pas abuser sur les combinaisons ;)

De plus, on peut aller jusqu'à l'ordre 10 mais on est pas obligé de faire les 10 ordres ! Mais oui je suis d'accord, la limite théorique d'Excel limite bien le truc ;)

Après, tu peux chiader le truc en créant N feuilles de résultats, ou des csv ou des trucs pour augmenter la mémoire disponible... mais comme il faut ensuite traiter ces combinaisons, je préfère me restreindre à la limite théorique de Excel de 2²⁰. Si je me prends un error dans la face, bah je ferai des combinaisons moins compliquées ! :D

Après oui K7/N7 c'est (6^0+6^1+6^2+...6^7) soit 335 923 combinaisons et dont 335 923 - 6^7 = 55 987 combinaisons gagnantes. Donc si tu recolles un K7/N7 derrière on se retrouve a (335 923 - 55 987) combinaisons perdantes avortées + 55 987 x 335 923 combinaisons "riches" soit 1,8808.10¹⁰ combinaisons soit lègèrement 17 936,33 fois la limite qu'Excel peut supporter haha. Mais pas grave, je comprendrais que si je "me fais" un K7/N7, après on va rester sur du N3 ou pas beaucoup plus :D

Mais visuellement ça ne me dérange pas de pouvoir saisir une chose sachant que ça peut devenir une erreur :) Parce ce code là il peut peut être servir dans d'autres conditions ou avec des trucs chiadés qui te génèrent 100 listes ou je ne sais pas quoi. Je vois bien le type taper K=10 N=10 pour les 10 ordres (la flemme de faire le calcul) mais je pense qu'il explose sa bécane là. Je l'imagine bien son ordi lui pondre 500 000 feuilles calc ou txt... Hahahaha. Non soyons sérieux, un simple programme qui se limite à l'affichage d'une feuille Excel soit 2²⁰ c'est déjà énorme. Puis ma bécane c'est une i5, pas les Monster que mes potes utilisent sur WoW :D

Sinon félicitations si tu es sur le point de réussir ça ! Moi ça m'aurait pris des années vu mes connaissances en VBA (je connais le sigle et je sais qu'il existe des formules ahah, même si il y a 5 ans je faisais du C... que ça me prenait la tête :D - les informaticiens que je connais détestent le C... mon niveau se limitant à printf et scanf). Par contre, plus jamais de langage assembleur (oui c'est autre chose)... :(

Salut gthe,

je suis très content, très mitigé et très déçu : ad libitum en fonction de la succession des ordres H2SO4...
Puisque le moteur tourne plusieurs ordres sans anicroche, il doit y avoir du bon dans la mécanique.
Le souci, c'est que, pour des raisons que j'ignore, les pistons grippent quand ça tourne trop fort!

J'imagine que je n'ai pas la technique et autres artifices nécessaires pour soulager la mémoire de l'ordi et il tourne, il tourne, il tourne...
Or donc, j'avais eu l'idée de stocker, sur une feuille 'BDD', TOUTES les combinaisons possibles H2SO4 : 380 Mo !, histoire d'éviter le recalcul permanent de ces mêmes combinaisons lors de chaque itération.
Las, c'est de toute façon impossible de faire tourner ce truc sans garde-fou sauf à bénéficier des ordis de la NASA.

Dans le fichier joint, en 'BDD', et sans cela, rien ne fonctionnera, tu as les combinaisons K(2-10) / n(2-3) : crois-moi, j'ai un i5 8Go, ça rame à n'en plus finir selon les ordres encodés !
Rendons à César ce qui est à César ; ces combinaisons ont été calculées grâce à la macro de H2SO4. !
Ce sont, pour l'heure, les seules combinaisons possibles, la macro de H2SO4 n'entrant pas en ligne de compte pour aucune autre !
Tu encodes tes ordres dans la feuille 'H2SO4' et tu double-cliques sur "RANG" pour démarrer la macro. La séquence programmée actuellement s'exécute en une fraction de seconde... Pour le reste, vogue la galère...

Le coeur du coeur...

        For x = 1 To UBound(tTab, 1)
            For y = UBound(tTab, 2) To iColT Step -1
                If tTab(x, y) <> "" Then
                    iOK = IIf(CInt(tTab(x, y)) = iMax, iRep, 1)
                    If iOK = 1 Then ReDim Preserve tMIN(UBound(tTab, 2), lngIdx1 + 1)
                    If iOK > 1 Then _
                        iData = 0: _
                        ReDim Preserve tMAX(iWidth, lngIdx2 + iOK)
                    For k = IIf(iOK = 1, lngIdx1, lngIdx2) To IIf(iOK = 1, lngIdx1, lngIdx2 + iOK - 1)
                        For w = 1 To y
                            If iOK = 1 Then tMIN(w - 1, k) = tTab(x, w)
                            If iOK > 1 Then tMAX(w - 1, k) = tTab(x, w)
                        Next
                        If iOK > 1 Then
                            iData = iData + 1
                            tMAX(UBound(tTab, 2), k) = "|"
                            For w = UBound(tTab, 2) + 1 To iWidth - 1
                                tMAX(w, k) = tData(iData, w - UBound(tTab, 2))
                            Next
                        End If
                    Next
                    If iOK = 1 Then lngIdx1 = lngIdx1 + 1
                    If iOK > 1 Then lngIdx2 = lngIdx2 + iOK
                    Exit For
                End If
            Next
        Next

J'ai à nouveau 8 hrs. à tuer... Tu me joins quand tu veux !

A+

Curulis 57,

Les premiers résultats sont vraiment impressionnants ! Je fais quelques tests et après ce sera place aux remarques :D

Mais en tout cas, chapeau bas !

Re Curulis57,

La façon dont le programme s'utilise pour réaliser la macro est impeccable.

Je comprends maintenant pourquoi tu ne voulais pas faire toutes les combinaisons qui combinent k=10 à n=10.

Malheureusement, certaines valeurs s'affichent en double et le nombre de combinaisons à obtenir ne correspond pas toujours.

Il faut que je t'aide à mon tour : je vais te générer deux tableaux : pour l'un, il faudra que tu rentres simplement les valeurs de k et de n pour connaître le nombre de combinaisons d'un ordre précis (c.a.d le nombre de combinaisons générées pour un ordre, soit le programme de h2so4 initial).

Pour l'autre tableau, ça va calculer le nombre de combinaisons totales en fonction du tableau k/n que je dois renseigner.

Je m'y mets ;)

Je t'envoie ça dès que je peux et je commenterai les résultats pour voir ce qu'il reste encore à faire pour atteindre les attendus ;) Mais on a passé un cap :D