Mathematica, comportement optimal sur les cas de test, 260 octets
For[a=f=1;{c,h}=Input@Grid;z=Characters;t=<|Thread[z@#->#2]|>&;r="";v=Floor[+##/2]&;b:=a~v~c;g:=f~v~h,r!="y",r=Input[g Alphabet[][[b]]];{{a,c},{f,h}}={t["NSu",{{a,b-1},{b+1,c},{b,b}}]@#,t["uWX",{{g,g},{f,g-1},{g+1,h}}]@#2}&@@Sort[z@r/.{c_}:>{c,"u"}/."E"->"X"]]
Ce programme peut être testé en coupant et collant le code ci-dessus dans Wolfram Cloud . (Testez rapidement, cependant: je pense qu'il y a une limite de temps pour chaque exécution de programme.) Les suppositions du programme ressemblent à la 2 c
place de C2
, mais sinon il s'exécute selon les spécifications ci-dessus. La grille doit être entrée sous la forme d'une paire ordonnée d'entiers, comme {26,100}
, et les réponses aux suppositions du programme doivent être entrées sous forme de chaînes, comme "NE"
ou "y"
.
Le programme garde une trace du plus petit et du plus grand numéro de ligne et de colonne qui est cohérent avec les entrées jusqu'à présent, et devine toujours le point central de la sous-grille de possibilités (arrondi NW). Le programme est déterministe, il est donc facile de calculer le nombre de suppositions dont il a besoin en moyenne sur une grille fixe. Sur une grille de 10x10, le programme nécessite 1 supposition pour un seul carré, 2 suppositions pour huit carrés, 3 suppositions pour 64 carrés et 4 suppositions pour les 27 carrés restants, pour une moyenne de 3,17; et c'est le minimum théorique, étant donné le nombre de séquences 1-deviner, 2-deviner, etc. peuvent conduire à des suppositions correctes. En effet, le programme devrait atteindre le minimum théorique sur n'importe quelle grille de taille pour des raisons similaires. (Sur une grille 5x5, le nombre moyen de suppositions est de 2,6.)
Une petite explication de code, bien que ce soit assez simple à part le golf. (J'ai échangé l'ordre de certaines instructions d'initialisation à des fins d'exposition - aucun effet sur le nombre d'octets.)
1 For[a = f = 1; z = Characters; t = <|Thread[z@# -> #2]|> &;
2 v = Floor[+##/2] &; b := a~v~c; g := f~v~h;
3 r = ""; {c, h} = Input@Grid,
4 r != "y",
5 r = Input[g Alphabet[][[b]]];
6 {{a, c}, {f, h}} = {t["NSu", {{a, b - 1}, {b + 1, c}, {b, b}}]@#,
7 t["uWX", {{g, g}, {f, g - 1}, {g + 1, h}}]@#2} & @@
8 Sort[z@r /. {c_} :> {c, "u"} /. "E" -> "X"]
]
Les lignes 1 à 3 initialisent la For
boucle, qui n'est en fait qu'une While
boucle déguisée, donc bon, deux octets de moins. Les plages de numéros de ligne et de colonne possibles à tout moment sont stockées dans {{a, c}, {f, h}}
, et la supposition centrée dans cette sous-grille est calculée par les fonctions {b, g}
définies à la ligne 2. La ligne 3 initialise la ligne c
max et la colonne max à h
partir de l'entrée utilisateur, et initialise également r
la variable testée en boucle ainsi que les entrées utilisateur suivantes.
Alors que le test de la ligne 4 est satisfait, la ligne 5 reçoit une entrée de l'utilisateur, où l'invite provient de la supposition actuelle {b, g}
( Alphabet[][[b]]]
convertit le numéro de ligne en lettre). Ensuite, les lignes 6-8 mettent à jour la sous-grille de possibilités (et donc implicitement la prochaine supposition). Par exemple, t["NSu", {{a, b - 1}, {b + 1, c}, {b, b}}]
(compte tenu de la définition de la t
ligne 1) se développe en
<| "N" -> {a, b - 1}, "S" -> {b + 1, c}, "u" -> {b, b}|>
où vous pouvez voir les numéros de ligne mini et max ligne mis à jour en fonction de la dernière entrée de l'utilisateur. La ligne 8 convertit toute entrée possible en une paire ordonnée de caractères du formulaire { "N" | "S" | "u", "u" | "W" | "X"}
; ici "u"
représente une ligne ou une colonne correcte et "X"
représente l'Est (juste pour permettre Sort
de bien fonctionner). Lorsque l'utilisateur entre enfin "y"
, ces lignes génèrent une erreur, mais le test de boucle échoue et l'erreur n'est jamais propagée (le programme s'arrête tout de même de toute façon).
A1
et que l'ordinateur devineB9
, est-ce la bonne réponseNW
ouW
?