Recopie d'un nombre de lignes espacées

[Message édité pour faciliter la compréhension du sujet]

Bonjour,

Je voulais vous demander si c'était possible la macro suivante (je ne maîtrise pas VBA) :

Cette macro a la faculté de recopier P fois toutes les lignes qui finissent par le nombre le plus grand (les cases vides n'étant pas comptabilisées) en les insérant entre les lignes initiales. (le programme identifie sur la feuille entière les nombres les plus grands)

La seule variable a fixer est P, la macro identifie automatiquement les lignes finissant par le nombre le plus grand.

Voici un petit exemple ci-joint.

Merci beaucoup, ça va vraiment m'aider !

Salut gthe,

attention : travail sans filet !
Un double-clic sur une cellule du tableau à traiter démarre la macro.

Private Sub Worksheet_BeforeDoubleClick(ByVal Target As Range, Cancel As Boolean)
'
Dim rCells As Range, iCol%, iMax%
'
If Target <> "" Then
    Cancel = True
    Set rCells = Target.CurrentRegion
    iMax = WorksheetFunction.Max(rCells)
    For x = rCells.Row + rCells.Rows.Count - 1 To rCells.Row Step -1
        iCol = Cells(x, rCells.Column).End(xlToRight).Column
        If iCol > rCells.Column + rCells.Columns.Count - 1 Then iCol = rCells.Column
        If Cells(x, iCol) = iMax Then
            Cells(x, rCells.Column).Resize(1, rCells.Columns.Count).Copy
            Cells(x, rCells.Column).Resize(1, rCells.Columns.Count).Interior.Color = RGB(255, 190, 0)
            Cells(x + 1, rCells.Column).Resize(3, rCells.Columns.Count).Insert xlShiftDown
            Cells(x + 1, rCells.Column).Resize(3, rCells.Columns.Count).Interior.Color = RGB(215, 215, 215)
        End If
    Next
    Application.CutCopyMode = False
End If
'
End Sub

Le tableau-miroir à droite sert à des copier-coller pour essais.
Reste à déterminer les procédures de déclenchement, histoire d'encadrer ce double-clic.
Pour éliminer les couleurs-témoins, supprime les deux lignes contenant Interior.Color...

A+

Bonjour curulis57,

Merci beaucoup pour cette contribution ! :)

Par contre, je n'ai pas réussi à reproduire ce que je voulais faire à la main (et je pense qu'on est pas loin).

Je vous envoie un nouveau fichier avec un exemple plus complexe qui explique les différences entre le résultat-objectif que je proposais et le votre.

J'effectue des manipulations manuelles entre chaque "application" de la macro, mais je ne demanderai pas de programmation spécifique dessus. Je préfère limiter le problème à la seule duplication des lignes finissant à chaque fois par le nombre le plus grand de tout le tableau considéré.

Aussi, le programme a été rédigé de telle manière à ce que ce soit toujours 3 lignes qui sont recopiées puis rajoutées en plus. Mais idéalement j'aimerais bien régler ce nombre de lignes (parfois j'aimerais en ajouter 6, parfois 2, parfois 9, etc). Juste une variable que je peux régler à chaque ouverture de la macro me suffirait : c'est à dire que je dupliquerai toujours P fois (mais P étant réglable) les lignes concernées.

Quelques remarques : les tableaux de nombres que je souhaite dupliquer peuvent atteindre le million. Idéalement, il faudrait que la macro puisse travailler jusqu'en bas de la feuille.

Nota important : Rien n'empêche que des combinaisons séparées par une ou plusieurs cases vides existent !

Par exemple :

où seules les lignes suivantes seraient dupliquées :

Le fichier en question :

Merci :)

Salut gthe,

je regarde ça ce soir, promis... euh, je vais quand même croiser les doigts dans mon dos, hein...
Question
Tu expliques que tu exécutes la macro plusieurs fois sur le même tableau. D'accord !
Si le nombre maxi n'a pas changé, les lignes dupliquées précédemment vont être à nouveau dupliquées individuellement.

Faudra quand même assouvir notre curiosité et expliquer grosso-modo à quoi ça sert...

A+

Salut Curulis57, je te tutoie aussi du coup ;)

Ah je me suis sûrement mal exprimé !

En fait, non, la macro ne doit s'exécuter qu'une seule fois (c'est juste que toutes les lignes concernées doivent se dupliquer P fois ;) ).

Aussi, ce que je disais porte à confusion : quand j'avais dit que la macro devait travailler jusqu'en bas de la feuille, je voulais simplement parler de sa "portée". (En réalité, il faudrait qu'elle puisse s'exécuter sur toute la feuille , même s'il y a 54 158 lignes et 158 colonnes).

Pour la petite histoire quant à la finalité des programmes :

L'idée c'est de construire un arbre de probabilités dénombrant tous les scénarios possibles pour des paris sportifs en fonction de scénarios de mise... et de trouver le trio{montant des paris ; nombre d'épreuves par montante ; taux de cavage inter-motante} qui augmente le rapport "gains potentiels" / "risque".

Le programme de duplication sert à démultiplier les possibilités permettant de "continuer à jouer" pour y accoler d'autres combinaisons (calculées par d'autres programmes - cf. mes autres topics) et permettre de réussir à faire le calcul !

Voilà voilà ;)

Encore merci !

Salut gthe,

Je n'ai rien compris. Par contre, je sais pourquoi je ne gagne jamais aux paris...

Peux-tu être précis, stp, quoique cela ne change pas grand'chose pour moi, finalement...
"J'effectue des manipulations manuelles entre chaque "application" de la macro..."
"...la macro ne doit s'exécuter qu'une seule fois..."

En fait, rien ne change pour moi : au double-clic sur un tableau, QUEL QU'IL SOIT, je ferai en sorte que la duplication ait lieu.
Pour plonger aussi profond dans les lignes d'Excel, je vais jouer avec des tableaux... Là, c'est toi qui ne comprends plus, non ?

Tu te débrouilleras bien avec les résultats ? 10% ? Bon, OK...

A+

Salut curulis57,

Les paris restent complexes, c'est juste qu'un ami à une "idée".

Mais comme toutes les idées, j'aime bien les tester et les soumettre à des épreuves mathématiques ;)

Quand je dis que la macro ne doit s'exécuter une seule fois je voulais dire qu'elle doit s'exécuter en une fois. C'est à dire qu'une fois que le clic est réalisée (car ta macro fonctionne au clic), les cellules concernées se dupliquent P fois. (de ton côté tu as fixé P = 3, comme dans l'exemple. Mais ça reste un exemple :D).

En effet, dans la macro que tu m'avais proposée, elles se dupliquent tout le temps 3 fois et je n'ai pas la liberté de choisir "autre chose que 3". Ce que j'aimerais, c'est que quand je vais sur la feuille et que je fais mon clic, je puisse choisir combien de fois elles se dupliquent (valeur de P dans mon premier post). Je peux faire ce choix de la façon que tu veux (soit une modif' dans le code, soit une fenêtre contextuelle, autre, à toi de voir). P peut même valoir 1 000 000 si je le désire (mais je serai vite limité vu que c'est pas loin de la limite d'Excel ahah...)

Dans l'esprit, ton programme (celui que tu m'as montré au début) est quasiment bon ! C'est juste qu'il y avait quelques erreurs (certaines cellules se dupliquaient et ne le devaient pas alors que d'autres ne se dupliquaient pas, mais elles le devaient - commentaires en U15, U16, U17, U18, U32 et U33 dans le fichier joint quand je t'avais répondu). J'ai bien détaillé tout dans la PJ que j'ai postée à nouveau pour bien que tu comprennes ce que j'attendais vis-à-vis de ces erreurs.

Enfin, quand je dis que je fais plusieurs applications de la macro, c'est simplement que j'efface et que je recommence (mais toujours en faisant le clic qui déclenche en une seule fois la duplication P fois des lignes concernées.

Je ferai de mon mieux avec les résultats. Ceux-ci n'aideront pas à mieux parier. Ils aideront à mieux comprendre ce qu'il ne faut surtout pas faire :D

Salut gthe,

l'erreur provient probablement de CurrentRegion qui calcule les limites d'un tableau jusqu'à la dernière valeur continue d'une ligne et d'une colonne.
Question :
Y a-t-il "autre chose" que ce tableau dans ta feuille de calcul lors de ces tests ?

Je regarde ça...

A+

Salut Curulis,

Non je ne veux pas compliquer les choses :) Cette feuille est destinée uniquement à jouer son rôle de duplication. Je clique, ça duplique les bonnes lignes et cette feuille ne sert qu'à ça :D

Sinon mon hypothèse de départ c'est qu'il était possible que ça puisse bugger du fait de l'existence de vides qui sépare certains nombres sur la même feuille ;) Mais tu l'as bien senti aussi.

Merci beaucoup :)

Salut gthe,

c'était bien CurrentRegion sans compter mon tableau-miroir qui mettaient le bouzin...
Dans le code suivant, je postule par défaut que ton tableau est en [A1].

- pour que ça roule, j'utilise maintenant des tableaux ;
- toujours un double-clic sur une cellule du tableau pour démarrer la macro ;
- tu es invité à encoder le nombre de duplications ;
- avant le calcul, ton tableau est sauvegardé dans 'COPY' ;
- un clic DROIT dans 'TEST' rétablit le tableau sauvegardé dans 'COPY'

Pour ta manipulation manuelle, tu m'expliques exactement ce que tu fais ? Je trouverai bien un truc pour te faciliter la vie...

Private Sub Worksheet_BeforeDoubleClick(ByVal Target As Range, Cancel As Boolean)
'
Dim tTab, tTest(), iMax%, iOK%, lngIdx&
'
If Target <> "" Then
    Cancel = True
    Application.ScreenUpdating = False
    Do
        iTime = Application.InputBox("Nombre de duplications ?", "TEST", 3, , , , , 1)
    Loop While Not IsNumeric(iTime) And iTime <> False
    If iTime > 0 Then
        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
                    iOK = IIf(CInt(tTab(x, y)) = iMax, iMax + 1, 1)
                    ReDim Preserve tTest(UBound(tTab, 2), lngIdx + iOK)
                    For k = lngIdx To (lngIdx + iOK - 1)
                        For w = 1 To y
                            tTest(w - 1, k) = tTab(x, w)
                        Next
                    Next
                    lngIdx = lngIdx + iOK
                    Exit For
                End If
            Next
        Next
        [A1].Resize(lngIdx, UBound(tTab, 2)) = WorksheetFunction.Transpose(tTest)
    End If
    Application.ScreenUpdating = True
End If
'
End Sub

Á tester en situation réelle en étant bien d'accord qu'il n'est censé exister aucune donnée ailleurs sur la feuille !

A+

Salut curulis57,

Merci pour cette aide ;)

J'ai eu un peu de mal à saisir au début comment ça fonctionne, mais c'est tout simple et la fonction de reset le tableau comme sur copy est un coup de génie, je dois dire ;) C'est très bien de pouvoir revenir à la situation initiale.

J'ai fait quelques tests. J'ai l'impression que la duplication ne fonctionne pas très bien :

- le programme ne réalise pas toutes les duplications voulues (par exemple, quand je rentre P=10, il me fait parfois que 3 duplications)

- il existe des duplications qui ne fonctionnent pas très bien (par exemple, quand j'isole un "50" disons en D14 et que j'ai mis un ou deux chiffres par ligne, pas forcément l'un à côté de l'autre, ça ne marche pas... (ça duplique parfois le 50 bien plus de fois que P...)

Je vais devoir retourner travailler, mais promis je te fais quelques exemples et "ce que ça aurait du donner" VS "ce que ça donne".

Après je peux t'expliquer la manipulation complète par un simple schéma ! Mais attention, ça va beaucoup plus loin que ton programme.

Je pensais simplifier en demandant les choses petit à petit, mais si tu veux je te pose mon problème (il n'est pas trop compliqué à formuler) et tu peux me fournir une solution par n'importe quel moyen (et je te laisse tout gérer de A à Z). Et là éventuellement, peut-être que tu utiliserais la duplication autrement.

C'est comme tu veux ;)

Salut gthe,

si ton calcul n'est pas un truc de mathématicien pur et dur (nul en math !), envoie avec les manip' et tout et tout.

Bon travail !

A+

Salut Curulis57,

Alors le programme général que je souhaiterais créér est exactement figuré ici : https://forum.excel-pratique.com/excel/generer-les-k-combinaisons-dependantes-de-plusieurs-variables...

Il y a plusieurs façons de le faire : soit avec 2 macros et je le construit par itération en automatisant les étapes de génération de combinaison (macro n°1 = de h2so4) ou de duplication de lignes (macro n°2 = la tienne), voire avec d'autres macros.

Soit, directement en renseignant toutes les variables k1 à k10 et n1 à n10 et que le programme calcule absolument tout tout seul ! (ce serait l'idéal absolu mais je pense que c'est pas simple à programmer).

Je peux essayer de préparer un algorithme si tu souhaites que je te guide !

;)

Salut gthe,

j'ai bien compris le principe de la macro de H2so4 et des règles à suivre.
Pour la suite de l'affaire, je ne vois pas le rapport avec la duplication et encore moins sur quelles bases on ajoute des combinaisons à ton tableau...

Là, tu commences à chatouiller l'insondable profondeur de mon incompétence mathématique !
Va falloir être vachement pédagogue pour je te suive sur ce terrain !

J'attends ton tableau des coquilles de la duplication...


A+

Curulis57,

Je comprends, c'est vraiment pas simple.

Je vais devoir m'absenter une petite demi-heure mais quand je reviens (donc bien après la demi-heure car je compte le temps de créer les 2 excels explicatifs) :

- je te fournirai un Excel avec le tableau sur les coquilles de la duplication (quelques exemples)

- je vais essayer de te faire un Excel qui te détaille pas à pas toutes les manipulations que je combine pour réussir à obtenir mes combinaisons. ;) Et du coup, promis tu vas comprendre pourquoi dans mes manipulations j'ai besoin de dupliquer des lignes :D
A l'oral ça s'explique en 15 minutes, mais c'est vrai qu'à l'écrit c'est une autre paire de manches !

Promis je reviens vers toi un peu plus tard dans la soirée ;)

En tout cas c'est vraiment sympa à toi de m'aider :) Mais tu verras, en fait ce que je demande n'est pas si compliqué :D (c'est complexe, mais pas compliqué ;) )

@Curulis57,

Comme prévu, voici un fichier qui présente certaines erreurs.

Je réfléchis à la façon dont je pourrais t'expliquer manuellement ce que je recherche.

Curulis57,

Je vais prendre une exemple tout simple pour l'algorithme (plutôt que de faire un fichier Excel compliqué).

1 nombre = 1 colonne (j'entends par là les valeurs allant de 1 à 10).

Vu que tu connais bien la macro de h2so4, ça va aller encore plus vite !

Par convention, tous les chiffres les plus élevés sont en verts.

X = désigne une case vide qui doit le rester (mais elle doit rester une case vide et pas un "X")

Notations : k(x) et n(x) sont respectivement le chiffre le plus élevé et le nombre de chiffres générés à l'étape x (je la note i parfois).

x (ou i c'est pareil) varient de 1 à 10

k varie de 1 à 10 (donc k(1), k(2), ... k(10) varient de 1 à 10)

n varie de 1 à 1000 (donc n(1), n(2), ... n(10) varient de 1 à 1000)

L'algorithme est le suivant :

1) je génère une combinaison avec les variables k(1) et n(1) par le programme de h2so4. Ca me donne pour k(1)=3 et n(1)=3 pris arbitrairement, ceci (pour rappel, je souhaite que dans mon programme on puisse choisir k allant de 1 à 10 et n allant de 1 à 1000) :

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

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

3) Ce qu'il faut bien comprendre, c'est que seules les issues les plus favorables (c.a.d celles contenant le chiffre le plus élevé de leur colonne) peuvent "continuer" à faire des combinaisons. Toutes les combinaisons de l'étape 2) vont "continuer" toutes celles qui finissent le chiffre final le plus favorable de celles de l'étape 1 (la 1ère itération) : c'est là qu'intervient la duplication ! Je représente toujours le chiffre le plus final en vert (des combinaisons qui doivent être dupliquées) et les combinaisons dupliquées en violet.

Et ensuite j'y accole les combinaisons de l'ordre 2 (c'est à dire celles générées avec le programme de h2so4 pour k(2) et n(2) , à l'étape "2)).

Je sépare l'ordre "1" et l'ordre "2" par le symbole "|" qui devra occuper une case

Il y a donc autant d'ordres dans une combinaison que de signes " | " plus 1.

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 1 1

1 1 3 | 1 1 2

1 1 3 | 1 2 X

1 1 3 | 2 X X

1 2 3 | 1 1 1

1 2 3 | 1 1 2

1 2 3 | 1 2 X

1 2 3 | 2 X X

1 3 X | 1 1 1

1 3 X | 1 1 2

1 3 X | 1 2 X

1 3 X | 2 X X

2 1 3 | 1 1 1

2 1 3 | 1 1 2

2 1 3 | 1 2 X

2 1 3 | 2 X X

2 2 3 | 1 1 1

2 2 3 | 1 1 2

2 2 3 | 1 2 X

2 2 3 | 2 X X

2 3 X | 1 1 1

2 3 X | 1 1 2

2 3 X | 1 2 X

2 3 X | 2 X X

3 X X | 1 1 1

3 X X | 1 1 2

3 X X | 1 2 X

3 X X | 2 X X

4) Ensuite, il faut réarranger ces combinaisons qui doivent être triées de manière à ce que :

- et celles qui ont pu être poursuivies (donc contiennent 6 caractères c'est-à-dire une somme de chiffres et de croix qui fait exactement 6 (pour rappel sur Excel la croix = du vide ou 2 étapes remplies c.a.d [combinaison étape 1]|[combinaison étape 2]) ;

- et celles qui ont le chiffre finale le plus élevé

apparaissent en fin de liste

(donc attention : il faut bien ces 2 conditions réunies). Celles qui respectent ces deux conditions ont le chiffre final en bleu :

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 1 1

1 2 3 | 1 1 1

1 3 X | 1 1 1

2 1 3 | 1 1 1

2 2 3 | 1 1 1

2 3 X | 1 1 1

3 X X | 1 1 1

1 1 3 | 1 1 2

1 1 3 | 1 2 X

1 1 3 | 2 X X

1 2 3 | 1 1 2

1 2 3 | 1 2 X

1 2 3 | 2 X X

1 3 X | 1 1 2

1 3 X | 1 2 X

1 3 X | 2 X X

2 1 3 | 1 1 2

2 1 3 | 1 2 X

2 1 3 | 2 X X

2 2 3 | 1 1 2

2 2 3 | 1 2 X

2 2 3 | 2 X X

2 3 X | 1 1 2

2 3 X | 1 2 X

2 3 X | 2 X X

3 X X | 1 1 2

3 X X | 1 2 X

3 X X | 2 X X

5) Ensuite, avec le programme de h2so4, on définit les combinaisons de l'ordre 3 : c'est à dire pour k(3) et n(3). Mettons que je choisisse k(3) = 2 et n(3) = 3 ça va me donner :

1 1 1

1 1 2

1 2 X

2 X X

6) Ensuite, on répète l'étape "3)" : les issues les plus favorables, c'est à dire celles qu'on a fait figurer en fin de liste d'après les conditions définies par l'étape 4, sont dupliquées et toutes les combinaisons de l'étape 5) continuent toutes ces issues les plus favorables, ce qui donne (désolé pour les couleurs, mais ça prendrai trop de temps...) :

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 1 1

1 2 3 | 1 1 1

1 3 X | 1 1 1

2 1 3 | 1 1 1

2 2 3 | 1 1 1

2 3 X | 1 1 1

3 X X | 1 1 1

1 1 3 | 1 1 2 | 1 1 1

1 1 3 | 1 1 2 | 1 1 2

1 1 3 | 1 1 2 | 1 2 X

1 1 3 | 1 1 2 | 2 X X

1 1 3 | 1 2 X | 1 1 1

1 1 3 | 1 2 X | 1 1 2

1 1 3 | 1 2 X | 1 2 X

1 1 3 | 1 2 X | 1 2 X

1 1 3 | 2 X X | 1 1 1

1 1 3 | 2 X X | 1 1 2

1 1 3 | 2 X X | 1 2 X

1 1 3 | 2 X X | 2 X X

1 2 3 | 1 1 2 | 1 1 1

1 2 3 | 1 1 2 | 1 1 2

1 2 3 | 1 1 2 | 1 2 X

1 2 3 | 1 1 2 | 2 X X

1 2 3 | 1 2 X | 1 1 1

1 2 3 | 1 2 X | 1 1 2

1 2 3 | 1 2 X | 1 2 X

1 2 3 | 1 2 X | 2 X X

1 2 3 | 2 X X | 1 1 1

1 2 3 | 2 X X | 1 1 2

1 2 3 | 2 X X | 1 2 X

1 2 3 | 2 X X | 2 X X

1 3 X | 1 1 2 | 1 1 1

1 3 X | 1 1 2 | 1 1 2

1 3 X | 1 1 2 | 1 2 X

1 3 X | 1 1 2 | 2 X X

1 3 X | 1 2 X | 1 1 1

1 3 X | 1 2 X | 1 1 2

1 3 X | 1 2 X | 1 2 X

1 3 X | 1 2 X | 2 X X

1 3 X | 2 X X | 1 1 1

1 3 X | 2 X X | 1 1 2

1 3 X | 2 X X | 1 2 X

1 3 X | 2 X X | 2 X X

2 1 3 | 1 1 2 | 1 1 1

2 1 3 | 1 1 2 | 1 1 2

2 1 3 | 1 1 2 | 1 2 X

2 1 3 | 1 1 2 | 2 X X

2 1 3 | 1 2 X | 1 1 1

2 1 3 | 1 2 X | 1 1 2

2 1 3 | 1 2 X | 1 2 X

2 1 3 | 1 2 X | 2 X X

2 1 3 | 2 X X | 1 1 1

2 1 3 | 2 X X | 1 1 2

2 1 3 | 2 X X | 1 2 X

2 1 3 | 2 X X | 2 X X

2 2 3 | 1 1 2 | 1 1 1

2 2 3 | 1 1 2 | 1 1 2

2 2 3 | 1 1 2 | 1 2 X

2 2 3 | 1 1 2 | 2 X X

2 2 3 | 1 2 X | 1 1 1

2 2 3 | 1 2 X | 1 1 2

2 2 3 | 1 2 X | 1 2 X

2 2 3 | 1 2 X | 2 X X

2 2 3 | 2 X X | 1 1 1

2 2 3 | 2 X X | 1 1 2

2 2 3 | 2 X X | 1 2 X

2 2 3 | 2 X X | 2 X X

2 3 X | 1 1 2 | 1 1 1

2 3 X | 1 1 2 | 1 1 2

2 3 X | 1 1 2 | 1 2 X

2 3 X | 1 1 2 | 2 X X

2 3 X | 1 2 X | 1 1 1

2 3 X | 1 2 X | 1 1 2

2 3 X | 1 2 X | 1 2 X

2 3 X | 1 2 X | 2 X X

2 3 X | 2 X X | 1 1 1

2 3 X | 2 X X | 1 1 2

2 3 X | 2 X X | 1 2 X

2 3 X | 2 X X | 2 X X

3 X X | 1 1 2 | 1 1 1

3 X X | 1 1 2 | 1 1 2

3 X X | 1 1 2 | 1 2 X

3 X X | 1 1 2 | 2 X X

3 X X | 1 2 X | 1 1 1

3 X X | 1 2 X | 1 1 2

3 X X | 1 2 X | 1 2 X

3 X X | 1 2 X | 2 X X

3 X X | 2 X X | 1 1 1

3 X X | 2 X X | 1 1 2

3 X X | 2 X X | 1 2 X

3 X X | 2 X X | 2 X X

Et ainsi de suite : réordonner ces combinaisons avec les mêmes critères qu'à l'étape 4 (sauf que cette fois ci il faut que ce soit uniquement celles avec le chiffre final parmi celles qui ont 3 ordres de remplies [en gras donc] qui seront affichées en bas... puis elles mêmes recomplétées par le programme de h2so4 qui aura généré les k(4) et les 1(4) qui seront accolés aux combinaisons en gras qui auront été dupliquées autant de fois que nécessaire, etc, etc, jusqu'à que 10 ordres sont réalisés.

Attention, comme le n d'un ordre peut varier, une combinaison finale peut très bien être celle-ci :

3 X X | 2 X X | 1 2 X | 5 3 3 2 7 X X | 1 7 X X X X X X X | 6 1 8 9 X X | 3 X | 2 5 X | 1 2 3 4 X X X | 1 1 3 3 8

(et elle comporte bien 10 ordres car 10 combinaisons séparées).

Pour rappel, là ce n'est qu'un exemple que j'ai fait mais tous les k peuvent varier de 1 à 10 et les n de 1 à 10. Par contre, l'algorithme en ce qui concerne la génération des combinaisons (le processus en lui même, et non les combinaisons générées qui ne sont qu'un exemple) ainsi que la duplication et la mise en ordre des combinaisons, c'est bien celui que je t'ai présenté. Sauf que je me suis arrêté ici à l'ordre 3.

Donc c'est la raison pour laquelle il faut que je puisse utiliser jusqu'à 1 048 576 lignes, car je vais vite être limité ;)

Donc pour conclure :

Idéalement la seule chose que j'aurais à faire c'est remplir un formulaire qui me demande de renseigner ce genre de tableau (puis après le programme génère automatiquement absolument toutes les combinaisons sur une seule feuille). Ce formulaire doit même pouvoir travailler avec des cases vides (et renvoyer une erreur si dans une colonne il n'y a pas k(x) et n(x) de renseigné... car c'est impossible de renseigner que l'un ou l'autre à un ordre donné).

Et l'exemple que je t'ai détaillé est le suivant :

Et l'exemple qui est en bleu c.a.d 3 X X | 2 X X | 1 2 X | 5 3 3 2 7 X X | 1 7 X X X X X X X | 6 1 8 9 X X | 3 X | 2 5 X | 1 2 3 4 X X X | 1 1 3 3 8 *** présente forcément ce tableau :

***Techniquement, je doute qu'Excel a la capacité disponible pour la générer, mais on ne sait jamais je n'ai pas fait le calcul :)

**en effet, rien n'indique que "8" est le meilleur chiffre ici (à l'ordre 10). Par contre pour tous les autres ordres on connaît les chiffres les plus élevés (k) car justement c'est la condition pour continuer à écrire la combinaison... ;)

Voilà voilà,

En espérant que c'était assez détaillé et pas trop confus.

N'hésite pas si tu as des questions ;)

Salut gthe,

une première lecture m'a déjà permis de saisir la philosophie du truc mais une deuxième, voire une troisième, seront certainement nécessaires.
Pour m'éviter une perte de temps en interprétation, faut-il effacer les combinaisons "pauvres" lors des itérations successives ?

As-tu testé la macro de tri des combinaisons dans ton fil dédié à cette question
Pas la peine : marche pas...

Je n'aurai plus le temps de me pencher sur ta demande avant demain en soirée : si tu as d'autres trucs et astuces...

A+

J'ai trouvé l'erreur, plutôt l"ânerie, qui produisait les coquilles.

iOK = IIf(CInt(tTab(x, y)) = iMax, iTime + 1, 1)

C'est mieux d'initialiser iOK avec la variable de duplication iTime qu'avec la variable iMax contenant la valeur maximum du tableau !

A+

Salut Curulis57,

J'ai vu passer ta macro de tri, je vais la tester de ce pas ! (je bidouillais des trucs sur mon Excel).

Edit : bien reçu ta modif' le temps que je l'écrive. Pas de problème j'attendrai :) En gros il faut exactement qu'elle fasse ce qui déclenche le clic sur :

Sinon pour le message suivant :

J'ai trouvé l'erreur, plutôt l"ânerie, qui produisait les coquilles.

iOK = IIf(CInt(tTab(x, y)) = iMax, iTime + 1, 1)

C'est mieux d'initialiser iOK avec la variable de duplication iTime qu'avec la variable iMax contenant la valeur maximum du tableau !

==> il faut que je réalise la modification dans la macro que tu m'avais envoyée juste avant ? C'est juste une ligne à remplacer ? Comment je dois m'y prendre :D ?

Sinon, si tu as réussi à comprendre la philosophie de la génération des combinaisons, c'est super ! Comme je te disais, c'est le genre de truc qui s'explique en 15 minutes à l'oral mais qui demande bien plus de temps à expliquer par écrit. Mais l'idée c'est ça : un algorithme qui se développe d'ordre en ordre. On est sur un processus purement itératif (et encore, l'exemple trèèèès simple que je t'ai fourni m'a pris du temps :D J'imagine pas avec des n=6 et des k=6 voire plus... (même si excel serait limité).

Alors, lorsqu'on fait les itérations successives, les combinaisons pauvres doivent rester car je dois dénombrer absolument toutes les combinaisons possibles entre l'ordre 1 et l'ordre 10. Mais en effet tu finiras par avoir

A combinaisons de n(1) chiffres

B combinaisons de n(1) |n(2) chiffres

C combinaisons de n(1) |n(2) |n(3) chiffres

...

J combinaisons de n(1) | n(2) | n(3) | ... | n(10) chiffres

Bien entendu, quand je parle de "chiffres", il peut aussi y avoir des cases vides (les fameuses croix, comme dans mon exemple) ou des "10" car k peut aller jusqu'à 10 (10 est un nombre mais là je l'ai appelé chiffre quand même) ;)

Mais oui, à la fin, le tableau final qui dépendra des variables k(1), k(2), k(3), k(4), ..., k(10) et n(1), n(2), n(3), n(4), ..., n(10) doit permettre de générer toutes les combinaisons (en un seul clic ce serait merveilleux :D). Et un message d'erreur si je dépasse le nombre de lignes ou de colonnes que Excel supporte.

L'idée, c'est de pouvoir vraiment générer absolument tous les chemins possibles, donc même les plus courts doivent figurer :D

Je regarde la macro de tri et te fait un retour sur le fil dédié ;)

Merci beaucoup !

Sinon, prends le temps qu'il te faut ;) Avec toutes les aides cumulatives que j'ai reçues, je peux générer un tableau d'ordre 3 en 15 minutes, ce qui est pas mal.

L'objectif, c'est de réussir le tableau d'ordre 10 en 1 minute. Et là ce serait le pied :D

A+ :D

G.H