Faça um programa que simule os portões lógicos básicos.

Entrada: uma palavra em maiúsculas seguida por 2 números binários de 1 dígito, separados por espaços, como OR 1 0. Os portões OR, AND, NOR, NAND, XOR, e XNORsão necessários.

Saída: qual a saída da porta lógica inserida receberia os dois números: 1 ou 0.

Exemplos:
AND 1 0 torna- 0
XOR 0 1se 1
OR 1 1torna- 1
NAND 1 1se torna- se torna0

Este é um codegolf, então o código mais curto vence.

Geléia , 13 10 bytes

OSị“ʋN’BŻ¤

Experimente online!

Resposta do porto de Peter Taylor.

Python 2 , 38 bytes

lambda s:sum(map(ord,s))*3%61%37%9%7%2

Experimente online!

Uma boa e antiga cadeia de módulos aplicada à soma dos valores ASCII da string de entrada, criando uma solução que é apenas sobreajustada. O valor ASCII total é distinto para cada entrada possível, exceto as que apresentam 0 1e 1 0apresentam o mesmo resultado, o que ocorre porque todos os portões lógicos usados ​​são simétricos.

Ele *3separa valores adjacentes para entradas que diferem apenas nos bits, pois dificultam a divisão da cadeia de mods. O comprimento e o tamanho dos números na cadeia de mods cria aproximadamente a quantidade certa de entropia para atender a 18 saídas binárias.

Uma solução mais curta é certamente possível usando hash(s)or id(s), mas eu as evitei porque elas dependem do sistema.

Python 2 , 50 bytes

lambda s:'_AX0NRD'.find((s*9)[35])>>s.count('0')&1

Experimente online!

Uma solução um pouco mais baseada em princípios. Cada porta lógica fornece um resultado diferente para cada contagem de zeros na entrada, codificável como um número de três bits de 1 a 6. Cada porta lógica possível é mapeada para o número correspondente, tirando (s*9)[35]todas as que são distintas. Pois OR, isso acaba lendo um dos bits para que o personagem possa ser 0ou1 , mas acaba funcionando para verificar se é 0, e a 1dará um 1resultado corretamente de qualquer maneira.

JavaScript (ES6), 39 bytes

s=>341139>>parseInt(btoa(s),34)%86%23&1

Experimente online!

Quão?

Não podemos analisar espaços com parseInt(), independentemente da base com a qual estamos trabalhando. Portanto, injetamos uma representação de base 64 da string de entrada. Isso pode gerar= caracteres de preenchimento (que também não podem ser analisados parseInt()), mas é garantido que esses caracteres estejam localizados no final da string e podem ser ignorados com segurança.

Analisamos como base $34$ e aplicamos um módulo $86$ , seguido por um módulo $23$ , que fornece os seguintes resultados. Isso inclui imprecisões devido à perda de precisão. O resultado final está em $[0..19]$ , com o maior índice de verdade sendo $18$ , levando a uma máscara de pesquisa de 19 bits.

 input      | to base-64     | parsed as base-34 | mod 86 | mod 23 | output
------------+----------------+-------------------+--------+--------+--------
 "AND 0 0"  | "QU5EIDAgMA==" |  1632500708709782 |   26   |    3   |    0
 "AND 0 1"  | "QU5EIDAgMQ==" |  1632500708709798 |   42   |   19   |    0
 "AND 1 0"  | "QU5EIDEgMA==" |  1632500708866998 |   34   |   11   |    0
 "AND 1 1"  | "QU5EIDEgMQ==" |  1632500708867014 |   50   |    4   |    1
 "OR 0 0"   | "T1IgMCAw"     |     1525562056532 |   52   |    6   |    0
 "OR 0 1"   | "T1IgMCAx"     |     1525562056533 |   53   |    7   |    1
 "OR 1 0"   | "T1IgMSAw"     |     1525562075028 |   58   |   12   |    1
 "OR 1 1"   | "T1IgMSAx"     |     1525562075029 |   59   |   13   |    1
 "XOR 0 0"  | "WE9SIDAgMA==" |  1968461683492630 |   48   |    2   |    0
 "XOR 0 1"  | "WE9SIDAgMQ==" |  1968461683492646 |   64   |   18   |    1
 "XOR 1 0"  | "WE9SIDEgMA==" |  1968461683649846 |   56   |   10   |    1
 "XOR 1 1"  | "WE9SIDEgMQ==" |  1968461683649862 |   72   |    3   |    0
 "NAND 0 0" | "TkFORCAwIDA=" | 61109384461626344 |   62   |   16   |    1
 "NAND 0 1" | "TkFORCAwIDE=" | 61109384461626350 |   70   |    1   |    1
 "NAND 1 0" | "TkFORCAxIDA=" | 61109384461665650 |   64   |   18   |    1
 "NAND 1 1" | "TkFORCAxIDE=" | 61109384461665656 |   72   |    3   |    0
 "NOR 0 0"  | "Tk9SIDAgMA==" |  1797025468622614 |   76   |    7   |    1
 "NOR 0 1"  | "Tk9SIDAgMQ==" |  1797025468622630 |    6   |    6   |    0
 "NOR 1 0"  | "Tk9SIDEgMA==" |  1797025468779830 |   84   |   15   |    0
 "NOR 1 1"  | "Tk9SIDEgMQ==" |  1797025468779846 |   14   |   14   |    0
 "XNOR 0 0" | "WE5PUiAwIDA=" | 66920415258533864 |    0   |    0   |    1
 "XNOR 0 1" | "WE5PUiAwIDE=" | 66920415258533870 |    8   |    8   |    0
 "XNOR 1 0" | "WE5PUiAxIDA=" | 66920415258573170 |    2   |    2   |    0
 "XNOR 1 1" | "WE5PUiAxIDE=" | 66920415258573176 |   10   |   10   |    1

CJam (13 bytes)

q1bH%86825Yb=

Assume que a entrada está sem uma nova linha à direita.

Conjunto de testes online

Este é apenas um hash simples que mapeia as 24 entradas possíveis em 17 valores distintos, mas consistentes, e depois as pesquisa em uma tabela compactada.

Python 2 (36 bytes)

lambda s:76165>>sum(map(ord,s))%17&1

Esta é apenas uma porta da resposta CJam acima. Conjunto de testes utilizando framework de testes de xnor.

05AB1E , 13 12 10 8 bytes

ÇO₁*Ƶï%É

O cálculo alternativo de Port of @mazzy mencionado no comentário em sua resposta do Powershell (em *256%339%2vez de *108%143%2).

Experimente online ou verifique todos os casos de teste .

Explicação:

Ç            # Convert each character in the (implicit) input to a unicode value
 O           # Sum them together
  ₁*         # Multiply it by 256
    Ƶï%      # Then take modulo-339
        É    # And finally check if it's odd (short for %2), and output implicitly

Veja este 05AB1E ponta do meu (seção Como comprimir grandes inteiros? ) Para entender por que Ƶïé 339.

Carvão , 32 bytes

§01÷⌕⪪”＆⌈4Ｙ⍘ＬH⦄vü|⦃³Ｕ}×▷” Ｓ∨⁺ＮＮ⁴

Experimente online! Link é a versão detalhada do código. Explicação: A cadeia compactada se expande para uma lista das operações suportadas, para que o índice da operação especificada seja então deslocado para a direita de acordo com as entradas e o bit assim extraído se torne o resultado.

XOR     001
AND     010
OR      011
NOR     100
NAND    101
XNOR    110
inputs  011
        010

A versão de 74 bytes funciona para todas as 16 operações binárias, que eu nomeei arbitrariamente da seguinte forma: ZERO E MENOS SEGUNDO MAIOR PRIMEIRO XOR OU NEM SINCRONIZA NORTE PRIMEIRO NORTE NSECOND NLESS NAND NZERO.

§10÷÷⌕⪪”＆↖VρＳ´↥cj/v⊗J[Rf↓⪫？9ＫO↘Ｙ⦄;↙W´Ｃ>η=⁴⌕✳AＫＸIＢ｜⊖\`⊖:Ｂ�Ｊ/≧vF@$h⧴” Ｓ∨Ｎ²∨Ｎ⁴

Experimente online! Link é a versão detalhada do código.

Mathematica, 55 bytes

Symbol[ToCamelCase@#][#2=="1",#3=="1"]&@@StringSplit@#&

Função pura. Toma uma string como entrada e retorna Trueou Falsecomo saída. Desde Or, And, Nor, Nand, Xor, e Xnorsão todos built-ins, usamos ToCamelCasepara mudar o operador caso Pascal, convertê-lo para o símbolo equivalente, e aplicá-lo aos dois argumentos.

J , 21 bytes

2|7|9|37|61|3*1#.3&u:

Experimente online!

Porta da solução Python 2 do xnor .

J , 30 bytes

XNOR=:=/
NAND=:*:/
NOR=:+:/
".

Experimente online!

Alguns pouco de diversão com eval ".biblioteca e padrão (que já inclui correta AND, OR, XOR).

J , 41 bytes

({7 6 9 8 14 1 b./)~1 i.~' XXNNA'E.~_2&}.

Experimente online!

Abordagem mais ao estilo J.

Como funciona

Um truque J muito geral está oculto aqui. Freqüentemente, a função desejada tem a estrutura "Executar F em uma entrada, executar H na outra e executar G nos dois resultados". Então deve funcionar como (F x) G H y. Na forma tácita, é equivalente a (G~F)~H:

x ((G~F)~H) y
x (G~F)~ H y
(H y) (G~F) x
(H y) G~ F x
(F x) G H y

E se G for uma primitiva assimétrica, basta trocar os argumentos esquerdo e direito da função alvo, e podemos salvar um byte.

Agora, vamos à resposta acima:

({7 6 9 8 14 1 b./)~1 i.~' XXNNA'E.~_2&}.

1 i.~' XXNNA'E.~_2&}.  Processing right argument (X): the operation's name
                _2&}.  Drop two chars from the end
1 i.~' XXNNA'E.~       Find the first match's index as substring
                       Resulting mapping is [OR, XOR, XNOR, NOR, NAND, AND]

7 6 9 8 14 1 b./  Processing left argument (Y): all logic operations on the bits
7 6 9 8 14 1 b.   Given two bits as left and right args, compute the six logic functions
               /  Reduce by above

X{Y  Operation on both: Take the value at the index

Powershell, 36 34 bytes

Inspirado no xnor , mas a sequência *108%143%2é mais curta que a original*3%61%37%9%7%2

$args|% t*y|%{$n+=108*$_};$n%143%2

Script de teste:

$f = {

 $args|% t*y|%{$n+=108*$_};$n%143%2
#$args|% t*y|%{$n+=3*$_};$n%61%37%9%7%2   # sequence by xnor

}

@(
    ,("AND 0 0", 0)
    ,("AND 0 1", 0)
    ,("AND 1 0", 0)
    ,("AND 1 1", 1)
    ,("XOR 0 0", 0)
    ,("XOR 0 1", 1)
    ,("XOR 1 0", 1)
    ,("XOR 1 1", 0)
    ,("OR 0 0", 0)
    ,("OR 0 1", 1)
    ,("OR 1 0", 1)
    ,("OR 1 1", 1)
    ,("NAND 0 0", 1)
    ,("NAND 0 1", 1)
    ,("NAND 1 0", 1)
    ,("NAND 1 1", 0)
    ,("NOR 0 0", 1)
    ,("NOR 0 1", 0)
    ,("NOR 1 0", 0)
    ,("NOR 1 1", 0)
    ,("XNOR 0 0", 1)
    ,("XNOR 0 1", 0)
    ,("XNOR 1 0", 0)
    ,("XNOR 1 1", 1)

) | % {
    $s,$e = $_
    $r = &$f $s
    "$($r-eq$e): $s=$r"
}

Resultado:

True: AND 0 0=0
True: AND 0 1=0
True: AND 1 0=0
True: AND 1 1=1
True: XOR 0 0=0
True: XOR 0 1=1
True: XOR 1 0=1
True: XOR 1 1=0
True: OR 0 0=0
True: OR 0 1=1
True: OR 1 0=1
True: OR 1 1=1
True: NAND 0 0=1
True: NAND 0 1=1
True: NAND 1 0=1
True: NAND 1 1=0
True: NOR 0 0=1
True: NOR 0 1=0
True: NOR 1 0=0
True: NOR 1 1=0
True: XNOR 0 0=1
True: XNOR 0 1=0
True: XNOR 1 0=0
True: XNOR 1 1=1

Perl 6 , 20 bytes

*.ords.sum*108%143%2

Experimente online!

Um porto da abordagem de maddy . Alternativamente, *256%339%2também funciona.

Perl 6 , 24 bytes

*.ords.sum*3%61%37%9%7%2

Experimente online!

Uma porta da resposta do xnor . Vou tentar encontrar um mais curto, mas acho que provavelmente é o melhor que existe.

JavaScript (Node.js) , 106 94 bytes

x=>([a,c,d]=x.split` `,g=[c&d,c^d,c|d]["OR".search(a.slice(1+(b=/N[^D]/.test(a))))+1],b?1-g:g)

Experimente online!

Link para o código e todos os 24 casos.

+9 para esquecer de mapear o caso XNOR.

Java 10, 30 28 bytes

s->s.chars().sum()*108%143%2

Porto da resposta do Powershell do @mazzy .

Experimente online.

JavaScript (Node.js) , 45 bytes

Apenas uma porta da excelente resposta Python 2 do xnor postada mediante consentimento, por favor, dê upvotes a essa resposta em vez disso.

x=>Buffer(x).reduce((a,b)=>a+b)*3%61%37%9%7%2

Experimente online!

Anexo , 55 bytes

{Eval!$"${Sum!Id''Downcase!SplitAt!_}${N=>__2}"}@@Split

Experimente online!

Uma solução bastante brutal. Converte a entrada no comando Attache relevante e a avalia. (O anexo possui built-ins para cada um dos 6 portões lógicos.)

Ruby , 20 bytes

->s{76277[s.sum%17]}

Experimente online!

Como funciona:

Basicamente, o mesmo que a resposta de Peter Taylor, mas Ruby facilita. O número mágico é diferente, mas a ideia era a mesma.