Python: j'ai essayé menteur et honnête

Problèmes de menteurs et d'honnêteté Je ne sais pas de quel numéro il s'agit, mais ça a l'air intéressant alors je l'ai essayé.

python

import itertools

#Renvoyer des réponses cohérentes du joueur et du paquet de cartes
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 
  )
)
#Générateur qui renvoie un tapple de la main de chaque carte
handss = lambda card_deck: itertools.permutations(card_deck)

#Un tuple de tuples si chaque joueur est honnête(Décisif 2)
is_each_honests = (
  (True, False, False, True)
  ,(False, True, True, False)
)

#Les données
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)    # (Décisif 1)
  , hands[3] == 1
)

#Application et affichage des fonctions
for e in consistents(players)(card_deck)(statements):
  print(e)

python

#résultat:
((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))

Il y a une décision définitive.

Décisif 1: "B est honnête" => "B est correct" => B dit => Converti en "la carte de B est 3 ou 4"

Une fois que la main de la carte est décidée, la vérité de chaque affirmation est décidée, le problème devient donc simple.

Décisif 2: Menteur / Honnêtement deux personnes chacun => B et C sont la même déclaration => B et C sont la même famille => A et D sont la famille opposée

Il y a 6 voies au total s'il n'y a pas de restrictions, mais lorsque B et C sont dans la même famille, la variation est réduite à 2 voies.

python

>>> players = 0, 1, 2, 3
#Pas de restrictions
>>> 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 façons
#Limited Liar est AD ou autrement 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 façons

Vous pouvez le calculer, mais il n'y en a que deux, alors je me demande si vous pouvez l'écrire directement.

Basé sur ce qui précède

Un peu court

Je vais essayer.

Décisif 1 => Combiner B et C

B et C sont les mêmes, qu'ils soient honnêtes ou non.

Définir 2 => Vrai / Faux

S'il n'y a que deux façons, cela peut être exprimé par une simple valeur logique au lieu d'un taple. Si l'affichage est important, vous pouvez le concevoir un peu.

python

import itertools

#Renvoyer des réponses cohérentes du joueur et du paquet de cartes
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)    # (Décisif 2)
    if  statements(hands) == (is_AD_honest, not is_AD_honest, is_AD_honest) # (Décisif 1) 
  )
)

#Les données
players = (0, 1, 2, 3)
card_deck = (1, 2, 3, 4)

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

#Application et affichage des fonctions
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)) # (Décisif 2)
  )

C'est facile à comprendre, mais c'est un peu plus court.

Mais en premier lieu ...

N'est-ce pas trop dur?

Si chaque énoncé est différent (par exemple, si C dit «B est un menteur»), la partie catégorielle devient inutile. Je recommencerai.

C'est ce qui semble fonctionner même si vous réécrivez le contenu de chaque instruction «instructions».

python

import itertools

#Renvoyer des réponses cohérentes du joueur et du paquet de cartes
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 
  )
)
#Générateur qui renvoie un tapple de la main de chaque carte
handss = lambda card_deck: itertools.permutations(card_deck)

#Un générateur qui renvoie un tuple indiquant si chaque joueur est honnête
is_each_honests = lambda players:( 
  tuple( e in honests for e in players ) 
  for honests in itertools.combinations(players, 2)
)

#Les données
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
)

#Application et affichage des fonctions
for e in consistents(players)(card_deck)(statements):
  print(e)

Cependant, il est toujours valable de «convertir une référence à une personne en une réclamation concernant la main d'une carte» qui a été faite dans le premier.