NOMBRES - Curiosités, théorie et usages

 

Accueil                           DicoNombre            Rubriques           Nouveautés      Édition du: 14/11/2016

Orientation générale        DicoMot Math          Atlas                   Références                     M'écrire

Barre de recherche          DicoCulture              Index alphabétique                               

     

CHIFFRES & LETTRES

 

Débutants

Général

PUZZLES

ARITHMÉTIQUES

 

Glossaire

Général

 

 

INDEX

 

Puzzles

 

Jeux de nombres

 

Jeux numériques

 

 

Additions

Soustractions

Amour+haine

Libres

Pastilles

Multiplications

Valet

Dix² – Six²

One four nine

Divisions

One Two

Twenty

Notes de musique

Triplets pannum.

Cats and dogs

 

Sommaire de cette page

>>> Solutions

>>> Résolution

>>> Recherche par programmation

>>> Archive – Recherche systématique

 

 

 

 

PUZZLES ARITHMÉTIQUES

 Cryptarithmes – Cryptogrammes

Arithmétique verbale

 

AMOUR + HAINE = NÉANT

 

Un exemple de cryptarithme ayant un sens manifeste, mais à solutions multiples et très ouvert (peu de possibilité de le résoudre par un raisonnement simple).

 

Exemple de programmation pour résoudre un tel puzzle arithmétique.

 

 

 

Solutions possibles de ce cryptarithme

 

Deux exemples de solutions avec opération posée

 

 

Les 14 (x2) solutions ordonnées par sommes croissantes

 

dont 11 avec U = 0

et       3 avec U = 9

doublées (soit 28)  en permutant O et I

 

 

 

 

 

RÉSOLUTION (tentative)

Vérification de la pertinence du puzzle

 

 

 

Recensement des lettres

 

A   M   O    U   R   H    I    N    E   T

= 10 lettres distinctes pour les 10 chiffres.

3 + 1 + 1 + 1 + 1 + 1 + 1 + 3 + 2 + 1

= 15 lettres au total.

Tentative de résolution raisonnée

*      Lettre de têtes

 

Les nombres de commencent jamais par un 0:

A et H ne sont pas 0.

A et H au minimum valent 1 et 2; leur somme A+H = N est supérieure ou égale à 3:

N différent de  0, 1, 2.

*      Lettres doublées

 

Le N est doublé sur l'avant-dernière colonne.

La valeur de U doit être neutre.

U vaut 0 ou 9 (s'il y a retenue sur la première addition).

Si U = 0

*      Première colonne

 

 

Alors, R et E ne sont pas nuls et valent au minimum 1 et 2:

T ³ 3.

La somme R + E ne produit pas de retenue, si l'un vaut 1 l'autre vaut 8 au maximum:

R et N jamais 9

Etc.

Pas simple!

 

 

Recherche par programmation

 

Ce cryptarithme utilise les dix chiffres. Le programme examine toutes les permutations des dix chiffres et ne retient que celles qui donnent l'égalité recherchée.

 

 

Initialisation.

Utilisation du package combinatoire.

Mise à zéro d'un compteur (kt) de solutions.

Liste des chiffres en L.

Liste des permutations de ces chiffres en LL et de leur quantité en qLL

 

Lancement de qLL boucles

Identification de chaque permutation en M.

Calcul numériques des mots: amour, haine et néant en respectant les répétitions de lettres.

 

Si l'opération est juste, imprimez cette opération et ajouter un au compteur de solutions.

 

Finalement imprimiez la valeur du compteur.

 

 

 

 

 

Impression des 28 solutions

 

 

(durée d'exécution: de l'ordre de la minute)

Voir Programmation

 

 

 

 

Archives

Recherche avec programmation moins élaborée, mais plus fastidieux.

 

RECHERCHE SYSTÉMATIQUE

 

Mise en équation

 

Avec exemple numérique pour aider à la compréhension.

La ligne ajoutée en haut sert à matérialiser les retenues.

 

Calcul de la première colonne.

Pour faciliter le calcul avec les retenues, nous allons distinguer la valeur de T, d'une part,  et la somme de R et E, d'autre part.

La fonction tronque donne la partie entière d'un nombre, en supprimant toute la partie décimale

SommeRE = R + E

2 + 8 = 10

a = la dizaine de SommeRE.

T= les unités de SommeRE.

a = tronque(SommeRE / 10)

T = SommeRE – 10*a

a = tr (10/10) = 1

T = 10 – 10x1 = 0

Procédons de la même manière pour la colonne suivante.

SommeUN = a + U + N

1 + 9 + 5 = 15

b = la dizaine de SommeUN .

Inutile de calculer N.

b = tronque(SommeUN / 10)

 

b = tr (15/10) = 1

 

Colonne 3.

SommeOI = b + O + I

c = tronque(SommeOI / 10)

A = SommeOI – 10*c

1 + 3 + 7 = 11

c = tr (11/10) = 1

A = 11 – 10x1 = 1

Colonne 4.

SommeMA = c + M + A

d = tronque(SommeMA / 10)

1 + 6 + 1 = 8

d= tr (8/10) = 0

Colonne 5: seul H est inconnue.

H = N – A - d

5 – 1 – 0 = 4

 

 

Principe de l'algorithme

 

Analyse systématique des valeurs des lettres. Les autres se déduisent par calcul.

R, E, U, N, O, I, M

T, A, H

Filtrage des valeurs des lettres pour ne conserver que les cas où elles sont différentes.

Il faut noter que le test sur la somme et le produit des 10 chiffres est une condition nécessaire mais pas suffisante.

Il faudra soigneusement vérifier les résultats pour éliminer les artefacts: ce programme va sortir 33 réponses pour 28 valides.

Somme

0 + 1 + 2 + 3 + 4 + 5 + 6 + 7+ 8 + 9 = 45

 

Produit

1 x 2x 3 x 4 x 5 x 6 x 7 x 8 x 9 x 10 = 10! = 3 628 800

(notez qu'il s'agit du produit des chiffres plus 1 de manière à s'affranchir de la valeur 0)

 

 

 

Programme (langage Mapple)

 

Les noms des lettres sont doublés pour qu'elles ne soient pas confondues avec des noms réservés par le langage (comme I pour le i imaginaire).

 

> #AMOUR + HAINE = NEANT

 

kt:=0:

for RR from 0 to 9 do

for EE from 0 to 9 do

for UU from 0 to 9 do

for NN from 0 to 9 do

for OO from 0 to 9 do

for II from 0 to 9 do

for MM from 0 to 9 do

 

SommeRE:=RR+EE:

    aa:=trunc(SommeRE/10):

    TT:= SommeRE-10*aa:

 

SommeUN:=UU+NN+aa:

    bb:=trunc(SommeUN/10):

   

SommeOI:=OO+II+bb:

    cc:=trunc(SommeOI/10):

    AA:=SommeOI-10*cc:

 

SommeMA:=MM+AA+cc:

    dd:=trunc(SommeMA/10):

   

   HH:=NN-AA-dd:

 

if (AA+MM+OO+UU+RR+HH+II+EE+NN+TT)
   =1+2+3+4+5+6+7+8+9

and ((AA+1)*(MM+1)*(OO+1)*(RR+1)*(HH+1)
   *(II+1)*(EE+1)*(NN+1)*(TT+1)*(UU+1))
   =1*2*3*4*5*6*7*8*9*10

then

 

HAINE:=10000*HH+1000*AA+100*II+10*NN+EE:

AMOUR:=10000*AA+1000*MM+100*OO+10*UU+RR:

NEANT:=10000*NN+1000*EE+100*AA+10*NN+TT:

 

if AMOUR+HAINE=NEANT then

kt:=kt+1;

lprint(Solution,kt):

lprint(AMOUR):

lprint(HAINE):

lprint(NEANT):

fi:

 

fi:

od:od:od:od:od:od:od:

 

 

 

 

 

Suite

*    Exemple avec Twenty

*    Exemple avec one, two, five, eight

*    Autres pages

Voir

*    100 en chiffres et autres …

*    Alphabet parlant

*    Anagramme de chiffres

*    ÉquationGlossaire

*    JeuxIndex

Livres et Sites

*    Voir Liste

Cette page

http://villemin.gerard.free.fr/Puzzle/lettadd2.htm