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


40

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 , 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

RĂ©ponses:


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


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


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

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


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

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?

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


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

x

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)


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

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



2

Python 2 , 34 32 octets

-2 octets grĂące Ă  @Rod

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

Essayez-le en ligne!


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 ...


2

PHP , 41 octets

affiche zéro si divisible, entier positif sinon.

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

Essayez-le en ligne!


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.



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.

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.


(:[]) 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)

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

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

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

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

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
}

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?

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

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!


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.


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.


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.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.