Existem muitas maneiras diferentes de expressar se algo é verdadeiro ou não! O objetivo desse desafio é produzir uma saída padronizada de truthyou falsypara vários valores de verdade e falsidade de entrada.

Para os propósitos deste desafio, as seguintes entradas são consideradas verdadeiras:

1. Uma sequência que representa um número inteiro assinado com um valor diferente de zero (contém apenas os dígitos [0-9], com um opcional -no início). Observe que a string -0nunca será fornecida como entrada. Um número inteiro diferente de zero nunca será precedido por a 0(ou seja 01, nunca será dado como entrada, da mesma forma -01nunca será obtido como entrada).
2. As cordas de maiúsculas e minúsculas equivalentes a um de defined, found, nonnil, non-nil, on, success, t, true, y, eyes

Para os propósitos deste desafio, as seguintes entradas são consideradas falsas:

1. A cadeia 0. Zeros repetidos ( 00, 00...) nunca serão dados como entrada.
2. Uma string vazia
3. As cordas de maiúsculas e minúsculas equivalentes a um de f, failure, false, n, nan, nil, no, notfound, not-found, null, nullptr, off, eundefined

Entrada

A entrada é uma sequência que representa um valor de verdade / falsidade. A string pode vir de qualquer fonte desejada (stdio, parâmetro de função etc.). Não há espaços em branco à esquerda / à direita.

A entrada é garantida para corresponder a um dos valores permitidos de verdade / falsidade acima (ou seja, você não precisa fornecer nenhum tratamento de erros).

Resultado

Seu programa / função deve gerar um valor de verdade / falsidade que represente a "verdade" ou "falsidade" da entrada. Você só pode especificar exatamente 1 valor de verdade e 1 valor de falsidade para o qual sua saída deve converter a entrada (esses são seus valores de verdade / falsidade "padronizados"). A saída pode ser gravada em qualquer coletor desejado (stdio, valor de retorno, parâmetro de saída, etc.).

Especifique o valor truthye o falsyvalor que você escolheu na sua resposta.

Ex .: Se você escolher a sequência truecomo um valor de verdade, também não poderá ter o número inteiro 1para a verdade.

Casos de teste

Os casos de teste são formatados como a primeira linha é a entrada e a segunda linha é a saída.

-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

Pontuação

Isso é código-golfe; o código mais curto em bytes vence. Aplicam-se brechas padrão. Você pode usar quaisquer embutidos desejados.

MATL , 20 bytes

U|sG36ZA13\[BID1]m+g

Entrada é uma cadeia de caracteres entre aspas simples. A saída é verdadeira 1ou 0falsa.

Experimente online! Ou verifique todos os casos de teste .

Como 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

Isso realiza dois testes na entrada:

1. Tente interpretar a entrada como um número e detectar se é diferente de zero. A função usada para interpretar uma string como um número gera uma matriz vazia, se não for possível; e a soma das entradas de uma matriz vazia é 0. Portanto, basta tentar a conversão, pegar o valor absoluto e somar. Isso fornece um valor positivo se a entrada contiver um número diferente de zero, e 0caso contrário.
2. Supondo que a string de entrada não represente um número, precisamos classificá-la em um dos dois conjuntos fornecidos. Para fazer isso, a entrada é interpretada como os dígitos de um número expresso na base 36, usando o alfabeto '01...9ab...z'. A função de conversão de base não diferencia maiúsculas de minúsculas e ignora os dígitos que não estão presentes no alfabeto (no nosso caso '-'). Acontece que o modulo 13 do número resultante é 1, 3, 6ou 8para as cordas truthy, e não dá qualquer um desses valores para as cordas Falsas. Portanto, pode ser usado como uma assinatura. Assim, executamos o módulo 13 e verificamos se o resultado é algum desses quatro valores. Isso dá 1se for ou 0não.

O resultado final deve ser verdadeiro se alguma das duas condições for atendida e, caso contrário, falsificado. Portanto, adicionamos os dois números resultantes de 1 e 2 acima e convertemos em lógico, que fornece 1ou 0como valores padronizados de verdade / falsidade.

Retina , 22 24 23 bytes

Guardado 1 byte graças a edc65

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

O código inteiro é apenas uma regex. O i`início torna o caso de regex insensitivo.

Saídas 1para verdade, 0para falsey.

Experimente online!

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

Saídas 1 por falsidade, nada por verdade.

JavaScript (ES6), 35 39

Edite usando o n?ontruque, roubado da resposta do BusinessCat

Editar 2 OP esclarecido, nenhum 0 inicial, salvo 4 bytes

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

Simplesmente retorna trueoufalse

Teste

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]

Testes na soma dos valores ASCII, verificação extra para, nopois ontem o mesmo valor.

• Edit1: esqueceu de testar valores inteiros. Agora verificando entradas falsas

Python, 129 79 78 bytes

Tem que enviar rápido!

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

Verdadeiro é falso e falso é verdadeiro; Eu tenho uma bela rima para isso, eu realmente (não)

Python, 83 75 bytes

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

Retorna 0 em caso de sucesso, AttributeError em falha.

Agora, usando o regex do edc85 para economizar 8 bytes.

PowerShell v2 +, 39 37 bytes

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

Supõe que a resposta à pergunta de @ feersum é "Não, números inteiros verdadeiros não podem começar com a 0".

Porta da resposta JavaScript do regex do @ edc65 , com minha própria 1-9substituição em vez de \d. Usa o n?ontruque do @ BusinessCat para jogar ainda mais.

Emite valores $trueou $falsevalores booleanos literais que, quando deixados no pipeline e enviados por meio de um implícito Write-Outputno final da execução, resultam Trueou Falsesão impressos no console.

Se a resposta for "Sim, inteiros verdadeiros podem começar com 0", as seguintes alterações deverão ser feitas para 51 49 bytes

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

Se você não gosta de regex, vá para o PowerShell v3 + e o seguinte em 107 bytes

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

Isso pega a cadeia de valores falsey, coloca- -splitos no espaço em branco e usa o -notinoperador para verificar a entrada $ncom base nessa matriz de cadeias (que, por padrão, não diferencia maiúsculas de minúsculas). Requer a $n-andverificação contra a cadeia vazia.

PHP, 50 bytes

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

imprime 1por verdade, nada por falsidade

tentou encontrar uma solução diferente, mas o menor regex para falsy é 3 bytes mais longo do que para verdade: %^(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