38
\$\begingroup\$

Given a positive integer as input, your task is to output a truthy value if the number is divisible by the double of the sum of its digits, and a falsy value otherwise (OEIS A134516). In other words:

(sum_of_digits)*2 | number
  • 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. For a simple example, you may use 0 for the true case and all other numbers for the false case (or vice versa, if you like).

  • Standard input and output rules apply. Default Loopholes also apply.

  • You can take input as an integer or as the string representation of that integer.

  • This is , hence the shortest code in bytes wins!

  • I am new to PPCG, so I would like you to post an explanation if it's possible.


Test Cases

Input - Output - (Reason)

80  - Truthy - (16 divides 80)
100 - Truthy - (2 divides 100)
60  - Truthy - (12 divides 60)
18 - Truthy - (18 divides 18)
12 - Truthy - (6 divides 12)

4 - Falsy - (8 does not divide 4)
8 - Falsy - (16 does not divide 8)
16  - Falsy  - (14 does not divide 16)
21 - Falsy - (6 does not divide 21)
78  - Falsy  - (30 does not divide 78)
110 - Falsy - (4 does not dide 110)
111 - Falsy - (6 does not divide 111)
390 - Falsy  - (24 does not divide 390)
\$\endgroup\$
  • \$\begingroup\$ Good challenge, welcome to PPCG! \$\endgroup\$ – Skidsdev Jul 3 '17 at 13:59
  • \$\begingroup\$ @Mayube Thanks, it is my second challenge, but the first one got closed :P \$\endgroup\$ – user70974 Jul 3 '17 at 14:00
  • \$\begingroup\$ Are we allowed to take digits as a list of Integers? \$\endgroup\$ – Henry Jul 3 '17 at 14:32
  • 4
    \$\begingroup\$ @Henry No, that would be way too trivial \$\endgroup\$ – user70974 Jul 3 '17 at 14:34
  • 1
    \$\begingroup\$ Indeed, the two sentences of "Instead of truthy / falsy values for the true and false cases, you may instead specify any finite set of values for the true case, and their complement for the falsy ones. For a simple example, you may use 0 for the true case and all other numbers for the false case (or vice versa, if you like)" seem to contradict each other (in particular, the "finite" and the "or vice versa"). \$\endgroup\$ – Greg Martin Jul 4 '17 at 2:52

68 Answers 68

7
\$\begingroup\$

Neim, 3 bytes

𝐬ᚫ𝕞

Explanation:

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

Try it online!

Detailed version

\$\endgroup\$
  • \$\begingroup\$ Umm...you should check if the input is a multiple of double the sum of the digits, not vice versa. \$\endgroup\$ – Erik the Outgolfer Jul 3 '17 at 13:31
  • \$\begingroup\$ @EriktheOutgolfer What do you mean? I do check if the input is a multiple of double the sum of the digits. Perhaps I did not explain it correctly. \$\endgroup\$ – Okx Jul 3 '17 at 13:32
  • 3
    \$\begingroup\$ Neim needs to get even golfier - when submissions get too long, my browser starts to lag. \$\endgroup\$ – Esolanging Fruit Jul 8 '17 at 18:12
  • 1
    \$\begingroup\$ @Challenger5 I sincerely apologise for the lack of golfiness. I will try again next time. Again, sorry about that. \$\endgroup\$ – Okx Jul 8 '17 at 19:59
  • \$\begingroup\$ @Okx And I sincerely apologize for being too lazy to find a Neim answer that was a better demonstration of what I was talking about. \$\endgroup\$ – Esolanging Fruit Jul 8 '17 at 21:48
16
\$\begingroup\$

JavaScript (ES6), 31 29 27 bytes

Takes input as a string. Returns zero for truthy and non-zero for falsy.

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

Commented

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

Test cases

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

\$\endgroup\$
  • \$\begingroup\$ I've never seen the [...x] method of splitting before, is there a name for this specifically? \$\endgroup\$ – Jacob Persi Nov 23 '17 at 19:02
  • \$\begingroup\$ @JacobPersi This is the spread operator. \$\endgroup\$ – Arnauld Nov 23 '17 at 20:07
7
\$\begingroup\$

C#, 46 bytes

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

Full/Formatted version:

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();
    }
}
\$\endgroup\$
4
\$\begingroup\$

Retina, 38 27 bytes

-11 bytes and fixed an error with the code thanks to @MartinEnder

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

Try it online!

Prints 1 if divisible, 0 otherwise

Explanation (hope I got this right)

$
$_¶$_

Appends the entire input, plus a newline, plus the input again

.+$|.
$*

Converts each match to unary (either the entire second line which is the original input, or each digit in the first line)

^(.+)¶\1+$

Check if the first line (the doubled digit sum) is a divisor of the second line

\$\endgroup\$
4
\$\begingroup\$

MATL, 7 bytes

tV!UsE\

Outputs 0 if divisible, positive integer otherwise. Specifically, it outputs the remainder of dividing the number by twice the sum of its digits.

Try it online!

Explanation

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
\$\endgroup\$
4
\$\begingroup\$

05AB1E, 5 4 bytes

-1 byte thanks to Okx

SO·Ö

Try it online!

You can also remove the last Ö to get 0 for truthy and something else for falsy resulting in only 3 bytes but to me that just doesn't seem to appropriately fit the definition.

Explanation

SO·Ö
SO    # Separate the digits and sum them
  ·   # Multiply the result by two
   Ö  # Is the input divisible by the result?
\$\endgroup\$
  • \$\begingroup\$ You can golf it to 4 bytes by replacing %_ with Ö. \$\endgroup\$ – Okx Jul 3 '17 at 13:24
4
\$\begingroup\$

x86-64 Machine Code, 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

The above code defines a function in 64-bit x86 machine code that determines whether the input value is divisible by double the sum of its digits. The function conforms to the System V AMD64 calling convention, so that it is callable from virtually any language, just as if it were a C function.

It takes a single parameter as input via the EDI register, as per the calling convention, which is the integer to test. (This is assumed to be a positive integer, consistent with the challenge rules, and is required for the CDQ instruction we use to work correctly.)

It returns its result in the EAX register, again, as per the calling convention. The result will be 0 if the input value was divisible by the sum of its digits, and non-zero otherwise. (Basically, an inverse Boolean, exactly like the example given in the challenge rules.)

Its C prototype would be:

int DivisibleByDoubleSumOfDigits(int value);

Here are the ungolfed assembly language instructions, annotated with a brief explanation of the purpose of each 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

In the first block, we do some preliminary initialization of registers:

  • PUSH+POP instructions are used as a slow but short way to initialize ESI to 10. This is necessary because the DIV instruction on x86 requires a register operand. (There is no form that divides by an immediate value of, say, 10.)
  • XOR is used as a short and fast way to clear the ECX register. This register will serve as the "accumulator" inside of the upcoming loop.
  • Finally, a copy of the input value (from EDI) is made, and stored in EAX, which will be clobbered as we go through the loop.

Then, we start looping and summing the digits in the input value. This is based on the x86 DIV instruction, which divides EDX:EAX by its operand, and returns the quotient in EAX and the remainder in EDX. What we'll do here is divide the input value by 10, such that the remainder is the digit in the last place (which we'll add to our accumulator register, ECX), and the quotient is the remaining digits.

  • The CDQ instruction is a short way of setting EDX to 0. It actually sign-extends the value in EAX to EDX:EAX, which is what DIV uses as the dividend. We don't actually need sign-extension here, because the input value is unsigned, but CDQ is 1 byte, as opposed to using XOR to clear EDX, which would be 2 bytes.
  • Then we DIVide EDX:EAX by ESI (10).
  • The remainder (EDX) is added to the accumulator (ECX).
  • The EAX register (the quotient) is tested to see if it is equal to 0. If so, we have made it through all of the digits and we fall through. If not, we still have more digits to sum, so we go back to the top of the loop.

Finally, after the loop is finished, we implement number % ((sum_of_digits)*2):

  • The LEA instruction is used as a short way to multiply ECX by 2 (or, equivalently, add ECX to itself), and store the result in a different register (in this case, EAX).

    (We could also have done add ecx, ecx+xchg ecx, eax; both are 3 bytes, but the LEA instruction is faster and more typical.)

  • Then, we do a CDQ again to prepare for division. Because EAX will be positive (i.e., unsigned), this has the effect of zeroing EDX, just as before.
  • Next is the division, this time dividing EDX:EAX by the input value (an unmolested copy of which still resides in EDI). This is equivalent to modulo, with the remainder in EDX. (The quotient is also put in EAX, but we don't need it.)
  • Finally, we XCHG (exchange) the contents of EAX and EDX. Normally, you would do a MOV here, but XCHG is only 1 byte (albeit slower). Because EDX contains the remainder after the division, it will be 0 if the value was evenly divisible or non-zero otherwise. Thus, when we RETurn, EAX (the result) is 0 if the input value was divisible by double the sum of its digits, or non-zero otherwise.

Hopefully that suffices for an explanation.
This isn't the shortest entry, but hey, it looks like it beats almost all of the non-golfing languages! :-)

\$\endgroup\$
3
\$\begingroup\$

Japt, 7 4 bytes

Takes input as a string. Outputs 0 for true or a number greater than 0 for false, which, from other solutions, would appear to be valid. If not, let me know and I'll rollback.

%²¬x

Test it


Explanation

Implicit input of string U.
"390"

²

Repeat U twice.
"390390"

¬

Split to array of individual characters.
["3","9","0","3","9","0"]

x

Reduce by summing, automatically casting each character to an integer in the process.
24

%

Get the remainder of dividing U by the result, also automatically casting U to an integer in the process. Implicitly output the resulting integer.
6 (=false)

\$\endgroup\$
  • 2
    \$\begingroup\$ Your explanations usually use up a lot of vertical space, which I feel isn't needed. Either way, it's your answer. \$\endgroup\$ – Okx Jul 3 '17 at 13:47
  • \$\begingroup\$ @Okx; I don't know how "usual" it can be when I only switched to this format a couple of days ago. \$\endgroup\$ – Shaggy Jul 3 '17 at 13:51
  • 4
    \$\begingroup\$ I liked the explanation format. Was easy to follow, especially for this problem, as it was a linear reduction and moved down the page like a math problem. Just my two cents. \$\endgroup\$ – Henry Jul 3 '17 at 14:34
  • 3
    \$\begingroup\$ This explaination format is a lot better than the usual format, especially for those who are not familiar with the languages. I wish other golfers using these golfing languages would do this too. \$\endgroup\$ – Peter1807 Jul 3 '17 at 14:48
3
\$\begingroup\$

C89, 55 53 bytes

(Thanks to Steadybox!

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

It takes a single input, x, which is the value to test. It returns 0 if x is evenly divisible by double the sum of its digits, or non-zero otherwise.

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

As you can see, this takes advantage of C89's implicit-int rules. The global variables s and t are implicitly declared as ints. (They're also implicitly initialized to 0 because they are globals, but we can't take advantage of this if we want the function to be callable multiple times.)

Similarly, the function, f, takes a single parameter, x, which is implicitly an int, and it returns an int.

The code inside of the function is fairly straightforward, although the for loop will look awfully strange if you're unfamiliar with the syntax. Basically, a for loop header in C contains three parts:

for (initialization; loop condition; increment)

In the "initialization" section, we've initialized our global variables. This will run once, before the loop is entered.

In the "loop condition" section, we've specified on what condition the loop should continue. This much should be obvious.

In the "increment" section, we've basically put arbitrary code, since this will run at the end of every loop.

The larger purpose of the loop is to iterate through each digit in the input value, adding them to s. Finally, after the loop has finished, s is doubled and taken modulo x to see if it is evenly divisible. (A better, more detailed explanation of the logic here can be found in my other answer, on which this one is based.)

Human-readable version:

int f(int x)
{
    int temp = x;
    int sum  = 0;
    while (temp > 0)
    {
        sum  += temp % 10;
        temp /= 10;
    }
    return x % (sum * 2);
}
\$\endgroup\$
  • \$\begingroup\$ You can save two bytes, if you use t instead of t>0 as the loop condition. \$\endgroup\$ – Steadybox Jul 4 '17 at 12:33
  • \$\begingroup\$ Ah, of course! Good catch, @Steadybox. Not sure how I missed that, since testing against 0 is exactly what my asm implementation did, on which this answer was heavily based. \$\endgroup\$ – Cody Gray Jul 6 '17 at 13:11
  • \$\begingroup\$ 45 \$\endgroup\$ – PrincePolka Nov 28 '17 at 1:41
2
\$\begingroup\$

Brachylog, 8 bytes

ẹ+×₂;I×?

Try it online!

Explanation

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

Python 2, 34 32 bytes

-2 bytes thanks to @Rod

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

Try it online!

\$\endgroup\$
  • 6
    \$\begingroup\$ based on the example of "clearly distinguishable" provided in the question, I believe you can remove the <1. \$\endgroup\$ – Sriotchilism O'Zaic Jul 3 '17 at 13:34
2
\$\begingroup\$

Mathematica, 26 bytes

(2Tr@IntegerDigits@#)∣#&

No clue why has a higher precedence than multiplication...

\$\endgroup\$
2
\$\begingroup\$

PHP, 41 bytes

prints zero if divisible, positive integer otherwise.

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

Try it online!

\$\endgroup\$
  • \$\begingroup\$ You put the assignment in the header block. You might as well use $a=10, but you forgot to count that towards your byte count \$\endgroup\$ – aross Jul 5 '17 at 9:34
  • \$\begingroup\$ @aross why should I count the input towards to my byte count. $argn is available with the -F (in this case) or -R option \$\endgroup\$ – Jörg Hülsermann Jul 5 '17 at 10:48
  • \$\begingroup\$ Hm, interesting. I didn't know about -F. But that's not reflected in your TIO (does it support echoing from STDIN?). \$\endgroup\$ – aross Jul 5 '17 at 11:53
  • \$\begingroup\$ @aross it works like your approach use only a file instead of code and the -Foption instead of -R php.net/manual/en/features.commandline.options.php If you found an better way to make the same in tio like in the commnd line let me know \$\endgroup\$ – Jörg Hülsermann Jul 5 '17 at 12:03
2
\$\begingroup\$

Excel, 63 bytes

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

Summing digits is the lengthy bit.

\$\endgroup\$
2
\$\begingroup\$

Perl 6, 19 bytes

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

Try it online!

\$\endgroup\$
2
\$\begingroup\$

Husk, 9 8 bytes

Thanks to Leo for saving 1 byte.

Ṡ¦ȯ*2ṁis

Try it online!

Explanation

Ṡ¦ȯ         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.
\$\endgroup\$
  • \$\begingroup\$ You can use ṁ to map and sum with a single command, saving one byte \$\endgroup\$ – Leo Jul 3 '17 at 17:09
2
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ (:[]) can be pure. \$\endgroup\$ – Zgarb Jul 3 '17 at 17:00
  • \$\begingroup\$ You will save 1 byte by replacing the lambda by function declaration \$\endgroup\$ – bartavelle Jul 4 '17 at 6:37
  • \$\begingroup\$ @bartavelle: Pretty sure it's a wash. Example? \$\endgroup\$ – Julian Wolf Jul 4 '17 at 15:33
  • \$\begingroup\$ You're right, it is the exact same length. Not sure how that crossed my mind :/ \$\endgroup\$ – bartavelle Jul 4 '17 at 15:43
2
\$\begingroup\$

Python 3, 35 bytes

lambda a:a%(sum(map(int,str(a)))*2)
\$\endgroup\$
  • \$\begingroup\$ 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. \$\endgroup\$ – Sriotchilism O'Zaic Jul 4 '17 at 15:58
  • \$\begingroup\$ int(c)for c in a could also be map(int,a), to save a few bytes. \$\endgroup\$ – Sriotchilism O'Zaic Jul 4 '17 at 16:52
  • \$\begingroup\$ This doesn't work - or rather, works backwards. Easily fixed with 4 extra bytes: lambda a:not a%(sum(map(int,str(a)))*2) \$\endgroup\$ – osuka_ Nov 21 '17 at 16:01
  • \$\begingroup\$ @osuka_ see bullet point one in the question description \$\endgroup\$ – wrymug Nov 21 '17 at 16:08
2
\$\begingroup\$

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
\$\endgroup\$
  • 2
    \$\begingroup\$ 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) \$\endgroup\$ – Oki Jul 9 '17 at 18:01
1
\$\begingroup\$

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
\$\endgroup\$
1
\$\begingroup\$

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
\$\endgroup\$
  • \$\begingroup\$ 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. \$\endgroup\$ – Shaggy Jul 3 '17 at 15:36
1
\$\begingroup\$

Haskell, 49 Bytes

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

Usage

f 80

Try it online!

\$\endgroup\$
  • 3
    \$\begingroup\$ Tips: there is an extra space, return==pure, list comprehensions are often very compact : Try it online! \$\endgroup\$ – bartavelle Jul 3 '17 at 16:41
1
\$\begingroup\$

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
}
\$\endgroup\$
  • \$\begingroup\$ Use int instead of byte to save... a byte. \$\endgroup\$ – Olivier Grégoire Jul 3 '17 at 14:42
  • \$\begingroup\$ @OlivierGrégoire Thanks. Didn't notice that. \$\endgroup\$ – Okx Jul 3 '17 at 14:45
  • \$\begingroup\$ @Okx Need to change golfed code as well. \$\endgroup\$ – Henry Jul 3 '17 at 14:48
  • \$\begingroup\$ 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. \$\endgroup\$ – Olivier Grégoire Jul 3 '17 at 14:52
  • \$\begingroup\$ @OlivierGrégoire Ah, that sucks. \$\endgroup\$ – Okx Jul 3 '17 at 14:53
1
\$\begingroup\$

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?
\$\endgroup\$
  • \$\begingroup\$ Very clever way to avoid parens or multiple @ or [:! \$\endgroup\$ – Jonah Jul 3 '17 at 20:05
  • 1
    \$\begingroup\$ I debated posting this as my own answer, but it's not really different enough. |~2*1#.,.&.": for 13 bytes. \$\endgroup\$ – cole Nov 29 '17 at 4:14
  • \$\begingroup\$ 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. \$\endgroup\$ – DrQuarius 11 hours ago
1
\$\begingroup\$

Ohm, 5 bytes

D}Σd¥

Try it online!

\$\endgroup\$
1
\$\begingroup\$

tcl, 45

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

demo

\$\endgroup\$
  • 1
    \$\begingroup\$ You can replace 0== with 1>. \$\endgroup\$ – Mr. Xcoder Jul 3 '17 at 19:25
1
\$\begingroup\$

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!

\$\endgroup\$
  • \$\begingroup\$ Same byte count if you go pointfree: mod<*>(2*).sum.map(read.pure).show \$\endgroup\$ – nimi Jul 4 '17 at 15:34
  • \$\begingroup\$ Looks good, I added it in my submission. \$\endgroup\$ – bartavelle Jul 4 '17 at 15:46
1
\$\begingroup\$

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.

\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ 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. \$\endgroup\$ – Krzysztof Cichocki Jul 5 '17 at 7:50
  • \$\begingroup\$ @KrzysztofCichoki No I can't: this is Java. The only truthy value is true. \$\endgroup\$ – Olivier Grégoire Jul 5 '17 at 7:56
  • \$\begingroup\$ @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.. \$\endgroup\$ – Laikoni Jul 5 '17 at 8:13
  • \$\begingroup\$ @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. \$\endgroup\$ – Olivier Grégoire Jul 5 '17 at 10:32
1
\$\begingroup\$

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.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy