Bei einer positiven ganzen Zahl als Eingabe, ist Ihre Aufgabe , ein truthy Wert ausgibt , wenn die Zahl teilbar durch das Doppelte der Summe ihrer Ziffern und ein falsy Wert sonst ( OEIS A134516 ). Mit anderen Worten:

(sum_of_digits)*2 | number

• Anstelle wahrer / falscher Werte für die Fälle true und false können Sie stattdessen eine beliebige endliche Menge von Werten für den Fall true / false angeben und diese Werte zu den anderen Werten ergänzen. Für ein einfaches Beispiel können Sie 0für den wahren Fall und alle anderen Zahlen für den falschen Fall verwenden (oder umgekehrt, wenn Sie möchten).

• Es gelten die Standard-Ein- und Ausgaberegeln. Es gelten auch Standardlücken.

• Sie können Eingaben als Ganzzahl oder als Zeichenfolgendarstellung dieser Ganzzahl übernehmen.

• Dies ist Code-Golf , daher gewinnt der kürzeste Code in Bytes!

• Ich bin neu bei PPCG und möchte, dass Sie eine Erklärung abgeben, wenn dies möglich ist.

Testfälle

Eingabe - Ausgabe - (Grund)

80 - Wahrheit - (16 teilt 80)
100 - Wahrheit - (2 teilt 100)
60 - Wahrheit - (12 teilt 60)
18 - Wahrheit - (18 teilt 18)
12 - Wahrheit - (6 teilt 12)

4 - Falsy - (8 teilt 4 nicht)
8 - Falsy - (16 teilt 8 nicht)
16 - Falsy - (14 teilt 16 nicht)
21 - Falsy - (6 teilt 21 nicht)
78 - Falsch - (30 teilt 78 nicht)
110 - Falsy - (4 dide nicht 110)
111 - Falsy - (6 teilt 111 nicht)
390 - Falsy - (24 teilt 390 nicht)

Neim , 3 Bytes

𝐬ᚫ𝕞

Erläuterung:

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

Probieren Sie es online!

Ausführliche Version

JavaScript (ES6), 31 29 27 Byte

Übernimmt die Eingabe als Zeichenfolge. Gibt null für wahr und ungleich null für falsch zurück.

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

Kommentiert

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

Testfälle

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

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

Retina , 38 27 Bytes

-11 Bytes und behebt einen Fehler mit dem Code dank @MartinEnder

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

Probieren Sie es online!

Gibt 1 aus, wenn teilbar, sonst 0

Erklärung (hoffe ich habe das richtig verstanden)

$
$_¶$_

Fügt die gesamte Eingabe plus eine neue Zeile plus die Eingabe erneut hinzu

.+$|.
$*

Konvertiert jede Übereinstimmung in Unary (entweder die gesamte zweite Zeile, die die ursprüngliche Eingabe ist, oder jede Ziffer in der ersten Zeile)

^(.+)¶\1+$

Überprüfen Sie, ob die erste Zeile (die Summe aus zwei Ziffern) ein Teiler der zweiten Zeile ist

MATL , 7 Bytes

tV!UsE\

Gibt aus, 0wenn teilbar, ansonsten positive Ganzzahl. Insbesondere gibt es den Rest der Division der Zahl durch die doppelte Summe ihrer Ziffern aus.

Probieren Sie es online!

Erläuterung

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 dank Okx

SO·Ö

Probieren Sie es online!

Sie können auch das letzte Ö entfernen, um 0 für truthy und etwas anderes für falsy zu erhalten, was nur 3 Bytes ergibt, aber für mich scheint das einfach nicht angemessen zu der Definition zu passen.

Erläuterung

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

x86-64-Maschinencode, 24 Byte

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

Der obige Code definiert eine Funktion im 64-Bit-x86-Maschinencode, die bestimmt, ob der Eingabewert durch die doppelte Summe seiner Ziffern teilbar ist. Die Funktion entspricht der System V AMD64-Aufrufkonvention, sodass sie aus praktisch jeder Sprache aufgerufen werden kann, als wäre sie eine C-Funktion.

Es wird ein einzelner Parameter als Eingabe über das EDIRegister gemäß der aufrufenden Konvention verwendet, bei der es sich um die zu testende Ganzzahl handelt. (Es wird angenommen, dass dies eine positive Ganzzahl ist, die den Herausforderungsregeln entspricht und für die CDQAnweisung erforderlich ist, die wir verwenden, um korrekt zu arbeiten.)

Es gibt sein Ergebnis EAXwieder gemäß der Aufrufkonvention im Register zurück. Das Ergebnis wird 0 sein , wenn der Eingangswert ist durch die Summe ihrer Ziffern teilbar und nicht-Null sonst. (Grundsätzlich ein inverser Boolescher Wert, genau wie das in den Herausforderungsregeln angegebene Beispiel.)

Sein C-Prototyp wäre:

int DivisibleByDoubleSumOfDigits(int value);

Hier sind die Anweisungen in Assemblersprache ohne Golf, die mit einer kurzen Erläuterung des Zwecks der einzelnen Anweisungen versehen sind:

; 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

Im ersten Block führen wir eine vorläufige Initialisierung der Register durch:

• PUSH+ POP-Anweisungen werden als langsamer, aber kurzer Weg zur Initialisierung ESIauf 10 verwendet. Dies ist erforderlich, da die DIVAnweisung auf x86 einen Registeroperanden erfordert. (Es gibt keine Form, die durch einen unmittelbaren Wert von beispielsweise 10 dividiert.)
• XORwird als kurzer und schneller Weg zum Löschen des ECXRegisters verwendet. Dieses Register dient als "Akkumulator" innerhalb der anstehenden Schleife.
• Schließlich wird eine Kopie des Eingabewerts (von EDI) erstellt und in gespeichert EAX, die beim Durchlaufen der Schleife gelöscht wird.

Dann beginnen wir, die Ziffern im Eingabewert zu schleifen und zu summieren. Dies basiert auf dem x86- DIVBefehl, der EDX:EAXdurch seinen Operanden dividiert und den Quotienten in EAXund den Rest in zurückgibt EDX. Was wir hier tun, ist, den Eingabewert durch 10 zu teilen, so dass der Rest die Ziffer an der letzten Stelle ist (die wir unserem Akkumulatorregister hinzufügen ECX) und der Quotient die verbleibenden Ziffern sind.

• Der CDQBefehl ist eine kurze Methode, um EDXauf 0 zu setzen. Er erweitert den Wert tatsächlich EAXauf EDX:EAX, was DIVals Dividende verwendet wird. Wir brauchen hier eigentlich keine Vorzeichenerweiterung, da der Eingabewert nicht vorzeichenbehaftet ist, sondern CDQ1 Byte beträgt, im Gegensatz zur Verwendung von XORto clear EDX, was 2 Byte entsprechen würde.
• Dann haben wir DIVide EDX:EAXdurch ESI(10).
• Der Rest ( EDX) wird zum Akku ( ECX) hinzugefügt .
• Das EAXRegister (der Quotient) wird getestet, um festzustellen, ob es gleich 0 ist. Wenn ja, haben wir alle Ziffern durchlaufen und fallen durch. Wenn nicht, haben wir noch mehr Ziffern zu summieren, und kehren zum oberen Ende der Schleife zurück.

Nachdem die Schleife beendet ist, implementieren wir number % ((sum_of_digits)*2):

• Der LEABefehl wird verwendet, um ECXmit 2 zu multiplizieren (oder ECXsich selbst zu addieren ) und das Ergebnis in einem anderen Register zu speichern (in diesem Fall EAX).

  ^{(Wir hätten auch add ecx, ecx+ machen können xchg ecx, eax; beide sind 3 Bytes, aber die LEAAnweisung ist schneller und typischer.)}

• Dann CDQbereiten wir uns erneut auf die Teilung vor. Da EAXpositiv (dh ohne Vorzeichen) ist, bewirkt dies EDXwie zuvor eine Nullsetzung .
• Als nächstes folgt die Division, diesmal dividiert EDX:EAXdurch den Eingabewert (eine ungestörte Kopie davon befindet sich noch in EDI). Dies ist äquivalent zu Modulo, mit dem Rest in EDX. (Der Quotient wird ebenfalls eingegeben EAX, aber wir brauchen ihn nicht.)
• Schließlich XCHGtauschen wir die Inhalte von EAXund aus EDX. Normalerweise würden Sie eine MOVhier machen, aber XCHGist nur 1 Byte (wenn auch langsamer). Da EDXder Rest nach der Division enthalten ist, ist er 0, wenn der Wert gleichmäßig teilbar war, oder ansonsten ungleich Null. Wenn wir also RETurnieren, ist EAX(das Ergebnis) 0, wenn der Eingabewert durch die doppelte Summe seiner Ziffern teilbar war, oder andernfalls ungleich Null.

Hoffentlich reicht das für eine Erklärung.
Dies ist nicht der kürzeste Eintrag, aber hey, es sieht so aus, als ob er fast alle Nicht-Golf-Sprachen übertrifft! :-)

Japt , 7 4 Bytes

Übernimmt die Eingabe als Zeichenfolge. Ausgaben 0für trueoder eine Zahl größer als 0für false, die aus anderen Lösungen als gültig erscheinen. Wenn nicht, lass es mich wissen und ich mache ein Rollback.

%²¬x

Probier es aus

Erläuterung

Implizite Eingabe eines Strings U.
"390"

²

Wiederholen Sie Uzweimal.
"390390"

¬

Aufteilen in eine Reihe einzelner Zeichen.
["3","9","0","3","9","0"]

x

Reduzieren durch Summieren, wobei jedes Zeichen automatisch in eine Ganzzahl umgewandelt wird.
24

%

Erhalten Sie den Rest der Division Udurch das Ergebnis, und wandeln Sie es dabei automatisch Uin eine Ganzzahl um. Die resultierende Ganzzahl implizit ausgeben.
6 (=false)

C89, 55 53 Bytes

^{(Danke an Steadybox!}

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

Es wird eine einzelne Eingabe benötigt, xder zu testende Wert. Es gibt 0 zurück, wenn xes gleichmäßig durch die doppelte Summe seiner Ziffern teilbar ist, oder andernfalls ungleich Null.

Probieren Sie es 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);
}

Wie Sie sehen, nutzt dies die impliziten Int-Regeln von C89. Die globalen Variablen sund twerden implizit als ints deklariert . (Sie werden auch implizit mit 0 initialisiert, da sie global sind. Dies können wir jedoch nicht nutzen, wenn die Funktion mehrmals aufgerufen werden soll.)

In ähnlicher Weise akzeptiert die Funktion feinen einzelnen Parameter, x,der implizit ein ist int, und gibt einen zurück int.

Der Code innerhalb der Funktion ist ziemlich einfach, obwohl die forSchleife furchtbar seltsam aussehen wird, wenn Sie mit der Syntax nicht vertraut sind. Grundsätzlich besteht ein forSchleifenkopf in C aus drei Teilen:

for (initialization; loop condition; increment)

Im Abschnitt "Initialisierung" haben wir unsere globalen Variablen initialisiert. Dies wird einmal ausgeführt, bevor die Schleife betreten wird.

Im Abschnitt "Schleifenbedingung" haben wir festgelegt, unter welcher Bedingung die Schleife fortgesetzt werden soll. Dies sollte offensichtlich sein.

Im Abschnitt "increment" haben wir im Grunde beliebigen Code eingefügt, da dieser am Ende jeder Schleife ausgeführt wird.

Der größere Zweck der Schleife besteht darin, jede Ziffer im Eingabewert zu durchlaufen und zu addieren s. Schließlich, nachdem die Schleife beendet ist, swird sie verdoppelt und modulo genommen, um xzu sehen, ob sie gleichmäßig teilbar ist. (Eine bessere, detailliertere Erklärung der Logik hier findet sich in meiner anderen Antwort , auf der diese basiert.)

Für Menschen lesbare Version:

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

Brachylog , 8 Bytes

ẹ+×₂;I×?

Probieren Sie es online!

Erläuterung

ẹ+           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 dank @Rod

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

Probieren Sie es online!

Mathematica, 26 Bytes

(2Tr@IntegerDigits@#)∣#&

Keine Ahnung, warum ∣eine höhere Priorität hat als die Multiplikation ...

PHP , 41 Bytes

Gibt Null aus, wenn teilbar, andernfalls positive Ganzzahl.

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

Probieren Sie es online!

Excel, 63 Bytes

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

Das Summieren von Ziffern ist das langwierige Bit.

Perl 6 , 19 Bytes

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

Probieren Sie es online!

Schale , 9 8 Bytes

Danke an Leo für das Speichern von 1 Byte.

Ṡ¦ȯ*2ṁis

Probieren Sie es online!

Erläuterung

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

Vielen Dank an Zgarb für das Golfen ab 1 Byte

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

Probieren Sie es online!

Nimmt die Eingabe als Zeichenfolge; Gibt 0 zurück, wenn teilbar, andernfalls ungleich Null.

Python 3, 35 Bytes

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

TI-BASIC, 27 26 21 Bytes

-5 danke an @Oki

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

Dies wird durch die Tatsache erschwert, dass es in TI-BASIC keinen präzisen Weg gibt, ganzzahlige Ziffern zu summieren . Gibt 0für Trueund eine andere Zahl für zurück False.

Erläuterung:

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

Probieren Sie es online!

Gibt 0 für Wahrheit aus, eine andere Zahl für Falsch.

Erläuterung

VR.Mvd&+2*c%  Implicit input from command-line args
VR            Create stack2, return to stack1
  .M          Duplicate input to stack2
    vd        Switch to stack2, split into digits
      &+      Sum up all digits
        2*    Double
          c   Collapse stack2 back into stack1
           %  Modulus
              Implicit output of last item on stack

Japt , 7 Bytes

vUì x*2

Rückgabe 1für true, 0fürfalse

Probieren Sie es online!

Erläuterung

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

Verwendungszweck

f 80

Probieren Sie es online!

Java , 66 Bytes

-1 Byte danke an Olivier

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

Ungolfed & Erklärung:

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 bedeutet Wahrhaftigkeit, ungleich Null bedeutet Falschheit.

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

Erläuterung

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

Probieren Sie es online!

tcl, 45

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

Demo

Haskell , 35 34 Bytes

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

Probieren Sie es online!

Liefert '0' im wahren Fall, der Rest sonst.

Haskell , pointfree edition von nimi, 34 bytes

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

Probieren Sie es online!

PHP, 44 Bytes

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

Laufen Sie wie folgt:

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

Erläuterung

Durchlaufen Sie die Ziffern, um die Summe zu berechnen, und geben Sie das Modulo wie die meisten Antworten aus.

Java (OpenJDK 8) , 55 53 Bytes

a->{int i=0,x=a;for(;x>0;x/=10)i+=x%10*2;return a%i;}

Probieren Sie es online!

Ein Rückgabewert von 0bedeutet Wahrheit, alles andere bedeutet Falsch.

Da mein Kommentar in Okx 'Antwort keine Kräuselung verursachte, löschte ich ihn und postete ihn als diese Antwort, spielte sogar noch ein bisschen mehr Golf.

Weiteres Golfen dank @KrzysztofCichocki und @Laikoni, die mir zu Recht gezeigt haben, dass ich nicht auf einen wahrheitsgemäßen / falschen Wert antworten muss, sondern auf einen beliebigen Wert, solange ich das Ergebnis beschreibe.

Mini-Flak, 296 292 Bytes

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

Probieren Sie es online!

Der TIO-Link hat mehr Kommentare von mir, daher ist es teilweise einfacher zu lesen.

Wahrheit / Falsch: Wahrheit (teilbar), wenn die zweite Zahl gleich der dritten Zahl ist, sonst falsch. Also sind sowohl die Wahrheit als auch die Falschheit unendlich, aber ich denke, das sollte erlaubt sein. +10 Byte, wenn dies nicht der Fall ist.

Hinweis: Führende / nachfolgende Zeilenumbrüche / Leerzeichen sind in der Eingabe nicht zulässig.