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 código de golf , 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)

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

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

let f =

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

console.log('[Truthy]');
console.log(f("80"))
console.log(f("100"))
console.log(f("60"))
console.log(f("18"))
console.log(f("12"))

console.log('[Falsy]');
console.log(f("4"))
console.log(f("8"))
console.log(f("16"))
console.log(f("21"))
console.log(f("78"))
console.log(f("110"))
console.log(f("111"))
console.log(f("390"))

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();
    }
}

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

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

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?

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! :-)

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)

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);
}

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

Python 2 , 34 32 bytes

-2 bytes gracias a @Rod

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

Pruébalo en línea!

Mathematica, 26 bytes

(2Tr@IntegerDigits@#)∣#&

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

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!

Excel, 63 bytes

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

Sumar dígitos es el bit largo.

Perl 6 , 19 bytes

{$_%%(2*.comb.sum)}

Pruébalo en línea!

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.

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.

Python 3, 35 bytes

lambda a:a%(sum(map(int,str(a)))*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

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

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

Haskell , 49 bytes

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

Uso

f 80

Pruébalo en línea!

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
}

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?

Ohm , 5 bytes

D}Σd¥

Pruébalo en línea!

tcl, 45

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

manifestación

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!

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.

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.

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.