Teilbarkeitstest

39

Aufgabe

Gegeben seien zwei streng positive ganze Zahlen n und d als Eingabe, bestimmen , ob n ist teilbar durch d , das heißt, wenn es vorhanden ist eine ganze Zahl q derart , daß n = qd.

Sie können ein Programm oder eine Funktion schreiben und eine unserer Standardmethoden zum Empfangen und Bereitstellen von Eingaben verwenden.

Die Ausgabe sollte ein wahrer oder falscher Wert sein . wahr, wenn n durch d teilbar ist , und falsch, wenn nicht.

Ihr Code muss nur Ganzzahlen verarbeiten, die er nativ darstellen kann, solange er für alle vorzeichenbehafteten 8-Bit-Ganzzahlen funktioniert. Ihr Algorithmus muss jedoch für beliebig große ganze Zahlen funktionieren.

Sie können jede Programmiersprache verwenden , beachten Sie jedoch, dass diese Lücken standardmäßig verboten sind.

Das ist Code-Golf , also gewinnt die kürzeste gültige Antwort - gemessen in Bytes .

Testfälle

 n,  d    output

 1,  1    truthy
 2,  1    truthy
 6,  3    truthy
17, 17    truthy
22,  2    truthy
 1,  2    falsy
 2,  3    falsy
 2,  4    falsy
 3,  9    falsy
15, 16    falsy

Bestenliste

Das Stapel-Snippet am Ende dieses Beitrags generiert den Katalog aus den Antworten a) als Liste der kürzesten Lösungen pro Sprache und b) als Gesamt-Bestenliste.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

## Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

## Perl, 43 + 3 (-p flag) = 45 bytes

Sie können den Namen der Sprache auch als Link festlegen, der dann im Snippet angezeigt wird:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

Code-Snippet anzeigen

code-golf  math  arithmetic  decision-problem  division 
— Undichte Nonne
quelle
Diese Unterhaltung wurde in den Chat verschoben .
— Dennis

Antworten:

29

Brain-Flak , 72 70 64 62 58 46 Bytes

{({}[()]{(<()>)}{}<({}[()]<({}())>)>)}{}{{}}{}

Nimmt Dividende und Divisor (in dieser Reihenfolge) als Eingabe und druckt den Divisor (wahr) oder nichts. Da jeder Stapel eine implizite, unendliche Anzahl von Nullen enthält, sollte eine leere Ausgabe als falsch betrachtet werden.

Diese Lösung ist zwar nicht stapelrein, verwendet jedoch nur einen Stapel.

Probieren Sie es online!

Vielen Dank an @WheatWizard für das Golfen mit 2 Bytes!

Wie es funktioniert

                INPUT: a (dividend), b (divisor)
                INITIAL STACK: n = a, d = b, r = 0
                               An infinite amount of zeroes follows.

{               While n is non-zero:
  (
    {}              Pop n from the stack.
    [()]            Yield -1.
    {               While the top of the stack (initially, d) is non-zero:
      (<()>)          Push 0.
    }
    {}              Pop 0. This will remove d from the stack if d = 0, leaving r
                    on top. We can think of this as performing the assignment
                    (d, r) = (r, d) if d = 0.
    <
      (
        {}              Pop d.
        [()]            Yield -1.
        <
          (
            {}              Pop r.
            ()              Yield 1.
          )               Push r + 1.
        >               Yield 0.
      )               Push d + (-1) + 0 = d - 1.
    >               Yield 0.
  )               Push n + (-1) + 0 + 0 + 0 = n - 1.
}               Each iteration decrements n, swaps d and r if d = 0, decrements d,
                and increments r.
                FINAL VALUES: n = 0
                              d = b - r
                              r = a % b if a % b > 0 else b
{}              Pop n.
{               While the top of the stack is non-zero:
  {}              Pop it.
}               This pops d and r if d > 0 (and, thus, a % b > 0) or noting at all.
{}              Pop d or a 0, leaving r if r = b and, thus, a % b = 0.

Modulberechnung, 42 Bytes

Das obige vollständige Programm kann in trivialer Weise modifiziert werden, um stattdessen den Modul zu berechnen.

{({}[()]<({}[()]<({}())>)>{(<()>)}{})}{}{}

Wie zuvor ist diese Methode nicht stapelrein, sondern verwendet nur einen einzelnen Stapel. Bei einem Modul von 0 bleibt der Stapel leer, was in etwa 0 entspricht . Jeder Stapel enthält unendlich viele Nullen.

Probieren Sie es online!

Wie es funktioniert

Vergleichen Sie die beiden Schleifen des Teilbarkeitstesters und des Modul-Rechners.

{({}[()]{(<()>)}{}<({}[()]<({}())>)>)}
{({}[()]<({}[()]<({}())>)>{(<()>)}{})}

Der einzige Unterschied ist der Ort von {(<()>)}{}, der d und r vertauscht, wenn d = 0 ist . Um den Modul zu berechnen, führen wir diesen Austausch durch, nachdem wir d dekrementiert und r inkrementiert haben .

Diese Änderung wirkt sich nicht auf das Ergebnis aus, wenn a% b> 0 ist. Wenn jedoch a% b = 0 ist , bleibt (n, d, r) = (0, b, 0) - und nicht (n, d, r) = (0, 0, b) - auf dem Stapel.

Um den Modul zu erhalten, müssen wir also nur n und d mit popen{}{} .

Berechnung des Stack-Clean-Moduls, 64 Byte

Der 42-Byte-Modulalgorithmus ist nicht stapelrein und kann daher nicht wie in allen Programmen verwendet werden. In der folgenden Version werden Dividende und Divisor (in dieser Reihenfolge) aus dem aktiven Stapel entfernt und der Modul zurückgesetzt. Es hat keine anderen Nebenwirkungen.

({}(<()>)){({}[()]<(({}()[({})])){{}(<({}({}))>)}{}>)}({}{}<{}>)

Diese Lösung basiert größtenteils auf dem vorherigen 72-Byte-Datensatz von @ WheatWizard, spart jedoch 6 Byte, da die Stapel nie gewechselt werden.

Probieren Sie es online!

Wie es funktioniert

             INPUT: a (dividend), b (divisor)
             INITIAL STACK: n = a, b

(
  {}         Pop and yield n = a.
  (<()>)       Push d = 0.
)              Push n + 0 = n.
             STACK: n, d = 0, b
{(           While n in non-zero:
  {}           Pop and yield n.
  [()]         Yield -1.
  <
   ((
     {}         Pop and yield d.
     ()         Yield 1.
     [({})]     Pop b, push it back on the stack, and yield -b.
   ))         Push d + 1 + -b = d + 1 - b twice.
   {          While/if d + 1 - b is non-zero, i.e., if d < b - 1
     {}         Pop d + 1 - b (second copy).
     (<(
       {}         Pop d + 1 - b (first copy).
       ({})       Pop b and push it back on the stack.
     )>)        Push d + 1 - b + b = d + 1, then 0.
   }          If the loop wasn't skipped entirely, pushing 0 breaks out.
              If d < b - 1, it essentially performs the assignment d = d + 1.
              However, if d = b - 1, we get d = d + 1 - b = b - 1 + 1 - b = 0.
              In all cases, we wind up with d = (d + 1) % b.
   {}         Pop 0.
  >         Yield 0.
)}        Push n + -1 + 0 = n - 1. Break if n - 1 = 0.
          STACK: n = 0, d = a % b, b
(
  {}        Pop and yield n = 0.
  {}        Pop and d = a % b.
  <{}>      Pop b, but yield 0.
)         Push 0 + a % b + 0 = a % b.
— Dennis
quelle
20

x86_32-Maschinencode, 8 Byte

08048550 <div7>:
 8048550:   99                      cdq   
 8048551:   f7 f9                   idiv   %ecx
 8048553:   85 d2                   test   %edx,%edx
 8048555:   0f 94 c0                sete   %al

Dies ist meine erste Code-Golf-Antwort. Hoffentlich befolge ich alle Regeln.

Dies ruft zuerst cdq auf, um das edx-Register zu löschen, und führt dann eine vorzeichenbehaftete Division des ecx-Registers durch, das den Rest in edx speichert. Die Zeile test edx, edx setzt das Null-Flag, wenn edx Null ist, und sete setzt eine 0 für false, wenn edx nicht Null war, und setzt eine 1 für true, wenn edx 0 war.

Dies ist nur das Code-Snippet, das zur Anzahl der Bytes beiträgt. Zum Testen ist hier der C-Code, den ich mit der Inline-Assembly geschrieben habe, da es auf diese Weise einfacher ist, mit E / A umzugehen.

— Davey
quelle
2
Willkommen bei PPCG, schöne erste Antwort!
— Undichte Nonne
Muss es ein volles Programm sein? Ich habe meine Antwort sozusagen aus dieser Antwort heraus formatiert . Und danke dir! Ich hoffe, dass ich beim Zusammenbau / Maschinencode besser werden kann, um mehr Code-Golf zu spielen!
— Davey
1
Die Eingabe und Ausgabe in angegebenen Registern in der Assembly ist standardmäßig zulässig: Eingabe , Ausgabe . Dies ist eine absolut akzeptable Einreichung. Willkommen bei PPCG!
— Mego
Fantastisch! Danke!
— Davey
17

Hexagony, 15, 13, 12 10 Bytes

Jedermanns liebste hexagonbasierte Sprache! : D

TL; DR arbeitet mit magischen, unformatierten Lösungen in abnehmender Byteanzahl:

?{?..>1'%<.@!'/
?{?!1\.'%<@.>
?{?\!1@'%\!(
?{?!1\@'%<

Dank des Layout-Assistenten von @ MartinEnder wurden 2 Bytes eingespart.

@FryAmTheEggman sparte 1 Byte, indem die Ecken kreativer genutzt wurden

Sowohl @MartinEnder als auch @FryAmTheEggman haben eine 10-Byte-Lösung entwickelt, die nichts für falsche Werte ausgibt.

Meine Lösung (15):

Unformatiert:

?{?..>1'%<.@!'/

Formatiert:

  ? { ?
 . . > 1
' % < . @
 ! ' / .
  . . .

@Martin Enders Lösung (13):

Unformatiert:

?{?!1\.'%<@.>

Formatiert:

  ? { ?
 ! 1 \ .
' % < @ .
 > . . .
  . . .

Erläuterung:

Zuerst erhalten wir die Eingabe und nehmen den Modul.

  ? { ?
 . . . .
' % . . .
 . . . .
  . . .

Dann wird geprüft, ob der Modul 0 ist oder nicht. Ist dies der Fall, dreht sich die IP um 60 Grad nach links, springt vom Spiegel ab, setzt die Zelle auf 1 und druckt.

Dann fährt die IP mit der vierten Reihe fort. Wenn es das erreicht >, dreht es sich stattdessen nach rechts (weil der Wert der Zelle jetzt 1 ist). Es geht oob und kommt in der unteren rechten Ecke in Richtung NW zurück. Die IP trifft die <, geht in die oberste Reihe und kehrt in die rechte Ecke zurück, um die zu treffen @und das Programm zu stoppen.

  . . .
 ! 1 \ .
. . < @ .
 > . . .
  . . .

Wenn der Modul positiv ausfällt, dreht sich die IP um 60 Grad nach rechts. Sobald es in der rechten unteren Ecke ausgeht, wird es aufgrund der Umbruchregeln von Hexagony am linken unteren Rand fortgesetzt. Das 'wird wiederverwendet, um die IP in eine Zelle mit 0 zu verschieben. Die IP wandert dann entlang der vierten Reihe, läuft zur zweiten um, trifft auf print und spiegelt sich in der <. Der Rest des Weges zum @ist der gleiche.

  . . .
 ! . \ .
' . < @ .
 > . . .
  . . .

Das ist eine ernsthafte Zauberei.

@ FryAmTheEggmans Lösung (12):

Unformatiert:

?{?\!1@'%\!(

Formatiert:

  ? { ?
 \ ! 1 @
' % \ ! (
 . . . .
  . . .

Erläuterung:

Wie die anderen Lösungen erhält es den Eingang und nimmt den Modul auf.

  ? { ?
 . . . .
' % . . .
 . . . .
  . . .

Dann wird die IP in die untere Ecke abgelenkt. Wenn der Modul positiv ist, wird er am oberen linken Rand angezeigt. Der ?hat keine Eingabe mehr, also setzt er die Zelle auf 0. Der gibt !dann die 0 aus und der @beendet das Programm.

  ? . .
 \ ! . @
. . \ . .
 . . . .
  . . .

Die Dinge sind viel schwieriger, wenn der Modul 0 ist. Zuerst wird er dekrementiert, dann auf 0 zurückgesetzt, dann auf 1 gesetzt und dann gedruckt. Dann wird die 1 auf 0 dekrementiert. Danach wird das Programm so wie am Anfang ausgeführt, bis es dies versucht 0%0. Das macht es zu einem stillen Fehler und beendet.

  ? { ?
 . . 1 .
' % \ ! (
 . . . .
  . . .

Ich mag die stille Fehler Trick, sondern ein einfacher Weg wäre, das zu ersetzen , (mit /so dass die IP ersten Mal durchläuft, wird aber in reflektiert @die zweite.

Kollaborative Lösung (10):

Unformatiert:

?{?!1\@'%<

Formatiert:

  ? { ?
 ! 1 \ @
' % < . .
 . . . .
  . . .

Dieses Programm startet wie alle anderen Programme, empfängt die Eingabe und modifiziert sie.

Wenn der Eingang 0 ist, wird die IP nach links gedreht, wenn sie trifft <. Es wird abgelenkt 1!@, was 1 ausgibt und beendet.

  . . .
 ! 1 \ @
. . < . .
 . . . .
  . . .

Wenn der Eingang positiv ist, wird die IP nach rechts gedreht, wenn sie trifft <. Es tritt durch die Ecke aus und geht am oberen rechten Rand entlang, wobei es auf das @ trifft, ohne zu drucken.

  . . ?
 . . . @
. . < . .
 . . . .
  . . .
— Blau
quelle
6
Ich denke, Sie sollten Ihre Antwort anders formatieren. Wenn Sie vier Antworten in einem einzigen Codeblock haben, sieht es so aus, als wäre Ihre Byteanzahl falsch.
— mbomb007
17

Brain-Flak 102, 98, 96 Bytes

(({}<>))<>{({}[()])<>(({}[()])){{}(<({}[({})])>)}{}({}({}))<>}{}<>([{}]{}){<>(([()])())}({}{}())

Eww. Brutto. Ich könnte eine Erklärung posten, aber ich verstehe sie selbst kaum. Diese Sprache tut meinem Gehirn weh.

Probieren Sie es online!

Vielen Dank an github user @Wheatwizard für die Erstellung eines Modulbeispiels . Ich hätte das wahrscheinlich nicht selbst herausfinden können!

Auch die kürzere Antwort ist hier .

Möglicherweise falsche Erklärung:

(({}<>))                    #Push this element onto the other stack
<>                          #Move back to stack one.
{                           #While the top element is non-zero:
 ({}[()])                   #  Decrement the number on top
 <>                         #  Move to the other stack
 (({}[()]))                 #  Push the top element minus one twice
 {                          #  While the top element is non-zero:
  {}                        #    Pop the top element
  (<          >)            #    Push a zero
        ({})                #    Push the second from top element
       [    ]               #    Evalue this second from top element as negative
    ({}      )              #    And push that negative plus the top element
 }
 {}                         #  Pop the top element
 ({}({}))                   #  Push the top element plus the second from the top, AND push the second from top
 <>                         #  Switch stacks
}

{}                          #Pop the stack
<>                          #Switch to the other stack
([{}]{})                    #And push the top element minus the second element.

Der Rest ist ziemlich unkompliziert.

{              }            #While the top element is non-zero:
 <>                         #Move to the other stack
   (([()])  )               #Push a negative one
          ()                #AND push the previously pushed value + 1 (e.g. 0)

                 (      )   #Push:
                  {}{}      #The top two elements added together
                      ()    #Plus one
— DJMcMayhem
quelle
The rest is pretty straightforward.Ja, es scheint so.
— Erik the Outgolfer
24 Bytes, wenn Sie jede Brainflak-Anweisung als Byte zählen.
— 8.
12

Javascript (ES6) 17 12 11 Bytes

a=>b=>a%b<1
  • BEARBEITEN: 5 Bytes entfernt, da 'a> 0' erwartet wird.
  • EDIT2: 1 Byte dank Downgoat entfernt .
— ETHproductions
quelle
Verwenden Sie currying, um ein Byte zu speichern: a => b =>
— Downgoat
Wie führe ich das aus? Wenn ich versuche , d=a=>b=>a%b<1gefolgt von d(32,2)in der JS - Konsole ... ich einfach die Antwortfunction b=>a%b<1
— WallyWest
@WallyWest Hierfür wird Currying verwendet. Geben Sie also Folgendes ein d(32)(2). Da d(32)gibt function b=>a%b<1, müssen Sie dann diese Funktion mit Ihrem bWert
— aufrufen
9

Vim, 11 Tastenanschläge

C<C-r>=<C-r>"<C-Left>%<C-Right><1<cr>

Nicht schlecht für eine Sprache, die nur Zeichenfolgen verarbeitet. : D

— DJMcMayhem
quelle
Was macht <C-Left>das? Kann es nicht testen, weil es Windows auf Mac> _> wechselt
— Downgoat
1
@Downgoat Verwenden Sie Strg oder Befehl? In beiden Fällen entspricht es "b", außer dass es auch im Einfügemodus funktioniert.
— DJMcMayhem
Um pedantisch zu sein, ist es Beher das Äquivalent zu als b(und Ctrl+ Rightist das Äquivalent zu W) - der Unterschied liegt bei Nicht-Wort-Zeichen, aber in diesem Fall tut es genau dasselbe :) vimdoc.sourceforge.net/htmldoc/motion. html # <C-Left >
— Christian Rondeau
9

Mathematica - 17 13 3 Bytes

∣

Vielen Dank an @MartinEnder für das Speichern einer Menge Bytes!

— Yytsi
quelle
Welcher Charakter ist das?
— Cyoce
@Cyoce Ich kenne den Unicode-Code (derzeit am Telefon) nicht, aber es ist ein kurzer Operator für Divisible[].
— Yytsi
@Cyoce Ich denke, es ist das Pipe-Symbol, auch bekannt als Shift + Backslash.
— Pavel
@Pavel Wenn es das Pipe-Symbol wäre, wären es nicht drei Bytes.
— Cyoce
@Cyoce es ist das U + 2223-Zeichen: fileformat.info/info/unicode/char/2223/index.htm
— numbermaniac
8

Retina, 12 Bytes

^(1+)\1* \1$

Nimmt eine durch Leerzeichen getrennte Eingabe in Unary auf, um 111111111111 1111zu prüfen, ob 12 durch 4 teilbar ist . Gibt 1 (wahr) oder 0 (falsch) aus.

Probieren Sie es online!

FryAmTheEggman sparte zwei Bytes. Hoppla, habe meine Antwort umgeschrieben, um die Argumente in die richtige Reihenfolge zu bringen. (Dann hat mich Fry in den Kommentaren geschlagen. Ich bin langsam im Regex!)

— Lynn
quelle
Um die Reihenfolge zu fixieren, wenn es nötig wird, denke ich, ^(1+)\1* \1$wird funktionieren.
— FryAmTheEggman
Ich denke mit der neuen Spezifikation ist die umgekehrte Eingabereihenfolge wieder in Ordnung.
— Martin Ender
8

Batch, 20 Bytes

@cmd/cset/a!(%1%%%2)

Ausgaben 1bei Erfolg, 0bei Misserfolg.

— Neil
quelle
8

C #, 27 13 12 Bytes

a=>b=>a%b<1;

Dank an TuukkaX für den Hinweis, dass anonyme Lambdas akzeptabel sind. Vielen Dank an David Conrad, der mich auf Currys aufmerksam gemacht hat, von denen ich nicht einmal wusste, dass es eine Sache ist.

Kurz und gut, da wir nur sind mit ganzen Zahlen zu tun können wir verwenden , <1statt ==0und ein ganzes Byte speichern.

— JustinM - Setzen Sie Monica wieder ein
quelle
Ich bin nicht sicher, aber ich denke , dass Sie nur ein Lambda verwenden: (a,b)=>a%b<1;. +1.
— Yytsi
@ TuukkaX, danke, ich war mir nicht sicher, es scheint nur so betrogen.
— JustinM
Die JS-Version von diesem verwendete Currying, um es um ein Byte zu reduzieren, und das sollte auch für C # funktionieren: a=>b=>a%b<1;(Hinweis: Sie müssen es dann als f(a)(b)anstatt aufrufen f(a,b))
— David Conrad
1
@ DavidConrad oo das ist ordentlich, danke.
— JustinM
7

Brainfuck, 53 Bytes

Nimmt die Eingabe als Byte, die Ausgabe ist ein Byte-Wert von 0x00oder 0x01. Es ist der DivMod-Algorithmus, gefolgt von der Booleschen Negation .

,>,<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>,>[<+>,]+<[>-<-]>.

Online ausprobieren -+Beinahe am Ende gibt es ein paar Extras,damit Sie die Ausgabe in ASCII sehen können.

— mbomb007
quelle
Könnten Sie den Teil "div" der Sache entfernen, um Bytes zu sparen?
— Undichte Nonne
1
@LeakyNun Dies ist der kürzeste bekannte Algorithmus, der den Modul angibt. Wenn Sie einen Teil davon entfernen, wird der Vorgang länger, da Sie mehr temporäre Zellen benötigen. Sie können keinen Modul finden, ohne zu teilen.
— mbomb007
Ich verstehe, danke .
— Undichte Nonne
@LeakyNun Schauen Sie sich nur an, wie lang der Division-Algorithmus ist.
— mbomb007
Es gibt wahrscheinlich kürzere, aber wenn ja, hat niemand sie gefunden oder veröffentlicht.
— mbomb007
7

Brain-Flak , 88 86 Bytes

(<({}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}<>(({}<{}>)){{}{}(<(())>)}{}

Dies ist eine dichtere Version des ursprünglichen Brain-Flak-Teilbarkeitstest-Algorithmus , der von Dr. Green Eggs und Iron Man DJMcMayhem und mir selbst geschrieben wurde.

Hier ist eine kurze (ish) Erklärung, wie es funktioniert:

  ({}<>)        #Move the top of the stack to the other stack #Start Mod
(<      >)      #Push zero
<>              #Switch stacks
{               #While the top of the stack is not zero
 ({}[()])       #Subtract one from the top of the stack
 <>             #Switch stacks
   {}()         #Pop the top, add one and ...
       [({})]   #Subtract the second element on the stack
 ((          )) #Push twice
 {              #If the top is not zero
  {}            #Pop the duplicate
    ({}({}))    #Add the second element to the first
  (<        >)  #Push zero
 }              #End if
 {}             #Pop the zero
 <>             #Switch back
}               #End While
<>              #Switch to the other stack
 ({}<{}>)       #Remove the second value on the stack         #End Mod
(        )      #Duplicate the result of modulation
{               #If the top is not zero
 {}{}           #Pop the top two elements
 (<(())>)       #Push a one and a zero
}               #End if
{}              #Pop the zero

Probieren Sie es online!

— Weizen-Assistent
quelle
Link zum Online-Dolmetscher?
— Undichte Nonne
Gute Arbeit! Willkommen auch auf der Seite! Ich hoffe du hast Spaß hier. (Ich habe sicherlich)
— DJMcMayhem
Schöne erste Antwort, willkommen bei PPCG!
— Undichte Nonne
6

C 60 Bytes

#include <stdio.h>
main(){int a,b;scanf("%d %d",&a,&b);a%b==0;}
— Ronronner
quelle
1
Warum -1? Erklären Sie mir
— Ronronner
3
Es ist möglich, dass niemand abstimmt. Dies ist eine kurze Antwort, die automatisch als minderwertig gekennzeichnet wurde und die Sie dann bearbeitet haben. Aus irgendeinem Grund führt dies zu einer automatischen Ablehnung . Das tut mir leid. +1von mir. Wir erlauben auch Funktionen, so dass Sie diese leicht auf int f(a,b){return !(a%b);}oder möglicherweise sogar noch kürzer kürzen können.
— DJMcMayhem
3
Nein, mein Punkt ist, dass es kein vollständiges Programm sein muss. Sie können stattdessen nur eine Funktion einreichen. int f(a,b){return!(a%b);}beträgt 25 Bytes, und wenn Sie den richtigen Compiler verwenden, können Sie sogar f(a,b){return!(a%b);}21 Bytes verwenden.
— DJMcMayhem
3
Noch kürzere Funktionsübermittlung: #define f(a,b)!(a%b)( ideone link )
— Mego
2
Sie müssen eine Funktion oder ein Programm definieren, nicht nur einen Ausschnitt.
— Undichte Nonne
5

R, 22-20 Bytes

a=scan();!a[1]%%a[2]

Liest wie gewohnt zwei Zahlen aus der Eingabe, die durch eine Leerzeile abgeschlossen wird.

Update: Vielen Dank an Jarko Dubbeldam für das Abschneiden von 2 Bytes (trotz der Tatsache, dass seine Bearbeitung abgelehnt wurde, war es sehr hilfreich!).

— Andreï Kostyrka
quelle
5

Java 8, 11 Bytes

a->b->a%b<1

Was zum Teufel, es gibt JS- und C # -Versionen davon, warum nicht auch eine Java-Version?

Verwendungszweck:

import java.util.function.Function;

public class Program {
    public static void main(String[] args) {
        System.out.printf("%d, %d %b%n", 9, 3, divides(9, 3, a->b->a%b<1));
        System.out.printf("%d, %d %b%n", 3, 9, divides(3, 9, a->b->a%b<1));
    }

    public static boolean divides(int a, int b,
            Function<Integer, Function<Integer, Boolean>> f) {
        return f.apply(a).apply(b);
    }
}
— David Conrad
quelle
a->b->a%b<1Dies löst einen Syntaxfehler aus, nicht wahr?
— Dorukayhan will Monica zurück
2
Nein, es ist gültiges Java 8.
— David Conrad
Manchmal sieht sogar Java aus wie Perl ...
— Mega Man
Ja, ich würde hinzufügen, dass dies nur Java 8 ist;).
— Magic Octopus Urn
Mit Java 8 müssen wir also nur Lambda-Ausdrucksbytes zählen, nicht die gesamte Klasse und Funktion. Cool!
— Sikorski
4

Python, 16 Bytes

lambda D,d:D%d<1
— Dennis
quelle
1
Beachten Sie, dass dies nicht funktionieren würde, wenn negative Ganzzahlen zulässig wären. Zum Glück sind die Eingänge ausschließlich positiv.
— TLW
Ich habe es getan lambda a,b:1.*a/b==a/b, war aber ziemlich beeindruckt. Dies ist ein so komplexes Stück Code ...
— Erik der Outgolfer
3

Fortran 95, 78 Bytes

function f(i,j)result(k)
integer::i,j,k
k=merge(1,0,MOD(i,j)<1)
end function f
— Jeremy
quelle
3

MarioLANG, 121 109 107 Bytes

14 Bytes gespart dank Martin Ender

;>(-)-)+(([!)
)"=========#[
; +(![-)< )<!+
  ==#==="  "#:
>!< >(+ !![(<
=#"="===##=:"
  !      <
  #======"

Probieren Sie es online!

Erläuterung

Der Algorithmus ist einfach zu halten Subtrahieren dvon nzu sehen , wenn Sie es eine ganze Anzahl von Zeiten tun und keinen Rest haben.

;
)
;

>
=
 
 

Zunächst wird die Eingabe gesammelt. nist in der ersten Zelle, din der zweiten.

 >(-)-)+(([!
 "=========#
          )<
           "
 !
 #"="===##=
  
  

Dies ist im Wesentlichen die Hauptschleife. Es dekrementiert die erste und die zweite Zelle und inkrementiert die dritte.

           [!)
           =#[
             !+
             #:
            (<
            :"
 
 

Dies ist die endgültige Ausgabe. Wenn nach dem Inkrementieren / Dekrementieren die erste Zelle 0 ist, haben wir beseitigt n. Wenn danach die zweite Zelle ( d) steht 0, dann dging das neben hinein. Wir erhöhen und drucken ( 1). Andernfalls gehen Sie zurück zur ersten Zelle (die ist 0) und drucken Sie sie aus.

 
 
  +(![-)<  
  ==#==="  
 !< >(+ !![
 #"="===##=
  !      <
  #======"

Diese Schleife tritt auf, wenn sich die zweite Zelle 0nach dem Inkrementieren und Dekrementieren befindet. Es kopiert die dritte Zelle in die zweite Zelle. Der Teil am unteren Rand dient dazu, die Schleife zu umgehen, wenn dies bei der Zelle nicht der Fall ist 0.

— Geschäfts-Katze
quelle
3

Tcl, 34 Bytes

ge stdin a
ge stdin b
exp $a%$b<1

Mein erster / * erfolgreicher * / Versuch im Codegolf! Dieser Code muss in der Tcl-Shell ausgeführt werden, da er sonst nicht funktioniert.

Ein Byte dank @Lynn.

Vier Bytes dank @Lynn und @LeakyNun (jetzt verstehe ich was er meinte)!

Kannst du weglassen ?1:0?
— Undichte Nonne
@LeakyNun es ist eine ternäre Operation. du meinst, nur um etw zurückzugeben, wenn es unsichtbar ist?
Was würde $a%$b==0zurückkehren?
— Undichte Nonne
1
Ich meine, kann deine dritte Zeile nur sein exp $a%$b==0?
— Undichte Nonne
1
Oder exp $a%$b<1vielleicht doch?
— Lynn
3

PHP, 23 22 Bytes

<?=$argv[1]%$argv[2]<1

Gibt 1 für true aus, leere Zeichenfolge (= nichts) für false

Aufruf von CLI mit nund dals Argumente

10 Bytes für altes PHP: <?=$n%$d<1

— Titus
quelle
Wenn Sie nichts dagegen nicht PHP4.1 mit: <?=!($A%$B). Die Werte können als Teil Ihrer weitergegeben werden $_SESSION, $_COOKIE, $_POST, $_GEToder (wenn ich mich nicht irre) über $_ENV.
— Ismael Miguel
@Ismael Miguel: Eigentlich nicht, aber ich bin es leid, für alte PHP-Versionen zu posten und hinzuzufügen for PHP<5.4 with register_globals=On. Aber ich werde es als Referenz hinzufügen.
— Titus
Eigentlich können Sie nicht " for PHP<5.4 with register_globals=On" sagen , da Sie die Bytes Ihrer php.iniDatei zählen müssen register_globals=On. PHP4.1 ist jedoch ein Sonderfall. register_globals=OnDies ist die letzte Version, in der der Standardwert verwendet wird. Die meisten Funktionen sind ab PHP4.1 verfügbar. Diese Version ermöglicht auch die Verwendung anderer Funktionen, wie eregund splitohne Warnungen.
— Ismael Miguel
3

J, 3 Bytes

0=|

Verwendungszweck:

2 (0=|) 10

Wir werden wiederkommen 1. Und ist gleichbedeutend mit Pseudocode10 MOD 2 EQ 0

Beachten Sie, dass dies der APL-Antwort sehr ähnlich ist , da J stark von APL inspiriert ist

— Emiflake
quelle
Schöne erste Antwort, willkommen bei PPCG!
— Undichte Nonne
@LeakyNun Danke, ich habe mich immer umgesehen, schön endlich zu antworten.
— Emiflake
3

PowerShell v2 +, 20 Byte

!($args-join'%'|iex)

Nimmt als Eingabe zwei Befehlszeilenargumente $args, -joins sie zusammen in einen String mit %als Separator, Rohrleitungen , die zu iex(kurz für Invoke-Expressionund ähnliche eval). Das Ergebnis ist entweder 0oder ungleich Null, daher nehmen wir den Booleschen Wert nicht !von diesem Ergebnis, was entweder $TRUEoder bedeutet $FALSE(Ganzzahlen ungleich Null in PowerShell sind wahr). Dieser Boolesche Wert verbleibt in der Pipeline und die Ausgabe ist implizit.

Alternative Versionen, jeweils auch 20 Bytes

param($a,$b)!($a%$b)
!($args[0]%$args[1])

Gleiches Konzept, nur leicht unterschiedliche Strukturierung der Eingabe. Vielen Dank an @DarthTwon für die Bereitstellung.

Beispiele

PS C:\Tools\Scripts\golfing> .\divisibility-test.ps1 24 12
True

PS C:\Tools\Scripts\golfing> .\divisibility-test.ps1 24 13
False

PS C:\Tools\Scripts\golfing> .\divisibility-test.ps1 12 24
False
— AdmBorkBork
quelle
Bei beiden anderen Methoden habe ich versucht, diese Frage Golf zu spielen, ich habe sie auch auf 20 Bytes gebracht: param($a,$b)!($a%$b)und!($args[0]%$args[1])
— ThePoShWolf
@ DarthTwon In der Tat. Bei kleinen Operationen gibt es in der Regel höchstens ein oder zwei Byte Unterschiede in der Art und Weise, wie die Eingabeargumente verwendet werden.
— AdmBorkBork
Ich hatte gehofft, etwas kürzeres zu finden: P, aber ja, es gibt immer mehrere Möglichkeiten, die Katze zu häuten, besonders bei PS.
— ThePoShWolf
3

Haskell, 13 11 Bytes

((1>).).mod

Dies definiert eine neue Funktion (!) :: Integral n => n -> n -> Bool. Da mod n mnur positive Zahlen zurückgegeben werden, wenn nund mpositiv sind, können wir ein Byte speichern, indem wir 1>anstelle von verwenden 0==.

Verwendungszweck:

ghci> let n!d=1>mod n d
ghci> 100 ! 2
True
ghci> 100 ! 3
False
— Zeta
quelle
Sie können pointfree gehen und 2 Bytes speichern: ((1>).).mod.
— nimi
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.