¡Hay tantas formas diferentes de expresar si algo es verdad o no! El objetivo de este desafío es producir una salida estandarizada de truthyo falsypara varios valores de verdad y falsedad de entrada.

Para los propósitos de este desafío, las siguientes entradas se consideran verdaderas:

1. Una cadena que representa un entero con signo con un valor distinto de cero (contiene solo los dígitos [0-9], con un opcional -al principio). Tenga en cuenta que la cadena -0nunca se dará como entrada. Un número entero distinto de cero nunca estará precedido por un 0(es decir 01, nunca se dará como entrada, de manera similar -01, nunca será gien como entrada).
2. Las cadenas de mayúsculas y minúsculas equivalentes a uno de defined, found, nonnil, non-nil, on, success, t, true, y, yyes

Para los propósitos de este desafío, las siguientes entradas se consideran falsas:

1. La cadena 0. Los ceros repetidos ( 00, 00...) nunca se darán como entrada.
2. Una cadena vacía
3. Las cadenas de mayúsculas y minúsculas equivalentes a uno de f, failure, false, n, nan, nil, no, notfound, not-found, null, nullptr, off, yundefined

Entrada

La entrada es una cadena que representa un valor verdadero / falso. La cadena puede provenir de cualquier fuente deseada (stdio, parámetro de función, etc.). No hay espacios en blanco iniciales / finales.

Se garantiza que la entrada coincida con uno de los valores de verdad / falsedad permitidos anteriores (es decir, no es necesario que proporcione ningún tratamiento de errores).

Salida

Su programa / función debe generar un valor de verdad / falsedad que represente la "verdad" o "falsedad" de la entrada. Solo se le permite especificar exactamente 1 valor de verdad y 1 valor de falsedad al que su salida debe convertir la entrada (estos son su valor de verdad / falsedad "estandarizado"). La salida puede escribirse en cualquier sumidero deseado (estándar, valor de retorno, parámetro de salida, etc.).

Especifique qué truthyy el falsyvalor que eligió en su respuesta.

Ej .: Si elige la cadena truecomo valor verdadero, no puede tener también el número entero 1para verdad.

Casos de prueba

Los casos de prueba están formateados ya que la primera línea es la entrada y la segunda línea es la salida.

-1
true

1
true

1234
true

-4321
true

defined
true

deFined
true

Found
true

nonnil
true

non-nil
true

ON
true

SuCCess
true

T
true

true
true

y
true

YeS
true

0
false

'' (empty string)
false

faLSE
false

f
false

Failure
false

n
false

NaN
false

nil
false

no
false

notfound
false

not-Found
false

NULL
false

nullptr
false

OFF
false

unDefined
false

Puntuación

Este es el código de golf; el código más corto en bytes gana. Se aplican lagunas estándar. Puede usar los complementos deseados.

MATL , 20 bytes

U|sG36ZA13\[BID1]m+g

La entrada es una cadena entre comillas simples. La salida es 1para la verdad o 0para la falsedad.

Pruébalo en línea! O verificar todos los casos de prueba .

Cómo funciona

U|s      % Take input implicitly. Interpret as number, absolute value, sum
G36ZA    % Push input again. Convert from base-36
13\      % Modulo 13
[BID1]   % Push array [6 3 8 1]
m        % True if member: gives 1 iff the result from modulo 13 is in the array
+g       % Add, convert to logical. Display implicitly

Esto realiza dos pruebas en la entrada:

1. Intente interpretar la entrada como un número y detecte si no es cero. La función utilizada para interpretar una cadena como un número genera una matriz vacía si no es posible; y la suma de las entradas de una matriz vacía es 0. Por lo tanto, es suficiente intentar la conversión, tomar el valor absoluto y sumar. Esto da un valor positivo si la entrada contiene un número distinto de cero, y de lo 0contrario.
2. Suponiendo que la cadena de entrada no representa un número, debemos clasificarla en uno de los dos conjuntos dados. Para hacer esto, la entrada se interpreta como los dígitos de un número expresado en base-36, usando el alfabeto '01...9ab...z'. La función de conversión de base no distingue entre mayúsculas y minúsculas e ignora los dígitos que no están presentes en el alfabeto (en nuestro caso '-'). Resulta que el módulo 13 del número resultante es 1, 3, 6o 8para las cadenas Truthy, y no da ninguna de esos valores para las cadenas Falsy. Por lo tanto, se puede usar como una firma. Por lo tanto, realizamos el módulo 13 y vemos si el resultado es alguno de esos cuatro valores. Esto da 1si es, o de lo 0contrario.

El resultado final debe ser verdadero si se cumple alguna de las dos condiciones, y falso de lo contrario. Por lo tanto, agregamos los dos números resultantes de 1 y 2 anteriores y los convertimos a lógicos, lo que da 1o 0como valores de verdad / falsedad estandarizados.

Retina , 22 24 23 bytes

Guardado 1 byte gracias a edc65

i`^([-1-9sdty]|fo|n?on)

Todo el código es solo una expresión regular. El i`principio hace que la expresión regular no sea sensible.

Salidas 1para la verdad, 0para falsey.

Pruébalo en línea!

Lote, 142 bytes

@goto l%1 2>nul
:l
:l0
:lfailure
:lfalse
:ln
:lnan
:lnil
:lno
:lnotfound
:lnot-found
:lnull
:lnullptr
:loff
:lundefined
@echo 1

Salidas 1 para falsedad, nada para verdad.

JavaScript (ES6), 35 39

Edite usando el n?ontruco, robado de la respuesta de BusinessCat

Editar 2 OP aclarado, sin ceros a la izquierda, guardado 4 bytes

v=>/^([-1-9dsty]|fo|n?on)/i.test(v)

Simplemente vuelve trueofalse

Prueba

f=v=>/^([-1-9dsty]|fo|n?on)/i.test(v)

trues=[-1,1,1234,-4321,'defined','deFined','Found',
'nonnil','non-nil','ON','SuCCess','T','true','y','YeS']
falses=[0,'','faLSE','f','Failure','n','NaN','nil',
'no','notfound','not-Found','NULL','nullptr','OFF','unDefined']

console.log('TRUE: '+trues.map(x=>f(x)))

console.log('FALSE:' +falses.map(x=>f(x)))

Python, 111 bytes

def b(s):s=s.lower();return s!='no'and not sum(map(ord,s))in[0,48,323,744,523,877,110,785,443,922,315,317,946]

Pruebas en la suma de los valores ASCII, verificación adicional noya que ontiene el mismo valor.

• Edit1: olvidé probar en valores enteros. Ahora buscando entradas falsas

Python, 129 79 78 bytes

Tengo que enviar rápido!

lambda n:n.lower()[:3]in" 0 f n no nil fai fal nan not nul off und".split(" ")

Verdadero es falso y falso es verdadero; Tengo una buena rima para esto, realmente (no)

Python, 83 75 bytes

import re
def f(s):return re.search(r'^([-1-9dsty]|fo|n?on)',s.lower()).pos

Devuelve 0 en caso de éxito, AttributeError en caso de error.

Ahora usando la expresión regular de edc85 para guardar 8 bytes.

PowerShell v2 +, 39 37 bytes

$args[0]-match'^([-1-9dsty]|fo|n?on)'

Presume que la respuesta a la pregunta de @ feersum es "No, los enteros verdaderos pueden no comenzar con a 0".

Puerto de la respuesta de JavaScript de regex de @ edc65 , con mi propia 1-9sustitución en lugar de \d. Utiliza el n?ontruco de @ BusinessCat para jugar más al golf.

Emite valores booleanos $trueo $falsevalores literales que, cuando se dejan en la tubería y se envían a través de un implícito Write-Outputal final de la ejecución, se imprimen Trueo Falsese imprimen en la consola.

Si la respuesta es "Sí, los enteros verdaderos pueden comenzar con 0", entonces los siguientes cambios deben hacerse para 51 49 bytes

param($n)$n-ne0-and$n-match'^([-\ddsty]|fo|n?on)'

Si no le gusta la expresión regular, vaya a PowerShell v3 + y lo siguiente en 107 bytes

param($n)$n-and$n-notin-split'0 f failure false n nan nil no notfound not-found null nullptr off undefined'

Esto toma la cadena de valores de falsey, -splitlos coloca en espacios en blanco y usa el -notinoperador para verificar la entrada $ncontra esa matriz de cadenas (que, por defecto, no distingue entre mayúsculas y minúsculas). Requiere $n-andque se compruebe contra la cadena vacía.

PHP, 50 bytes

<?=preg_match('%^([-1-9dsty]|fo|n?on)%i',$argv[1])

impresiones 1para la verdad, nada para la falsedad

intenté encontrar una solución diferente, pero la expresión regular más corta para falsedad es 3 bytes más larga que la de verdad: %^(0|fa|f?$|n(?!on)|of|u)%i

Python, 83 bytes

lambda x:x.lower()[:3]in['fou','non','on']or x[:1].lower()in'dsty-123456789'and''<x

https://repl.it/ClgO/1