[PYTHON] Das Problem der Lügner und der Ehrlichkeit

Einführung

Irgendwann fand ich das folgende "Problem zwischen Lügner und ehrlichen Menschen". Ich war neugierig und habe es in Python programmiert.

In einem Dorf gab es vier Personen, Herr A, Herr B, Herr C und Herr D. Zwei von ihnen sind als Lügner bekannt, und zwei von ihnen sind als ehrlich bekannt. Lügner lügen immer und Ehrlichkeiten antworten immer ehrlich. Sie sind logisch und es gibt keine Fehler. Sie haben vier Karten mit den Bezeichnungen 1, 2, 3 und 4. Keine Karte hat die gleiche Nummer. Wir haben sie zufällig ausgewählt und einzeln gegeben. Sie sagten: Herr A: Meine Karte ist gerade. Herr B: Meine Karte ist entweder 3 oder 4. Herr C: Herr B ist eine ehrliche Familie. Herr D: Meine Karte ist 1. Erstellen Sie ein Programm, das die Zahlen auf den Karten anzeigt, die ihnen möglicherweise ausgeteilt wurden, und wer der Lügner / Ehrliche ist.

Wie geht es weiter?

Ich weiß nicht, wer A, B, C oder D ein Lügner oder eine ehrliche Person ist (natürlich, weil dies ein Problem ist), daher werde ich alle Muster verwenden, vorausgesetzt, dass jede Person ein Lügner oder eine ehrliche Person ist. Bestimmen Sie den Lügner oder ehrlichen Stamm jeder Person. Als nächstes dachte ich, dass es besser wäre, die Lösung zu finden, wenn das angenommene Muster und das beurteilte Muster übereinstimmen, also werde ich ein solches Programm erstellen.

Beurteilung des Lügners oder der Ehrlichkeit

Wie unten gezeigt, bestimmen die Karten, ob Herr A, Herr B, Herr C und Herr D Lügner oder ehrlich sind. Herr C wird jedoch nach dem Lügner / der Ehrlichkeit von Herrn B urteilen.

Herr A:

Herr B:

Herr C:

Herr D:

Eine Kombination aus Lügner und Ehrlichkeit

Die Kombination aus Lügner und Ehrlichkeit ergibt die folgenden 6 Muster. Lügner sind 0 und Ehrlichkeit ist 1.

Kombination von Karten zum Austeilen

Die Kombination der zu verteilenden Karten wird aus der Reihenfolge _{n </ sub> P k </ sub> berechnet (die Zahl, wenn k aus n ausgewählt wird). Verwenden Sie diesmal 4 </ sub> P 4 </ sub>. Das itertools-Paket von Python verfügt über eine Funktion permutations (), die nach einer Sequenz fragt. Verwenden Sie diese.}

Tatsächlicher Code

Python

#Das Problem der Lügner und der Ehrlichkeit
import itertools

#Urteil von Herrn A: Meine Karte ist gerade.
def judge_A(card_no):
    if (card_no % 2) == 0:
        ret = 1
    else:
        ret = 0
    return ret

#Das Urteil von Herrn B: Meine Karte ist entweder 3 oder 4.
def judge_B(card_no):
    if card_no == 3 or card_no == 4:
        ret = 1
    else:
        ret = 0
    return ret

#Urteil von Herrn C: Herr B ist eine ehrliche Familie.
def judge_C(judge_of_B):
    if judge_of_B == 1:
        ret = 1
    else:
        ret = 0
    return ret

#Urteil von Herrn D: Meine Karte ist 1.
def judge_D(card_no):
    if card_no == 1:
        ret = 1
    else:
        ret = 0
    return ret

#Beurteilung
#   deal_card :Ausgegebene Karten (1, 2, 3, 4). Eine Liste von 4 Elementen.
#               [0]=Herr A,[1]=Herr B, "2"=Herr C,[3]=Herr D.
#   return    :Urteilsergebnis. Eine Liste von 4 Elementen.
#               [0]=Herr A,[1]=Herr B, "2"=Herr C,[3]=Herr 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():
    #Eine Kombination aus Lügner und Ehrlichkeit
    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]]

    #Karten zu behandeln(1 bis 4)Kombination (sequentiell: nPk)
    cards_comb = list(itertools.permutations([1, 2, 3, 4]))

    #Untersuchen Sie durch die Kombination von Lügner und Ehrlichkeit x Kartenkombination.
    print("\
Lügner(0)/ Ehrlich(1)          |Karten ausgeteilt\n\
Herr A, Herr B, Herr C, Herr D.|Herr A, Herr B, Herr C, Herr 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()

Ausführungsergebnis

Es stellte sich heraus, dass es die folgenden 6 Fälle gibt.

Lügner(0)/ Ehrlich(1)           |Karten ausgeteilt
Herr A, Herr B, Herr C, Herr D.|Herr A, Herr B, Herr C, Herr 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   

abschließend

Es war ein gutes Problem für meine Gehirnübungen.