Le problème des menteurs et de l'honnêteté

introduction

À un moment donné, j'ai trouvé le "problème suivant entre le menteur et les honnêtes gens". J'étais curieux, alors je l'ai programmé en Python.

Dans un village, il y avait quatre personnes, M. A, M. B, M. C et M. D. Deux d'entre eux sont connus pour être des menteurs, et deux d'entre eux sont connus pour être honnêtes. Les menteurs mentent toujours, et les honnêtes répondent toujours honnêtement. Ils sont logiques et il n'y a pas d'erreur. Vous avez quatre cartes étiquetées 1, 2, 3 et 4. Aucune carte n'a le même numéro. Je les ai choisis au hasard et je les ai donnés un par un. Ils ont dit: Mr. A: Ma carte est paire. Mr. B: Ma carte est de 3 ou 4. Mr. C: Mr. B est une famille honnête. Mr. D: Ma carte est 1. Créez un programme qui montre les numéros sur les cartes qui peuvent leur avoir été distribués et qui est le menteur / honnête.

La façon de procéder

Je ne sais pas qui A, B, C ou D est un menteur ou une personne honnête (naturellement parce que c'est un problème), alors j'utiliserai tous les modèles en supposant que chaque personne est un menteur ou une personne honnête. Déterminez si chaque personne est un menteur ou une personne honnête. Ensuite, j'ai pensé qu'il serait préférable de trouver la solution lorsque le modèle supposé et le modèle jugé correspondent, je vais donc créer un programme comme celui-là.

Jugement de menteur ou d'honnêteté

Comme indiqué ci-dessous, les cartes distribuées détermineront si M. A, M. B, M. C et M. D sont des menteurs ou sont honnêtes. Cependant, M. C jugera par le menteur / l'honnêteté de M. B.

M. A:

Cartes distribuées Contenu de la remarque (fixe) Jugement
Même 私のカードは、Mêmeです. Honnête
Pas même Ma carte est paire. Menteur

M. B:

Cartes distribuées Contenu de la remarque (fixe) Jugement
3 ou 4 Ma carte est 3 ou 4. Honnête
Ni 3 ni 4 Ma carte est 3 ou 4. Menteur

M. C:

Monsieur B Contenu de la remarque (fixe) Jugement
Honnête Bさんは、Honnête者です. Honnête
Menteur M. B est une personne honnête. Menteur

M. D:

Cartes distribuées Contenu de la remarque (fixe) Jugement
1 Ma carte est 1. Honnête
Pas 1 Ma carte est 1. Menteur
Une combinaison de menteur et d'honnêteté

La combinaison du menteur et de l'honnêteté est les 6 modèles suivants. Les menteurs valent 0 et l'honnêteté vaut 1.

Monsieur A Monsieur B Monsieur C M. D
0 0 1 1
0 1 0 1
0 1 1 0
1 0 0 1
1 0 1 0
1 1 0 0
Combinaison de cartes à traiter

La combinaison de cartes à distribuer est calculée à partir de l'ordre n </ sub> P k </ sub> (le nombre lorsque k sont sélectionnés parmi n). Cette fois, utilisez 4 </ sub> P 4 </ sub>. Le package itertools de Python a une fonction permutations () qui demande une séquence, alors utilisez-la.

Code réel

Python


#Le problème des menteurs et de l'honnêteté
import itertools

#Jugement de M. A: Ma carte est paire.
def judge_A(card_no):
    if (card_no % 2) == 0:
        ret = 1
    else:
        ret = 0
    return ret

#Jugement de M. B: Ma carte est de 3 ou 4.
def judge_B(card_no):
    if card_no == 3 or card_no == 4:
        ret = 1
    else:
        ret = 0
    return ret

#Jugement de M. C: M. B est une famille honnête.
def judge_C(judge_of_B):
    if judge_of_B == 1:
        ret = 1
    else:
        ret = 0
    return ret

#Jugement de M. D: Ma carte est 1.
def judge_D(card_no):
    if card_no == 1:
        ret = 1
    else:
        ret = 0
    return ret

#Jugement
#   deal_card :Cartes distribuées (1, 2, 3, 4). Une liste de 4 éléments.
#               [0]=Monsieur A,[1]=M. B, «2»=Monsieur C,[3]=M. D
#   return    :résultat du jugement. Une liste de 4 éléments.
#               [0]=Monsieur A,[1]=M. B, «2»=Monsieur C,[3]=M. D
def judge(deal_card):
    lh_judge = [None, None, None, None]
    lh_judge[0] = judge_A(deal_card[0])
    lh_judge[1] = judge_B(deal_card[1])
    lh_judge[2] = judge_C(lh_judge[1])
    lh_judge[3] = judge_D(deal_card[3])
    return lh_judge

def main():
    #Une combinaison de menteur et d'honnêteté
    lh_comb = [[0, 0, 1, 1],
               [0, 1, 0, 1],
               [0, 1, 1, 0],
               [1, 0, 0, 1],
               [1, 0, 1, 0],
               [1, 1, 0, 0]]

    #Cartes à distribuer(1 à 4)Combinaison (séquentielle: nPk)
    cards_comb = list(itertools.permutations([1, 2, 3, 4]))

    #Enquêter sur la combinaison de la combinaison menteur et honnêteté x carte.
    print("\
Menteur(0)/ Honnête(1)          |Cartes distribuées\n\
M. A, M. B, M. C, M. D|M. A, M. B, M. C, M. D\n\
---------------------------------------------------------")
    for lh_assumption in lh_comb:
        for deal_card in cards_comb:
            lh_judge = judge(deal_card)
            if lh_assumption == lh_judge:
                print("{:^7d}{:^7d}{:^7d}{:^7d}|{:^7d}{:^7d}{:^7d}{:^7d}".
                      format(lh_judge[0],lh_judge[1],lh_judge[2],lh_judge[3],
                             deal_card[0],deal_card[1],deal_card[2],deal_card[3]))
    return

if __name__ == '__main__':
    main()
Résultat d'exécution

Il s'est avéré qu'il y avait les 6 cas suivants.

Menteur(0)/ Honnête(1)           |Cartes distribuées
M. A, M. B, M. C, M. D|M. A, M. B, M. C, M. D
---------------------------------------------------------
   0      1      1      0   |   1      3      2      4   
   0      1      1      0   |   1      3      4      2   
   0      1      1      0   |   1      4      2      3   
   0      1      1      0   |   1      4      3      2   
   0      1      1      0   |   3      4      1      2   
   1      0      0      1   |   4      2      3      1   
en conclusion

C'était un bon problème pour mes exercices cérébraux.

Recommended Posts

Le problème des menteurs et de l'honnêteté
Le problème des menteurs et de l'honnêteté
À propos des problèmes et des solutions d'OpenPyXL (version Ver 3.0)
Problème FizzBuzz ceci et cela
Mécanisme de pyenv et virtualenv
Pré-traitement et post-traitement de pytest
Combinaison de récursif et de générateur
Combinaison de anyenv et direnv
Explication et mise en œuvre de SocialFoceModel
Différenciation du tri et généralisation du tri
Coexistence de pyenv et autojump
Utilisation et intégration de "Shodan"
Comparaison de la loi hongroise et des solveurs polyvalents pour les problèmes d'allocation
[Astuces] Problèmes et solutions dans le développement de python + kivy
Occurrence et résolution de tensorflow.python.framework.errors_impl.FailedPreconditionError
Comparaison d'Apex et de Lamvery
Installation source et installation de Python
Introduction et astuces de mlflow.
Construction d'environnement de python et opencv
Combinaison de problèmes typiques d'optimisation et comment le faire
Ordre des arguments pour RegularGridInterpolator et interp2d
L'histoire de Python et l'histoire de NaN
Explication et mise en œuvre de PRML Chapitre 4
Introduction et mise en œuvre de JoCoR-Loss (CVPR2020)
Avantages et exemples d'utilisation de Rabbit Mq
Risque de mélange! ndarray et matrice
Installer SciPy et matplotlib (Python)
Importance de l'apprentissage automatique et de l'apprentissage par mini-lots
Introduction et mise en œuvre de la fonction d'activation
Mémorandum de sauvegarde et modèle de chargement
Malentendus et interprétations des dépendances de Luigi
Explication et mise en œuvre du perceptron simple
Calcul de la classe auto-fabriquée et de la classe existante
Ceci et cela des propriétés python
Méthode de planification des expériences et optimisation des combinaisons
Caractéristiques du lien symbolique et dur
Coexistence de Python2 et 3 avec CircleCI (1.0)
Résumé des index et des tranches Python
Agrégation et visualisation des nombres accumulés
Réputation des livres Python et des livres de référence