Générateur de phrases unique

[TBM]

Bonjour tout le monde!

Premièrement si vous êtes en train de lire ceci, merci de prendre de votre temps pour m'aider!

Je suis en train (d'essayer) de programmer un "spinner" et je m'arrache les cheveux depuis plusieurs jours au point où j'ai même de la difficulté à dormir tellement cette "simple" routine me hante.

C'est un problème d'analyse combinatoire et selon moi il doit y avoir plusieurs solutions à ce projet (comme c'est souvent le cas avec Labview me direz-vous), laissez moi vous donner un exemple de la routine que j'utilise. Je suis peut-être partis dans la mauvaise direction dès le départ, à ce moment je vous serez super reconnaissant de mettre la doigt là où je me trompe.

Voici la phrase d'input :

Hey [bonjour, salut, hey, yo] Laurent! [Comment vas-tu, Sa va, Wassup]? Le [chien, chat, oiseau, rat, cheval, maringouin] [bleu, vert, rouge, jaune] à Jacques est mort!

Mon programme analyse la phrase, détermine qu'il y a 4 variables et 4*3*6*4 possibilités, soit 288 phrases unique possible.

Le programme construit ensuite 2 array, le premier contient les constantes (Hey, Laurent!, ? Le, à Jacques est mort) et le deuxièmes les variables (Bonjour, salut, hey, yo | Comment vas-tu, etc.).

Je fais ensuite une première étape de reconstruction qui résulte en un array 2D du genre :

[Hey bonjour | Hey salut | Hey hey | Hey yo]
[Laurent! Comment vas-tu | Laurent! Sa va | Laurent! Wassup]

[? Le chien | ? Le chat | ? Le oiseau | ? Le rat | ? Le cheval | ? Le maringouin]

[bleu | vert | rouge| jaune]

Ensuite j'utilise un système de pointeurs XY que j'incrémente par itération pour créer les phrases, et là c'est le bordel car je veux que le truc marche même s'il y a 200 variables avec chacune un nombre de possibilités différente. Le pointeur Y représente la variable à analyser (la ligne) et le pointeur en X représente quelle possibilité de cette variable choisir (la colonne). Sur le principe c'est simple, j'initialise un array de nombre entier de longueur égal au nombre de variables (dans ce cas présent, 4), le tout dans une boucle while. Ce nouvel array, je l'ai appellé "Mémoire PX", car c'est lui qui mémorise le pointeur X de chaque variable. Chaque tour de boucle représente un troncon d'une phrase unique, cette boucle devra donc s'executer 288 fois (nombre de phrase unique) fois 4 variables (4 tronçon de phrase).

Cependant, impossible (du moins je n'y suis pas encore arrivé) d'obtenir la bonne séquence pour "Mémoire PX". La séquence ressemble beaucoup à un compteur binaire, excepté que chaque bit peut prendre une valeur entre 0 et le nombre de possibilités de chaque variable. Dans ce cas présent, la séquence de "mémoire PX" devrait être

[0,0,0,0] = Hey Bonjour Laurent! Comment vas-tu? Le chien bleu à Jacques est mort (cette partie provient de la dernière ligne du premier array généré)

[0,0,0,1] = Hey Bonjour Laurent! Comment vas-tu? Le chien vert à Jacques est mort

[0,0,0,2] = Hey Bonjour Laurent! Comment vas-tu? Le chien rouge à Jacques est mort

[0,0,0,3] = Hey Bonjour Laurent! Comment vas-tu? Le chien jaune à Jacques est mort

[0,0,1,0] = Hey Bonjour Laurent! Comment vas-tu? Le chat bleu à Jacques est mort

[0,0,1,1] = Hey Bonjour Laurent! Comment vas-tu? Le chat vert à Jacques est mort

[0,0,1,2] = Hey Bonjour Laurent! Comment vas-tu? Le chat rouge à Jacques est mort

[0,0,1,3] = Hey Bonjour Laurent! Comment vas-tu? Le chat jaune à Jacques est mort

[0,0,2,0] = Hey Bonjour Laurent! Comment vas-tu? Le oiseau bleu à Jacques est mort

etc...

Voilà donc à priori c'est très simple et je me sens limite mal à l'aise de venir chercher de l'aide ici, mais comme je vous dis cela fait bientôt une semaine que je suis là-dessus et ça commence à perturber mon sommeil (oui je sais je devrais peut-être allez me faire soigner lol). Ce serait peut-être trop demander d'avoir le bout de code tout cuit qui irait m'incrémenter la mémoire, mais il y a peut-être une logique à laquelle je n'ai pas pensé, qui est toute bête et qui me permettrait de faire ce que je veux (des fois on se complique la vie alors qu'il y a un truc très simple qui fait ce qu'on se casse la tête à essayer de faire).

Je vous ai joint ce que j'ai fait jusqu'à présent. Bonne chance pour vous y retrouver dans le bordel, je n'ai vraiment pas l'habitude de coder ainsi, vous en témoignerai par la partie supérieure gauche qui elle, est très propre. J'ai rajouter des annotations qui devrait vous permettre de vous y retrouver facilement.

Cordialement,

Bastien

[MikhailK]

Bonjour Bastien,

J'ai crée un exemple simple qui offre un autre approche pour résoudre votre problème (au lieu d'utiliser des pointeurs XY).

Regardez-le. Pour l'instant ca marche avec 4 variables, mais avec plus d'effort c'est possible de le généraliser (en utilisant un boucle for dans un boucle while et quelques shift-registers ).

Pour couvrir tout 288 possibilités ce exemple utilise un array qui contiens quatre compteur (Modulo-4, Modulo-3, Modulo-6, Modulo-4).

Le « modulus » de chaque compteur correspond à nombre des valeurs dans chaque variable. Par example, le compteur Modulo-6 couvre le variable avec des valeurs: [? [Le chien | ? Le chat | ? Le oiseau | ? Le rat | ? Le cheval | ? Le maringouin]

[TBM]

Bonjour Mikhail,

Merci beaucoup pour votre aide! Cependant, je suis dans l'impossibilité d'ouvrir le fichier que vous avez fournis puisqu'il a été créé dans une version de LabVIEW plus récente que celle que j'utilise (je tourne sur LabVIEW 2010).

Serait-il possible de renvoyer un fichier que je puisse ouvrir?

Merci encore!

Cordialement,

Bastien

[MikhailK · Accepted solution]

Bonjour Bastien,

Voici le fichier pour LabVIEW 2010.

[TBM]

Après avoir bidouiller un peu votre solution, entre autre en jouant avec les registres à décalage, j'ai pu rendre la solution hautement adaptable (testé avec plus de 10 variables pour un total de plus de 35,000 phrases unique) et le tout marche à merveille!

Merci beaucoup pour votre aide, j'aime l'élégance de votre solution dans sa simplicité. Il est probable que ce ne soit pas la manière la plus efficace de faire la "reconstruction" des phrases (je pense entre autre à l'utilisation du VI Division avec Reste) mais cela me permet au moins de continuer de développer mon logiciel. Lorsqu'il y a moins de 10,000 possibilités l'éxecution est très rapide, c'est au dessus de 25,000 que l'ordinateur commence à ramer (les divisions prennent des proportion énorme, par exemple dans mon test j'avait 9 variables totalisant 36288 possibilités, sachant que pour faire une phrase il faut faire le tour des 9 variables, on se retrouve avec des divisions allant jusqu'à 36,288*9 soit grosso-modo 360,000).

Ceci étant dit, merci encore de votre aide!

Cordialement,

TBM