** "Hit & Blow" ** est C'est un type de jeu de devinettes dans lequel deux joueurs s'affrontent et s'appelle ** Bulls & Cows ** à l'étranger.
En tant que jeu dérivé, ** Numer0n **, qui figurait dans le programme télévisé, est célèbre. https://ja.wikipedia.org/wiki/Numer0n
Le contenu du jeu lui-même semble avoir été conçu il y a plus d'un siècle.
Il existe également un jeu de société appelé ** "Mastermind" ** qui a été vendu vers 1970. Les règles sont légèrement différentes de ** Hit & Blow (Bulls & Cows) **.
Les règles du jeu ** Hit & Blow (Bulls & Cows) ** sont les suivantes.
Il est généralement joué en 4 chiffres, mais il peut également être lu en 3 chiffres ou tout autre chiffre.
Sur papier, chaque joueur écrit un numéro secret à quatre chiffres. Tous les nombres doivent être différents.
Puis, à son tour, le joueur devine le numéro de l'adversaire donnant le nombre de matchs et pose des questions. ** "Hit" ** si les numéros correspondants sont dans la bonne position, ** "Blow" ** s'ils sont dans des positions différentes. (Dans Numer0n, ils sont appelés respectivement ** EAT ** et ** BITE **.)
Par exemple
Ma réponse (solution): ** 4721 ** Question de l'adversaire: ** 1234 **
Si, la réponse est
** 1 coup ** et ** 2 coup ** (** Hit ** est ** "2" **, ** Blow ** est ** "4" ** et ** "1" **.)
Et dites le résultat à l'autre partie. Lorsque la question de l'autre personne est terminée, demandez à l'autre personne le numéro que vous avez deviné.
La personne qui devine le ** numéro secret (réponse (solution)) ** de l'adversaire avec ** moins de questions ** que l'adversaire est le ** gagnant **.
Les règles de ** Hit & Blow (Bulls & Cows) ** sont simples et
Générer des réponses aléatoires et répondre aux nombres de taureaux et de vaches aux questions humaines Le ** Programme des questionneurs ** a été créé très tôt.
Le premier est célèbre pour ** "MOO" **, [Système d'exploitation Multics](https: // en) utilisant ** PL / I ** par ** JM Grochow ** en 1970 Écrit pour .wikipedia.org / wiki / Multics).
Certains ** Unix ** de la ** série BSD ** ont toujours le programme de questions ** MOO ** installé en standard.
En tant que tâche de débutant en programmation, il semble qu'elle soit souvent demandée dans les écoles.
D'autre part, le ** programme côté questionneur ** qui permet à l'ordinateur de jouer ** Hit & Blow (Bulls & Cows) ** Par rapport au ** programme côté questionneur **, la quantité de calcul est importante et compliquée.
En fait, sur un PC 16 bits typique il y a 30 ans, Il a fallu quelques minutes pour trouver la bonne réponse.
Cependant, avec les PC de nos jours, la bonne réponse peut être trouvée en un instant. (Quand il s'agit de traiter 8 chiffres ou plus en Python, vous devez attendre un moment)
Au fait, même si vous écrivez le processus pour trouver une solution à 4 chiffres en ** Python3 **, Avec les processeurs modernes, il semble que la solution puisse être trouvée en ** 0,02 seconde **. Même les ** 10 000 questions ** questions ont été complétées en ** 170 secondes **. (Pour processeur Inten (R) Core (TM) i5-8265U à 1,60 GHz (1,80 GHz))
Vers 1995-2000, il a commencé à être décrit dans ** JavaScript ** etc. De nombreux sites sont apparus et peuvent être lus avec le ** programme côté questionneur ** sur le Web. Vous pouvez toujours en trouver plusieurs en recherchant.
Dans le cas d'un jeu à 4 chiffres, le nombre de candidats au moment de la première question est
10×9×8×7 = 5040
Il y a.
En fonction du nombre que vous avez demandé et du résultat de la réponse, l'ensemble qui remplit les conditions de réponse sera décidé.
Comment poser la meilleure question pour l'ensemble C'est un point de faire un solide ** programme côté questionneur **.
Cette histoire sera discutée plus tard dans un chapitre ultérieur.
En ** 1987 **, ce problème a été soulevé comme un problème pour ** bit ** ** Nanopico Class **. Le programme du gagnant à ce moment-là était que le ** nombre moyen minimum de questions ** était de ** 5,22 (nombre total de questions 26347) **.
En ** 1996 **, le ** nombre moyen minimum de questions 26274/5040 = 5,2131 ** a été atteint.
Dans le cas de ** Hit & Blow (Bulls & Cows) ** à 4 chiffres, il a été prouvé que n'importe quel nombre peut être résolu en ** 7 tours **.
** Classe Nano Pico ** http://www.pro.or.jp/~fuji/computerbooks/algorithm/nanopico.bit.html
** Stratégie de question minimale et stratégie la plus forte du jeu de devinettes de nombres MOO **
https://www.tanaka.ecc.u-tokyo.ac.jp/ktanaka/moo/moo.html
https://www.tanaka.ecc.u-tokyo.ac.jp/ktanaka/papers/gpw96.pdf
Le programme créé est présenté ci-dessous. https://github.com/NobuyukiInoue/pyHitAndBlow
Il est temps de décider du numéro de la première question, Il existe un moyen de poser des questions telles que ** "0123" **,
Si l'autre partie est un être humain, des mesures seront prises, donc Les nombres aléatoires sont utilisés pour générer et utiliser des nombres aléatoires à n chiffres qui sont différents les uns des autres.
** Dans le programme côté questionneur **, le processus de préparation du numéro de réponse, Dans ** Programme côté questionneur **, en cours de sélection du numéro pour poser une question,
Vous aurez besoin de chacun.
Dans mon programme, j'ai calculé ** Hits ** et ** Blows ** pour les questions. Pour simplifier (pas accélérer) J'ai décidé de traiter le ** nombre à n chiffres ** de la réponse ou de la question comme une ** chaîne de caractères **.
Si vous générez des nombres aléatoires un chiffre à la fois et que vous les concaténez, la procédure est la suivante.
Renvoie n nombres aléatoires différents(random.randint()Édition)
def create_random_n_digits_number(n:int) -> str:
target_number_str = ""
for _ in range(n):
while True:
d = str(random.randint(0, 9))
if d not in target_number_str:
target_number_str += d
break
return target_number_str
À propos, le processus ci-dessus est Ceci peut être réalisé en une seule ligne en utilisant la ** fonction d'exemple ** du ** module aléatoire **.
Renvoie n nombres aléatoires différents(random.sample()Édition)
def create_random_n_digits_number(n:int) -> str:
return "".join([str(_) for _ in random.sample(list(range(10)), n)])
En outre, lorsque vous traitez les numéros de réponse et les numéros de question sous forme de chaînes de caractères, ** Le numéro de coup ** et le ** numéro de coup ** peuvent être rassemblés par le traitement suivant.
Faites correspondre le numéro de la question avec le numéro de la solution candidate et renvoyez le numéro de réponse et le numéro de coup (partie 1)
def response_check(n:int, answer_number:str, target_number:str) -> (int, int):
"""
response check.
"""
H, B = 0, 0
for i in range(0, n):
if target_number[i] == answer_number[i]:
H += 1
else:
for j in range(0, n):
if i != j and target_number[i] == answer_number[j]:
B += 1
return H, B
Ou
Faites correspondre le numéro de la question avec le numéro de la solution candidate et renvoyez le numéro de réponse et le numéro de coup (partie 2)
def response_check(n:int, answer_number:str, target_number:str) -> (int, int):
"""
response check.
"""
H, B = 0, 0
for n, m in zip(answer_number, target_number):
if n == m:
H += 1
elif n in target_number:
B += 1
return H, B
À propos, le temps de traitement de la seconde est plus court.
Vient ensuite le processus de génération de candidats à n chiffres pour la première question.
Dans le cas de 4 chiffres, la plage de nombres est 0123-9876 '', Le nombre de solutions candidates est 9 * 8 * 7 * 6 = 5040 ''.
Il existe différentes manières de le générer, Si vous l'appelez récursivement pour correspondre à n chiffres, ce sera comme suit.
Faites une liste de numéros de candidats pour la (première) solution
def create_target_numbers(n:int)-> [str]:
"""
create target numbers.
"""
target_numbers = []
def sub_create_target_numbers(n, workStr):
if n == 0:
target_numbers.append(workStr)
return
for i in range(10):
if str(i) not in workStr:
sub_create_target_numbers(n - 1, workStr + str(i))
if n == 1:
for i in range(10):
target_numbers.append(str(i))
elif n > 1:
for i in range(10):
sub_create_target_numbers(n - 1, str(i))
return target_numbers
Nous avons préparé un programme qui ne produit que des nombres aléatoires à n chiffres différents les uns des autres. Ce programme est utilisé pour tester le ** Questionnaire Program **.
https://github.com/NobuyukiInoue/pyHitAndBlow/blob/master/create_random_n_digits_number.py https://github.com/NobuyukiInoue/pyHitAndBlow/blob/master/mylibs/lib_hit_and_blow.py
Le format du programme questionneur est le suivant.
create_random_n_digits_number.py [N]
| option | La description |
|---|---|
| N | Nombre de chiffres (2 <= N <= 10) (la valeur par défaut est 4) |
$ python create_random_n_digits_number.py 4
2357
Le ** programme côté questionneur ** que j'ai créé est ci-dessous. ** Le programme côté questionneur ** est un programme relativement simple.
Comme ce sera long, je vais omettre d'afficher la source.
https://github.com/NobuyukiInoue/pyHitAndBlow/blob/master/pyHitAndBlow_defence.py https://github.com/NobuyukiInoue/pyHitAndBlow/blob/master/mylibs/lib_hit_and_blow.py
Le format de l'argument est le suivant.
pyHitAndBlow_defence.py [N [enable print] [answer number]]]
| option | La description |
|---|---|
| N | Nombre de chiffres dans la réponse (2 <= N <= 10) (la valeur par défaut est 4) |
| enable_print | non utilisé (la valeur par défaut est False) |
| answer_number | Numéro de réponse. Vous pouvez également spécifier le numéro de réponse à l'avance. |
$ python pyHitAndBlow_defence.py 4
N ... 4
When you want to end on the way, please input 0
[1] : select number xxxx = 3429 <--- "3429"Entrer
input response is Hit = 0, Blow = 2
[2] : select number xxxx = 7594 <--- "7594"Entrer
input response is Hit = 0, Blow = 1
[3] : select number xxxx = 9613 <--- "9613"Entrer
input response is Hit = 1, Blow = 2
[4] : select number xxxx = 9386 <--- "9386"Entrer
input response is Hit = 2, Blow = 1
[5] : select number xxxx = 9036 <--- "9036"Entrer
input response is Hit = 1, Blow = 3
[6] : select number xxxx = 9360 <--- "9360"Entrer
input response is Hit = 4, Blow = 0
congratulations!!!
my answer number is 9360.
===== challenge history ======
[1] .... 3429 (0, 2)
[2] .... 7594 (0, 1)
[3] .... 9613 (1, 2)
[4] .... 9386 (2, 1)
[5] .... 9036 (1, 3)
[6] .... 9360 (4, 0)
Le programme côté questionneur est ci-dessous.
https://github.com/NobuyukiInoue/pyHitAndBlow/blob/master/pyHitAndBlow_offence.py https://github.com/NobuyukiInoue/pyHitAndBlow/blob/master/mylibs/lib_hit_and_blow.py
Le flux de traitement général du programme de l'interrogateur est
En traitement,
Si le nombre de chiffres est de 4, répétez jusqu'à ce que la réponse soit ** Hits 4 **.
Le processus de 3 est le suivant.
Régénérez la prochaine liste de "solutions candidates", ne laissant que les candidats avec des succès et des coups correspondants
# create new canidiates numbers list.
new_target_numbers = []
for current_number in target_numbers:
if answer_check(n, current_number, selected_number, H, B):
# new candidates number add.
new_target_numbers.append(current_number)
target_numbers = new_target_numbers
Dans la première question, peu importe le numéro que vous demandez
La probabilité de réponse correcte est de ** 1/5040 ** lorsque le nombre de chiffres est de 4 et Le nombre de questions nécessaires pour trouver une solution est indécis,
En fonction du résultat de la réponse à la deuxième question Au pire, le nombre total de questions pour parvenir à la solution est déterminé.
Surtout dans cette deuxième question
** Au lieu de choisir le numéro à demander ensuite dans la liste des «numéros candidats» ** ** Il vaut mieux sélectionner «Nombre qui minimise le nombre de questions jusqu'à ce qu'une solution soit trouvée» ** et poser une question.
Le nombre moyen de questions est faible. Cette méthode est appelée ** "stratégie de question minimale" **.
Après avoir essayé environ 10000 fois,
** Lorsqu'il est sélectionné dans la liste des "Numéros qui sont des solutions candidates" ** Le nombre moyen de questions était d'environ ** 5,469 **,
Seule la deuxième question (dans l'implémentation actuelle), Si vous demandez dans ** "Stratégie de question minimale" ** Le nombre moyen de questions est tombé à ** 5,436 **.
Si vous allez en bas, il descendra à ** 5.2131 **, Nous n'avons pas beaucoup implémenté (pour le moment).
Vous devez peut-être également prendre en compte le biais aléatoire du module aléatoire en python. (En fait, les bibliothèques liées au hasard qui sont généralement utilisées présentent des variations en ce sens qu'il existe des valeurs susceptibles de se produire et des valeurs qui ne se produiront probablement pas car l'intérieur est représenté par des nombres binaires.)
** "Sélectionnez le numéro pour poser la question suivante parmi les candidats de la solution" ** Le traitement dans le cas est le suivant.
En utilisant des nombres aléatoires, retournez un entier dans la plage des éléments (0 à len (target_numbers) -1) dans la ** liste des candidats de la solution **, Renvoie la valeur de cet élément comme numéro à demander ensuite.
À partir de la deuxième fois, le même numéro que celui que vous avez demandé dans le passé peut être sélectionné, donc Si les nombres sont identiques, les candidats sont à nouveau sélectionnés.
Sélectionnez le numéro pour poser la question suivante parmi les candidats de solution
def create_canidiate_number(n:int, target_numbers:[str], history:HistoryRecords) -> str:
"""
create canidiate number.
"""
if len(history.challenge) == 0:
index = random.randint(0, len(target_numbers) - 1)
return target_numbers[index]
else:
while True:
index = random.randint(0, len(target_numbers) - 1)
if target_numbers[index] in history.challenge:
continue
return target_numbers[index]
Dans cette méthode, j'ai expliqué que le nombre moyen de questions est de ** 5,469 **. Pourtant, il est ** assez fort ** par rapport aux humains. (Au fait, je peux difficilement gagner)
Dans le cas de la "stratégie de question minimale", le numéro de la deuxième question est déterminé par le numéro et la réponse de la première question.
Si la première question est, par exemple, ** "0123" **, sélectionnez un nombre comme celui ci-dessous.
Le nombre que vous sélectionnez n'est pas limité aux candidats à la solution, donc Dans certains cas, un numéro auquel il est peu probable qu'il soit répondu correctement sera sélectionné,
Il a été prouvé que le nombre moyen de questions auxquelles répondre correctement diminue.
| Première réponse | Deuxième question | Nombre d'éléments | Nombre total de questions | Avec le premier numéro de question Deuxième question番号の différence |
|---|---|---|---|---|
| 4H0B | ---- | 1 | 0 | --- |
| 3H0B | 0245 | 24 | 73 | 1H1B |
| 2H2B | 0132 | 6 | 15 | 2H2B |
| 2H1B | 0145 | 72 | 240 | 2H0B |
| 2H0B | 0245 | 180 | 659 | 1H1B |
| 1H3B | 0134 | 8 | 22 | 2H1B |
| 1H2B | 0245 | 216 | 804 | 1H1B |
| 1H1B | 0245 | 720 | 2992 | 1H1B |
| 1H0B | 0456 | 480 | 1446 | 1H0B |
| 0H4B | 1230 | 9 | 23 | 0H4B |
| 0H3B | 1435 | 264 | 1004 | 0H2B |
| 0H2B | 1245 | 1260 | 5548 | 0H2B |
| 0H1B | 1456 | 1440 | 6595 | 0H1B |
| 0H0B | 4567 | 360 | 1446 | 0H0B |
Références) Stratégie de question minimale et stratégie la plus forte du jeu de devinettes de nombres MOO
https://www.tanaka.ecc.u-tokyo.ac.jp/ktanaka/papers/gpw96.pdf
Choisissez le nombre qui minimise le nombre de questions
def create_canidiate_number4_Minimum_question_strategy(n:int, target_numbers:[str], history:HistoryRecords) -> str:
"""
create canidiate number.
(Minimum question strategy)
"""
if len(history.challenge) == 1:
while True:
selected_number = create_random_n_digits_number(n)
if selected_number in history.challenge:
continue
H, B = response_check(n, history.challenge[-1], selected_number)
if history.response[-1] == [3, 0]:
if (H, B) == (1, 1):
return selected_number
elif history.response[-1] == [2, 2]:
if (H, B) == (2, 2):
return selected_number
elif history.response[-1] == [2, 1]:
if (H, B) == (2, 0):
return selected_number
elif history.response[-1] == [2, 0]:
if (H, B) == (1, 1):
return selected_number
elif history.response[-1] == [1, 3]:
if (H, B) == (2, 1):
return selected_number
elif history.response[-1] == [1, 2]:
if (H, B) == (1, 1):
return selected_number
elif history.response[-1] == [1, 1]:
if (H, B) == (1, 1):
return selected_number
elif history.response[-1] == [1, 0]:
if (H, B) == (1, 0):
return selected_number
elif history.response[-1] == [0, 4]:
if (H, B) == (0, 4):
return selected_number
elif history.response[-1] == [0, 3]:
if (H, B) == (0, 2):
return selected_number
elif history.response[-1] == [0, 2]:
if (H, B) == (0, 2):
return selected_number
elif history.response[-1] == [0, 1]:
if (H, B) == (0, 1):
return selected_number
elif history.response[-1] == [0, 0]:
if (H, B) == (0, 0):
return selected_number
else:
return selected_number
else:
while True:
index = random.randint(0, len(target_numbers) - 1)
if target_numbers[index] in history.challenge:
continue
return target_numbers[index]
Le format du programme questionneur est le suivant.
pyHitAndBlow_offence.py [N [enable print] [answer number]]]
| option | La description |
|---|---|
| N | Nombre de chiffres dans la réponse (2 <= N <= 10) (la valeur par défaut est 4) |
| enable print | Spécifier l'affichage / non-affichage de la liste des solutions candidates restantes (la valeur par défaut est False) |
| anser_number | numéro de réponse |
Le nombre de chiffres par défaut est de 4. Les candidats pour les étages restants sont des exemples d'exécution lorsqu'ils sont cachés. Saisissez manuellement ** Hits ** et ** Blows **.
$ python pyHitAndBlow_offence.py
(remaining count = 5040) Is your number 7016 ?
[1] : please input H, B = 0,1 <-- "0,1"outre"0 1", "01"Mais oui
(remaining count = 1440) Is your number 2950 ?
[2] : please input H, B = 0,1
(remaining count = 378) Is your number 4365 ?
[3] : please input H, B = 0,2 <-- "0,2"outre"0 2", "02"Mais oui
(remaining count = 99) Is your number 3628 ?
[4] : please input H, B = 0,2
(remaining count = 19) Is your number 1234 ?
[5] : please input H, B = 4,0 <-- "4,0"outre"4 0", "4"Mais oui
calculate successful.
===== challenge history =====
[1](5040) ---> 7016 (0, 1)
[2](1440) ---> 2950 (0, 1)
[3]( 378) ---> 4365 (0, 2)
[4]( 99) ---> 3628 (0, 2)
[5]( 19) ---> 1234 (4, 0)
Si vous entrez la mauvaise réponse ** pour la réponse que vous avez préparée, Puisqu'il n'y a pas de solution candidate au milieu, elle se terminera avant que le ** numéro de hit atteigne 4 **.
** Comparez le nombre demandé et votre réponse ** et soyez prudent ** pour être sûr. ** Je fais moi-même des erreurs environ 5 à 10% du temps. ** **
Puisque ** le calcul a échoué ** ne s'est pas produit dans des dizaines de milliers de tests, Il ne semble y avoir aucun bogue dans le programme (probablement). (Le script de test sera décrit plus tard.)
Ce qui suit est
La réponse que j'ai préparée était censée être ** "1234" **, Parce que j'ai répondu ** "0 2" ** au lieu de ** "2 0" ** dans la première réponse Voici un exemple de sortie sans atteindre ** Hits == 4 **.
$ python pyHitAndBlow_offence.py
(remaining count = 5040) Is your number 9238 ?
[1] : please input H, B = 0 2 <--- "2 0"Pas par erreur"0 2"Est entrée
input response is Hit = 0, Blow = 2
(remaining count = 1260) Is your number 1792 ?
[2] : please input H, B = 1 1
input response is Hit = 1, Blow = 1
(remaining count = 204) Is your number 2763 ?
[3] : please input H, B = 0 2
input response is Hit = 0, Blow = 2
(remaining count = 47) Is your number 1324 ?
[4] : please input H, B = 2 2
input response is Hit = 2, Blow = 2
(remaining count = 0) calculate failed.
===== challenge history ======
[1](5040) ---> 9238 (0, 2)
[2](1260) ---> 1792 (1, 1)
[3]( 204) ---> 2763 (0, 2)
[4]( 47) ---> 1324 (2, 2)
Si vous ne parvenez pas à saisir la réponse,
Après avoir spécifié le nombre de chiffres et affiché les solutions candidates, donnez le bon numéro de réponse, Vous pouvez également leur demander de répondre automatiquement.
Dans le script de test décrit plus loin, le ** programme côté interrogateur ** est exécuté dans ce ** mode de réponse automatique **.
$ python pyHitAndBlow_offence.py 4 false 1234
N ... 4
set answer number ... 1234
(remaining count = 5040) Is your number 1653 ?
input response is Hit = 1, Blow = 1
(remaining count = 720) Is your number 7463 ?
input response is Hit = 0, Blow = 2
(remaining count = 165) Is your number 6054 ?
input response is Hit = 1, Blow = 0
(remaining count = 16) Is your number 3257 ?
input response is Hit = 1, Blow = 1
(remaining count = 2) Is your number 1234 ?
input response is Hit = 4, Blow = 0
calculate successful.
===== challenge history =====
[1](5040) ---> 1653 (1, 1)
[2]( 720) ---> 7463 (0, 2)
[3]( 165) ---> 6054 (1, 0)
[4]( 16) ---> 3257 (1, 1)
[5]( 2) ---> 1234 (4, 0)
Un script de test est également disponible pour tester le programme interrogateur. https://github.com/NobuyukiInoue/pyHitAndBlow/blob/master/test_pyHitAndBlow.py https://github.com/NobuyukiInoue/pyHitAndBlow/blob/master/testscripts/test_pyHitAndBlow.sh https://github.com/NobuyukiInoue/pyHitAndBlow/blob/master/testscripts/test_pyHitAndBlow.ps1
Les deux scripts de test prennent comme argument Vous pouvez spécifier ** le nombre de chiffres dans la réponse et la question ** et ** le nombre d'exécutions du programme de l'interrogateur **. Après avoir exécuté le programme côté question un nombre spécifié de fois, le ** nombre moyen de questions ** et le ** temps d'exécution ** requis jusqu'à la bonne réponse finale sont affichés.
Pour référence, le programme côté interrogateur en mode de réponse automatique, Nous publierons l'heure d'exécution lorsque la solution est à 4 chiffres et exécutée 10000 fois.
| Article | Valeur |
|---|---|
| CPU | Inten(R) Core(TM) i7-8559U CPU @ 2.70GHz |
| Mémoire | 16 Go (LPDDR3 / 2133 MHz) |
| nom de fichier | OS | Temps d'exécution |
|---|---|---|
| test_pyHitAndBlow.py | Windows 10 Pro(version 2004) | 166[s] |
| test_pyHitAndBlow.py | Windows 10 Pro(version 2004) (Out-Exportez vers un fichier avec l'applet de commande File. Le disque dur peut être plus lent) |
129[s] |
| test_pyHitAndBlow.py | WSL2(ubuntu18.04) | 123[s] |
| type | OS | Temps d'exécution |
|---|---|---|
| test_pyHitAndBlow.sh(bash) | WSL2(ubuntu18.04) | 530[s] |
| test_pyHitAndBlow.ps1(PowerShell) | WSL2(ubuntu18.04) | 554[s] |
| test_pyHitAndBlow.ps1(PowerShell) | Windows 10 Pro(version 2004) | 1295[s] |
Dans la version du script shell, pyHitAndBlow_offence.py est lancé chaque fois qu'une question est posée. En raison de la surcharge importante de démarrage / arrêt de processus, elle est considérablement plus lente que la version de processus unique.
python test_pyHitAndBlow.py [N [MAX]]
$ python test_pyHitAndBlow.py 4 10
...
...
(remaining count = 2) Is your number 3970 ?
input response is Hit = 2, Blow = 2
(remaining count = 1) Is your number 9370 ?
input response is Hit = 4, Blow = 0
===== challenge history ======
[1] .... 5076 (1, 1)
[2] .... 6049 (0, 2)
[3] .... 5634 (0, 1)
[4] .... 4870 (2, 0)
[5] .... 3970 (2, 2)
[6] .... 9370 (4, 0)
# Latest Average = 5.4000
==== ResultCount history =====
ResultCount[0] = 7
ResultCount[1] = 5
ResultCount[2] = 6
ResultCount[3] = 5
ResultCount[4] = 4
ResultCount[5] = 5
ResultCount[6] = 5
ResultCount[7] = 5
ResultCount[8] = 6
ResultCount[9] = 6
======== distribution ========
0 ... 0
1 ... 0
2 ... 0
3 ... 0
4 ... 1
5 ... 5
6 ... 3
7 ... 1
8 ... 0
9 ... 0
10 ... 0
11 ... 0
12 ... 0
Distribution list Total = 10
==============================
Total Questions = 54
Total Average = 5.4
==============================
start ... 2020-09-05 12:03:34.129205
end ... 2020-09-05 12:03:34.271266
test_pyHitAndBlow.sh [N [MAX]]
$ ./testscripts/test_pyHitAndBlow.sh 4 10
...
...
(remaining count = 6) Is your number 6097 ?
input response is Hit = 0, Blow = 2
(remaining count = 1) Is your number 8160 ?
input response is Hit = 4, Blow = 0
calculate successful.
===== challenge history ======
[1](5040) ---> 4065 (1, 1)
[2]( 720) ---> 4203 (0, 1)
[3]( 180) ---> 8495 (1, 0)
[4]( 26) ---> 1467 (1, 1)
[5]( 6) ---> 6097 (0, 2)
[6]( 1) ---> 8160 (4, 0)
# Latest Average = 5.4000
==== ResultCount history =====
result_count[0] = 4
result_count[1] = 5
result_count[2] = 6
result_count[3] = 5
result_count[4] = 6
result_count[5] = 4
result_count[6] = 5
result_count[7] = 6
result_count[8] = 7
result_count[9] = 6
======== distribution ========
0 ... 0
1 ... 0
2 ... 0
3 ... 0
4 ... 2
5 ... 4
6 ... 3
7 ... 1
8 ... 0
9 ... 0
10 ... 0
11 ... 0
12 ... 0
Distribution list total = 10
==============================
Total Questions = 53
Total average = 5.3000
==============================
start ... 2020-09-05 13:09:44
end ... 2020-09-05 13:09:46
total execution time ... 2[s]
test_pyHitAndBlow.ps1 [N] [MAX]
D:\pyHitAndBlow> .\testscripts\test_pyHitAndBlow.ps1 4 10
...
...
(remaining count = 16) Is your number 3895 ?
input response is Hit = 2, Blow = 2
(remaining count = 1) Is your number 5893 ?
input response is Hit = 4, Blow = 0
calculate successful.
===== challenge history ======
[1](5040) ---> 6380 (0, 2)
[2](1260) ---> 4069 (0, 1)
[3]( 304) ---> 1938 (0, 3)
[4]( 16) ---> 3895 (2, 2)
[5]( 1) ---> 5893 (4, 0)
# Latest Average = 5.4
==== ResultCount history =====
ResultCount[0] = 6
ResultCount[1] = 5
ResultCount[2] = 7
ResultCount[3] = 4
ResultCount[4] = 5
ResultCount[5] = 7
ResultCount[6] = 4
ResultCount[7] = 6
ResultCount[8] = 5
ResultCount[9] = 5
======== distribution ========
0 ... 0
1 ... 0
2 ... 0
3 ... 0
4 ... 2
5 ... 4
6 ... 2
7 ... 2
8 ... 0
9 ... 0
10 ... 0
11 ... 0
Distribution list Total = 10
==============================
Total Questions = 54
Total Average = 5.4
==============================
start ... 2020-09-05 12:20:56
end ... 2020-09-05 12:20:57
Total execution time ... 1.1599779[s]
Pour la stratégie moyenne minimale,
Comme mentionné ci-dessus Actuellement mis en œuvre uniquement lorsque ** n = 4 **, Nous mettons en œuvre la stratégie de question minimale uniquement pour la deuxième question.
autres, Il peut y avoir des erreurs dans le programme, mais Je vous serais reconnaissant de bien vouloir m'en informer.