cryptarithme

Version imprimable

25/03/2022, 13h15
Ksquare

cryptarithme

bonjour, je travaille actuellement sur un projet de cryptarithme en C. Mon programme est divisé en trois parties qui sont l'arbre binaire, l'arrangement et la cryptarithme. j'ai déjà effectué les deux premiers mais j'ai des difficultés pour écrire le fichier c de la cryptarithme. Besoin d'aide s'il vous plaît.
29/03/2022, 12h19
Sve@r

Bonjour
Ta formulation est un peu vague. C'est quoi un "projet de cryptarythme" ? Le programme propose l'équation et attend la réponse ? Le programme reçoit l'équation et trouve la réponse ?

Et puis "aide" ne signifie pas "écrire ton code". Montre déjà ce que tu as fait...
31/03/2022, 07h06
Ksquare

Bonjour,
voici ce que le programme doit faire:
UN*(UN+UN+UN)=TROIS
I->8 N->9 O->2 R->4 S->3 T->1 U->6
I->0 N->4 O->5 R->6 S->8 T->2 U->9

Pour pourvoir réalisé le programme j'ai besoin d'utilisé un arbre syntaxique, une itération d'arrangements et la recharche exhaustive. J'ai pu réalisé les deux premiers mais pour la recherche exhaustive je ne sais pas comment m'y prendre

Citation:

Envoyé par Ksquare

mais pour la recherche exhaustive je ne sais pas comment m'y prendre

Code:

1
2
3
4
5
6
7
8
9
10
11
12
#!/usr/bin/env python3
# coding: utf-8
 
import itertools
def cherche(lettres):
	for x in itertools.combinations_with_replacement("0123456789", len(set(lettres))):
		if len(set(x)) != len(x): continue
		yield dict(zip(lettres, map(int, x)))
	# for
# cherche()
 
for c in cherche("UNTROIS"): print(c)

31/03/2022, 10h30
Ksquare

Merci Sve@r pour ta réponse. J'aimerais comprendre ce que fait ton code car je ne m'y connais pas en python. C'est vrai que la faute me revient car j'ai pas précisé le langage utilisé.

Citation:

Envoyé par Ksquare

Merci Sve@r pour ta réponse. J'aimerais comprendre ce que fait ton code car je ne m'y connais pas en python. C'est vrai que la faute me revient car j'ai pas précisé le langage utilisé.

Oh zut, désolé, je me croyais dans le forum Python où je suis le plus souvent... Pffff faire ça en C ça va vraiment être galère. T'es sûr de pas vouloir le faire en Python?

Sinon ce que fait mon code: il utilise un outil de Python nommé itertools contenant différentes fonctions de dénombrement en tout genre dont notemment "combination_with_replacement" qui génère tous les dénombrements croissant de n éléments (par exemple pour "ABCD" par 2 ça donnera AA, AB, AC, AD, BB, BC, BD, CC, CD et DD).
La ligne len(set(x)) != len(x) permet d'éliminer les éléments contenant ne serait-ce qu'un seul dupliqué (AA, BB, CC et CD) (set(x) donne tous les x sans doublons donc si len(set(x)) != len(x) c'est qu'il y a doublon dans x).
Et l'instruction yield permet à une fonction de retourner une valeur tout en conservant sa position => quand on revient dans la fonction, on repart de là et non pas du début => il n'y a pas d'équivalent en C.
Et enfin un dictionnaire (dict()) c'est comme un tableau sauf que les éléments ne sont pas indicés par un rang mais indexés par ce que l'on veut (un mot, une lettre, un objet, etc). Ca me permet d'associer donc une lettre et une valeur. Pareil, en C ça n'existe pas.

Voilà ce que ça sort pour "UNTROIS"

Code:

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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 4, 'I': 5, 'S': 6}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 4, 'I': 5, 'S': 7}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 4, 'I': 5, 'S': 8}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 4, 'I': 5, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 4, 'I': 6, 'S': 7}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 4, 'I': 6, 'S': 8}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 4, 'I': 6, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 4, 'I': 7, 'S': 8}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 4, 'I': 7, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 4, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 5, 'I': 6, 'S': 7}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 5, 'I': 6, 'S': 8}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 5, 'I': 6, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 5, 'I': 7, 'S': 8}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 5, 'I': 7, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 5, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 6, 'I': 7, 'S': 8}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 6, 'I': 7, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 6, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 3, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 4, 'O': 5, 'I': 6, 'S': 7}
{'U': 0, 'N': 1, 'T': 2, 'R': 4, 'O': 5, 'I': 6, 'S': 8}
{'U': 0, 'N': 1, 'T': 2, 'R': 4, 'O': 5, 'I': 6, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 4, 'O': 5, 'I': 7, 'S': 8}
{'U': 0, 'N': 1, 'T': 2, 'R': 4, 'O': 5, 'I': 7, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 4, 'O': 5, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 4, 'O': 6, 'I': 7, 'S': 8}
{'U': 0, 'N': 1, 'T': 2, 'R': 4, 'O': 6, 'I': 7, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 4, 'O': 6, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 4, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 5, 'O': 6, 'I': 7, 'S': 8}
{'U': 0, 'N': 1, 'T': 2, 'R': 5, 'O': 6, 'I': 7, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 5, 'O': 6, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 5, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 2, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 3, 'R': 4, 'O': 5, 'I': 6, 'S': 7}
{'U': 0, 'N': 1, 'T': 3, 'R': 4, 'O': 5, 'I': 6, 'S': 8}
{'U': 0, 'N': 1, 'T': 3, 'R': 4, 'O': 5, 'I': 6, 'S': 9}
{'U': 0, 'N': 1, 'T': 3, 'R': 4, 'O': 5, 'I': 7, 'S': 8}
{'U': 0, 'N': 1, 'T': 3, 'R': 4, 'O': 5, 'I': 7, 'S': 9}
{'U': 0, 'N': 1, 'T': 3, 'R': 4, 'O': 5, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 3, 'R': 4, 'O': 6, 'I': 7, 'S': 8}
{'U': 0, 'N': 1, 'T': 3, 'R': 4, 'O': 6, 'I': 7, 'S': 9}
{'U': 0, 'N': 1, 'T': 3, 'R': 4, 'O': 6, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 3, 'R': 4, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 3, 'R': 5, 'O': 6, 'I': 7, 'S': 8}
{'U': 0, 'N': 1, 'T': 3, 'R': 5, 'O': 6, 'I': 7, 'S': 9}
{'U': 0, 'N': 1, 'T': 3, 'R': 5, 'O': 6, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 3, 'R': 5, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 3, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 4, 'R': 5, 'O': 6, 'I': 7, 'S': 8}
{'U': 0, 'N': 1, 'T': 4, 'R': 5, 'O': 6, 'I': 7, 'S': 9}
{'U': 0, 'N': 1, 'T': 4, 'R': 5, 'O': 6, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 4, 'R': 5, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 4, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 1, 'T': 5, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 2, 'T': 3, 'R': 4, 'O': 5, 'I': 6, 'S': 7}
{'U': 0, 'N': 2, 'T': 3, 'R': 4, 'O': 5, 'I': 6, 'S': 8}
{'U': 0, 'N': 2, 'T': 3, 'R': 4, 'O': 5, 'I': 6, 'S': 9}
{'U': 0, 'N': 2, 'T': 3, 'R': 4, 'O': 5, 'I': 7, 'S': 8}
{'U': 0, 'N': 2, 'T': 3, 'R': 4, 'O': 5, 'I': 7, 'S': 9}
{'U': 0, 'N': 2, 'T': 3, 'R': 4, 'O': 5, 'I': 8, 'S': 9}
{'U': 0, 'N': 2, 'T': 3, 'R': 4, 'O': 6, 'I': 7, 'S': 8}
{'U': 0, 'N': 2, 'T': 3, 'R': 4, 'O': 6, 'I': 7, 'S': 9}
{'U': 0, 'N': 2, 'T': 3, 'R': 4, 'O': 6, 'I': 8, 'S': 9}
{'U': 0, 'N': 2, 'T': 3, 'R': 4, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 2, 'T': 3, 'R': 5, 'O': 6, 'I': 7, 'S': 8}
{'U': 0, 'N': 2, 'T': 3, 'R': 5, 'O': 6, 'I': 7, 'S': 9}
{'U': 0, 'N': 2, 'T': 3, 'R': 5, 'O': 6, 'I': 8, 'S': 9}
{'U': 0, 'N': 2, 'T': 3, 'R': 5, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 2, 'T': 3, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 2, 'T': 4, 'R': 5, 'O': 6, 'I': 7, 'S': 8}
{'U': 0, 'N': 2, 'T': 4, 'R': 5, 'O': 6, 'I': 7, 'S': 9}
{'U': 0, 'N': 2, 'T': 4, 'R': 5, 'O': 6, 'I': 8, 'S': 9}
{'U': 0, 'N': 2, 'T': 4, 'R': 5, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 2, 'T': 4, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 2, 'T': 5, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 3, 'T': 4, 'R': 5, 'O': 6, 'I': 7, 'S': 8}
{'U': 0, 'N': 3, 'T': 4, 'R': 5, 'O': 6, 'I': 7, 'S': 9}
{'U': 0, 'N': 3, 'T': 4, 'R': 5, 'O': 6, 'I': 8, 'S': 9}
{'U': 0, 'N': 3, 'T': 4, 'R': 5, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 3, 'T': 4, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 3, 'T': 5, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 0, 'N': 4, 'T': 5, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 1, 'N': 2, 'T': 3, 'R': 4, 'O': 5, 'I': 6, 'S': 7}
{'U': 1, 'N': 2, 'T': 3, 'R': 4, 'O': 5, 'I': 6, 'S': 8}
{'U': 1, 'N': 2, 'T': 3, 'R': 4, 'O': 5, 'I': 6, 'S': 9}
{'U': 1, 'N': 2, 'T': 3, 'R': 4, 'O': 5, 'I': 7, 'S': 8}
{'U': 1, 'N': 2, 'T': 3, 'R': 4, 'O': 5, 'I': 7, 'S': 9}
{'U': 1, 'N': 2, 'T': 3, 'R': 4, 'O': 5, 'I': 8, 'S': 9}
{'U': 1, 'N': 2, 'T': 3, 'R': 4, 'O': 6, 'I': 7, 'S': 8}
{'U': 1, 'N': 2, 'T': 3, 'R': 4, 'O': 6, 'I': 7, 'S': 9}
{'U': 1, 'N': 2, 'T': 3, 'R': 4, 'O': 6, 'I': 8, 'S': 9}
{'U': 1, 'N': 2, 'T': 3, 'R': 4, 'O': 7, 'I': 8, 'S': 9}
{'U': 1, 'N': 2, 'T': 3, 'R': 5, 'O': 6, 'I': 7, 'S': 8}
{'U': 1, 'N': 2, 'T': 3, 'R': 5, 'O': 6, 'I': 7, 'S': 9}
{'U': 1, 'N': 2, 'T': 3, 'R': 5, 'O': 6, 'I': 8, 'S': 9}
{'U': 1, 'N': 2, 'T': 3, 'R': 5, 'O': 7, 'I': 8, 'S': 9}
{'U': 1, 'N': 2, 'T': 3, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 1, 'N': 2, 'T': 4, 'R': 5, 'O': 6, 'I': 7, 'S': 8}
{'U': 1, 'N': 2, 'T': 4, 'R': 5, 'O': 6, 'I': 7, 'S': 9}
{'U': 1, 'N': 2, 'T': 4, 'R': 5, 'O': 6, 'I': 8, 'S': 9}
{'U': 1, 'N': 2, 'T': 4, 'R': 5, 'O': 7, 'I': 8, 'S': 9}
{'U': 1, 'N': 2, 'T': 4, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 1, 'N': 2, 'T': 5, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 1, 'N': 3, 'T': 4, 'R': 5, 'O': 6, 'I': 7, 'S': 8}
{'U': 1, 'N': 3, 'T': 4, 'R': 5, 'O': 6, 'I': 7, 'S': 9}
{'U': 1, 'N': 3, 'T': 4, 'R': 5, 'O': 6, 'I': 8, 'S': 9}
{'U': 1, 'N': 3, 'T': 4, 'R': 5, 'O': 7, 'I': 8, 'S': 9}
{'U': 1, 'N': 3, 'T': 4, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 1, 'N': 3, 'T': 5, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 1, 'N': 4, 'T': 5, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 2, 'N': 3, 'T': 4, 'R': 5, 'O': 6, 'I': 7, 'S': 8}
{'U': 2, 'N': 3, 'T': 4, 'R': 5, 'O': 6, 'I': 7, 'S': 9}
{'U': 2, 'N': 3, 'T': 4, 'R': 5, 'O': 6, 'I': 8, 'S': 9}
{'U': 2, 'N': 3, 'T': 4, 'R': 5, 'O': 7, 'I': 8, 'S': 9}
{'U': 2, 'N': 3, 'T': 4, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 2, 'N': 3, 'T': 5, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 2, 'N': 4, 'T': 5, 'R': 6, 'O': 7, 'I': 8, 'S': 9}
{'U': 3, 'N': 4, 'T': 5, 'R': 6, 'O': 7, 'I': 8, 'S': 9}

31/03/2022, 14h14
Ksquare

je peux pas le faire en python. C'est pas un langage que je connais et j'ai pas le logiciel pour celà. Cette année en licence on fait de la programmation en c.

j'ai essayé de mon côté pour la resolution la cryptarithme SEND+MORE = MONEY j'ai des erreurs.

Code:

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
 
include <stdio.h>
#include <string.h>
#include<C:\Users\intel\OneDrive\Bureau\Tchoubat_Kouontchou\Tchoubat_Kouontchou\arrangement.h>
 
int main () {
    /* resolution de la cryptarithme SEND+MORE=MONEY
    les lettres distinctes de cette cryptarithme sont SENDMORY*/
   char str[50];
   int len;
 
   strcpy(str, "SENDMORY");// copie des lettres distinctes dans le tableau de caractère str
 
   len = strlen(str);//taille de str
   printf("Length of |%s| is |%d|\n", str, len);
 
   ar_iter_t *it=CreateArIterator(len, 10);
    for(;;)
    {
        PrintArrangement(stdout, it);
        if(SetNextArIterator(it)) break;
    }
 
    for(int i = 1; i<=len;i++){
        printf("%c = %d ", str[i], it);
    }
 
 
   return(0);
}

et voici le code de l'arrangement

Code:

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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
 
#include<stdio.h>
#include<stdlib.h>
#include"arrangement.h"
 
 
ar_iter_t *CreateArIterator(unsigned int n, unsigned int k)
{
 
    if(n<k)
        return 0;
    ar_iter_t *obj=(ar_iter_t*)malloc(sizeof(ar_iter_t));
    obj->pl = (unsigned int *)malloc(sizeof(unsigned int)*k);//allocation dynamique de mémoire
    obj->el = (int*)malloc(sizeof(int)*n);
    obj->k=k;
    obj->n=n;
    ResetArIterator(obj);
    return obj;
}
 
void ResetArIterator(ar_iter_t *it)
{
    /*réinitialisation de l'itérateur d'arrangements
        en initialisant pl et el*/
 
    unsigned int j,i;
 
    for(i=0; i<= it->k-1; i++)
    {
        it->pl[i]= it->k-i-1;
    }
 
 
    for(j=0; j<=it->n-1; j++)
    {
        if(j<=it->k-1)
            it->el[j]= it->k-i-1;//remplir les cases d'indice équivalent avec les éléments de pl
        else
            it->el[j]= -1;//remplir les cases restantes par -1 si indice de el supérieur à celui de pl
    }
 
 
}
void DestroyArIterator(ar_iter_t *it)
{
    free(it->el);
    free(it->pl);
    free(it);
 
}
 
void PrintArrangement(FILE *out, ar_iter_t *it)
{
 
    unsigned int i;
    for(i=0; i<it->k; i++)
    {
        fprintf(out,"%u ", it->pl[i]);
 
    }
    fprintf(out,"\n");
}
 
int SetNextArIterator(ar_iter_t *it)
{
 
    int p,j;
    int i = 0;
    //vérification de si i est déplaçable
    for(;;)/*boucle sans fin*/{
        p=it->pl[i];//p reçoit un élément de la table pl
        for(;;){
            p=p+1;
            if(p>=it->n){
                break;
            }
            if(it->el[p]<i){
                break;
            }// si c'est le cas on sort du deuxième for(;;) et on retourne à la ligne 70
        }
        if(p>=it->n){
            //i est non déplaçable
            i=i+1;
            if(i<it->k)/*on revient à la ligne 70*/{
                continue;
            }else{
                return -1;
            }
        }
        break;//on sort de la boucle for(;;) primaire
    }
 
    //on déplace i
    for(j=0;j<it->n;j++){
        if(it->el[j]<=i)
            it->el[j]=-1;
    }
    it->pl[i]=p;
    it->el[p]=i;
 
 
    //ranger par ordre croissant
    for(j=i-1;j>=0;j--)/*pour un i=0 on entre pas dans la boucle*/{
        for(int k=0;k<it->n;k++){
            if(it->el[k]<j){
                it->el[k]=j;
                it->pl[j]=k;
                break;
            }
        }
    }
    return 0;
}

je commence par créer une liste des lettres distinctes de la cryptarithme ensuite je veux parcourir les arrangements tous les arrangements, calculer les valeurs numériques correspondantes et évaluer le cryptarithme, si l'entité est valide et enfin affiché la solution correspondante malheureusement j'ai aucun résultat et j'ai des erreurs du genre "undefined reference".

J'ai écrit un code qui peut générer toutes les combinaisons de 0 à 9 pour n chiffres (n ne pouvant bien évidemment pas dépasser 10 puisque les chiffres vont de 0 à 9).
Ce code ne génère que les combinaisons ayant toutes des chiffres différents.

Code:

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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define SZ_ALLOC			(1000)
 
typedef struct {
	unsigned short **tab;
	size_t lig;
	size_t col;
	size_t sz_alloc;
} t_total;
 
// Vérification si le tableau de nombre ne contient que des nombres différents
void *isUniq(unsigned short *tab, size_t col) {
	for (size_t i=0; i < col; i++) {
		for (size_t j=i+1; j < col; j++)
			if (tab[i] == tab[j]) return NULL;
	}
	return tab;
}
 
void totalFree(t_total *total, size_t n) {
	for (size_t i=0; i < n; i++) free(total->tab[i]);
	free(total->tab);
}
 
void totalAffich(t_total *total) {
	for (size_t i=0; i < total->lig; i++) {
		printf("total[%lu/%lu]=", i, total->lig);
		for (size_t j=total->col; j > 0; j--)
			printf("%hu ", total->tab[i][j-1]);
		printf("(%lu)\n", total->col);
	}
	printf("sz=%lu(%lu)\n", total->lig, total->sz_alloc);
}
 
void *totalCreate(t_total *total, size_t n) {
	// Création zone de travail à 0
	unsigned short *work=calloc(n, sizeof(*work));
	if (work == NULL) return NULL;
 
	// Initialisation colonnes et lignes
	total->tab=NULL;
	total->col=n;
	total->lig=0;
	total->sz_alloc=0;
 
	// Boucle de remplissage
	size_t pos=0;
	while (1) {
		// Si on n'a plus de place
		if (total->lig == total->sz_alloc) {
			// Réallocation
			total->sz_alloc+=SZ_ALLOC;
			unsigned short **tmp=realloc(total->tab, total->sz_alloc * sizeof(*total->tab));
			if (tmp == NULL) {
				totalFree(total, total->lig);
				return NULL;
			}
			total->tab=tmp;
		}
 
		// Allocation de la ligne de nombres
		total->tab[total->lig]=malloc(total->col * sizeof(**total->tab));
		if (total->tab[total->lig] == NULL) {
			totalFree(total, total->lig);
			return NULL;
		}
 
		// Boucle d'incrémentations zone de travail
		while (1) {
			// Si le nombre en cours d'incrément n'est pas à son max
			if (work[pos] < 9) {
				// On incrémente le nombre
				work[pos]++;
 
				// La position d'incrément revient au premier nombre
				pos=0;
 
				// Si la zone de travail contient des valeurs toutes différentes
				if (isUniq(work, total->col)) {
					// Boucle d'incrémentation terminée
					break;
				}
			}
			else {
				// Ici le nombre en cours est à son max => il repasse à 0
				work[pos]=0;
 
				// La position d'incrément se décale
				pos++;
 
				// Si la position d'incrément a dépassé la zone de nombres
				if (pos == total->col) {
					// Remplisage terminé
					free(work);
					return total;
				}
			}
		}
 
		// On copie la zone de travail dans la ligne
		memcpy(total->tab[total->lig], work, total->col * sizeof(**total->tab));
 
		// On a créé une ligne
		total->lig++;
	}
}
 
int main() {
	t_total total;
	totalCreate(&total, 4);
	totalAffich(&total);
	totalFree(&total, total.lig);
}

De là, tu n'as plus qu'à balayer toutes les possibilités de total.tab et pour chaque possibilité, affecter chaque chiffre à une lettre pour regarder si le cryptarithme est vérifié.

01/04/2022, 17h42
Ksquare

Merci Sve@r
01/04/2022, 18h18
Sve@r

Citation:

Envoyé par Ksquare

Merci Sve@r

Mouais. J'ai un peu rectifié entre temps. Maintenant je ne stocke que ce qui est utile (évite un malloc de 10 milliards d'adresses pour gérer les 10 chiffres)
Mais en fait, je me rends compte qu'au lieu de compter bêtement en ne prenant pas en considération les éléments inutiles (et donc calculés pour rien), j'aurais pu partir sur des permutations.
Enfin tant pis. J'ai testé dans les grosses valeurs. Pour 10 chiffres ça prend un peu de temps mais ça fonctionne.