Ce fichier utilise une expression régulière pour voir si un calcul n’utilise que les touches de la calculatrice. Au début du source, on crée la RegExp avec

var	RE = /[^47\+\-=]/g;

La lettre « g » à la fin demande que la recherche soit globale (que la RegExp cherche tous les caractères illégaux, pas seulement le premier d’entre eux). Entre crochets, figure la liste des caractères autorisés (le « + » et le « - » sont « échappés » pour être compris comme des caractères), mais précédés d’un chapeau qui demande à la RegExp, non pas de chercher ces caractères, mais de lister les autres caractères (ceux qui ne sont pas sur la calculatrice cassée).

Pour savoir si un caractère non autorisé a été utilisé dans le calcul, on récupère le calcul (non effectué) et on effectue sur celui-ci une fouille au corps exhaustive à l’aide de la RegExp. Le résultat, noté v, est la liste des caractères non autorisés :

var v = calcul.match(RE);
if (v==null){
	discours = "";
} else {
	discours = "Mais les éléments suivants ont été utilisés, alors qu'ils ne sont pas disponibles sur la calculatrice : {"+v+"}.";
}

La variable discours, affichée en bas du fichier en rouge, contient alors l’ensemble des caractères non autorisés (ou rien si le calcul est « légal »).

Le script suivant, testé dans alcoffeethmique, donne les premiers nombres qu’on peut obtenir avec ce système dynamique :

S = new Ensemble [0]
A = (x) -> 2*x+1
B = (x) ->
    if x%2 is 0
        x
    else
        (x+5)/2
for n in [1..9]
    S.ajoute A(x) for x in S.support
    S.ajoute B(x) for x in S.support
affiche S

Il donne le résultat suivant, confirmant que 100 peut être atteint et en combien d’étapes :

Question : L’ensemble des entiers ainsi obtenus est-il récursif ? Autrement dit, y a-t-il un moyen calculable de dire si un entier n’y est pas ?

L’étage où se trouve actuellement l’ascenceur est calculé par des additions et des soustractions [1], et stocké dans la variable S. Alors pour mettre à jour la liste des étages restant à parcourir, on applique l’algorithme suivant :

• On calcule la position de S dans le tableau aFaire ;
• on stocke cet entier dans index ;
• si index vaut -1, c’est que S n’est pas dans le tableau (étage déjà parcouru) ;
• sinon, on enlève du tableau l’élément de numéro index (c’est donc S)

En JavaScript ça donne ceci :

var index = aFaire.indexOf(S);
if (index>-1) {
	aFaire.splice(index,1);
}

Pour mettre à jour la liste des étages déjà parcourus c’est beaucoup plus simple, il suffit de faire fait.push(S); si le tableau des étages déjà parcourus s’appelle fait.

Une fonction adjacency permet de savoir qui est à côté de qui [2] :

adjacency = (a,b) ->
    if a>b
        adjacency b, a
    else
        false if a is b
        switch b
            when 2 then (a is 1)
            when 3 then (a is 2)
            when 4 then (a in [1,2])
            when 5 then (a in [1..4])
            when 6 then (a in [2,3,5])
            when 7 then (a in [4,5])
            when 8 then (a in [4..7])
            when 9 then (a in [5,6,8])
            else false

Ensuite, on désactive tous les boutons, puis on ne réactive que ceux qui sont à côté de celui qui vient d’être joué (et qui s’appelle riposte) :

 $(".calc").each (x) -> $(this).removeClass "actif"
 $(".calc").each (x) -> $(this).addClass "actif" if adjacency(parseInt($(this)[0].innerHTML),riposte)

En effet, $(this)[0].innerHTML renvoie le contenu du bouton (le nombre qui est dessus) et en le « parseIntant », on a le nombre correspondant (parseInt convertit en entier)