Sou divisível pelo dobro da soma dos meus dígitos?

40

Dado um número inteiro positivo como entrada, sua tarefa é gerar um valor verdadeiro se o número for divisível pelo dobro da soma de seus dígitos e, caso contrário, um valor falso ( OEIS A134516 ). Em outras palavras:

(sum_of_digits)*2 | number
  • Em vez de valores verdadeiros / falsos para os casos verdadeiros e falsos, você pode especificar qualquer conjunto finito de valores para o caso verdadeiro / falso, e eles complementam os outros valores. Para um exemplo simples, você pode usar 0para o caso verdadeiro e todos os outros números para o caso falso (ou vice-versa, se desejar).

  • Regras de entrada e saída padrão se aplicam. As brechas padrão também se aplicam.

  • Você pode receber a entrada como um número inteiro ou como a representação de sequência desse número inteiro.

  • Este é o , portanto o código mais curto em bytes vence!

  • Eu sou novo no PPCG, então gostaria que você publicasse uma explicação, se possível.


Casos de teste

Entrada - Saída - (Razão)

80 - Verdade - (16 divide 80)
100 - Verdade - (2 divide 100)
60 - Verdade - (12 divide 60)
18 - Verdade - (18 divide 18)
12 - Verdade - (6 divide 12)

4 - Falsia - (8 não divide 4)
8 - Falsia - (16 não divide 8)
16 - Falsia - (14 não divide 16)
21 - Falsia - (6 não divide 21)
78 - Falsy - (30 não divide 78)
110 - Falsy - (4 não aparece 110)
111 - Falsy - (6 não divide 111)
390 - Falsy - (24 não divide 390)

fonte
Bom desafio, bem-vindo ao PPCG!
Skidsdev 03/07
@ Mayay Obrigado, é o meu segundo desafio, mas o primeiro foi fechado: P
Podemos aceitar dígitos como uma lista de números inteiros?
Henry
4
@Henry Não, isso seria muito trivial
11
De fato, as duas frases de "Em vez de valores verdadeiros / falsos para os casos verdadeiros e falsos, você pode especificar qualquer conjunto finito de valores para o caso verdadeiro e seu complemento para os casos falsos. Para um exemplo simples, você pode usar 0 para o caso verdadeiro e todos os outros números para o caso falso (ou vice-versa, se você preferir) "parecem contradizer-se (em particular, o" finito "e o" ou vice-versa ").
9789 Greg Martin

Respostas:

7

Neim , 3 bytes

𝐬ᚫ𝕞

Explicação:

𝐬      Implicitly convert to int array and sum the digits
 ᚫ     Double
  𝕞   Is it a divisor of the input?

Experimente online!

Versão detalhada

Okx
fonte
Umm ... você deve verificar se a entrada é um múltiplo do dobro da soma dos dígitos, e não vice-versa.
Erik the Outgolfer
@EriktheOutgolfer O que você quer dizer? Eu verifico se a entrada é um múltiplo do dobro da soma dos dígitos. Talvez eu não tenha explicado isso corretamente.
Okx 03/07/19
4
O Neim precisa ficar ainda mais animado - quando os envios são muito longos, meu navegador começa a ficar lento.
Esolanging Fruit
11
@ Challenger5 Peço sinceras desculpas pela falta de golfe. Vou tentar novamente na próxima vez. Mais uma vez, desculpe por isso.
Okx 08/07/19
@Okx E sinceramente peço desculpas por ter preguiça de encontrar uma resposta Neim que fosse uma demonstração melhor do que eu estava falando.
Esolanging Fruit
16

JavaScript (ES6), 31 29 27 bytes

Recebe a entrada como uma sequência. Retorna zero para verdade e diferente de zero para falsidade.

n=>n%eval([...n+n].join`+`)

Comentado

n => n % eval([...n + n].join`+`)
n =>                                   // take input string n  -> e.g. "80"
                  n + n                // double the input     -> "8080"
              [...     ]               // split                -> ["8", "0", "8", "0"]
                        .join`+`       // join with '+'        -> "8+0+8+0"
         eval(                  )      // evaluate as JS       -> 16
     n %                               // compute n % result   -> 80 % 16 -> 0

Casos de teste

Arnauld
fonte
Eu nunca vi o método [...] de dividir antes, existe um nome para isso especificamente?
23417 Jacob Persi
@JacobPersi Este é o operador de spread .
Arnauld
7

C #, 46 bytes

using System.Linq;n=>n%(n+"").Sum(c=>c-48)*2<1

Versão completa / formatada:

using System;
using System.Linq;

class P
{
    static void Main()
    {
        Func<int, bool> f = n => n % (n + "").Sum(c => c - 48) * 2 < 1;

        Console.WriteLine(f(80));
        Console.WriteLine(f(100));
        Console.WriteLine(f(60));

        Console.WriteLine();

        Console.WriteLine(f(16));
        Console.WriteLine(f(78));
        Console.WriteLine(f(390));

        Console.ReadLine();
    }
}
TheLethalCoder
fonte
4

Retina , 38 27 bytes

-11 bytes e corrigiu um erro no código graças a @MartinEnder

$
$_¶$_
.+$|.
$*
^(.+)¶\1+$

Experimente online!

Imprime 1 se divisível, 0 caso contrário

Explicação (espero que eu entendi direito)

$
$_¶$_

Anexa toda a entrada, mais uma nova linha, mais a entrada novamente

.+$|.
$*

Converte cada correspondência em unária (a segunda linha inteira que é a entrada original ou cada dígito na primeira linha)

^(.+)¶\1+$

Verifique se a primeira linha (a soma de dois dígitos) é um divisor da segunda linha

PunPun1000
fonte
4

MATL , 7 bytes

tV!UsE\

Saída 0se divisível, número inteiro positivo caso contrário. Especificamente, ele gera o restante da divisão do número pelo dobro da soma de seus dígitos.

Experimente online!

Explicação

t   % Implicit input. Duplicate
V!U % Convert to string, transpose, convert to number: gives column vector of digits
s   % Sum
E   % Times 2
\   % Modulus. Implicit display
Luis Mendo
fonte
4

05AB1E , 5 4 bytes

-1 byte graças a Okx

SO·Ö

Experimente online!

Você também pode remover o último Ö para obter 0 para verdade e outra coisa para falsidade, resultando em apenas 3 bytes, mas para mim isso parece não se encaixar adequadamente na definição.

Explicação

SO·Ö
SO    # Separate the digits and sum them
  ·   # Multiply the result by two
   Ö  # Is the input divisible by the result?
Datboi
fonte
Você pode jogá-lo em 4 bytes substituindo %_por Ö.
Okx 03/07/19
4

Código da máquina x86-64, 24 bytes

6A 0A 5E 31 C9 89 F8 99 F7 F6 01 D1 85 C0 75 F7 8D 04 09 99 F7 F7 92 C3

O código acima define uma função no código de máquina x86 de 64 bits que determina se o valor de entrada é divisível pelo dobro da soma de seus dígitos. A função está em conformidade com a convenção de chamada do System V AMD64, para que possa ser chamada de praticamente qualquer idioma, como se fosse uma função C.

Ele usa um único parâmetro como entrada via EDIregistrador, conforme a convenção de chamada, que é o número inteiro a ser testado. (Supõe-se que seja um número inteiro positivo , consistente com as regras de desafio e é necessário para que as CDQinstruções que usamos funcionem corretamente.)

Retorna seu resultado no EAXregistro, novamente, conforme a convenção de chamada. O resultado será 0 se o valor de entrada for divisível pela soma de seus dígitos e diferente de zero. (Basicamente, um booleano inverso, exatamente como o exemplo dado nas regras de desafio.)

Seu protótipo C seria:

int DivisibleByDoubleSumOfDigits(int value);

Aqui estão as instruções da linguagem assembly não destruídas, anotadas com uma breve explicação do objetivo de cada instrução:

; EDI == input value
DivisibleByDoubleSumOfDigits:
   push 10
   pop  rsi             ; ESI <= 10
   xor  ecx, ecx        ; ECX <= 0
   mov  eax, edi        ; EAX <= EDI (make copy of input)

SumDigits:
   cdq                  ; EDX <= 0
   div  esi             ; EDX:EAX / 10
   add  ecx, edx        ; ECX += remainder (EDX)
   test eax, eax
   jnz  SumDigits       ; loop while EAX != 0

   lea  eax, [rcx+rcx]  ; EAX <= (ECX * 2)
   cdq                  ; EDX <= 0
   div  edi             ; EDX:EAX / input
   xchg edx, eax        ; put remainder (EDX) in EAX
   ret                  ; return, with result in EAX

No primeiro bloco, fazemos algumas inicializações preliminares dos registros:

  • PUSHAs POPinstruções + são usadas como uma maneira lenta, mas curta, de inicializar ESIpara 10. Isso é necessário porque a DIVinstrução em x86 requer um operando de registro. (Não existe uma forma que divida por um valor imediato de, digamos, 10.)
  • XORé usado como uma maneira curta e rápida de limpar o ECXregistro. Este registro servirá como o "acumulador" dentro do próximo loop.
  • Finalmente, uma cópia do valor de entrada (de EDI) é feita e armazenada EAX, que será eliminada à medida que avançamos no loop.

Então, começamos a repetir e somar os dígitos no valor de entrada. Isso se baseia na DIVinstrução x86 , que divide EDX:EAXpor seu operando e retorna o quociente in EAXe o restante in EDX. O que faremos aqui é dividir o valor de entrada por 10, de modo que o restante seja o dígito em último lugar (que adicionaremos ao nosso registro acumulador ECX), e o quociente é o restante.

  • A CDQinstrução é uma maneira curta de definir EDXcomo 0. Na verdade , ela estende o valor EAXpara EDX:EAX, que é o que DIVusa como dividendo. Na verdade, não precisamos de extensão de sinal aqui, porque o valor de entrada não é assinado, mas CDQé de 1 byte, em vez de usar XORpara limpar EDX, que seria de 2 bytes.
  • Então DIVide EDX:EAXpor ESI(10).
  • O restante ( EDX) é adicionado ao acumulador ( ECX).
  • O EAXregistro (quociente) é testado para verificar se é igual a 0. Nesse caso, passamos por todos os dígitos e seguimos em frente. Caso contrário, ainda temos mais dígitos para somar, então voltamos ao topo do loop.

Por fim, após a conclusão do loop, implementamos number % ((sum_of_digits)*2):

  • A LEAinstrução é usada como uma maneira curta de multiplicar ECXpor 2 (ou, equivalentemente, adicionar ECXa si mesma) e armazenar o resultado em um registro diferente (neste caso EAX).

    (Também poderíamos ter feito add ecx, ecx+ xchg ecx, eax; ambos são 3 bytes, mas a LEAinstrução é mais rápida e mais típica.)

  • Então, fazemos CDQnovamente para nos preparar para a divisão. Como EAXserá positivo (isto é, não assinado), isso tem o efeito de zerar EDX, exatamente como antes.
  • A seguir, é a divisão, desta vez dividida EDX:EAXpelo valor de entrada (uma cópia não-modificada da qual ainda reside EDI). Isso é equivalente ao módulo, com o restante em EDX. (O quociente também é inserido EAX, mas não precisamos dele.)
  • Finalmente, XCHGtrocamos o conteúdo de EAXe EDX. Normalmente, você faria um MOVaqui, mas XCHGé apenas 1 byte (embora mais lento). Como EDXcontém o restante após a divisão, será 0 se o valor for igualmente divisível ou diferente de zero. Assim, quando RETurn, EAX(o resultado) será 0 se o valor de entrada for divisível pelo dobro da soma de seus dígitos, ou diferente de zero.

Espero que isso seja suficiente para uma explicação.
Esta não é a entrada mais curta, mas, ei, parece que bate quase todas as línguas que não são de golfe! :-)

Cody Gray
fonte
3

Japonês , 7 4 bytes

Recebe a entrada como uma sequência. Saídas 0para trueou um número maior que 0para false, que, de outras soluções, parecem válidas. Caso contrário, avise-me e reverteremos.

%²¬x

Teste-o


Explicação

Entrada implícita da sequência U.
"390"

²

Repita Uduas vezes.
"390390"

¬

Dividir para matriz de caracteres individuais.
["3","9","0","3","9","0"]

x

Reduza pela soma, convertendo automaticamente cada caractere para um número inteiro no processo.
24

%

Obtenha o restante da divisão Upelo resultado, também convertendo automaticamente Upara um número inteiro no processo. Implica implicitamente o número inteiro resultante.
6 (=false)

Shaggy
fonte
2
Suas explicações geralmente usam muito espaço vertical, o que eu acho que não é necessário. De qualquer forma, é a sua resposta.
Okx 03/07/19
@Okx; Não sei como pode ser "normal" quando mudei para esse formato há alguns dias.
Shaggy
4
Gostei do formato da explicação. Foi fácil de seguir, principalmente para esse problema, pois era uma redução linear e descia a página como um problema de matemática. Apenas meus dois centavos.
Henry
3
Esse formato de explicação é muito melhor que o formato usual, especialmente para aqueles que não estão familiarizados com os idiomas. Eu gostaria que outros jogadores que usassem essas línguas também fizessem isso.
Jul1
3

C89, 55 53 bytes

(Obrigado a Steadybox!

s,t;f(x){for(t=x,s=0;t;t/=10)s+=t%10;return x%(s*2);}

É preciso uma única entrada x, que é o valor a ser testado. Retorna 0 se xfor divisível igualmente pelo dobro da soma de seus dígitos, ou diferente de zero.

Experimente online!

Ungolfed:

/* int */ s, t;
/*int */ f(/* int */ x)
{
    for (t = x, s = 0; t /* != 0 */; t /= 10)
        s += (t % 10);
    return x % (s * 2);
}

Como você pode ver, isso tira proveito das regras implit-int do C89. As variáveis ​​globais se tsão implicitamente declaradas como ints. (Eles também são implicitamente inicializados como 0 porque são globais, mas não podemos tirar proveito disso se queremos que a função seja solicitada várias vezes.)

Da mesma forma, a função, fleva um único parâmetro, x,que é implicitamente um int, e retorna um int.

O código dentro da função é bastante direto, embora o forloop pareça muito estranho se você não estiver familiarizado com a sintaxe. Basicamente, um forcabeçalho de loop em C contém três partes:

for (initialization; loop condition; increment)

Na seção "inicialização", inicializamos nossas variáveis ​​globais. Isso será executado uma vez, antes que o loop seja inserido.

Na seção "condição do loop", especificamos em que condição o loop deve continuar. Isso deve ser óbvio.

Na seção "incremento", basicamente colocamos código arbitrário, pois ele será executado no final de cada loop.

O objetivo maior do loop é iterar através de cada dígito no valor de entrada, adicionando-o a s. Finalmente, depois que o loop termina, sé duplicado e levado xpara o módulo para ver se é igualmente divisível. (Uma explicação melhor e mais detalhada da lógica aqui pode ser encontrada em minha outra resposta , na qual esta se baseia.)

Versão legível por humanos:

int f(int x)
{
    int temp = x;
    int sum  = 0;
    while (temp > 0)
    {
        sum  += temp % 10;
        temp /= 10;
    }
    return x % (sum * 2);
}
Cody Gray
fonte
Você pode salvar dois bytes, se usar em tvez de t>0como a condição de loop .
Steadybox 4/07
Ah, claro! Boa captura, @Steadybox. Não tenho certeza de como eu perdi isso, já que testar contra 0 é exatamente o que minha implementação de asm fez, na qual essa resposta foi fortemente baseada.
Cody Gray
45
PrincePolka 28/11
2

Braquilog , 8 bytes

ẹ+×₂;I×?

Experimente online!

Explicação

ẹ+           Sum the digits
  ×₂         Double
    ;I×?     There is an integer I such that I×(double of the sum) = Input
Fatalizar
fonte
2

Python 2 , 34 32 bytes

-2 bytes graças a @Rod

lambda n:n%sum(map(int,`n`)*2)<1

Experimente online!

ovs
fonte
6
com base no exemplo de "claramente distinguível" fornecido na pergunta, acredito que você possa remover o <1.
Assistente de trigo
2

Mathematica, 26 bytes

(2Tr@IntegerDigits@#)∣#&

Nenhuma pista por que tem uma precedência mais alta que a multiplicação ...

Martin Ender
fonte
2

PHP , 41 bytes

imprime zero se divisível, número inteiro positivo caso contrário.

<?=$argn%(2*array_sum(str_split($argn)));

Experimente online!

Jörg Hülsermann
fonte
Você coloca a atribuição no bloco de cabeçalho. Assim como você pode usar $a=10, mas você se esqueceu de contar isso para a sua contagem de bytes
aross
@aross Por que devo contar a entrada para a minha contagem de bytes? $argnestá disponível com o -F(neste caso) ou -Ropção
Jörg Hülsermann 5/17/17
Hum, interessante. Eu não sabia -F. Mas isso não se reflete no seu TIO (ele suporta eco do STDIN?).
Aross
@aross, funciona como sua abordagem, use apenas um arquivo em vez de código e a -Fopção em vez de -R php.net/manual/en/features.commandline.options.php Se você encontrou uma maneira melhor de fazer o mesmo no tio como no commnd linha me avise
Jörg Hülsermann
2

Excel, 63 bytes

=MOD(A1,2*SUMPRODUCT(--MID(A1,ROW(OFFSET(A$1,,,LEN(A1))),1)))=0

A soma de dígitos é o bit longo.

Wernisch
fonte
2

Casca , 9 8 bytes

Agradecemos a Leo por economizar 1 byte.

Ṡ¦ȯ*2ṁis

Experimente online!

Explicação

Ṡ¦ȯ         Test whether f(x) divides x, where f is the function obtained by
            composing the next 4 functions.
       s    Convert x to a string.
     ṁi     Convert each character to an integer and sum the result.
   *2       Double the result.
Martin Ender
fonte
Você pode usar M para mapear e soma com um único comando, salvando um byte
Leo
2

Haskell , 38 37 42 bytes

Agradecimentos a Zgarb por jogar fora 1 byte

f x=read x`mod`foldr((+).(*2).read.pure)0x

Experimente online!

Recebe entrada como uma string; retorna 0 se divisível e diferente de zero caso contrário.

Julian Wolf
fonte
(:[])pode ser pure.
Zgarb 3/07
Você vai economizar 1 byte, substituindo o lambda pela declaração da função
bartavelle
@ Bartavelle: Tenho certeza que é uma lavagem. Exemplo?
Julian Lobo
Você está certo, é exatamente o mesmo comprimento. Não sei como isso passou pela minha cabeça: /
bartavelle
2

Python 3, 35 bytes

lambda a:a%(sum(map(int,str(a)))*2)
wrymug
fonte
Olá e bem-vindo ao site. Você pode remover alguns espaços em branco aqui. Particularmente em torno =e após o )no int(c). Além disso, como sumpode usar um gerador como argumento, você pode remover o [..]interior dele. Se você tiver alguma dúvida adicional, sinta-se à vontade para me enviar um ping.
Assistente de trigo
int(c)for c in atambém poderia ser map(int,a), para salvar alguns bytes.
Assistente de trigo
Isso não funciona - ou melhor, funciona ao contrário. Facilmente corrigido com 4 bytes extras:lambda a:not a%(sum(map(int,str(a)))*2)
osuka_
@osuka_ ver um ponto de bala na descrição questão
wrymug
2

TI-BASIC, 27 26 21 bytes

-5 graças a @Oki

:fPart(Ans/sum(2int(10fPart(Ans10^(~randIntNoRep(1,1+int(log(Ans

Isso é complicado pelo fato de não haver uma maneira concisa de somar dígitos inteiros no TI-BASIC . Retorna 0para Truee um número diferente para False.

Explicação:

:fPart(Ans/sum(2int(10fPart(Ans10^(-randIntNoRep(1,1+int(log(Ans
                               10^(-randIntNoRep(1,1+int(log(Ans #Create a list of negative powers of ten, based off the length of the input, i.e. {1,0.1,0.01}
                            Ans                                  #Scalar multiply the input into the list
                    10fPart(                                     #Remove everything left of the decimal point and multiply by 10
               2int(                                             #Remove everything right of the decimal point and multiply by 2
           sum(                                                  #Sum the resulting list
       Ans/                                                      #Divide the input by the sum
:fPart(                                                          #Remove everything left of the decimal, implicit print
Scott Milner
fonte
2
10^-randIntNoRep(1,1+int(log(Ansfaz o mesmo que seq(10^(~A-1),A,0,log(Ansem menor número de bytes como matéria ordem esquentar (Assumindo versão 2.55MP)
Oki
1

Braingolf , 13 12 bytes

VR.Mvd&+2*c%

Experimente online!

Saídas 0 para verdade, qualquer outro número para falsey.

Explicação

VR.Mvd&+2*c%  Implicit input from command-line args
VR            Create stack2, return to stack1
  .M          Duplicate input to stack2
    vd        Switch to stack2, split into digits
      &+      Sum up all digits
        2*    Double
          c   Collapse stack2 back into stack1
           %  Modulus
              Implicit output of last item on stack
Skidsdev
fonte
1

Japonês , 7 bytes

vUì x*2

Retorna 1para true, 0porfalse

Experimente online!

Explicação

vUì x*2
v        // Return 1 if the input is divisible by:
 Uì      //   Input split into a base-10 array
    x    //   Sum the array
     *2  //   While mapped by *2
Oliver
fonte
Também vim com algumas outras soluções de 7 bytes (embora eu não ache que seja uma delas) - estou convencido de que há uma solução mais curta.
Shaggy
1

Haskell , 49 bytes

f x=(==) 0.mod x.(*)2.sum.map(read.return).show$x

Uso

f 80

Experimente online!

Henry
fonte
3
Dicas: existe um espaço extra, retorno == puro, a compreensão da lista geralmente é muito compacta: Experimente on-line!
#
1

Java , 66 bytes

-1 byte graças a Olivier

a->{int i=0;for(int b:(""+a).getBytes())i+=b-48;return a%(i*2)<1;}

Ungolfed & explicação:

a -> {
    int i = 0;

    for(int b : (""+a).getBytes()) { // Loop through each byte of the input converted to a string
        i += b-48; // Subtract 48 from the byte and add it to i
    }

    return a % (i*2) < 1 // Check if a % (i*2) is equal to one
    // I use <1 here for golfing, as the result of a modulus operation should never be less than 0
}
Okx
fonte
Use em intvez de bytepara salvar ... um byte.
Olivier Grégoire
@ OlivierGrégoire Obrigado. Não percebi isso.
Okx 03/07/19
@Okx Precisa mudar o código também.
Henry
Seu código (golfed) fornece valores incorretos para 110, 111. Provavelmente, o a%i*2que é analisado, (a%i)*2uma vez que o módulo e a multiplicação têm a mesma ordem.
Olivier Grégoire
@ OlivierGrégoire Ah, isso é péssimo.
Okx 03/07/19
1

J, 15 bytes

0 indica verdade, diferente de zero indica falsidade.

|~[:+/2#"."0@":

Explicação

        "."0@":  convert to list of digits
  [:+/2#         sum 2 copies of the list ([: forces monadic phrase)
|~               residue of sum divided by argument?
hoosierEE
fonte
Maneira muito inteligente de evitar parênteses ou múltiplos @ou [:!
Jonah
11
Eu debati postar isso como minha própria resposta, mas não é realmente diferente o suficiente. |~2*1#.,.&.":por 13 bytes.
cole
Eu recebo um 'erro de domínio' por isso no meu J Qt IDE. (| ~ [: + / 2 # "." 0 @ ": 112) Então, para o código de cole, recebo (| ~ 2 * 1 #.,. &.": 112) = 0. : / Possivelmente algo errado do meu lado.
DrQuarius
1

tcl, 45

puts [expr 1>$n%(2*([join [split $n ""] +]))]

demonstração

sergiol
fonte
11
Você pode substituir 0==por 1>.
Mr. Xcoder
1

Haskell , 35 34 bytes

f x=mod x$2*sum[read[c]|c<-show x]

Experimente online!

Retorna '0' no caso verdadeiro e o restante no caso contrário.

Haskell , edição pointfree por nimi, 34 bytes

mod<*>(2*).sum.map(read.pure).show

Experimente online!

bartavelle
fonte
Contagem de mesmo byte, se você for sem pontos:mod<*>(2*).sum.map(read.pure).show
nimi
Parece bom, eu adicionei na minha submissão.
bartavelle
1

PHP, 44 bytes

for(;~$d=$argn[$i++];)$t+=2*$d;echo$argn%$t;

Execute assim:

echo 80 | php -nR 'for(;~$d=$argn[$i++];)$t+=2*$d;echo$argn%$t;'

Explicação

Repete os dígitos para calcular o total e, em seguida, gera o módulo como a maioria das respostas.

aross
fonte
1

Java (OpenJDK 8) , 55 53 bytes

a->{int i=0,x=a;for(;x>0;x/=10)i+=x%10*2;return a%i;}

Experimente online!

Um valor de retorno de 0significa verdade, qualquer outra coisa significa falsidade.

Como meu comentário na resposta de Okx não fez ondulações, eu a apaguei e publiquei como esta resposta, ainda mais.

Mais golfe graças a @KrzysztofCichocki e @Laikoni, que por direito me mostraram que eu não preciso responder a um valor de verdade / falsidade, mas a qualquer valor desde que eu descreva o resultado.

Olivier Grégoire
fonte
Você pode remover a parte <1 no final, para que o resultado seja 0 para verdadeiro e> 0 para falso, o que é aceitável, isso resultará em -2 bytes adicionais, para que você possa responder como 53 bytes.
Krzysztof Cichocki
@KrzysztofCichoki Não, não posso: é Java. O único valor verdadeiro é true.
Olivier Grégoire
@ OlivierGrégoire Embora isso seja verdade, se nada mais for especificado, esse desafio é específico Instead of truthy / falsy values for the true and false cases, you may instead specify any finite set of values for the true/false case, and their complement the other values..
Laikoni
@KrzysztofCichocki e Laikoni Desculpe por interpretar mal essa parte, eu apenas a corrigi! Obrigado a ambos :) Além disso, desculpe-nos por rejeitar a edição que era realmente apropriada neste caso.
Olivier Grégoire
1

Mini-Flak, 296 292 bytes

({}((()[()]))){(({}[((((()()()){}){}){}){}])({}(((({})){}){}{}){})[({})])(({}({})))({}(({}[{}]))[{}])({}[({})](({}{})(({}({})))({}(({}[{}]))[{}])({}[({})]))[{}])(({}({})))({}(({}[{}]))[{}])({}[({})])}{}({}(((({}){})))[{}]){({}((({}[()]))([{(({})[{}])()}{}]()){{}{}(({}))(()[()])}{})[{}][()])}

Experimente online!

O link do TIO tem mais comentários meus, por isso é parcialmente mais fácil de ler.

Truthy / Falsey: Truthy (divisível) se o segundo número for igual ao terceiro número, caso contrário, falso. Portanto, tanto o conjunto verdadeiro quanto o falso são infinitos, mas suponho que isso deva ser permitido. 10 bytes, se não estiver.

Nota: Novas linhas / espaços em branco à esquerda / à direita não são permitidos na entrada.

user202729
fonte