¿Soy divisible por el doble de la suma de mis dígitos?

40

Dado un entero positivo como entrada, su tarea es generar un valor verdadero si el número es divisible por el doble de la suma de sus dígitos, y un valor falso de lo contrario ( OEIS A134516 ). En otras palabras:

(sum_of_digits)*2 | number
  • En lugar de los valores de verdad / falsedad para los casos verdadero y falso, puede especificar cualquier conjunto finito de valores para el caso verdadero / falso y su complemento a los otros valores. Para un ejemplo simple, puede usar 0para el caso verdadero y todos los demás números para el caso falso (o viceversa, si lo desea).

  • Se aplican las reglas estándar de entrada y salida. Las lagunas predeterminadas también se aplican.

  • Puede tomar la entrada como un entero o como la representación de cadena de ese entero.

  • Este es el , por lo tanto, gana el código más corto en bytes.

  • Soy nuevo en PPCG, por lo que me gustaría que publique una explicación si es posible.


Casos de prueba

Entrada - Salida - (Motivo)

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

4 - Falsy - (8 no divide 4)
8 - Falsy - (16 no divide 8)
16 - Falsy - (14 no divide 16)
21 - Falsy - (6 no divide 21)
78 - Falsy - (30 no divide 78)
110 - Falsy - (4 no dide 110)
111 - Falsy - (6 no divide 111)
390 - Falsy - (24 no divide 390)

fuente
Buen desafío, bienvenido a PPCG!
Skidsdev
@Mayube Gracias, es mi segundo desafío, pero el primero se cerró: P
¿Se nos permite tomar dígitos como una lista de enteros?
Henry
44
@ Henry No, eso sería demasiado trivial
1
De hecho, las dos oraciones de "En lugar de valores de verdad / falsedad para los casos verdadero y falso, puede especificar cualquier conjunto finito de valores para el caso verdadero, y su complemento para los casos falsos. Para un ejemplo simple, puede usar 0 para el caso verdadero y todos los demás números para el caso falso (o viceversa, si lo desea) "parecen contradecirse (en particular, el" finito "y el" o viceversa ").
Greg Martin

Respuestas:

7

Neim , 3 bytes

𝐬ᚫ𝕞

Explicación:

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

Pruébalo en línea!

Versión detallada

Okx
fuente
Umm ... deberías comprobar si la entrada es un múltiplo del doble de la suma de los dígitos, no viceversa.
Erik the Outgolfer
@EriktheOutgolfer ¿Qué quieres decir? Verifico si la entrada es un múltiplo del doble de la suma de los dígitos. Quizás no lo expliqué correctamente.
Okx
44
Neim necesita ser aún más golfista: cuando los envíos son demasiado largos, mi navegador comienza a retrasarse.
Esolanging Fruit
1
@ Challenger5 Me disculpo sinceramente por la falta de golf. Lo intentaré la próxima vez. De nuevo, perdón por eso.
Okx
@Okx Y me disculpo sinceramente por ser demasiado vago para encontrar una respuesta de Neim que fuera una mejor demostración de lo que estaba hablando.
Esolanging Fruit
16

JavaScript (ES6), 31 29 27 bytes

Toma la entrada como una cadena. Devuelve cero para la verdad y no cero para la falsedad.

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 prueba

Arnauld
fuente
Nunca he visto el [... x] método de división antes, ¿hay un nombre para esto específicamente?
Jacob Persi
@JacobPersi Este es el operador de propagación .
Arnauld
7

C #, 46 bytes

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

Versión completa / formateada:

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
fuente
4

Retina , 38 27 bytes

-11 bytes y reparó un error con el código gracias a @MartinEnder

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

Pruébalo en línea!

Imprime 1 si es divisible, 0 de lo contrario

Explicación (espero haberlo hecho bien)

$
$_¶$_

Agrega toda la entrada, más una nueva línea, más la entrada nuevamente

.+$|.
$*

Convierte cada coincidencia en unario (ya sea la segunda línea completa, que es la entrada original, o cada dígito en la primera línea)

^(.+)¶\1+$

Verifique si la primera línea (la suma de dos dígitos) es un divisor de la segunda línea

PunPun1000
fuente
4

MATL , 7 bytes

tV!UsE\

Salidas 0si es divisible, entero positivo de lo contrario. Específicamente, genera el resto de dividir el número por el doble de la suma de sus dígitos.

Pruébalo en línea!

Explicación

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
fuente
4

05AB1E , 5 4 bytes

-1 byte gracias a Okx

SO·Ö

Pruébalo en línea!

También puede eliminar el último Ö para obtener 0 para veracidad y algo más para falsedad, lo que resulta en solo 3 bytes, pero para mí eso no parece encajar adecuadamente en la definición.

Explicación

SO·Ö
SO    # Separate the digits and sum them
  ·   # Multiply the result by two
   Ö  # Is the input divisible by the result?
Datboi
fuente
Puede jugar golf a 4 bytes reemplazando %_con Ö.
Okx
4

Código de 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

El código anterior define una función en el código de máquina x86 de 64 bits que determina si el valor de entrada es divisible por el doble de la suma de sus dígitos. La función se ajusta a la convención de llamadas System V AMD64, por lo que se puede llamar desde prácticamente cualquier lenguaje, como si fuera una función C.

Toma un solo parámetro como entrada a través del EDIregistro, según la convención de llamada, que es el número entero para probar. (Se supone que este es un número entero positivo , consistente con las reglas de desafío, y se requiere para que la CDQinstrucción que usemos funcione correctamente).

Devuelve su resultado en el EAXregistro, nuevamente, según la convención de llamada. El resultado será 0 si el valor de entrada fue divisible por la suma de sus dígitos, y de lo contrario no será cero. (Básicamente, un booleano inverso, exactamente como el ejemplo dado en las reglas de desafío).

Su prototipo C sería:

int DivisibleByDoubleSumOfDigits(int value);

Aquí están las instrucciones de lenguaje ensamblador no escritas, anotadas con una breve explicación del propósito de cada instrucción:

; 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

En el primer bloque, hacemos una inicialización preliminar de registros:

  • PUSHLas POPinstrucciones + se usan como una forma lenta pero corta de inicializar ESIa 10. Esto es necesario porque la DIVinstrucción en x86 requiere un operando de registro. (No existe una forma que se divida por un valor inmediato de, digamos, 10.)
  • XORse usa como una forma corta y rápida de borrar el ECXregistro. Este registro servirá como el "acumulador" dentro del próximo ciclo.
  • Finalmente, se hace una copia del valor de entrada (desde EDI) y se almacena en ella EAX, que se registrará a medida que avancemos por el bucle.

Luego, comenzamos a recorrer y sumar los dígitos en el valor de entrada. Esto se basa en la DIVinstrucción x86 , que se divide EDX:EAXpor su operando, y devuelve el cociente EAXy el resto en EDX. Lo que haremos aquí es dividir el valor de entrada por 10, de modo que el resto sea el dígito en el último lugar (que agregaremos a nuestro registro de acumulador ECX), y el cociente son los dígitos restantes.

  • La CDQinstrucción es una forma corta de establecer EDXa 0. En realidad, firma-extiende el valor EAXa EDX:EAX, que es lo que se DIVusa como dividendo. En realidad, no necesitamos la extensión de signo aquí, porque el valor de entrada no está firmado, pero CDQes de 1 byte, en lugar de usar XORpara borrarEDX , que sería de 2 bytes.
  • Entonces DIVide EDX:EAXpor ESI(10).
  • El resto ( EDX) se agrega al acumulador (ECX ).
  • El EAXregistro (el cociente) se prueba para ver si es igual a 0. Si es así, hemos superado todos los dígitos y hemos caído. Si no, todavía tenemos más dígitos para sumar, así que volvemos a la parte superior del ciclo.

Finalmente, una vez finalizado el ciclo, implementamos number % ((sum_of_digits)*2):

  • La LEAinstrucción se utiliza como una forma corta de multiplicar ECXpor 2 (o, equivalentemente, sumar ECXa sí mismo) y almacenar el resultado en un registro diferente (en este caso EAX).

    (También podríamos haber hecho add ecx, ecx+ xchg ecx, eax; ambos son 3 bytes, pero la LEAinstrucción es más rápida y más típica).

  • Luego, hacemos otra CDQvez para prepararnos para la división. Como EAXserá positivo (es decir, sin signo), esto tiene el efecto de poner a cero EDX, como antes.
  • Luego está la división, esta vez dividida EDX:EAXpor el valor de entrada (una copia no molestada de la cual aún reside EDI). Esto es equivalente al módulo, con el resto adentro EDX. (El cociente también se incluye EAX, pero no lo necesitamos).
  • Finalmente, XCHG(intercambiamos) los contenidos de EAXy EDX. Normalmente, harías un MOVaquí, pero XCHGes solo 1 byte (aunque más lento). Debido a que EDXcontiene el resto después de la división, será 0 si el valor era igualmente divisible o distinto de cero. Por lo tanto, cuando RETurnamos, EAX(el resultado) es 0 si el valor de entrada era divisible por el doble de la suma de sus dígitos, o de lo contrario no sería cero.

Esperemos que eso sea suficiente para una explicación.
Esta no es la entrada más corta, pero bueno, ¡parece que supera a casi todos los idiomas que no son de golf! :-)

Cody Gray
fuente
3

Japt , 7 4 bytes

Toma la entrada como una cadena. Salidas 0para trueo un número mayor que 0para false, que, desde otras soluciones, parecerían ser válidas. Si no, házmelo saber y retrocederé.

%²¬x

Pruébalo


Explicación

Entrada implícita de cadena U.
"390"

²

Repite Udos veces.
"390390"

¬

Dividir en una matriz de caracteres individuales.
["3","9","0","3","9","0"]

x

Reduzca sumando, convirtiendo automáticamente cada personaje en un entero en el proceso.
24

%

Obtenga el resto de la división Upor el resultado, también se convierte automáticamente Ua un número entero en el proceso. Salida implícita del entero resultante.
6 (=false)

Lanudo
fuente
2
Sus explicaciones usualmente usan mucho espacio vertical, lo cual creo que no es necesario. De cualquier manera, es tu respuesta.
Okx
@Okx; No sé cuán "habitual" puede ser cuando solo cambié a este formato hace un par de días.
Shaggy
44
Me gustó el formato de explicación. Fue fácil de seguir, especialmente para este problema, ya que era una reducción lineal y se movía hacia abajo de la página como un problema matemático. Solo mis dos centavos.
Henry
3
Este formato de explicación es mucho mejor que el formato habitual, especialmente para aquellos que no están familiarizados con los idiomas. Desearía que otros golfistas que usan estos lenguajes de golf hicieran esto también.
Peter1807
3

C89, 55 53 bytes

(¡Gracias a Steadybox!

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

Se necesita una sola entrada x, que es el valor a probar. Devuelve 0 si xes divisible por el doble de la suma de sus dígitos, o si no es cero.

Pruébalo en línea!

Sin golf:

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

Como puede ver, esto aprovecha las reglas implícitas de C89. Las variables globales sy tse declaran implícitamente como ints. (También se inicializan implícitamente a 0 porque son globales, pero no podemos aprovechar esto si queremos que la función se pueda llamar varias veces).

Del mismo modo, la función, ftoma un único parámetro, x,que es implícitamente un int, y devuelve un int.

El código dentro de la función es bastante sencillo, aunque el forbucle se verá terriblemente extraño si no está familiarizado con la sintaxis. Básicamente, un forencabezado de bucle en C contiene tres partes:

for (initialization; loop condition; increment)

En la sección "inicialización", hemos inicializado nuestras variables globales. Esto se ejecutará una vez, antes de ingresar el ciclo.

En la sección "condición del bucle", hemos especificado en qué condición debe continuar el bucle. Esto debería ser obvio.

En la sección "incremento", básicamente hemos puesto código arbitrario, ya que esto se ejecutará al final de cada ciclo.

El propósito más grande del ciclo es iterar a través de cada dígito en el valor de entrada, agregándolos a s. Finalmente, después de que el ciclo ha terminado, sse duplica y se toma un módulo xpara ver si es divisible de manera uniforme. (Una explicación mejor y más detallada de la lógica aquí se puede encontrar en mi otra respuesta , en la que se basa esta).

Versión legible para 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
fuente
Puede guardar dos bytes, si los usa en tlugar de t>0como condición de bucle .
Steadybox el
Ah, por supuesto! Buena captura, @Steadybox. No estoy seguro de cómo me perdí eso, ya que probar contra 0 es exactamente lo que hizo mi implementación de asm, en lo que esta respuesta se basó en gran medida.
Cody Gray
45
PrincePolka
2

Brachylog , 8 bytes

ẹ+×₂;I×?

Pruébalo en línea!

Explicación

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

Python 2 , 34 32 bytes

-2 bytes gracias a @Rod

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

Pruébalo en línea!

ovs
fuente
66
basado en el ejemplo de "claramente distinguible" proporcionado en la pregunta, creo que puede eliminar el <1.
Wheat Wizard
2

Mathematica, 26 bytes

(2Tr@IntegerDigits@#)∣#&

No tengo idea de por qué tiene mayor prioridad que la multiplicación ...

Martin Ender
fuente
2

PHP , 41 bytes

imprime cero si es divisible, entero positivo de lo contrario.

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

Pruébalo en línea!

Jörg Hülsermann
fuente
Pones la tarea en el bloque de encabezado. También podría usarlo $a=10, pero olvidó contar eso para su recuento de bytes
aross el
@aross, ¿por qué debería contar la entrada para mi recuento de bytes? $argnestá disponible con -F(en este caso) u -Ropción
Jörg Hülsermann
Hm, interesante. No sabía acerca -F. Pero eso no se refleja en su TIO (¿admite eco de STDIN?).
aross
@aross funciona como su enfoque, use solo un archivo en lugar de código y la -Fopción en lugar de -R php.net/manual/en/features.commandline.options.php Si encuentra una mejor manera de hacer lo mismo en tio como en el comando línea hágamelo saber
Jörg Hülsermann
2

Excel, 63 bytes

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

Sumar dígitos es el bit largo.

Wernisch
fuente
2

Cáscara , 9 8 bytes

Gracias a Leo por guardar 1 byte.

Ṡ¦ȯ*2ṁis

Pruébalo en línea!

Explicación

Ṡ¦ȯ         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
fuente
Puede usar ṁ para asignar y sumar con un solo comando, guardando un byte
Leo
2

Haskell , 38 37 42 bytes

Gracias a Zgarb por jugar golf en 1 byte

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

Pruébalo en línea!

Toma la entrada como una cadena; devuelve 0 si es divisible y distinto de cero.

Julian Wolf
fuente
(:[])puede ser pure.
Zgarb
Ahorrará 1 byte reemplazando la declaración lambda por función
bartavelle
@bartavelle: Estoy seguro de que es un lavado. ¿Ejemplo?
Julian Wolf
Tienes razón, es exactamente la misma longitud. No estoy seguro de cómo se me pasó por la mente: /
bartavelle
2

Python 3, 35 bytes

lambda a:a%(sum(map(int,str(a)))*2)
wrymug
fuente
Hola y bienvenidos al sitio. Puede eliminar algunos espacios en blanco aquí. Particularmente alrededor =y después de la )en int(c). Además, dado que sumpuede tomar un generador como argumento, puede eliminar el [..]interior. Si tiene alguna pregunta adicional, no dude en enviarme un ping.
Wheat Wizard
int(c)for c in aTambién podría ser map(int,a), para guardar unos pocos bytes.
Wheat Wizard
Esto no funciona, o más bien, funciona al revés. Fácilmente arreglado con 4 bytes adicionales:lambda a:not a%(sum(map(int,str(a)))*2)
osuka_
@osuka_ vea el punto uno en la descripción de la pregunta
wrymug
2

TI-BASIC, 27 26 21 bytes

-5 gracias a @Oki

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

Esto se hace más complicado por el hecho de que no hay una forma concisa de sumar dígitos enteros en TI-BASIC . Devuelve 0para Truey un número diferente paraFalse .

Explicación:

: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
fuente
2
10^-randIntNoRep(1,1+int(log(Anshace lo mismo que seq(10^(~A-1),A,0,log(Ansen menos bytes ya que el orden no importa (asumiendo la versión 2.55MP)
Oki
1

Braingolf , 13 12 bytes

VR.Mvd&+2*c%

Pruébalo en línea!

Salidas 0 para verdad, cualquier otro número para falsey.

Explicación

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
fuente
1

Japt , 7 bytes

vUì x*2

Devoluciones 1para true, 0parafalse

Pruébalo en línea!

Explicación

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
fuente
También se me ocurrieron algunas otras soluciones de 7 bytes para esto (aunque, no creo que esta fuera una de ellas). Sin embargo, estoy convencido de que hay una solución más corta.
Shaggy
1

Java , 66 bytes

-1 byte gracias a Olivier

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

Sin golfos y explicación:

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
fuente
Use en intlugar de byteguardar ... un byte.
Olivier Grégoire
@ OlivierGrégoire Gracias. No me di cuenta de eso.
Okx
@Okx También necesita cambiar el código de golf.
Henry
Su código (golfizado) da valores incorrectos para 110, 111. Probablemente el a%i*2que se analiza (a%i)*2ya que el módulo y la multiplicación tienen el mismo orden.
Olivier Grégoire
@ OlivierGrégoire Ah, eso apesta.
Okx
1

J, 15 bytes

0 indica verdad, no cero indica falsedad.

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

Explicación

        "."0@":  convert to list of digits
  [:+/2#         sum 2 copies of the list ([: forces monadic phrase)
|~               residue of sum divided by argument?
hoosierEE
fuente
Manera muy inteligente para evitar parens o múltiples @o [:!
Jonás
1
Discutí publicar esto como mi propia respuesta, pero en realidad no es lo suficientemente diferente. |~2*1#.,.&.":por 13 bytes.
cole
Recibo un 'error de dominio' para esto en mi J Qt IDE. (| ~ [: + / 2 # "." 0 @ ": 112) Luego, para el código de cole, obtengo (| ~ 2 * 1 #.,. &.": 112) = 0. : / Posiblemente algo mal de mi parte.
DrQuarius
1

tcl, 45

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

manifestación

sergiol
fuente
1
Se puede reemplazar 0==con 1>.
Sr. Xcoder
1

Haskell , 35 34 bytes

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

Pruébalo en línea!

Devuelve '0' en el caso verdadero, el resto de lo contrario.

Haskell , edición sin puntos por nimi, 34 bytes

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

Pruébalo en línea!

bartavelle
fuente
El mismo recuento de bytes si no tiene puntos:mod<*>(2*).sum.map(read.pure).show
nimi
Se ve bien, lo agregué en mi presentación.
bartavelle
1

PHP, 44 bytes

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

Corre así:

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

Explicación

Itera sobre los dígitos para calcular el total, luego genera el módulo como la mayoría de las respuestas.

aross
fuente
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;}

Pruébalo en línea!

Un valor de retorno de 0 significa verdad, cualquier otra cosa significa falsedad.

Como mi comentario en la respuesta de Okx no hizo ondas, lo eliminé y lo publiqué como esta respuesta, jugando golf aún un poco más.

Más golf gracias a @KrzysztofCichocki y @Laikoni que me mostraron con razón que no necesito responder un valor verdadero / falso, sino cualquier valor siempre que describa el resultado.

Olivier Grégoire
fuente
Puede eliminar la parte <1 al final, por lo que el resultado será 0 para verdadero y> 0 para falso, lo cual es aceptable, esto dará como resultado -2 bytes adicionales, por lo que su respuesta podría ser como 53 bytes.
Krzysztof Cichocki
@KrzysztofCichoki No, no puedo: esto es Java. El único valor verdadero es true.
Olivier Grégoire
@ OlivierGrégoire Si bien esto es cierto si no se especifica nada más, este desafío establece específicamente 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 y Laikoni Lo siento, leí mal esa parte, ¡solo la arreglé! Gracias a ambos :) Además, perdón por rechazar la edición que en realidad era apropiada en este caso.
Olivier Grégoire
1

Mini-Flak, 296 292 bytes

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

Pruébalo en línea!

El enlace TIO tiene más comentarios míos, por lo que es parcialmente más fácil de leer.

Verdad / Falsey: Verdad (divisible) si el segundo número es igual al tercer número, falso de lo contrario. Entonces, tanto el conjunto de verdad como el de falsedad son infinitos, pero supongo que eso debería permitirse. +10 byte si no es así.

Nota: Las líneas nuevas / finales / espacios en blanco iniciales no se permiten en la entrada.

usuario202729
fuente