[résolu] Comment générer des séries de 40 lettres

temps · Le 14/04/2014, à 00:54

Bonjour,
Je cherche à créer un code qui génère toutes les combinaisons possibles sur des séries de 40 lettres en utilisant 4 lettres (ABCD)
en exemple ligne 1 : 40 fois le A
ligne 2 39 fois le A plus une fois le B
...

Est-ce que quelqu'un a une idée de comment aborder ce problème ?

Cordialement

Dernière modification par temps (Le 18/04/2014, à 15:26)

claudius01 · Le 14/04/2014, à 10:12

Bonjour,

Ton problème est équivalent à la conversion d'un nombre entier en base 4 ou Système quaternaire puis remplacer les chiffres 0, 1, 2 et 3 respectivement par A, B, C et D.
Exemples en utilisant bc et en indiquant la substitution:

$ bc
obase=4
123456
132021000 => BDCACBAAA

999999
3310020333 => DDBAACADDD

Maintenant, considérer des séries de 40 lettres revient à faire toutes les conversions des nombres décimaux compris entre 0 et 1208925819614629174706175 ;-)
Car, toujours en utilsant bc (40 lettres 'D' => 40 chiffres '3' correspondant au plus grand nombre à convertir):

$ bc
ibase=4
3333333333333333333333333333333333333333
1208925819614629174706175

Edit: Commandes en ligne complète:

$ echo "obase=4; 123456" | bc | sed 's/0/A/g' | sed 's/1/B/g' | sed 's/2/C/g' | sed 's/3/D/g'
BDCACBAAA

$ echo "obase=4; 1208925819614629174706175" | bc | sed 's/0/A/g' | sed 's/1/B/g' | sed 's/2/C/g' | sed 's/3/D/g'
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD

Cordialement, A+
--
Claudius

Dernière modification par claudius01 (Le 14/04/2014, à 10:38)

pingouinux · Le 14/04/2014, à 10:41

Bonjour,
J'espère que tu n'es pas pressé, car le nombre de combinaisons possibles, comme l'indique claudius01, est très élevé (4**40=2**80). Même en en générant 1 milliard par seconde, il te faudra environ 38 millions d'années pour les générer toutes, et 48000 milliards de disques durs de 1To pour les stocker.

claudius01 · Le 14/04/2014, à 11:32

Effectivement, c'est à ces moments là que l'on découvre que l'on est à l'aube de l'informatique pour appréhender avec la force brute un problème d'algorithmique qui, somme toute, est relativement simple et borné...

Ce qui m'inquiète dans ces très grands nombres évoqués par pingouinux, indépendamment du temps, c'est le nombres d'atomes que va nécessiter cette tâche car avec tous les µ-processeurs, mémoires et autres disque durs que l'homme est en train de fabriquer pour satisfaire sa soif technologique, il n'y en n'aura bientôt plus sur Terre (cf. Combien y a-t-il d'atomes dans l'Univers ? ;-)

Par conséquent, cher temps, lorsque tu lanceras la génération, tu nous préviens ... Merci par avance ;-))

temps · Le 14/04/2014, à 12:55

Merci pour les réponses.
Je vais donc diminuer le nombre de caractères par ligne pour passer à 10
De plus maintenant que le sujet possède une première approche, je m’aperçois que par rapport à celle-ci, il manque une information importante quand à la lecture de ces lignes de caractères.
En fait les lignes générées vont être lu avec un outil qui va lui indiquer combien de caractères par ligne il faut lire ; et un autre outil qui va lui dire combien de fois il doit aller lire la série de caractères.
De fait une série de lettre identique pourra s'écrire la lecture d'une seule lettre fois 40, et de fait toute combinaison non première ne serait qu'un doublon.
Ou bien même pour une série de 39 lettre identique et un lettre différente ce sera une série de 1 +39 auquel on ajoute une série de 1 car le lecteur ne se pilote qu'avec 14 octets.

Pour résumer avant de partir dans les considérations de grands nombres bien que le sujet soit passionnant, le problème ici à résoudre revient à trouver un équilibre entre une application lectrice de 14 octets et une générateur de combinaisons premières de 4 cas

Le problème rencontré ici, n'est pas un problème d'algo, il n'y a pas d'algèbre, c'est un problème d'adressage, et d'équilibre entre les différentes formes d'adressage.

Cordialement

Dernière modification par temps (Le 14/04/2014, à 13:16)

pingouinux · Le 14/04/2014, à 13:06

claudius01 #2 a écrit :

$ echo "obase=4; 123456" | bc | sed 's/0/A/g' | sed 's/1/B/g' | sed 's/2/C/g' | sed 's/3/D/g'

BDCACBAAA

Pour info, tu peux simplifier la commande

$ echo "obase=4; 123456" | bc | tr "0123" "ABCD"
BDCACBAAA

temps · Le 14/04/2014, à 13:26

Je pense que la première chose à identifier est de savoir si c'est bien nécessaire d'utiliser des lignes de 10 caractères.
En d'autres mots, à quel moment il vaut mieux lancer la lecture des 14 octets pour aborder la lecture d'une série première de lettres.

Car pour que la solution génératrice soit pratique, il faut qu'elle soit le plus simple d'utilisation et en fait peut être que la meilleure solution serait de se contenter de créer des lignes de 4 , avec les 4 cas contenant toutes les formes premières, le reste ne serait que répétitions ou appel à la lecture d'une autre forme première sous 14 octets ?

Si nous arrivons à répondre à cette question je pense que nous pouvons commencer à chercher les codes pour la réaliser l'objectif.

Cordialement

Dernière modification par temps (Le 14/04/2014, à 13:27)

claudius01 · Le 14/04/2014, à 14:15

@pingouinux: Merci pour cette amélioration (je ne pense jamais à tr ;-)
@temps: Exemples et cas d'utilisation concis car je ne comprends pas l'expression des besoins ni des définitions comme formes premières ;-(

temps · Le 14/04/2014, à 17:30

Bonjour,

claudius01 a écrit :

@temps: Exemples et cas d'utilisation concis car je ne comprends pas l'expression des besoins ni des définitions comme formes premières ;-(

Afin d'éclaicir le cas, je vais donner plus de détails et aussi essayer de clarifier ma pensée.

L'environement est la BAUL qui construit une infinité de Go de fichiers audio piloté par 14 octets.

Dans un des mécanismes de la BAUL, j'utilise une fichiers texte constitué de séries de formes.
Les deux derniers octets (des 14) qui pilotent la BAUL servent pour le premier à dire combien de caractères sont lus, pour le second combien de fois la série de caractère est lu.

Quand j'ai utilisé les termes "formes premières" je les entendais comme une analogie à nombres premier, (quelques choses qui ne peut être reconstitué à l'aide d'autres formes de bases).

Quand je parle de mettre en équilibre, je respecte la logique des arts et sciences (CNAM) toujours agir en fonction du poids et de la mesure. D'ou la question sur le nombre de caractères par ligne par rapport à une nouvelle action qui ne pèse que 14 octets.

Cordialement

temps · Le 14/04/2014, à 21:19

Bonjour,
Je vais essayer d'expliquer par l'exemple :
soit une ligne de forme :
aabccbdd...
je veux lire une ligne de la forme
aabaabaab
je vais pouvoir utiliser la première ligne indiquée en donnant la valeur 3 au treizième octet pour dire qu'il faut lire que trois caractère de la ligne,
et la valeur 3 au quatorzième octet pour dire qui faut répéter la lecture de la ligne 3 fois.

autre exemple,
je veux la ligne :
bababababa

il me suffit de trouver une ligne de forme première commençant par ba et de donner la valeur 2 au treizième octet et la valeur de 5 au dernier octet

autre cas :
je veux la forme
abcddcddcddcddcd
je vais lire en premier une forme première commençant par abcd
ensuite je vais chercher une forme première commençant par dcd que je fais répéter avec le quatorzième octet

Ce qui intéresse dans la démarche, c'est de trouver la forme d'écriture la plus simple pour marier les différentes formes, tout en gardant tous les choix accessibles facilement.

lire les formes une à une serait un absolue bien lourd, écrire tous cas de lignes possibles serait un absolue bien contraignant, entre les deux nous apparaît les cas les plus simples qui permettent de percevoir et donc comprendre et par effet manipuler facilement toutes les méta associations facilement.

Cordialement

Dernière modification par temps (Le 14/04/2014, à 21:31)

temps · Le 18/04/2014, à 15:26

Bonjour,
Je poste en résolu.
le code pour donner les différentes formes sur 4 cas avec des ligne de 40 caractères a été donné.
Pour ceux qui n'ont pas vu la solution, plus en détail, cela donne 24 lignes représentants les 24 alignements possibles des cas les un par rapport aux autres
ABCD
ABDC
ACBD
ACDB
ADCB
ADBC
puis id en commençant par les 3 autres lettres soit 24 lignes
Ensuite la gestion des formes finales créant les 40 caractères ou même plus se fait à l'aide de l'application qui va dire combien il faut prendre de caractères et combien de fois il faut boucler la ligne de caractères.
En cas de forme première, c'est une nouvelle demande de lecture 14 octets qui est créée.
Pour éviter d'éventuels appels il est possible de développer d'autres lignes sur cette forme puisque les fichiers textes sont prévus pour 256 lignes.

Cordialement

Ubuntu-fr

Navigation

Liens de recherche

Annonce

#1 Le 14/04/2014, à 00:54

[résolu] Comment générer des séries de 40 lettres

#2 Le 14/04/2014, à 10:12

Re : [résolu] Comment générer des séries de 40 lettres

#3 Le 14/04/2014, à 10:41

Re : [résolu] Comment générer des séries de 40 lettres

#4 Le 14/04/2014, à 11:32

Re : [résolu] Comment générer des séries de 40 lettres

#5 Le 14/04/2014, à 12:55

Re : [résolu] Comment générer des séries de 40 lettres

#6 Le 14/04/2014, à 13:06

Re : [résolu] Comment générer des séries de 40 lettres

#7 Le 14/04/2014, à 13:26

Re : [résolu] Comment générer des séries de 40 lettres

#8 Le 14/04/2014, à 14:15

Re : [résolu] Comment générer des séries de 40 lettres

#9 Le 14/04/2014, à 17:30

Re : [résolu] Comment générer des séries de 40 lettres

#10 Le 14/04/2014, à 21:19

Re : [résolu] Comment générer des séries de 40 lettres

#11 Le 18/04/2014, à 15:26

Re : [résolu] Comment générer des séries de 40 lettres

Pied de page des forums