Su misión, si elige aceptarla, es construir un evaluador de verdad simple para los siguientes operadores lógicos:
----------------------------------------------------------------------------------
Logical Name | Gate Name | Symbol | Symbol Name | Truth Table
----------------------------------------------------------------------------------
Identity | is | | (none) | 10
Negation | not | ~ | tilde | 01
Conjunction | and | & | ampersand | 1000
Disjunction | or | | | pipe | 1110
Negative Conjunction | nand | ^ | caret | 0111
Joint Denial | nor | v | "vee" | 0001
Exclusive Disjunction | xor | x | "ecks" | 0110
Equivalence | equals/xnor | = | equals | 1001
Implication | implies | > | greater than | 1011
Las tablas de verdad están en el siguiente orden:
- 1 1
- 1 0
- 0 1
- 0 0
La entrada vendrá como una cadena simple de 0, 1 y el símbolo. Puede aceptar la entrada como parámetro o leerla del usuario en stdin. Aquí hay algunos pares de entrada / salida de muestra:
Input: 1
Output: 1
Input: ~1
Output: 0
Input: 0|1
Output: 1
Input: 1>0
Output: 0
El operador unario (negación) siempre aparecerá antes del valor booleano, mientras que los operadores binarios siempre aparecerán entre los dos valores booleanos. Puede suponer que todas las entradas serán válidas. Las cadenas son cadenas ASCII normales.
Si lo prefieres, puedes usar T y F en lugar de 1 y 0. -6 para tu recuento de personajes si admites ambos.
Esto es code-golf : ¡el código más corto en cualquier idioma gana!
fuente
^
el nombre del símbolo debería decir caret .Respuestas:
APL (45-6 = 39)
Admite
T
yF
como entrada pero siempre saldrá0
o1
.Explicación:
Z←⍞
: lee una línea y guárdala enZ
L←'TF&|^vx>'⍳Z
: obtener el índice'TF&|^vx>'
para cada carácterZ
, dando9
si el personaje no está en'TF&|^vx>'
.'10∧∨⍲⍱≠≤*'[
...]
: encuentra el carácter correspondiente en'10∧∨⍲⍱≠≤*'
. (Entonces se convierten en personajes que no estaban en la primera lista*
).↓⍉Z⍪⍉⍪
: haga esto en una matriz, coloque el original (Z
) encima y divídalo en una lista de cadenas, donde el primer carácter es el original y el segundo carácter es su traducción, si corresponde.(1+9≠L)⌷¨
: para cada una de estas cadenas, obtenga el primer carácter si no hubo traducción (si estabaL=9
en ese lugar) y el segundo carácter si la hubo.T|0
, ya tendríamos1∨0
cuál es la expresión APL correspondiente⍎
: evalNota:
~
y=
ya hacen lo correcto para que no necesiten ser reemplazados por nada.fuente
⍎'1010~∧∨⍲⍱≠=≤'['10TF~&|^vx=>'⍳⍞]
? (Puntuación 33-6 = 27)C -
165127¡Eso fue divertido! Tabla de búsqueda simple basada en un desplazamiento fijo para la búsqueda.
Por alguna razón
gets
no consigue implícitamente declarado, así que cuando me quité el incluir tuve que cambiargets(t+2)
a(gets(t+2),t)
(o de manera similar en otras partes, costando tanto).Explicación
En primer lugar, dado que las tablas de verdad para los operadores tienen muchos caracteres superpuestos, deseamos almacenar las tablas de búsqueda de una manera que permita la superposición. Así es como elegí almacenarlos:
A continuación, queremos asignar símbolos de operador a estos desplazamientos. Hacemos esto almacenando los símbolos del operador en la misma cadena en un desplazamiento fijo de los datos LUT (es decir, 16 caracteres más tarde, es decir, directamente después de los datos LUT). El proceso de búsqueda es "buscar operador en
s
, restar16
, sumarleft*2+right
(operando izquierda / derecha). Para la búsqueda de la" operación de identidad "vacía, debido a cómo se obtiene la entrada, el operador en este caso resolverá lo quet[1]
se haya inicializado para- -en nuestro caso/
. Por lo tanto, usamos/
como la clave de la tabla de búsqueda para representar la operación de identidad. Cuando procesamos la~
operación unaria "left
" (para el cálculo de búsqueda mencionado anteriormente) es siempre la misma/
./
Resulta que es una menor que0
En cuanto a ASCII, significa que cuando compensamos los dígitos ASCII\
representaremos-1
. La barra diagonal en el área clave de la tabla de búsqueda (penúltimo carácters
, es decir) se coloca para compensar esto.A continuación, manejo de entrada. La entrada tiene una longitud dinámica, pero sería más fácil si tenemos nombres estáticos específicos para el operando izquierdo, el operador y el operando derecho, independientemente de la entrada. Si pretendemos que podríamos leer la entrada de derecha a izquierda, esto sucedería básicamente de forma automática: el operando derecho es siempre el carácter más a la derecha, el operador (si está presente) es el segundo a la derecha, el operando izquierdo (si está presente) ) es de la tercera a la derecha. Para poder indexar la cadena de esta manera, la usamos
strchr
para ubicar el\0
terminador (- 3
para simplificar la indexación). Esto muestra por quét[0]
y set[1]
convierte en el operador / operador izquierdo respectivamente cuando la entrada es de 1 o 2 caracteres.Al unirlo, la salida sería
putchar(strchr(s,u[1])[(u[0] - '0')*2 + (u[2] - '0') - 15])
, pero una refactorización y un plegado constante en su lugar nos acortanputchar(strchr(s,u[1])[u[0]*2+u[2]-159])
.fuente
Tcl,
212208-6 = 202Sin golf:
Creo que la línea foreach necesita alguna explicación:
split $argv {}
divide la cadena de entrada (en realidad es una lista, pero code-golf) en sus caracteres.string map {{~ 0} 1 {~ 1} 0} ...
toma una cuerda y la reemplaza~ 0
por1
y~ 1
con0
lassign ... a
toma el primer elemento de la lista y lo asigna a la variable a, devuelve el resto.foreach {op b} ... {code}
recorre la lista y toma 2 elementos cada vez:op
yb
set a [$op $a $b]
ejecuta el comando en la variableop
, almacena el resultado ena
fuente
JavaScript -
107105caracteresfuente
eval()
cuando inventé esto. Solo dame un poco para llegar a casa y probarlo.&~
y nor =|~
?&~
y|~
, pero NAND es solo el inverso de AND. Entonces, invertir uno de los bits también invierte el resultado.Befunge-
98-104101 98-672... porque cada tarea necesita una solución esolang ... traducción de mi implementación en C, pero procesando caracteres uno a la vez.
Dato curioso: cambie elEl REPL ya no existe.@
toa,$
y obtendrá un REPL elegante e interminable en su lugar (sin embargo, si hace esto, notará que la identidad es en realidad "repita el último comando con lhs = 0 y rhs = input", que por defecto es el predeterminado a la identidad )Ungolfed (versión anterior):
Editar: inspirado en la solución de @jpjacobs, ahora confío en la posición de los personajes en la LUT para representar tablas de verdad. Por ejemplo,
|
está en la posición 1110 2 = 14 porque corresponde a la tabla de verdad para|
.fuente
J -
6567-6 = 61No más el b. Adverbio. Sin contar la asignación de la función: 67 caracteres para la versión TF, 63 para la versión no TF:
LgcTF maneja tanto 0 como 1, así como T y F.
Admite toda la sintaxis de J en términos de trenes, paréntesis y evalúa estrictamente de derecha a izquierda (no hay otras reglas de precedencia).
No se pueden usar todos los caracteres que no están en la lista de operadores + Z, otros actuarán como en el estándar J (incluidas las variables).
Uso:
fuente
Posdata 263
La idea de Firefly traducida a PostScript.
Sangrado:
fuente
Befunge-93, 86 personajes
Funciona haciendo hash el segundo símbolo de la entrada (encontrar una función que sea compacta y evitar colisiones fue un trabajo) para una coordenada ay, y tomando el primer y el tercer símbolo de cada módulo 2 como los dos bits menos significativos de la coordenada x, luego recuperando cualquier valor que esté en la posición indicada. Una mejor función hash o un método más compacto de almacenamiento / direccionamiento de las tablas de verdad son solo dos formas posibles de reducir la longitud.
fuente