Bin ich durch die doppelte Summe meiner Ziffern teilbar?

40

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

quelle
Gute Herausforderung, willkommen bei PPCG!
Skidsdev
@ Mayube Danke, es ist meine zweite Herausforderung, aber die erste wurde geschlossen: P
Dürfen wir Ziffern als Liste von ganzen Zahlen verwenden?
Henry
4
@ Henry Nein, das wäre viel zu trivial
1
In der Tat können die beiden Sätze von "Anstelle von Wahrheits- / Falschwerten für den wahren und den falschen Fall können Sie stattdessen eine beliebige endliche Menge von Werten für den wahren Fall und deren Ergänzung für den falschen Fall angeben. Als einfaches Beispiel können Sie verwenden 0 für den wahren Fall und alle anderen Zahlen für den falschen Fall (oder umgekehrt, wenn Sie möchten) scheinen sich zu widersprechen (insbesondere das "Endliche" und das "oder umgekehrt").
Greg Martin

Antworten:

7

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

Okx
quelle
Umm ... Sie sollten überprüfen, ob die Eingabe ein Vielfaches der doppelten Summe der Ziffern ist, nicht umgekehrt.
Erik der Outgolfer
@EriktheOutgolfer Was meinst du? Ich überprüfe, ob die Eingabe ein Vielfaches der doppelten Summe der Ziffern ist. Vielleicht habe ich es nicht richtig erklärt.
Okx
4
Neim muss noch mehr Golf spielen - wenn die Einreichungen zu lang werden, verzögert sich mein Browser.
Esolanging Fruit
1
@ Challenger5 Ich entschuldige mich aufrichtig für den Mangel an Golf. Ich werde es beim nächsten Mal wieder versuchen. Nochmals, tut mir leid.
Okx
@Okx Und ich entschuldige mich aufrichtig dafür, dass ich zu faul bin, um eine Neim-Antwort zu finden, die besser demonstriert, wovon ich sprach.
Esolanging Fruit
16

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

Arnauld
quelle
Ich habe die [...] Methode des Aufteilens noch nie gesehen. Gibt es einen Namen dafür?
Jacob Persi
@JacobPersi Dies ist der Spread-Operator .
Arnauld
7

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

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

PunPun1000
quelle
4

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
Luis Mendo
quelle
4

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?
Datboi
quelle
Sie können Golf auf 4 Bytes durch den Ersatz %_mit Ö.
Okx
4

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

Cody Gray
quelle
3

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)

Zottelig
quelle
2
Ihre Erklärungen beanspruchen normalerweise viel vertikalen Raum, den ich nicht benötige. In jedem Fall ist es Ihre Antwort.
Okx
@Okx; Ich weiß nicht, wie "normal" es sein kann, wenn ich vor ein paar Tagen auf dieses Format umgestiegen bin.
Shaggy
4
Mir hat das Erklärungsformat gefallen. War leicht zu verfolgen, besonders für dieses Problem, da es sich um eine lineare Verkleinerung handelte und sich wie ein mathematisches Problem auf der Seite nach unten bewegte. Nur meine zwei Cent.
Henry
3
Dieses Erklärungsformat ist viel besser als das übliche Format, insbesondere für diejenigen, die mit den Sprachen nicht vertraut sind. Ich wünschte, andere Golfer, die diese Golfsprachen verwenden, würden dies auch tun.
Peter1807
3

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);
}
Cody Gray
quelle
Sie können zwei Bytes speichern, wenn Sie tstatt t>0als Schleifenbedingung verwenden .
Steadybox
Ah, natürlich! Guter Fang, @Steadybox. Ich bin mir nicht sicher, wie ich das verpasst habe, da das Testen gegen 0 genau das war, was meine ASM-Implementierung tat, auf der diese Antwort stark basierte.
Cody Grey
45
PrincePolka
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
Tödlich
quelle
2

Python 2 , 34 32 Bytes

-2 Bytes dank @Rod

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

Probieren Sie es online!

ovs
quelle
6
Anhand des in der Frage angegebenen Beispiels "klar unterscheidbar" können Sie meines Erachtens das entfernen <1.
Weizen-Assistent
2

Mathematica, 26 Bytes

(2Tr@IntegerDigits@#)∣#&

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

Martin Ender
quelle
2

PHP , 41 Bytes

Gibt Null aus, wenn teilbar, andernfalls positive Ganzzahl.

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

Probieren Sie es online!

Jörg Hülsermann
quelle
Sie setzen die Zuordnung in den Kopfblock. Du $a=10könntest es genauso gut benutzen , aber du hast vergessen, das für deine
Byteanzahl zu
@aross Warum soll ich die Eingabe zu meiner Byteanzahl hinzählen? $argnist mit der -F(in diesem Fall) oder -ROption
Jörg Hülsermann
Hm, interessant. Ich wusste es nicht -F. Dies spiegelt sich jedoch nicht in Ihrem TIO wider (unterstützt es das Echo von STDIN?).
5.
@aross Es funktioniert so, als ob Sie nur eine Datei anstelle von Code und die -FOption anstelle von -R php.net/manual/en/features.commandline.options.php verwenden würden line lass es mich wissen
Jörg Hülsermann
2

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.

Wernisch
quelle
2

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.
Martin Ender
quelle
Sie können ṁ verwenden, um mit einem einzigen Befehl zuzuordnen und zu summieren, wobei ein Byte gespeichert wird
Leo
2

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.

Julian Wolf
quelle
(:[])kann sein pure.
Zgarb
Sie sparen 1 Byte, indem Sie das Lambda durch die Funktionsdeklaration ersetzen
bartavelle
@bartavelle: Ziemlich sicher, dass es eine Wäsche ist. Beispiel?
Julian Wolf
Du hast recht, es ist genau die gleiche Länge. Nicht sicher, wie mir das in den Sinn kam: /
Bartavelle
2

Python 3, 35 Bytes

lambda a:a%(sum(map(int,str(a)))*2)
Wrymug
quelle
Hallo und willkommen auf der Seite. Hier können Sie Leerzeichen entfernen. Besonders um =und nach dem )in int(c). Da sumein Generator als Argument verwendet werden kann, können Sie das [..]Innere des Generators entfernen . Wenn Sie weitere Fragen haben, können Sie mich gerne anrufen.
Weizen-Assistent
int(c)for c in akönnte auch sein map(int,a), ein paar bytes zu sparen.
Weizen-Assistent
Das funktioniert nicht - oder eher rückwärts. Leicht mit 4 zusätzlichen Bytes lambda a:not a%(sum(map(int,str(a)))*2)
behoben
@osuka_ siehe Punkt eins in der Frage Beschreibung
Wrymug
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
Scott Milner
quelle
2
10^-randIntNoRep(1,1+int(log(Anstut das gleiche wie seq(10^(~A-1),A,0,log(Ansin weniger Bytes, da die Reihenfolge keine Rolle spielt (vorausgesetzt, Version 2.55MP)
Oki
1

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
Skidsdev
quelle
1

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
Oliver
quelle
Ich habe mir auch ein paar andere 7-Byte-Lösungen ausgedacht (obwohl ich nicht glaube, dass dies eine davon war) - ich bin jedoch überzeugt, dass es eine kürzere Lösung gibt.
Shaggy
1

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
}
Okx
quelle
Verwenden Sie intstatt bytezu speichern ... ein Byte.
Olivier Grégoire
@ OlivierGrégoire Danke. Das habe ich nicht bemerkt.
Okx
@Okx Müssen auch Golf-Code ändern.
Henry
Ihr (Golf-) Code gibt falsche Werte für 110, 111 an. Wahrscheinlich wird der Code a%i*2analysiert, (a%i)*2da Modul und Multiplikation dieselbe Reihenfolge haben.
Olivier Grégoire
@ OlivierGrégoire Ah, das nervt.
Okx
1

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?
hoosierEE
quelle
Sehr kluger Weg, um Parens oder Mehrfach- @oder [:!
Jonah
1
Ich habe darüber diskutiert, dies als meine eigene Antwort zu veröffentlichen, aber es ist nicht wirklich verschieden genug. |~2*1#.,.&.":für 13 Bytes.
Cole
Ich erhalte dafür einen Domain-Fehler auf meiner J Qt-IDE. (| ~ [: + / 2 # "." 0 @ ": 112) Dann erhalte ich für den Code von cole (| ~ 2 * 1 #.,. &.": 112) = 0. : / Möglicherweise stimmt etwas nicht an meinem Ende.
DrQuarius
1

tcl, 45

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

Demo

Sergiol
quelle
1
Sie können ersetzen 0==mit 1>.
Mr. Xcoder
1

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!

Bartavelle
quelle
Gleiche Byteanzahl, wenn Sie ohne Punkte arbeiten:mod<*>(2*).sum.map(read.pure).show
nimi
Sieht gut aus, habe ich in meinem Beitrag hinzugefügt.
Bartavelle
1

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.

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

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.

Olivier Grégoire
quelle
Sie können den Teil <1 am Ende entfernen, so dass das Ergebnis 0 für wahr und> 0 für falsch ist. Dies führt zu zusätzlichen -2 Bytes. Sie antworten also mit 53 Bytes.
Krzysztof Cichocki
@KrzysztofCichoki Nein, ich kann nicht: das ist Java. Der einzig wahre Wert ist true.
Olivier Grégoire
@ OlivierGrégoire Während dies wahr ist, wenn nichts anderes angegeben ist, heißt es in dieser Herausforderung ausdrücklich 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 und Laikoni Sorry, ich habe diesen Teil falsch gelesen, ich habe ihn gerade behoben! Vielen Dank an beide :) Tut mir auch leid, dass du die Bearbeitung abgelehnt hast , die in diesem Fall tatsächlich angebracht war.
Olivier Grégoire
1

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.

user202729
quelle