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

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

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

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

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

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

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

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?

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

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)

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

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

Python 2 , 34 32 bytes

-2 bytes graças a @Rod

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

Experimente online!

Mathematica, 26 bytes

(2Tr@IntegerDigits@#)∣#&

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

PHP , 41 bytes

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

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

Experimente online!

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.

Perl 6 , 19 bytes

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

Experimente online!

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.

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.

Python 3, 35 bytes

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

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

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

Haskell , 49 bytes

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

Uso

f 80

Experimente online!

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
}

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?

Ohm , 5 bytes

D}Σd¥

Experimente online!

tcl, 45

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

demonstração

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!

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.

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.

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.