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:

M. B:

M. C:

M. D:

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.

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.