A tarefa é retirada de uma palestra do Prof. Devadas, do MIT, chamada Você pode ler mentes . Uma explicação detalhada do truque pode ser encontrada no vídeo vinculado ou neste documento . Vou tentar explicar em termos mais simples.
Acontece que isso foi inventado na década de 1930 e é conhecido como o "truque de cinco cartas da Fitch Cheney" .
O truque é assim:
- Cinco cartas aleatórias são escolhidas de um baralho. A platéia e seu assistente podem vê-los, mas você não.
- Seu assistente (com quem você praticou) selecionará quatro dessas cartas e as mostrará em uma ordem específica. Observe que o cartão oculto não é escolhido aleatoriamente entre os 5 cartões. O assistente escolhe um / o cartão que fará o truque funcionar.
- Você deduzirá, com base nas informações que pode coletar dos quatro cartões, o que é o quinto cartão.
Quão?
Lembre-se dos dois pontos a seguir:
Ao escolher 5 cartas aleatórias, você tem a garantia de que pelo menos duas cartas têm o mesmo naipe 1 .
A imagem abaixo mostra um círculo com todas as classificações 2 . Como é um círculo, é possível contar: J, Q, K, A, 2, 3 (isto é, contagem modular). Você está garantido que a carta oculta não tem a mesma classificação que a primeira, pois será do mesmo naipe (explicado abaixo). Sempre é possível escolher o primeiro cartão e os cartões ocultos, de modo que o cartão oculto esteja entre 1 e 6 graus mais alto que o primeiro (quando contando em círculos). Se o primeiro cartão for 1 , o cartão oculto será 2,3,4,5,6 ou 7 . Se o primeiro cartão for J , o cartão oculto será Q, K, A, 2,3 ou 4 e assim por diante.
O algoritmo:
A primeira carta: esta carta terá o mesmo naipe da carta oculta. O cartão também será o ponto de referência que você usará ao descobrir a classificação do cartão oculto.
As 2ª, 3ª e 4ª cartas decodificam um valor no intervalo inclusivo 1 ... 6 . Chamaremos os três cartões de S, M, L (cartão menor, cartão do meio, cartão maior). Os valores serão codificados desta forma (ordem lexicográfica):
S M L -> 1
S L M -> 2
M S L -> 3
M L S -> 4
L S M -> 5
L M S -> 6
Portanto, se o ranking da primeira carta for 5 e as três cartas restantes tiverem classificação 4 Q 7 (elas são ordenadas SLM ), a última carta terá classificação 5 + 2 = 7 . Você pode escolher se o ás deve ser a carta mais alta ou mais baixa, desde que seja consistente.
Se várias cartas compartilharem o mesmo ranking, o naipe determinará a ordem em que C <D <H <S .
Formato de entrada:
As quatro cartas serão dadas como H3 (três de copas), DK (rei de diamantes) e assim por diante. Você pode optar por considerar a entrada como 3H e KD .
A entrada pode estar em qualquer formato conveniente, mas você não pode combinar a lista de naipes em uma variável e a lista de classificações em outra. 'D5', 'H3' ..
e [['D',5],['H',3] ...
são ambos OK, mas 'DHCH',[5,3,1,5]
não é. Você não pode usar números em vez de letras, com exceção de T .
Resultado
O cartão oculto, no mesmo formato que a entrada.
Exemplo
Vamos fazer uma explicação passo a passo:
Input:
D3 S6 H3 H9
Sabemos que o cartão oculto é um diamante, pois o primeiro cartão é um diamante. Também sabemos que o ranking é 4,5,6,7,8 ou 9, já que o ranking da primeira carta é 3 .
Os cartões restantes são encomendados 6,3,9 ==> M, S, L , que codifica o valor 3 . O cartão oculto é, portanto, 3 + 3 = 6 de diamantes, portanto a saída deve ser D6 .
Casos de teste:
C3 H6 C6 S2
C9 # The order is LMS (H6 > C6, and 2 < 6). 3+6=9
SQ S4 S3 ST # (ST = S10. Format is optional)
S2 # The order is MSL. 12+3=2
HA CA DA SA
H2 # The order is SML. 14+1=2
Isso é código-golfe , então a solução mais curta em cada idioma vence. As explicações são incentivadas!
1 Existem quatro naipes ( C Lubs, D iamonds, H earts e S PAdES).
2 Existem 13 fileiras, 2,3,4,5,6,7,8,9,10, J, Q, K, A . Você pode optar por usar T em vez de 10 .
fonte
92427**3
e modifiquek+7
parak+8
salvar 1 byte:a=>(k='A23456789TJQK'+92427**3)[[[r,s],...x]=a.map((c,i)=>[k.search(c[0])+10,c[1],i]),(r-k[x.sort().map(c=>k=k*2|c[2])|k+8])%13]+s
187**97
ek+15
também funciona, mas tenho certeza de que esses são os únicos dois conjuntos mais curtos para esse algoritmo.1/34547
comk+14
também funciona.Python 2 ,
143140138136127125124123121 bytesExperimente online!
Ases são altos
Codifica as três cartas localizando sua posição em uma lista ordenada de cartas (
0=smallest, 1=middle, 2=largest
):Isso é convertido em um número inteiro na base 3 e multiplicado por 3 e dividido por 10:
As diferentes codificações são:
Salvou:
fonte
3
era inteligente! Resposta agradável :)0
ao final e divido por 10, o que parece ser equivalente.Gelatina , 33 bytes
Experimente online!
Explicação
A primeira linha é niládica. Rende uma lista dos 52 cartões
No link principal,
¢
chama o resultado do primeiro link, que é a lista de cartões.fonte
1
ás.APL (Dyalog Unicode) , 49 bytes SBCS
Experimente online!
Visão geral:
'CDHS'∘.,2↓⎕D,'TJQKA'
gera o produto externo, portanto, uma matriz 2D com(C2 C3 C4 ...), (D2 D3 D4 ...), ...
. Transporemos essa matriz para obter(C2 D2 H2 ...), ...
e achatar isso.Obrigado a @ngn pelo
2-⌊1.8⊥
, que pega a ordem dos cartões (SML = 1 2 3) e os classifica (como de 1 a 6 no OP).Explicação do código:
fonte
Retina ,
218208 bytesExperimente online!
Explicação:
Substitui Ases, Valetes, Rainhas e Reis por 1, 11, 12 e 13. As duas primeiras linhas precedem a
1
antes da letra e o último translitera o segundo dígito.A
*
indica que nesta fase não deve modificar a seqüência de trabalho. Isso pode fazer o cenário parecer inútil, mas será útil mais tarde. Ele'
divide a cadeia de trabalho em todos os espaços eG0
pega a primeira (para encontrar a primeira carta).As duas primeiras linhas multiplicam os números dos cartões por 5 e depois os tornam unários (por exemplo, 5 é representado como _____), para que possamos adicionar quantias menores para os fatos mais tarde. A linha final se divide em espaços e mantém as três últimas cartas.
Isso converte Clubes, Diamantes, Copas e Espadas em 0, 1, 2 e 3, respectivamente, e transforma o número em unário. Como está agora anexado à parte numérica do cartão, ele fornecerá um valor exclusivo para o cartão, determinando a sua altura.
Isso encontra a ordem dos cartões e o valor a ser adicionado ao primeiro cartão. Por exemplo, na primeira linha
/^(_+)¶\1_+/(
corresponde a pedidos que têm o valor do meio maior que o primeiro valor. Ele cria um loop if-else para o que fazer (pois essa ordem corresponde às permutações 1, 2 e 4).K
marca uma constante.Lembra-se anteriormente, quando costumávamos
*
indicar que um estágio não afetaria a sequência de trabalho? É aqui que a usamos. Este estágio é um estágio de substituição; ele substitui o número a ser adicionado$+3-$&
.$+3
acessa o*
palco, pega o naipe e o número da primeira carta,-
atua como um separador e$&
é a partida. Então a cadeia de trabalho está agora{suit}{original number}-{number to add}
Isso transforma os dois números em unários e os soma.
A linha superior captura o número ou o número - 13 (para que não tenhamos saídas, por exemplo, S16). A linha inferior transforma o número capturado novamente na base 10 e o resultado é impresso implicitamente.
fonte
Carvão ,
6462 bytesExperimente online! Link é a versão detalhada do código. Usa
T
para 10 e classificaA
alto. O índice de permutação não foi decodificado com muita facilidade; uma ordem de permutação diferente teria me poupado pelo menos três bytes. Explicação:Adicione 2 a todos os números inteiros de 0 a 7 e concatente-os e sufixo
TJQKA
para os cartões de figuras e ás. Isso economiza 2 bytes sobre um literal de cadeia de caracteres, embora aconteça que terA
alto teria economizado um byte através da compactação de cadeia de qualquer maneira.Mapa sobre as cartas e os naipes, concatentando os dois juntos. Como isso normalmente produziria uma matriz aninhada, os resultados são concatenados em uma única sequência, que é dividida em pares de caracteres novamente.
Encontre as posições do segundo, terceiro e quarto cartões.
Calcule o índice de permutação indexado em 1. As duas primeiras permutações têm a menor carta primeiro; isso é testado via
⌕υ⌊υ
. Os outros dois pares de permutações são diferenciados quanto à primeira carta maior; isso é testado via⌕υ⌈υ
. As operações lógicas e aritméticas mapeiam esses testes para os valores0
,2
e4
; isso é aumentado1
dependendo da comparação entre a terceira e a quarta placas, testadas via‹⊟υ⊟υ
. Finalmente, o índice é incrementado para fornecer a codificação desejada.Multiplique isso por 4 representando a distância entre as cartas do mesmo naipe, adicione a posição da primeira carta e indexe ciclicamente e imprima o resultado.
fonte
Python 2 , 147 bytes
Experimente online!
fonte
Pitão, 42 bytes
Realmente feio...
Experimente on-line: Demontration ou Test Suite
fonte
J , 68 bytes
Experimente online!
Nota: -3 fora de bytes TIO porque o
f=.
não conta. Tentará jogar mais e adicionar explicações amanhã.fonte
JavaScript (Node.js) , 124 bytes
Experimente online!
JavaScript (Node.js) , 125 bytes
Experimente online!
fonte
T-SQL, 211 bytes
Entrada é uma variável de tabela. Usando T para 10, ases são baixos
Formato para classificação de cartas / naipe KH, 6D, TS
Experimente on-line sem limites
Observe como o valor SML (12-17) é calculado:
Logicamente S, M, L (1,2,3) é convertido em um valor numérico
Ao multiplicar por 3, a raiz quadrada arredondada para baixo se torna um bom número seqüencial.
fonte
05AB1E , 37 bytes
Porto de @dylnan resposta Jelly 's , mas infelizmente 05AB1E não tem o builtin índice de permutação ..
Experimente online ou verifique todos os casos de teste .
Explicação:
Consulte esta dica 05AB1E (seção Como compactar cadeias de caracteres que não fazem parte do dicionário? ) Para entender por que
.•3u§•
é"jqka"
e.•ôì•
é"cdhs"
.fonte