Si vous entrez un nombre entier positif , votre tâche consiste à produire une valeur de vérité si le nombre est divisible par le double de la somme de ses chiffres et une valeur de fausseté sinon ( OEIS A134516 ). En d'autres termes:

(sum_of_digits)*2 | number

Au lieu de valeurs vérité / fausseté pour les cas vrais et faux, vous pouvez spécifier un ensemble fini de valeurs pour le cas vrai / faux et leur complément aux autres valeurs. Pour un exemple simple, vous pouvez utiliser 0pour le cas réel et tous les autres nombres pour le casse faux (ou vice versa, si vous voulez).
Les règles d'entrée et de sortie standard s'appliquent. Les failles par défaut s'appliquent également.
Vous pouvez prendre l’entrée sous forme d’entier ou sous forme de représentation sous forme de chaîne de cet entier.
C'est du code-golf , d'où le code le plus court en octets gagne!
Je suis nouveau à PPCG, alors j'aimerais que vous publiez une explication si c'est possible.

Cas de test

Entrée - Sortie - (Raison)

80 - Vérité - (16 divise 80)
100 - Vérité - (2 divise 100)
60 - Vérité - (12 divise 60)
18 - Vérité - (18 divides 18)
12 - Vérité - (6 divides 12)

4 - Falsy - (8 ne divise pas 4)
8 - Falsy - (16 ne divise pas 8)
16 - Falsy - (14 ne divise pas 16)
21 - Falsy - (6 ne divise pas 21)
78 - Falsy - (30 ne divise pas 78)
110 - Falsy - (4 ne meurt pas 110)
111 - Falsy - (6 ne divise pas 111)
390 - Falsy - (24 ne divise pas 390)

Bon défi, bienvenue à PPCG!

— Skidsdev

@Mayube Merci, c'est mon deuxième défi, mais le premier a été fermé: P

Sommes-nous autorisés à prendre des chiffres en tant que liste d'entiers?

— Henry

4

@ Henry Non, ce serait beaucoup trop trivial

1

En effet, les deux phrases de "Au lieu de valeurs vérité / fausseté pour les cas vrais et faux, vous pouvez spécifier un ensemble fini de valeurs pour le cas vrai et leur complément pour les cas faux. Pour un exemple simple, vous pouvez utiliser 0 pour le cas vrai et tous les autres nombres pour le cas faux (ou vice versa, si vous préférez) "semblent se contredire (en particulier, le" fini "et le" ou vice versa ").

— Greg Martin

7

Neim , 3 octets

𝐬ᚫ𝕞

Explication:

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

Essayez-le en ligne!

Version détaillée

— Okx
source

Umm ... vous devriez vérifier si l'entrée est un multiple de deux fois la somme des chiffres, et non l'inverse.

— Erik the Outgolfer

@EriktheOutgolfer Que voulez-vous dire? Je vérifie si l'entrée est un multiple de deux fois la somme des chiffres. Peut-être que je ne l'ai pas expliqué correctement.

— Okx

4

Neim doit devenir encore plus golfeur - lorsque les soumissions deviennent trop longues, mon navigateur commence à ralentir.

— Esolanging Fruit

1

@ Challenger5 Je m'excuse sincèrement pour le manque de finesse. Je vais réessayer la prochaine fois. Encore une fois, désolé pour ça.

— Okx

@Okx Et je m'excuse sincèrement d'être trop paresseux pour trouver une réponse Neim qui soit une meilleure démonstration de ce dont je parlais.

— Esolanging Fruit

16

JavaScript (ES6), 31 29 27 octets

Prend l'entrée sous forme de chaîne. Retourne zéro pour la vérité et non nul pour la fausseté.

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

Commenté

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

Cas de test

Afficher l'extrait de code

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"))

Expand snippet

— Arnauld
source

Je n'ai jamais vu la méthode de scission [... x] auparavant, existe-t-il un nom spécifique?

— Jacob Persi

@JacobPersi C'est l' opérateur de diffusion .

— Arnauld

7

C #, 46 octets

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

Version complète / formatée:

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
source

4

Rétine , 38 27 octets

-11 octets et correction d'une erreur de code grâce à @MartinEnder

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

Essayez-le en ligne!

Imprime 1 si divisible, 0 sinon

Explication (j'espère que j'ai bien compris)

$
$_¶$_

Ajoute l'entrée entière, plus une nouvelle ligne, plus l'entrée encore

.+$|.
$*

Convertit chaque correspondance en unary (soit la seconde ligne entière qui est l'entrée d'origine, soit chaque chiffre de la première ligne)

^(.+)¶\1+$

Vérifiez si la première ligne (la somme des chiffres doublés) est un diviseur de la deuxième ligne

— PunPun1000
source

4

MATL , 7 octets

tV!UsE\

Sorties 0si divisible, entier positif sinon. Plus précisément, il sort le reste de la division du nombre par deux fois la somme de ses chiffres.

Essayez-le en ligne!

Explication

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
source

4

05AB1E , 5 4 octets

-1 octet grâce à Okx

SO·Ö

Essayez-le en ligne!

Vous pouvez également supprimer le dernier Ö pour obtenir 0 pour la vérité et quelque chose d'autre pour la fausseté, qui ne donne que 3 octets, mais pour moi, cela ne semble tout simplement pas correspondre à la définition.

Explication

SO·Ö
SO    # Separate the digits and sum them
  ·   # Multiply the result by two
   Ö  # Is the input divisible by the result?

— Datboi
source

Vous pouvez jouer au golf à 4 octets en remplaçant %_par Ö.

— Okx

4

Code machine x86-64, 24 octets

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

Le code ci-dessus définit une fonction dans le code machine x86 64 bits qui détermine si la valeur d'entrée est divisible par le double de la somme de ses chiffres. La fonction est conforme à la convention d'appel System V AMD64, de sorte qu'elle peut être appelée à partir de pratiquement n'importe quel langage, comme s'il s'agissait d'une fonction C.

Il faut un seul paramètre en entrée via le EDIregistre, conformément à la convention d'appel, qui est le nombre entier à tester. (Ceci est supposé être un entier positif , compatible avec les règles de challenge, et est nécessaire au bon fonctionnement de l' CDQinstruction utilisée.)

Il retourne son résultat dans le EAX registre, encore une fois, conformément à la convention d'appel. Le résultat sera 0 si la valeur en entrée était divisible par la somme de ses chiffres et non nul sinon. (Fondamentalement, un booléen inverse, exactement comme dans les règles de challenge.)

Son prototype C serait:

int DivisibleByDoubleSumOfDigits(int value);

Voici les instructions non assemblées du langage d'assemblage, annotées avec une brève explication du but de chaque instruction:

; 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

Dans le premier bloc, nous effectuons une initialisation préliminaire des registres:

PUSH+ les POPinstructions sont utilisées comme moyen lent mais court d'initialisationESI à 10. Cela est nécessaire car l' DIVinstruction sur x86 nécessite un opérande de registre. (Aucune forme ne divise par une valeur immédiate, disons 10.)
XOR est utilisé comme un moyen rapide et rapide pour effacer le ECX registre. Ce registre servira d’accumulateur à l’intérieur de la prochaine boucle.
Enfin, une copie de la valeur d’entrée (de EDI) est créée et stockée dansEAX laquelle elle sera compressée au fur et à mesure de notre progression dans la boucle.

Ensuite, nous commençons à boucler et à additionner les chiffres de la valeur d’entrée. Ceci est basé sur l’ DIVinstruction x86 , qui divise EDX:EAXpar son opérande et renvoie le quotient dans EAXet le reste dans EDX. Ce que nous ferons ici est de diviser la valeur d’entrée par 10, de sorte que le reste soit le chiffre de la dernière position (que nous ajouterons à notre registre accumulateur,ECX ) et le quotient, les chiffres restants.

L’ CDQinstruction est un moyen simple de définir la valeur EDXsur 0. En fait, elle signe-étend la valeur EAXà EDX:EAX, qui correspond DIVau dividende. En fait, nous n’avons pas besoin de l’extension de signe ici, car la valeur en entrée est non signée, mais CDQvaut 1 octet, par opposition àXOR de clear EDX, qui serait de 2 octets.
Ensuite , nous DIVIde EDX:EAXparESI (10).
Le reste ( EDX) est ajouté à l'accumulateur ( ECX).
Le EAXregistre (le quotient) est testé pour voir s'il est égal à 0. Si c'est le cas, nous l'avons fait à travers tous les chiffres et nous échouons. Sinon, nous avons toujours plus de chiffres à additionner, alors nous retournons au début de la boucle.

Enfin, une fois la boucle terminée, nous implémentons number % ((sum_of_digits)*2):

L' LEAinstruction est utilisée comme un moyen rapide de multiplier ECXpar 2 (ou, de manière équivalente, de s'ajouter ECXà elle-même) et de stocker le résultat dans un registre différent (dans ce cas, EAX).

^{(Nous aurions aussi pu faire add ecx, ecx+ xchg ecx, eax; les deux sont de 3 octets, mais l' LEAinstruction est plus rapide et plus typique.)}
Ensuite, nous faisons à CDQnouveau une préparation pour la division. Parce que EAXsera positif (c'est-à-dire non signé), cela a pour effet de réduire à zéro EDX, comme avant.
Vient ensuite la division, divisée cette fois EDX:EAXpar la valeur d'entrée (une copie non altérée de celle-ci réside toujours dans EDI). Cela équivaut à modulo, le reste étant en EDX. (Le quotient est également ajouté EAX, mais nous n'en avons pas besoin.)
Enfin, nous XCHGéchangeons le contenu de EAXet EDX. Normalement, vous feriez MOVici, mais ce XCHGn’est qu’un octet (bien que plus lent). Parce que EDXcontient le reste après la division, il sera 0 si la valeur est divisible de façon égale ou non nulle sinon. Ainsi, lorsque nous RETurn, EAX(le résultat) est égal à 0 si la valeur entrée est divisible par le double de la somme de ses chiffres, ou différente de zéro dans le cas contraire.

J'espère que cela suffit pour une explication.
Ce n'est pas l'entrée la plus courte, mais bon, on dirait qu'elle bat presque toutes les langues autres que le golf! :-)

— Cody Gray
source

3

Japt , 7 4 octets

Prend l'entrée sous forme de chaîne. Sorties 0pour trueou un plus grand nombre de que 0pour falsequi, à partir d' autres solutions, semblent valides. Sinon, faites le moi savoir et je reviens en arrière.

%²¬x

Essaye-le

Explication

Entrée implicite de chaîne U.
"390"

²

Répétez Udeux fois.
"390390"

¬

Diviser en tableau de caractères individuels.
["3","9","0","3","9","0"]

Réduisez en faisant la somme, en transformant automatiquement chaque caractère en un entier du processus.
24

Obtenez le reste de la division Upar le résultat, ainsi que la conversion automatique Uen un entier du processus. Sortie implicite de l'entier résultant.
6 (=false)

— Hirsute
source

2

Vos explications utilisent généralement beaucoup d'espace vertical, ce qui, à mon avis, n'est pas nécessaire. De toute façon, c'est ta réponse.

— Okx

@Okx; Je ne sais pas à quel point cela peut être "normal" quand je suis passé à ce format il y a quelques jours seulement.

— Shaggy

4

J'ai aimé le format d'explication. Était facile à suivre, en particulier pour ce problème, car il s’agissait d’une réduction linéaire et se déplaçait au bas de la page comme un problème de maths. Juste mes deux cents.

— Henry

3

Ce format d’explication est bien meilleur que le format habituel, en particulier pour ceux qui ne sont pas familiers avec les langues. Je souhaite que d'autres golfeurs utilisant ces langues jouent également.

— Peter1807

3

C89, 55 53 octets

^{(Merci à Steadybox!}

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

Il faut une seule entrée, xqui est la valeur à tester. Il renvoie 0 si xest divisible par le double de la somme de ses chiffres, ou non nul sinon.

Essayez-le en ligne!

Ungolfed:

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

Comme vous pouvez le constater, cela tire parti des règles implicit-int de C89. Les variables globales set tsont implicitement déclarées comme ints. (Ils sont également implicitement initialisés à 0 car ils sont globaux, mais nous ne pouvons en tirer parti si nous voulons que la fonction puisse être appelée plusieurs fois.)

De même, la fonction,, fprend un seul paramètre, x,qui est implicitement un int, et renvoie un int.

Le code à l’intérieur de la fonction est assez simple, bien que le for boucle paraisse terriblement étrange si vous ne connaissez pas la syntaxe. Fondamentalement, un en- fortête de boucle en C contient trois parties:

for (initialization; loop condition; increment)

Dans la section "initialisation", nous avons initialisé nos variables globales. Cela fonctionnera une fois, avant que la boucle ne soit entrée.

Dans la section "condition de boucle", nous avons spécifié à quelle condition la boucle doit continuer. Cela devrait être évident.

Dans la section "incrément", nous avons essentiellement mis du code arbitraire, car il sera exécuté à la fin de chaque boucle.

Le but plus important de la boucle est de parcourir chaque chiffre de la valeur en entrée, en les ajoutant s. Enfin, une fois la boucle terminée, son double et on prend modulo xpour voir si elle est divisible. (On trouvera une explication meilleure et plus détaillée de la logique ici dans mon autre réponse , sur laquelle celle-ci est basée.)

Version lisible par l'homme:

int f(int x)
{
    int temp = x;
    int sum  = 0;
    while (temp > 0)
    {
        sum  += temp % 10;
        temp /= 10;
    }
    return x % (sum * 2);
}

— Cody Gray
source

Vous pouvez enregistrer deux octets, si vous utilisez tplutôt t>0que la condition de boucle .

— Steadybox

Ah bien sur! Bonne prise, @Steadybox. Je ne suis pas sûr de savoir comment j'ai raté cela, car tester contre 0 est exactement ce que mon implémentation asm a fait, sur laquelle cette réponse était fortement basée.

— Cody Gray

45

— PrincePolka

2

Brachylog , 8 octets

ẹ+×₂;I×?

Essayez-le en ligne!

Explication

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

— Fataliser
source

2

Python 2 , 34 32 octets

-2 octets grâce à @Rod

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

Essayez-le en ligne!

— ovs
source

6

sur la base de l’exemple de "clairement distinguable" fourni dans la question, je pense que vous pouvez supprimer le <1.

— Wheat Wizard

2

Mathematica, 26 octets

(2Tr@IntegerDigits@#)∣#&

Aucune idée pourquoi ∣a une priorité plus élevée que la multiplication ...

— Martin Ender
source

2

PHP , 41 octets

affiche zéro si divisible, entier positif sinon.

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

Essayez-le en ligne!

— Jörg Hülsermann
source

Vous mettez l'affectation dans le bloc d'en-tête. Vous pourriez aussi bien l'utiliser $a=10, mais vous avez oublié de compter cela dans votre nombre d'octets

— aross

@aross pourquoi devrais-je compter l'entrée vers mon nombre d'octets. $argnest disponible avec l' option -F(dans ce cas) ou l' -Roption

— Jörg Hülsermann

Hm, intéressant. Je ne savais pas -F. Mais cela ne se voit pas dans votre TIO (cela supporte-t-il l'écho de STDIN?).

— aross

@aross cela fonctionne comme si votre approche utilisait seulement un fichier au lieu de code et l' -Foption au lieu de -R php.net/manual/en/features.commandline.options.php Si vous aviez trouvé un meilleur moyen de faire la même chose comme dans la commande ligne faites le moi savoir

— Jörg Hülsermann

2

Excel, 63 octets

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

La somme des chiffres est le bit le plus long.

— Wernisch
source

2

Perl 6 , 19 octets

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

Essayez-le en ligne!

— Sean
source

2

Husk , 9 à 8 octets

Merci à Leo d’avoir économisé 1 octet.

Ṡ¦ȯ*2ṁis

Essayez-le en ligne!

Explication

Ṡ¦ȯ         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
source

Vous pouvez utiliser ṁ pour mapper et faire la somme avec une seule commande, en enregistrant un octet

— Leo

2

Haskell, 38 37 42 bytes

Thanks to Zgarb for golfing off 1 byte

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

Try it online!

Takes input as a string; returns 0 if divisible and nonzero otherwise.

— Julian Wolf
source

(:[]) can be pure.

— Zgarb

You will save 1 byte by replacing the lambda by function declaration

— bartavelle

@bartavelle: Pretty sure it's a wash. Example?

— Julian Wolf

You're right, it is the exact same length. Not sure how that crossed my mind :/

— bartavelle

2

Python 3, 35 bytes

lambda a:a%(sum(map(int,str(a)))*2)

— wrymug
source

Hello and welcome to the site. You can remove some whitespace here. Particularly around = and after the ) in int(c). In addition since sum can take a generator as an argument you can remove the [..] inside it. If you have any additional questions feel free to ping me.

— Wheat Wizard

int(c)for c in a could also be map(int,a), to save a few bytes.

— Wheat Wizard

This doesn't work - or rather, works backwards. Easily fixed with 4 extra bytes: lambda a:not a%(sum(map(int,str(a)))*2)

— osuka_

@osuka_ see bullet point one in the question description

— wrymug

2

TI-BASIC, 27 26 21 bytes

-5 thanks to @Oki

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

This is made trickier by the fact that there is no concise way to sum integer digits in TI-BASIC. Returns 0 for True, and a different number for False.

Explanation:

: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
source

2

10^-randIntNoRep(1,1+int(log(Ans does the same as seq(10^(~A-1),A,0,log(Ans in fewer bytes as order doesnt matter (Assuming version 2.55MP)

— Oki

1

Braingolf, 13 12 bytes

VR.Mvd&+2*c%

Try it online!

Outputs 0 for truthy, any other number for falsey.

Explanation

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
source

1

Japt, 7 bytes

vUì x*2

Returns 1 for true, 0 for false

Try it online!

Explanation

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
source

I came up with a few other 7 byte solutions for this, too (although, I don't think this was one of them) - I'm convinced there's a shorter solution, though.

— Shaggy

1

Haskell, 49 Bytes

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

Usage

f 80

Try it online!

— Henry
source

3

Tips: there is an extra space, return==pure, list comprehensions are often very compact : Try it online!

— bartavelle

1

Java, 66 bytes

-1 byte thanks to Olivier

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

Ungolfed & explanation:

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
source

Use int instead of byte to save... a byte.

— Olivier Grégoire

@OlivierGrégoire Thanks. Didn't notice that.

— Okx

@Okx Need to change golfed code as well.

— Henry

Your (golfed) code gives incorrect values for 110, 111. Probably the a%i*2 that's parsed as (a%i)*2 since modulus and multiplication have the same order.

— Olivier Grégoire

@OlivierGrégoire Ah, that sucks.

— Okx

1

J, 15 bytes

0 indicates truthy, nonzero indicates falsy.

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

Explanation

        "."0@":  convert to list of digits
  [:+/2#         sum 2 copies of the list ([: forces monadic phrase)
|~               residue of sum divided by argument?

— hoosierEE
source

Very clever way to avoid parens or multiple @ or [:!

— Jonah

1

I debated posting this as my own answer, but it's not really different enough. |~2*1#.,.&.": for 13 bytes.

— cole

I get a 'domain error' for this on my J Qt IDE. (|~[:+/2#"."0@": 112) Then for cole's code I get (|~2*1#.,.&.": 112)=0. :/ Possibly something wrong on my end.

— DrQuarius

1

Ohm, 5 bytes

D}Σd¥

Try it online!

— FrodCube
source

1

tcl, 45

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

demo

— sergiol
source

1

You can replace 0== with 1>.

— Mr. Xcoder

1

Haskell, 35 34 bytes

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

Try it online!

Returns '0' in the true case, the remainder otherwise.

Haskell, pointfree edition by nimi, 34 bytes

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

Try it online!

— bartavelle
source

Same byte count if you go pointfree: mod<*>(2*).sum.map(read.pure).show

— nimi

Looks good, I added it in my submission.

— bartavelle

1

PHP, 44 bytes

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

Run like this:

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

Explanation

Iterates over the digits to compute the total, then outputs the modulo like most answers.

— aross
source

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

Try it online!

A return value of 0 means truthy, anything else means falsy.

Since my comment in Okx's answer made no ripple, I deleted it and posted it as this answer, golfed even a bit more.

Further golfing thanks to @KrzysztofCichocki and @Laikoni who rightfully showed me I needn't answer a truthy/falsy value, but any value as long as I describe the result.

— Olivier Grégoire
source

You can remove the <1 part at the end, so the result will be 0 for true and >0 for false, which is accebtable, this will result in additional -2 bytes, so you answer coiuld be like 53 bytes.

— Krzysztof Cichocki

@KrzysztofCichoki No I can't: this is Java. The only truthy value is true.

— Olivier Grégoire

@OlivierGrégoire While this true if nothing else is specified, this challenge specifically states

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 and Laikoni Sorry I misread that part, I just fixed it! Thank you both :) Also, sorry for rejecting the edit which was actually appropriate in this case.

— Olivier Grégoire

1

Mini-Flak, 296 292 bytes

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

Try it online!

The TIO link have more comments from me, so it is partially easier to read.

Truthy/Falsey: Truthy (divisible) if the second number is equal to the third number, falsy otherwise. So both the truthy and falsy set are infinite, but I suppose that should be allowed. +10 byte if that is not.

Note: Leading/trailing newlines/whitespaces are not allowed in input.

— user202729
source

Suis-je divisible par le double de la somme de mes chiffres?

Cas de test

Neim , 3 octets

JavaScript (ES6), 31 29 27 octets

Commenté

Cas de test

C #, 46 octets

Rétine , 38 27 octets

Explication (j'espère que j'ai bien compris)

MATL , 7 octets

Explication

05AB1E , 5 4 octets

Explication

Code machine x86-64, 24 octets

Japt , 7 4 octets

Explication

C89, 55 53 octets

Brachylog , 8 octets

Explication

Python 2 , 34 32 octets

Mathematica, 26 octets

PHP , 41 octets

Excel, 63 octets

Perl 6 , 19 octets

Husk , 9 à 8 octets

Explication

Haskell, 38 37 42 bytes

Python 3, 35 bytes

TI-BASIC, 27 26 21 bytes

Braingolf, 13 12 bytes

Explanation

Japt, 7 bytes

Explanation

Haskell, 49 Bytes

Java, 66 bytes

J, 15 bytes

Ohm, 5 bytes

tcl, 45

demo

Haskell, 35 34 bytes

Haskell, pointfree edition by nimi, 34 bytes

PHP, 44 bytes

Explanation

Java (OpenJDK 8), 55 53 bytes

Mini-Flak, 296 292 bytes