Discussion :

[valentin03]

Les parenthèses sont dans l'expression initiale et je suis bien obligé d'en tenir compte dans l'analyse et la résolution de l'expression; en RPN les résultats intermédiaires montent dans la pile et pour simuler une pile, je dois traiter les parenthèses à part pour réintégrer le contenu dans le calcul.
La RPN n'est utilisable que pour les calculs instantanés (calculatrices)

[tbc92]

Le but est d'obtenir à partir d'une expression x=variables et opérateurs
Les expressions variable=variables et opérateurs pour toutes les variables
Je pensais fixer des valeurs à l'expression initiale pour calculer x
Puis faire toutes les combinaisons variable=variables et opérateurs
Eliminer les incohérences du genre: a=x+/b*(-)
Calculer les expressions cohérentes
Les valeurs de chaque variable restant fixes tout au long des calculs
Il me semble que quand il y a égalité l'expression est valide
Et ainsi avoir l'expression de chaque variable en fonction des autres
Il semble que je me plante dans le raisonnement mais où ?

Et on est sensé comprendre le besoin avec cette explication ????

En français, il y a un truc bien pratique, c'est la ponctuation. On met un symbole "." entre les phrases, et hop, d'un coup, un message devient plus lisible. Là, je ne sais toujours pas ce que tu veux faire. Comme Flodelarab, j'imagine que tu veux simuler le jeux 'des chiffres et des lettres', mais aucune certitude.

[valentin03]

Et on est sensé comprendre le besoin avec cette explication ????

Une seule ligne suffit à comprendre le but: "avoir l'expression de chaque variable en fonction des autres"
Et s'il faut préciser: Dans x=a+b; j'appelle a+b l'expression de x (ce qui n'est pas tout à fait correct puisque l'expression complète c'est: x=a+b)
Si quelqu'un a une autre façon de parler de la chose, je suis preneur.

[tbc92]

Donc, par exemple, à partir des nombres 3 4 8 et 20, on veut que le programme donne en sortie :
20=(8-3)*4
8=(20/4)+3
4=20/(8-3)
3=8-(20/4)
20=(8*3)-4
8=(20+4)/3
4=(8*3)-20
3=(20+4)/8

Plus peut-être encore d'autres combinaisons.

C'est ça ?
Et on veut aussi : 20=(3*8)-4 et les autres déclinaisons du même type ?

[valentin03]

Donc, par exemple, à partir des nombres 3 4 8 et 20, on veut que le programme donne en sortie :
20=(8-3)*4
8=(20/4)+3
4=20/(8-3)
3=8-(20/4)
20=(8*3)-4
8=(20+4)/3
4=(8*3)-20
3=(20+4)/8

Plus peut-être encore d'autres combinaisons.

C'est ça ?
Et on veut aussi : 20=(3*8)-4 et les autres déclinaisons du même type ?

Exactement.
La combinatoire se fera sur les lettres (20=x; 8=a; 3=b; 4=c)
Puis l'expression issue de la combinatoire (expurgée des incohérences) sera évaluée en remplaçant les lettres par leurs valeurs
Et donc je veux savoir si quand je trouve une égalité l'expression est obligatoirement valide

[tbc92]

Je ne comprends toujours pas la question.

Si le besoin c'est : on a 6 nombres , et on veut trouver toutes les frmules qui permettent de trouver l'un des nombres à partir des 5 autres, ça se fait bien.
Par exemple, à partir des nombres 2 7 13 23 33 et 41, un petit programme donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
13 = ((7*23)-((33+41)*2))
2 = (((7*23)-13)/(33+41))
7 = ((((33+41)*2)+13)/23)
23 = ((((33+41)*2)+13)/7)
7 = ((2+33)/((41-23)-13))
13 = ((41-23)-((2+33)/7))
2 = ((((41-23)-13)*7)-33)
33 = ((((41-23)-13)*7)-2)
13 = ((41-2)/((33-23)-7))
7 = ((33-23)-((41-2)/13))
2 = (41-(((33-23)-7)*13))
41 = ((((33-23)-7)*13)+2)
7 = ((2+33)/((41-13)-23))
23 = ((41-13)-((2+33)/7))
2 = ((((41-13)-23)*7)-33)
33 = ((((41-13)-23)*7)-2)
7 = ((2+33)/(41-(13+23)))
41 = (((2+33)/7)+(13+23))
2 = (((41-(13+23))*7)-33)
33 = (((41-(13+23))*7)-2)
13 = ((41-2)/((33-7)-23))
23 = ((33-7)-((41-2)/13))
2 = (41-(((33-7)-23)*13))
41 = ((((33-7)-23)*13)+2)
33 = ((((7*23)-13)/2)-41)
41 = ((((7*23)-13)/2)-33)
13 = ((41-2)/(33-(7+23)))
33 = (((41-2)/13)+(7+23))
2 = (41-((33-(7+23))*13))
41 = (((33-(7+23))*13)+2)
33 = ((7+23)+((41-2)/13))
7 = ((33-((41-2)/13))-23)
23 = ((33-((41-2)/13))-7)
7 = (33-(((41-2)/13)+23))
33 = ((((41-2)/13)+23)+7)
23 = (33-(((41-2)/13)+7))
33 = ((((41-2)/13)+7)+23)
41 = ((13+23)+((2+33)/7))
13 = ((41-((2+33)/7))-23)
23 = ((41-((2+33)/7))-13)
13 = (41-(((2+33)/7)+23))
41 = ((((2+33)/7)+23)+13)
23 = (41-(((2+33)/7)+13))
41 = ((((2+33)/7)+13)+23)

[valentin03]

Je ne comprends toujours pas la question.

Si le besoin c'est : on a 6 nombres , et on veut trouver toutes les frmules qui permettent de trouver l'un des nombres à partir des 5 autres, ça se fait bien.
Par exemple, à partir des nombres 2 7 13 23 33 et 41, un petit programme donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
13 = ((7*23)-((33+41)*2))
2 = (((7*23)-13)/(33+41))
7 = ((((33+41)*2)+13)/23)
23 = ((((33+41)*2)+13)/7)
7 = ((2+33)/((41-23)-13))
13 = ((41-23)-((2+33)/7))
2 = ((((41-23)-13)*7)-33)
33 = ((((41-23)-13)*7)-2)
13 = ((41-2)/((33-23)-7))
7 = ((33-23)-((41-2)/13))
2 = (41-(((33-23)-7)*13))
41 = ((((33-23)-7)*13)+2)
7 = ((2+33)/((41-13)-23))
23 = ((41-13)-((2+33)/7))
2 = ((((41-13)-23)*7)-33)
33 = ((((41-13)-23)*7)-2)
7 = ((2+33)/(41-(13+23)))
41 = (((2+33)/7)+(13+23))
2 = (((41-(13+23))*7)-33)
33 = (((41-(13+23))*7)-2)
13 = ((41-2)/((33-7)-23))
23 = ((33-7)-((41-2)/13))
2 = (41-(((33-7)-23)*13))
41 = ((((33-7)-23)*13)+2)
33 = ((((7*23)-13)/2)-41)
41 = ((((7*23)-13)/2)-33)
13 = ((41-2)/(33-(7+23)))
33 = (((41-2)/13)+(7+23))
2 = (41-((33-(7+23))*13))
41 = (((33-(7+23))*13)+2)
33 = ((7+23)+((41-2)/13))
7 = ((33-((41-2)/13))-23)
23 = ((33-((41-2)/13))-7)
7 = (33-(((41-2)/13)+23))
33 = ((((41-2)/13)+23)+7)
23 = (33-(((41-2)/13)+7))
33 = ((((41-2)/13)+7)+23)
41 = ((13+23)+((2+33)/7))
13 = ((41-((2+33)/7))-23)
23 = ((41-((2+33)/7))-13)
13 = (41-(((2+33)/7)+23))
41 = ((((2+33)/7)+23)+13)
23 = (41-(((2+33)/7)+13))
41 = ((((2+33)/7)+13)+23)

Wouah ! génial ! Tu le montrerais-donnerais le "petit programme" ?
Mais bon, ce n'est pas exactement ça, au départ, il n'y a que des lettres et des opérateurs.On donne des valeurs (arbitraires) aux lettres et on résout. Puis on crée toutes les combinaisons des lettres et opérateurs initiaux.On supprime les combinaisons incohérentes. On remplace les lettres par leurs valeurs et on résout. Si aucune égalités trouvées, on ajoute des opérateurs, on refait une combinatoire et on re-teste à la recherche d'égalités. Je ne sais pas le décrire plus clairement que ça, pourtant c'est bien clair pour moi.

[Flodelarab]

Tu ne sauras jamais à l'avance ce qui est incohérent ou pas car la division n'est valide que si le dividende est un multiple du diviseur.

De plus, faire ce programme toi-même est à haute valeur pédagogique.

[wiwaxia]

.. De plus, faire ce programme toi-même est à haute valeur pédagogique.

C'est bien justement ce que j'avais proposé de mettre sur pied à valentin03 (# 10, 13, 15): construire des chaînes de 13 caractères comportant 5 des six variables (a, b, c, d, e, x), les quatre signes d'opérations (+, -, *, /) et deux paires de parenthèses; la syntaxe (ou règles d'écriture, "légitimité", ... etc) étant vérifiée par une matrice de compatibilité entre deux termes successifs.

Par exemple: x = F(a, b, c, d, e) ou tout ce qu'on voudra d'autre a = F_a(b, c, d, e, x) ... puisé dans le même ensemble de symboles.
Pour obtenir au moins quelques chaînes grammaticalement correctes, par tirage pseudo-aléatoire (à défaut d'une énumération complète).
J'avais même donné pour incitation la première colonne de la matrice ... peine perdue.

J'ai abandonné faute de répondant: valentin03 a de réelles connaissances, propres à donner le change sur un forum, mais il n'écrira aucune instruction, et le débat s'enlisera dans les considérations générales, et les contestations de vocabulaire ... au risque d'exaspérer les intervenants , et à gâcher inutilement le paisible lendemain de réveillon auquel ils ont droit .

Il est possible que je me trompe complètement: si l'un d'entre vous réussit à lui mettre le pied à l'étrier, même sur un projet simplifié à l'extrême, je l'encourage sans réserve .

# Rêvons un peu: valentin03, aurais-tu par hasard rempli les douze dernières colonnes de la matrice, ou rédigé au moins un début de programme délivrant des expressions correctes de (a, b, c, d) ou (e) ?

[tbc92]

Moi , j'essaie toujours de comprendre l'objectif.

Dans un précédent message, tu m'as dit : c'est exactement ça, mais dans la suite du message, tu m'as dit en fait que ce n'était pas du tout ça.

Visiblement, à partir d'une chaîne qu'on donne au programme, le programme doit donner une certaine réponse.
A priori, en entrée, on donne une chaine de caractère de ce type : x=(a+b)*(c-d)/e, ou bien x=a*b/c*d+e, ou bien x=a*b/c*(d+e) ... ...
Et, si on donne la 1ère chaîne donnée en exemple, le programme doit renvoyer les 5 chaines suivantes :
a=x*e/(c-d)-b
b=x*e/(c-d)-a
c=x*e/(a+b)+d
d=c-x*e/(a+b)
e=(a+b)*(c-d)/x

C'est ça ?
Et le programme devrait savoir inverser toutes les formules de ce genre.

[valentin03]

C'est bien justement ce que j'avais proposé de mettre sur pied à valentin03 (# 10, 13, 15): construire des chaînes de 13 caractères comportant 5 des six variables (a, b, c, d, e, x), les quatre signes d'opérations (+, -, *, /) et deux paires de parenthèses; la syntaxe (ou règles d'écriture, "légitimité", ... etc) étant vérifiée par une matrice de compatibilité entre deux termes successifs.

Par exemple: x = F(a, b, c, d, e) ou tout ce qu'on voudra d'autre a = F_a(b, c, d, e, x) ... puisé dans le même ensemble de symboles.
Pour obtenir au moins quelques chaînes grammaticalement correctes, par tirage pseudo-aléatoire (à défaut d'une énumération complète).
J'avais même donné pour incitation la première colonne de la matrice ... peine perdue.

J'ai abandonné faute de répondant: valentin03 a de réelles connaissances, propres à donner le change sur un forum, mais il n'écrira aucune instruction, et le débat s'enlisera dans les considérations générales, et les contestations de vocabulaire ... au risque d'exaspérer les intervenants , et à gâcher inutilement le paisible lendemain de réveillon auquel ils ont droit .

Il est possible que je me trompe complètement: si l'un d'entre vous réussit à lui mettre le pied à l'étrier, même sur un projet simplifié à l'extrême, je l'encourage sans réserve .

# Rêvons un peu: valentin03, aurais-tu par hasard rempli les douze dernières colonnes de la matrice, ou rédigé au moins un début de programme délivrant des expressions correctes de (a, b, c, d) ou (e) ?

Je te trouve bien dur, je ne connais rien aux matrices, je ne suis pas matheux; mais ça n'empêche que je code depuis plus de trente ans dans un langage dont je n'oserais pas parler ici tellement il est ostracisé par des gens qui certes codes dans des langages fort évolués mais dont on cherche désespérément les productions.

Moi , j'essaie toujours de comprendre l'objectif.

Dans un précédent message, tu m'as dit : c'est exactement ça, mais dans la suite du message, tu m'as dit en fait que ce n'était pas du tout ça.

Visiblement, à partir d'une chaîne qu'on donne au programme, le programme doit donner une certaine réponse.
A priori, en entrée, on donne une chaine de caractère de ce type : x=(a+b)*(c-d)/e, ou bien x=a*b/c*d+e, ou bien x=a*b/c*(d+e) ... ...
Et, si on donne la 1ère chaîne donnée en exemple, le programme doit renvoyer les 5 chaines suivantes :
a=x*e/(c-d)-b
b=x*e/(c-d)-a
c=x*e/(a+b)+d
d=c-x*e/(a+b)
e=(a+b)*(c-d)/x

C'est ça ?
Et le programme devrait savoir inverser toutes les formules de ce genre.

Voila ! Mais ces inversions tu les a faites avec ton cerveau et tes connaissances en math; moi je veux que ce soit le programme qui les fasse, et comme je pressens que lui donner des règles et les lui faire appliquer sera au dessus de mes capacités, je compte faire par force brute en testant la validité de toutes les combinaisons cohérentes, en ajoutant des opérateurs si besoin et en passant par les valeurs numériques pour tester
Et la question est, cela est-il jouable ou est-ce que je me fourvoie ?

[tbc92]

Donner cet exemple aurait été simple, et clair.
Et quand tu donnes les explications, inutile de parler de valeurs numériques, ça ne fait que perturber la compréhension.

Ce que tu envisages, c'est de générer plein de chaines, des millions de chaines, et pour chacune, tester d'une part si elle est valide, et d'autre part si elle est équivalente à la chaine d'origine. Ca va être atrocement long, et ça va être atrocement compliqué.
Pour au final garder seulement 5 chaines, les 5 chaines qui donnent respectivement a, b, c, d, e en fonction des 5 autres variables.
Ce n'est pas simple, mais intéressant.

[valentin03]

Donner cet exemple aurait été simple, et clair.
Et quand tu donnes les explications, inutile de parler de valeurs numériques, ça ne fait que perturber la compréhension.

Ce que tu envisages, c'est de générer plein de chaines, des millions de chaines, et pour chacune, tester d'une part si elle est valide, et d'autre part si elle est équivalente à la chaine d'origine. Ca va être atrocement long, et ça va être atrocement compliqué.
Pour au final garder seulement 5 chaines, les 5 chaines qui donnent respectivement a, b, c, d, e en fonction des 5 autres variables.
Ce n'est pas simple, mais intéressant.

Je compte me limiter à 200 ou 300 000 combinaisons. Je suis bien obligé de passer par les valeurs numériques pour tester. Le temps n'est pas un problème on peut faire autre chose pendant que ça tourne; et à part l'analyse de la chaine pour la résolution le reste n'est pas très compliqué.
Existe t-il un soft qui fait ça ? (avec une méthode plus orthodoxe).

[wiwaxia]

... je ne connais rien aux matrices ...

Celle qui a été évoquée est un tableau à 2 dimensions, contenant tous les cas de compatibilité (ou d'incompatibilité) des caractères qui se succèdent. Il n'intervient aucun calcul matriciel, à proprement parler.

... je ne suis pas matheux; mais ça n'empêche que je code depuis plus de trente ans dans un langage dont je n'oserais pas parler ici tellement il est ostracisé ...

Si l'on connaissait enfin le langage qui t'est familier, ce serait déjà un premier pas de franchi ... Et aucun langage n'est proscrit sur ce forum: l'argument persécutoire ne tient pas, ce sont des enfantillages.
Le seul obstacle serait que le logiciel correspondant soit trop ancien pour fonctionner sur les machines actuelles - encore que cela soit peu probable, et que les ressources disponibles sur le site permettraient probablement de contourner la difficulté.

Et en codant depuis si longtemps, tu es forcément devenu familier des notions de base des mathématiques, mais avec un langage différent de celui couramment utilisé - d'où des difficultés certaines, et l'impression de ne pas être au niveau. Tes scrupules excessifs te font du tort, en te conduisant à refuser tout échange de code.

[wiwaxia]

... Ca va être atrocement long, et ça va être atrocement compliqué.
Pour au final garder seulement 5 chaines, les 5 chaines qui donnent respectivement a, b, c, d, e en fonction des 5 autres variables ...

5x4 , à cause des permutations autorisées. Cependant la perspective demeure toute aussi décourageante ...

[valentin03]

aucun langage n'est proscrit sur ce forum: l'argument persécutoire ne tient pas, ce sont des enfantillages.

Je me doute bien qu'il n'est pas proscrit, mais tu pourra dire tout ce que tu voudra je sais très bien que rien que d'en évoquer le nom on passe pour un débile; j'ai quelques humiliantes expériences à ce sujet. Alors enfantillages pour toi, grande circonspection pour moi et de toutes façons le langage on s'en tape, on parle de méthode.
Quand j'ai commencé ce truc, j'ai douté, parce si 20=10+10; 20 égale aussi 13+7 et tout le reste...
Je suis donc venu poser la question, et tu m'a dit qu'effectivement ma méthode de chercher des égalités allait donner plein de résultats cohérents mais faux (inexploitables). Et je ne comprends pas pourquoi puisque les valeurs et les variables sont soudées tout au long des manips et que s'il y a égalité, l'expression me paraît forcément bonne (exploitable).
Je suis bien conscient que la méthode est farfelue et pas du tout optimisée, mais à priori y en a pas d'autres puisqu'aucun soft ne fait ce genre de permutation.

[wiwaxia]

Je pense, pour avoir abordé des sujets apparentés, que l'inventaire systématique des combinaisons (potentiellement au nombre de 13!) risque d'être très long, même en usant en permanence des contraintes pour limiter le nombre de calculs.

J'ai déjà indiqué (#10) qu'une autre voie était envisageable, en partant des parenthèses structurant l'expression.
Il y a deux sortes de séquences, selon que les paires de parenthèses se contiennent [...(...(...)...)...] ou non [...(...)...(...)...]
et chacune d'entre elles peut être caractétisée par le nombre de variables présentes aux cinq endroits possibles; les opérateurs suivent toujours:
a) Type (1): [...<h>...(...<i>...(...<j>...)...<k>...)...<l>...]
h + i + j + k + l = 5
1 < j < 6 (le contenu correspond à plus d'un terme⁽¹⁾, et ne peut dépasser 5)
tous les autres indices (h, i, k, l) sont positifs ou nuls

b) Type (2): [...<h>...(...<i>...)...<j>...(...<k>...)...<l>...]
h + i + j + k + l = 5
1 < i < 6 et 1 < k < 6 (le contenu correspond à plus d'un terme⁽¹⁾, et ne peut dépasser 5)
tous les autres indices (h, j, l) sont positifs ou nuls, d'où: i + k < 6
les combinaisons sont ici moins nombreuses.

(1) un terme isolé [... (v) ...] rend la paire de parenthèses inutile.

D'où le dénombrement ordonné des chaînes de caractères:
a) Séquences de type (1) - N₁ = 69 (somme de nombres pyramidaux)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
00104 _ 00203 _ 00302 _ 00401 _ 00500 (15)
00113 _ 00212 _ 00311 _ 00410
00122 _ 00221 _ 00320
00131 _ 00230
00140
 
01103 _ 01202 _ 01301 _ 01400 (10)
01112 _ 01211 _ 01310
01121 _ 01220
01130
 
02102 _ 02201 _ 02300 (6)
02111 _ 02210
02120
 
03101 _ 03200 (3)
03110
 
04100 1)
 
10103 _ 10202 _ 10301 _ 10400 (10)
10112 _ 10211 _ 10310
10121 _ 10220
10130
 
11102 _ 11201 _ 11300 (6)
11111 _ 11210
11120
 
12101 _ 12110 (3)
12200
 
13100 (1)
 
20102 _ 20201 _ 20300 (6)
20111 _ 20210
20120
 
21101_21200 (3)
21110
 
22100 (1)
 
30101 _ 30200 (3)
30110
 
40100 (1)

b) Séquences de type (2) N₂ = 20 (autre somme de nombres pyramidaux):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
01013 _ 01022 _ 01031 _ 01040 (10)
01112 _ 01121 _ 01130
01211 _ 01220
01310
 
02012 _ 02021 _ 02030 (6)
02111 _ 02120
02210
 
03011 _ 03020 (3)
03110
 
04010 (1)

Soit au total: N = 89 types de séquences.
Sachant qu'on y trouve 5 variables et 4 signes, cela fait à chaque fois 5!*4! = 2880 arrangements, cela conduit finalement à 256320 chaînes de 13 caractères conformes aux règles algébriques d'écriture.

Deux sortes de programmes écriront la liste complète des expressions.

Problème résolu. Point barre.

PS: Petit détail: les expressions exactes sont absentes de la liste obtenue, lorsque l'on passe à l'une des fonctions réciproques, par exemple: c = d + (x*e)/(a+b), en raison de l'interconversion entre signes (+, -) et(*, /).
Pour inclure les solutions exactes, il faut donc ratisser plus large, et le nombre d'arrangement est plus élevé.

[valentin03]

Je pense, pour avoir abordé des sujets apparentés, que l'inventaire systématique des combinaisons (potentiellement au nombre de 13!) risque d'être très long, même en usant en permanence des contraintes pour limiter le nombre de calculs.

J'ai déjà indiqué (#10) qu'une autre voie était envisageable, en partant des parenthèses structurant l'expression.
Il y a deux sortes de séquences, selon que les paires de parenthèses se contiennent [...(...(...)...)...] ou non [...(...)...(...)...]
et chacune d'entre elles peut être caractétisée par le nombre de variables présentes aux cinq endroits possibles; les opérateurs suivent toujours:
a) Type (1): [...<h>...(...<i>...(...<j>...)...<k>...)...<l>...]
h + i + j + k + l = 5
1 < j < 6 (le contenu correspond à plus d'un terme⁽¹⁾, et ne peut dépasser 5)
tous les autres indices (h, i, k, l) sont positifs ou nuls

b) Type (2): [...<h>...(...<i>...)...<j>...(...<k>...)...<l>...]
h + i + j + k + l = 5
1 < i < 6 et 1 < k < 6 (le contenu correspond à plus d'un terme⁽¹⁾, et ne peut dépasser 5)
tous les autres indices (h, j, l) sont positifs ou nuls, d'où: i + k < 6
les combinaisons sont ici moins nombreuses.

(1) un terme isolé [... (v) ...] rend la paire de parenthèses inutile.

D'où le dénombrement ordonné des chaînes de caractères:
a) Séquences de type (1) - N₁ = 69 (somme de nombres pyramidaux)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
00104 _ 00203 _ 00302 _ 00401 _ 00500 (15)
00113 _ 00212 _ 00311 _ 00410
00122 _ 00221 _ 00320
00131 _ 00230
00140
 
01103 _ 01202 _ 01301 _ 01400 (10)
01112 _ 01211 _ 01310
01121 _ 01220
01130
 
02102 _ 02201 _ 02300 (6)
02111 _ 02210
02120
 
03101 _ 03200 (3)
03110
 
04100 1)
 
10103 _ 10202 _ 10301 _ 10400 (10)
10112 _ 10211 _ 10310
10121 _ 10220
10130
 
11102 _ 11201 _ 11300 (6)
11111 _ 11210
11120
 
12101 _ 12110 (3)
12200
 
13100 (1)
 
20102 _ 20201 _ 20300 (6)
20111 _ 20210
20120
 
21101_21200 (3)
21110
 
22100 (1)
 
30101 _ 30200 (3)
30110
 
40100 (1)

b) Séquences de type (2) N₂ = 20 (autre somme de nombres pyramidaux):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
01013 _ 01022 _ 01031 _ 01040 (10)
01112 _ 01121 _ 01130
01211 _ 01220
01310
 
02012 _ 02021 _ 02030 (6)
02111 _ 02120
02210
 
03011 _ 03020 (3)
03110
 
04010 (1)

Soit au total: N = 89 types de séquences.
Sachant qu'on y trouve 5 variables et 4 signes, cela fait à chaque fois 5!*4! = 2880 arrangements, cela conduit finalement à 256320 chaînes de 13 caractères conformes aux règles algébriques d'écriture.

Deux sortes de programmes écriront la liste complète des expressions.

Problème résolu. Point barre.

Je suis d'accord qu'on est fortement limité pour la longueur de la chaine initiale, et que les parenthèses imbriquées sont une difficulté supplémentaire à l'analyse.
Tu focalise sur l'analyse et la combinatoire qu'on peut faire de trente six façons, et je vais m'en débrouiller à la mienne.
Ce que je voudrais savoir c'est si cette méthode est valide:
Expression initiale: x=a*b
valeurs forfaitaires: a=3; b=5
Résolution: x=15
Combinatoire:
a=x*b Résolution-->3=?15*5 --> non=> éliminée
b=x*a Résolution-->5=?15*3 --> non=> éliminée
Pas d'égalité trouvée => ajout d'opérateur "/"
Combinatoire:
a=b/x Résolution-->3=?5/15 --> non=> éliminée
b=a/x Résolution-->5=?3/15 --> non=> éliminée
a=x/b Résolution-->3=?15/5 --> oui=> stockée
b=x/a Résolution-->5=?15/3 --> oui=> stockée
Ce qui fonctionne avec 3 termes doit fonctionner avec n termes sous réserve de la factorielle=>temps
Pourquoi y aurait-il des égalités qui donneraient des expressions non valides ?

[wiwaxia]

... de toutes façons le langage on s'en tape, on parle de méthode.
...

Alors il faut introduire du pseudo-code, qui permet d'écarter les problèmes de traduction.

Il faut à un moment donné sortir des généralités rapidement stériles, des discussions de "méthode" avec toutes les ambivalences du langage ordinaire, pour proposer une démarche précise et compréhensible décrite par un algorithme.
Sinon le débat tourne en rond et ne manque pas de susciter des réactions d'agacement: le forum se trouve alors détourné de sa finalité, qui est pour l'essentiel le partage -éventuellement la correction - d'algorithmes et de programmes.

... Je suis donc venu poser la question, et tu m'a dit qu'effectivement ma méthode de chercher des égalités allait donner plein de résultats cohérents mais faux (inexploitables). Et je ne comprends pas pourquoi puisque les valeurs et les variables sont soudées tout au long des manips et que s'il y a égalité, l'expression me paraît forcément bonne (exploitable).
Je suis bien conscient que la méthode est farfelue et pas du tout optimisée, mais à priori y en a pas d'autres puisqu'aucun soft ne fait ce genre de permutation.

Il y a quelque chose que tu discerne mal, et que tu perds de vue au fil des échanges:

1°) D'une équation admise y = a*x + b on peut déduire par les règles du calcul algébrique une expression (et une seule) de l'autre variable: x = (y - b)/a .
Ceci relève du calcul formel, dont la programmation est hors de portée pour être envisagée ici (par moi tout au moins).

2°) On peut par contre (excellent exercice) envisager la sélection de chaînes de caractères lisibles, compréhensibles, non fautives - c'est à dire conformes aux règles d'écriture - par exemple:
x = y/(b - a) , x = b/(a - y) , x = y*b + a ... toutes variantes évidemment fausses,
mais cependant parfaitement discernables, moyennant un programme approprié, des expressions fautives, illisibles, dépourvues de sens telles que:
x = )y - b(/a , x = (y - b)a/ , x = ay + b ...
C'est ce que je viens de présenter, pour une chaîne bien définie.

3°) Ce qui est proprement sidérant, c'est l'extrême simplicité des exemples sur lesquels tu prétends fonder ta méthode.
a) Déjà pour l'exemple précédent (y = a*x + b) on peut noter l'apparition de 4 nouveaux signes { ( , ) , - , / } dans la véritable expression de (x), ce qui n'est pas de bon augure ...
b) La présente discussion partait de (x = (a+b)*(c-d)/e) , exemple limité à 5 variables, 4 signes et 2 paires de parenthèses ... et tu peux apprécier la lourdeur du dénombrement.
c) Tu propose maintenant une expression réduite à 3 signes, dont tu déduis deux variantes possibles , ce qui revient à viser une vache dans un couloir !
# d'abord, tu oublies l'interconversion des signes (+ et - , * et /) qui conduit à considérer 4 termes:
a = x/b , x*b , b/x , b*x
et deux fois plus encore, dans le cas d'un traitement plus vaste:
a = ... , x+b, x-b, b+x , b-x
Déjà, ça se gâte ...
d) Dans le cas d'une chaîne comportant (N) variables, (N-1) signes et limitée aux opérations de l'arithmétique (+ , - , * , /), le nombre de combinaisons possibles suit une loi factorielle, et augmente plus vite que toute exponentielle.
Le domaine des valeurs possibles restant fini, beaucoup d'entre elles peuvent résulter d'un très grand nombre de combinaisons.
La démarche que tu proposes, déjà lourdement handicapée par le nombre des vérifications à faire, risque de comporter une majorité de faux positifs, ce qui lui ôte toute fiabilité.

Pour reprendre l'exemple initial, avec:
a = 10 ; b = 9 ; c = 8 ; d = 7 ; e = 6 ; N_md = 2 (nombre total de multiplications et de divisions)
toute expression x = F(a, b, c, d, e) est limitée supérieurement par F_max = (Max(Abs(a), Abs(b) ... Abs(e))^^N_md+1 = 10³ = 1000 ;
or le nombre de combinaisons N_c vaut ~ 10⁶ ,
La comparaison est confirmée: N_c >> F_max .

[tbc92]

En terme de difficulté, qu'est-ce qui est simple, et qu'est-ce qui est compliqué ? Tu envisages de générer plein de chaines, qui vérifient une certaine syntaxe. Vérifier que la syntaxe est correcte, ce n'est pas simple.
Puis tu envisages de remplacer les a,b,c,d,x par des nombres pour faire un calcul, ça non plus ce n'est pas simple.
Et si le calcul donne le résultat voulu, alors tu considères que la chaine est celle voulue. Ca, c'est simple, et on peut répéter le test avec 7 ou 8 jeux de valeurs différents pour se protéger contre les coïncidences.


L'autre option, c'est de partir de la chaine d'entrée. Restons sur le même exemple : x=(a+b)*(c-d)/e
Etape 1 : on normalise cette chaine, en ajoutant un maximum de parenthèses : x=((a+b)*(c-d))/e ; C'est certainement l'étape la plus compliquée.
Etape 2, on cherche à isoler a.
Etape 2a : on inverse l'égalité, pour que a soit à gauche du signe égal : ((a+b)*(c-d))/e = x
Etape 2b : La première opération à inverser est la division; c'est la seule qui n'est pas entre des parenthèses : ((a+b)*(c-d))=x*e
Etape 2c : Dans le terme de gauche on se retrouve forcément avec des parenthèses inutiles, on les supprime : (a+b)*(c-d)=x*e
Etape 2d : on met des parenthèses autour de l'experession de gauche, par anticipation : (a+b)*(c-d)=(x*e)
Et on répète les opérations 2b 2c et 2d autant que nécessaire : (a+b)=(x*e)/(c-d)
a+b=((x*e)/(c-d))
a=((x*e)/(c-d))-b

Et idem pour isoler b, c, d ou e.

Pour d, la fin se présente comme ça :
c-d = ((x*e)/(a+b))
C'est une soustraction, et d est à droite du signe -, c'est un peu plus compliqué à gérer qu'une addition, mais ça se gère :
d =c-((x*e)/(a+b))

L'étape n°1 est complexe, mais la suite est plutôt abordable. C'est long et fastidieux, mais chaque étape est bien identifiée, et simple. Au pire, on peut envisager une première version où l'utilisateur doit entrer des chaines avec un maximum de parenthèses. Du coup, pas besoin de programmer l'étape 1.

Et le gros avantage, c'est que ça marche même avec des expressions du type x = ((a+1)*((b+c)-d)) + ((5-e)/(f+(g*h+2)))*(2+(i*j))


Ceci dit, je sais que tu travailles en VB, et c'est clair que je ne me lancerais pas dans ce chantier en VB.