Python: Ich habe es mit Lügner und Ehrlichkeit versucht

Probleme von Lügnern und Ehrlichkeit Ich weiß nicht, um welche Nummer es sich handelt, aber es sieht interessant aus, also habe ich es versucht.

python

import itertools

#Geben Sie konsistente Antworten vom Spieler und vom Kartenspiel zurück
consistents = (
  lambda players: lambda card_deck: lambda statements:
  (
    (hands, is_each_honest) 
    for hands in handss(card_deck) 
    for is_each_honest in is_each_honests
    if  statements(hands) == is_each_honest 
  )
)
#Generator, der einen Schlag auf die Hand jeder Karte zurückgibt
handss = lambda card_deck: itertools.permutations(card_deck)

#Ein Tupel von Tupeln, ob jeder Spieler ehrlich ist(Entscheidend 2)
is_each_honests = (
  (True, False, False, True)
  ,(False, True, True, False)
)

#Daten
players = (0, 1, 2, 3)
card_deck = (1, 2, 3, 4)

statements = lambda hands: (
  hands[0] % 2 == 0
  , hands[1] in (3, 4)
  , hands[1] in (3, 4)    # (Entscheidend 1)
  , hands[3] == 1
)

#Funktionsanwendung und Anzeige
for e in consistents(players)(card_deck)(statements):
  print(e)

python

#Ergebnis:
((1, 3, 2, 4), (False, True, True, False))
((1, 3, 4, 2), (False, True, True, False))
((1, 4, 2, 3), (False, True, True, False))
((1, 4, 3, 2), (False, True, True, False))
((3, 4, 1, 2), (False, True, True, False))
((4, 2, 3, 1), (True, False, False, True))

Es gibt eine endgültige Entscheidung.

Entscheidend 1: "B ist ehrlich" => "B ist richtig" => B sagt => Umgerechnet in "B's Karte ist 3 oder 4"

Sobald die Hand der Karte entschieden ist, wird die Wahrheit jeder Aussage entschieden, so dass das Problem einfach wird.

Entscheidend 2: Lügner / Ehrlich gesagt zwei Personen => B und C sind die gleiche Aussage => B und C sind die gleiche Familie => A und D sind die entgegengesetzte Familie

Es gibt insgesamt 6 Möglichkeiten, wenn keine Einschränkungen bestehen. Wenn jedoch B und C zur selben Familie gehören, wird die Abweichung auf zwei Möglichkeiten reduziert.

python

>>> players = 0, 1, 2, 3
#Keine Einschränkungen
>>> tuple( tuple( not e in liars for e in players ) for liars in itertools.combinations(players, 2))
((False, False, True, True), (False, True, False, True), (False, True, True, False), (True, False, False, True), (True, False, True, False), (True, True, False, False))    #6 Möglichkeiten
#Limited Liar ist AD oder anderweitig BC
>>> tuple( tuple( not e in liars for e in players ) for liars in itertools.combinations(players, 2) if liars in ((0,3),(1,2)))
((False, True, True, False), (True, False, False, True))    #2 Wege

Sie können es berechnen, aber es gibt nur zwei, also frage ich mich, ob es in Ordnung ist, es direkt zu schreiben.

basierend auf dem oben genannten

Ein bisschen kurz

Ich werde versuchen.

Entscheidend 1 => Kombiniere B und C.

B und C sind gleich, ob sie ehrlich sind oder nicht.

Setze 2 => Richtig / Falsch

Wenn es nur zwei Möglichkeiten gibt, kann dies durch einen einfachen logischen Wert anstelle eines Taple ausgedrückt werden. Wenn das Display wichtig ist, können Sie es ein wenig gestalten.

python

import itertools

#Geben Sie konsistente Antworten vom Spieler und vom Kartenspiel zurück
consistents = (
  lambda players: lambda card_deck: lambda statements:
  (
    (hands, is_AD_honest) 
    for hands in itertools.permutations(card_deck)
    for is_AD_honest in (True, False)    # (Entscheidend 2)
    if  statements(hands) == (is_AD_honest, not is_AD_honest, is_AD_honest) # (Entscheidend 1) 
  )
)

#Daten
players = (0, 1, 2, 3)
card_deck = (1, 2, 3, 4)

statements = lambda hands: (
  hands[0] % 2 == 0
  , hands[1] in (3, 4)    # (Entscheidend 1)
  , hands[3] == 1
)

#Funktionsanwendung und Anzeige
for hands, is_AD_honest in consistents(players)(card_deck)(statements):
  print(
    (hands, (is_AD_honest, not is_AD_honest, not is_AD_honest, is_AD_honest)) # (Entscheidend 2)
  )

Es ist leicht zu verstehen, aber etwas kürzer.

Aber an erster Stelle ...

Ist es nicht zu schwer?

Wenn jede Aussage anders ist (zum Beispiel wenn C sagt "B ist ein Lügner"), wird der kategoriale Teil unbrauchbar. Ich werde von vorne anfangen.

Dies scheint auch dann zu funktionieren, wenn Sie den Inhalt jeder Anweisung "Anweisungen" neu schreiben.

python

import itertools

#Geben Sie konsistente Antworten vom Spieler und vom Kartenspiel zurück
consistents = (
  lambda players: lambda card_deck: lambda statements:
  (
    (hands, is_each_honest) 
    for hands in handss(card_deck) 
    for is_each_honest in is_each_honests(players)
    if  statements(hands) == is_each_honest 
  )
)
#Generator, der einen Schlag auf die Hand jeder Karte zurückgibt
handss = lambda card_deck: itertools.permutations(card_deck)

#Ein Generator, der ein Tupel zurückgibt, ob jeder Spieler ehrlich ist
is_each_honests = lambda players:( 
  tuple( e in honests for e in players ) 
  for honests in itertools.combinations(players, 2)
)

#Daten
players = (0, 1, 2, 3)
card_deck = (1, 2, 3, 4)

statements = lambda hands: (
  hands[0] % 2 == 0
  , hands[1] in (3, 4)
  , hands[1] in (3, 4)    
  , hands[3] == 1
)

#Funktionsanwendung und Anzeige
for e in consistents(players)(card_deck)(statements):
  print(e)

Es gilt jedoch weiterhin, "einen Verweis auf eine Person in einen Anspruch auf die Hand einer Karte umzuwandeln", der in der Entscheidung 1 vorgenommen wurde.