Musique & Mathématique

14 septembre 2012

Le compte est bon

Filed under: Informatique — Mots-clefs :, — admin @ 14 h 57 min

Français English

Le compte est bon

Version V 1.67

Si vous connaissez l’émission de France2 « Des chiffres et des lettres », et que vous aimez en particulier les chiffres, vous trouverez ici un programme capable de résoudre ce type de problème, et serez sans doute étonné des performances de CEB.

Téléchargement

La dernière version 1.67

(1) Le source en C est directement compilable avec les compilateurs GNU Gcc, Borland TurboC ou Microsoft VisualC++.

Utilisation

CEB est un programme qui fonctionne en mode console, l’interface utilisateur est rudimentaire mais il offre l’avantage d’être multi-plateforme (Dos, Windows, Unix) car tous les paramètres sont dans la ligne de commande.

Pour exécuter ce programme sous Windows XP, il faut le lancer dans la fenêtre Dos activée par le menu Démarrer->Exécuter, puis entrer ‘cmd’.
Aide en ligne :

> CEB -h
CEB a1 a2 a3 a4 a5 a6 [cible] [options]            V 1.67
Permet de resoudre un probleme du type 'Compte Est Bon'.
La cible doit etre atteinte arithmetiquement avec les
six nombres 'a1'..'a6' et les operateurs +, *, -, /, ^
a1..a6    Six arguments numeriques positifs.
[cible]   Nombre positif a atteindre.
          Si 'cible' n'est pas precisee, retourne pour les
          cibles de 0 a 999 une statistique des solutions.
[options] Permet de modifier certaines valeurs par defaut:
-aN       fixe a N le nombre d'arguments    (6 par defaut)
-bP       fixe a P la borne min pour stat   (0 par defaut)
-d        mode debug
-eP       fixe a P la borne max pour stat (999 par defaut)
-f        nombres fractionnaires autorises
-g        mode global
-o        recherche avec nombre d'arguments minimum
-s[+*-/e] liste des operateurs autorises (+*-/ par defaut)
-uP       avec au plus P arguments utilises (N par defaut)
-v        affiche la solution            (en multi-lignes)
-v1       affiche la solution               (en une ligne)
-wP       avec au moins P arguments utilises(1 par defaut)
-xP       recherche jusqu'au Pieme recalcitrant.
Auteur:                              gilles.bannay@free.fr

Commandes standard

Est-il possible avec les nombres 4 5 6 7 8 9 d’atteindre 999 ?

> CEB 4 5 6 7 8 9 999
Possible !
Temps = 0.0000 sec.

Si oui, avec combien d’arguments au minimum ?
Option ‘-o’ pour optimize

> CEB 4 5 6 7 8 9 999 -o
Possible (avec 6 args) !
Temps = 0.0300 sec.

et de quelle manière ?
Option ‘-v’ pour verbose (présentation de la solution enfin…)

> CEB 4 5 6 7 8 9 999 -o -v
5 + 4 = 9
8 * 6 = 48
7 * 9 = 63
48 + 63 = 111
9 * 111 = 999
Temps = 0.0300 sec.

Option ‘-v1′ pour verbose (présentation de la solution en une seule ligne)

> CEB 4 5 6 7 8 9 999 -o -v1
((5 + 4) * ((8 * 6) + (7 * 9))) = 999
Temps = 0.0300 sec.

On peut lancer le programme avant même de connaître la cible, pour avoir une statistique sur l’ensemble des cibles de 0 à 999 :

> CEB 4 5 6 7 8 9
Recalcitrants = 842 898 926 939 947
Succes = 99.50%, 5 recalcitrants dans 0-999.
Temps moyen par cible = 0.0001 sec.
Temps = 0.1200 sec.

S’il y a 0 récalcitrant comme par exemple avec le tirage (1, 2, 3, 4, 10, 100), on peut dire avant tout le monde « le compte est bon » !! Sinon on prie pour que le tirage ne soit pas un récalcitrant !!

Les six nombres de départ peuvent être quelconques (contrairement au jeu télévisé). On peut poser par exemple le problème suivant:

> CEB 111 222 333 444 555 666 6666
Possible !
Temps = 0.0100 sec.

Avez-vous trouvé une solution ? (je vous accorde plus de 0.0100 seconde).

> CEB 111 222 333 444 555 666 6666 -v
222 * 111 = 24642
666 * 555 = 369630
369630 + 333 = 369963
369963 * 444 = 164263572
164263572 / 24642 = 6666
Temps = 0.0100 sec.

Commandes étendues

On peut modifier le nombre d’arguments ainsi que les bornes inf et sup pour les statistiques. Par exemple pour un problème à 7 arguments pour les cibles de 1000 à 9999
Option ‘-a’ pour nombre d’arguments
Option ‘-b’ pour begin
Option ‘-e’ pour end

> CEB -a7 6 7 8 9 10 11 12 -b1000 -e9999
Recalcitrants = 9105 9267 9538 9686 9914 9957
Succes = 99.93%, 6 recalcitrants dans 1000-9999.
Temps moyen par cible = 0.0006 sec.
Temps = 5.8000 sec.

Quelle est la deuxième cible que l’on ne peut pas atteindre avec douze ’1′ ?
Option ‘-x’ pour exclude

> CEB -a12 1 1 1 1 1 1 1 1 1 1 1 1 -x2
58 59
2eme recalcitrant = 59.
Temps moyen par cible = 0.0017 sec.
Temps = 0.1000 sec.

Même chose mais en commençant à 62 (on peut combiner les options) :

> CEB -a12 1 1 1 1 1 1 1 1 1 1 1 1 -x2 -b62
62 65
2eme recalcitrant = 65.
Temps moyen par cible = 0.0150 sec.
Temps = 0.0600 sec.

Pour avoir une contrainte supplémentaire, on peut préciser le nombre d’arguments à utiliser au maximum, dans la liste d’arguments. Par exemple peut-on faire 100 avec 1 2 3 4 5 6 en utilisant seulement quatre arguments :
Option ‘-u’ pour using

> CEB 1 2 3 4 5 6 -u4 100
Possible !
Temps = 0.0000 sec.

Quel est le premier nombre qu’on ne peut pas exprimer à l’aide de 4 chiffres differents ?

> CEB -a9 1 2 3 4 5 6 7 8 9 -u4 -x1
298
1er recalcitrant = 298.
Temps moyen par cible = 0.0070 sec.
Temps = 2.0900 sec.

Quel est le premier nombre qu’on ne peut pas exprimer à l’aide de 4 chiffres differents et les opérateurs +,-,*,/ et ^ (exponentiation) ?
Option ‘-s’ pour définir la liste des opérateurs autorisés (‘e’ pour exponentiation)

> CEB -a9 1 2 3 4 5 6 7 8 9 -u4 -x1 -s+-*/e
417
1er recalcitrant = 417.
Temps moyen par cible = 0.0070 sec.
Temps = 2.0900 sec.

Bien sûr, on peut combiner les options précédentes :
voici la liste des plus courtes expressions des nombres [0..20] avec six ’2′ et les opérateurs +,-,*,/,^

> CEB -a6 2 2 2 2 2 2 -b0 -e20 -o -v1 -s+-*/e
(2 - 2) = 0
(2 / 2) = 1
(2) = 2
(2 + (2 / 2)) = 3
(2 + 2) = 4
((2 / 2) + (2 + 2)) = 5
(2 + (2 + 2)) = 6
((2 / 2) + (2 + (2 + 2))) = 7
(2 * (2 + 2)) = 8
((2 + (2 / 2)) ^ 2) = 9
(2 + (2 * (2 + 2))) = 10
(2 + ((2 + (2 / 2)) ^ 2)) = 11
(2 * (2 + (2 + 2))) = 12
((2 / 2) + (2 * (2 + (2 + 2)))) = 13
((2 ^ (2 + 2)) - 2) = 14
((2 ^ (2 + 2)) - (2 / 2)) = 15
(2 ^ (2 + 2)) = 16
((2 / 2) + (2 ^ (2 + 2))) = 17
(2 + (2 ^ (2 + 2))) = 18
((2 + ((2 + (2 + 2)) ^ 2)) / 2) = 19
(2 * (2 + (2 * (2 + 2)))) = 20
Succes = 100.00%, 0 recalcitrants dans 0-20.
Temps moyen par cible = 0.0000 sec.
Temps = 0.0000 sec.

Même chose mais avec obligation d’utiliser tous les arguments :
Option ‘-w’ (pour with)

> CEB -a6 2 2 2 2 2 2 -b0 -e20 -o -v1 -s+-*/e -w6
((2 - 2) * (2 + (2 + (2 + 2)))) = 0
((2 + (2 + (2 + 2))) ^ (2 - 2)) = 1
(((2 + (2 + (2 + 2))) / 2) - 2) = 2
(((2 + (2 + (2 + 2))) - 2) / 2) = 3
((2 + (2 + (2 + 2))) - (2 + 2)) = 4
((2 + (2 + (2 + (2 + 2)))) / 2) = 5
(2 + ((2 + (2 + (2 + 2))) / 2)) = 6
((2 + (2 + (2 + 2))) - (2 / 2)) = 7
((2 + (2 + (2 + (2 + 2)))) - 2) = 8
((2 / 2) + (2 + (2 + (2 + 2)))) = 9
(2 + (2 * ((2 + (2 + 2)) - 2))) = 10
((2 * (2 + (2 + 2))) - (2 / 2)) = 11
(2 + (2 + (2 + (2 + (2 + 2))))) = 12
((2 / 2) + (2 * (2 + (2 + 2)))) = 13
((2 * (2 + (2 + (2 + 2)))) - 2) = 14
((2 * (2 * (2 + 2))) - (2 / 2)) = 15
(2 ^ ((2 + (2 + (2 + 2))) / 2)) = 16
((((2 + (2 + 2)) ^ 2) - 2) / 2) = 17
(2 + (2 * (2 + (2 + (2 + 2))))) = 18
((2 + ((2 + (2 + 2)) ^ 2)) / 2) = 19
(2 * (2 + (2 + (2 + (2 + 2))))) = 20
Succes = 100.00%, 0 recalcitrants dans 0-20.
Temps moyen par cible = 0.0000 sec.
Temps = 0.0000 sec.

Vous pouvez poser un problème dans l’ensemble des rationnels :
Option ‘-f’ pour une recherche avec fractions

> CEB -a4 1 5 6 7 21 -f -v
5 / 7 = 5/7
1 - 5/7 = 2/7
6 / 2/7 = 21

Time = 0.0000 sec.

Le programme affiche de manière détaillée tous les essais qu’il effectue (très pratique pour le debug ou la compréhension du programme) :
voici la sortie du problème simple « Comment faire 9 avec six ’1′ ? »
Option ‘-d’ pour debug

> CEB 1 1 1 1 1 1 9 -d
1: 9 (6) 1     1     1     1     1     1
2: 9 (5)    2+    1     1     1     1
3: 9 (4)       3+    1     1     1
4: 9 (3)          4+    1     1
5: 9 (2)             5+    1
6: 9 (1)                6+
7: 9 (1)                4-
8: 9 (2)             3-    1
9: 9 (2)             4+    2+
10: 9 (1)               8*
11: 9 (2)            4+    0-
12: 9 (3)         2-    1     1
13: 9 (2)            2-    2+
14: 9 (1)               1/
15: 9 (2)            2-    0-
16: 9 (3)         3+    2+    1
17: 9 (2)            6*    1
18: 9 (1)               7+
19: 9 (1)               5-
20: 9 (2)            1-    1
21: 9 (2)            2+    4+
22: 9 (1)               8*
23: 9 (2)            2+    2-
24: 9 (1)               1/
25: 9 (2)            3+    3+
26: 9 (1)               9*
27: 9 (1)               9*
28: 9 (2)            3+    3+
29: 9 (3)         3+    2+    1
30: 9 (4)      3+    1     1     1
31: 9 (5)   2+    1     1     1     1
Possible !
Temps = 0.0000 sec.

Recherche appronfondie

L’option -g a été ajoutée pour permettre la recherche des meilleurs n-uplets (n1,..nk) qui réalisent toutes les cibles de 1 à Nk  (voir ici  http://mathoverflow.net/questions/61034/optimal-countdown)
La recherche s’effectue sur tous les n-uplets (n1,..nk) < (m1,..mk), les (m1,..mk) sont indiqués dans la commande à lancer, par exemple pour les 4-uplets on peut lancer :

> CEB -g -b1 -e10000 -a4 4 8 80 80

pour trouver le meilleur 4-uplets (2,3,14,60) qui permet de résoudre tous les comptes pour N de 1 à 86.

♦       ♦

<Retour au sommaire>


2 commentaires »

  1. je narive pas a faire se compte et bon

    4-5-6-7 28

    pouvais vous maidez ?

    merci davance

    Commentaire by tamerde — 4 mars 2010 @ 18 h 50 min

  2. 4*7*(6-5) = 28

    Commentaire by admin — 10 mars 2010 @ 14 h 40 min

Flux RSS des commentaires de cet article.

Laisser un commentaire

Powered by WordPress, QuickLaTeX