Teilung und Rest

36

Obwohl diese Herausforderung in den meisten "Standard" -Sprachen wahrscheinlich trivial ist, richtet sie sich an Sprachen, die so esoterisch, einfach und / oder schwierig zu bedienen sind, dass sie auf dieser Website nur sehr selten zu finden sind. Es sollte ein interessantes Problem zu lösen sein, also ist dies Ihre Gelegenheit, die seltsame Sprache auszuprobieren, über die Sie gelesen haben!

Die Aufgabe

Nehmen Sie zwei natürliche Zahlen aund bals Eingabe und geben Sie zwei andere Zahlen aus: das Ergebnis der Ganzzahldivision a/bund den Rest einer solchen Division ( a%b).

Das ist : Die kürzeste Antwort (in Bytes) für jede Sprache gewinnt!

Input-Output

  • 0 <= a<= 255, 1 <= b<= 255. Jeder Ihrer Eingänge (und auch Ausgänge) passt in ein einzelnes Byte.
  • Sie können ein beliebiges Format sowohl für die Eingabe als auch für die Ausgabe auswählen, sofern die beiden Zahlen klar voneinander zu unterscheiden sind (z. B. kein Ausdruck der beiden Ergebnisse ohne Trennzeichen).

Beispiele

a,b->division,remainder
5,7->0,5
5,1->5,0
18,4->4,2
255,25->10,5

Hinweis: Builtins, die sowohl das Ergebnis der Division als auch den Rest zurückgeben, sind verboten . Zeigen Sie uns zumindest, wie Ihre Sprache damit umgeht, zwei Funktionen auf dieselben Argumente anzuwenden.

Hinweis 2: Wie immer ist eine Erklärung der Funktionsweise Ihres Codes sehr willkommen, auch wenn er für Sie lesbar aussieht, ist dies für andere möglicherweise nicht der Fall!


Bestenliste

Hier ist ein Stack-Snippet, um eine Übersicht der Gewinner nach Sprache zu generieren.

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 + 2 (-p flag) = 45 bytes

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

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

Löwe
quelle
Kann ich die Argumente umkehren, anstatt stattdessen a bbereitzustellen b a?
Erik der Outgolfer
@EriktheOutgolfer:You may choose any format you like for both input and output, as long as the two numbers are clearly distinguishable
Emigna
@Emigna Ja, ich war mir nicht sicher, ob das Rückwärtsfahren sie nicht ununterscheidbar machte.
Erik der Outgolfer
@EriktheOutgolfer Wenn Sie wissen, dass sie umgekehrt werden müssen, haben Sie kein Problem bei der Unterscheidung :)
Leo
Leider funktioniert der BF-Algorithmus nicht, wenn der Divisor ist 1.
mbomb007

Antworten:

23

BitCycle , 146 79 64 Bytes

Ich habe gerade festgestellt, dass ein ganzer Abschnitt meines ursprünglichen Codes nicht erforderlich war. Riesige Reduzierung!

v  <>!
A\B^^=
? D^>^<
 >\v^~ D@
 >/ C/
  > C ^
A/B v
^   <
?  D^

Das Programm nimmt Eingaben in unary über die Befehlszeile vor, wobei der Divisor an erster Stelle steht. Es gibt den Quotienten und den Rest in Unary aus, getrennt durch ein 0. Zum Beispiel, hier ist a=11, b=4, a/b=2, a%b=3:

C:\>python bitcycle.py divmod.btc 1111 11111111111
110111

Ungolfed in Aktion

Hier ist meine ungolfed Version Computing a=3, b=5mit Animation eingeschaltet (sorry über die glitchiness):

Divmod läuft in BitCycle

Versuch einer Erklärung

Die Erklärung gilt für die ungolfed Version. Bevor Sie es angehen, empfehle ich Ihnen dringend, die Esolangs-Seite zu lesen , um ein Gefühl dafür zu bekommen, wie die Sprache funktioniert.

Der Algorithmus sieht folgendermaßen aus:

  • Führen Sie eine äußere Schleife aus, bis das Programm beendet ist.
    • Führen Sie eine innere Schleife über die Bits des Divisors und koppeln Sie sie mit Bits aus der Dividende.
      • Wenn alle Bits des Divisors übereinstimmende Dividendenbits haben, geben Sie ein einzelnes Bit aus.
      • Wenn nicht alle Bits des Divisors übereinstimmende Dividendenbits haben, geben Sie das Trennzeichen aus, 0gefolgt von den vorhandenen Dividendenbits, und schließen Sie dann ab.

Das Herzstück des Codes sind die Beziehungen zwischen den Sammlern (die Großbuchstaben). Da es mit jedem Buchstaben mehrere separate Kollektoren sind, lassen Sie uns auf sie beziehen , wie A1, A2, B1, B2usw., die Nummerierung von oben nach unten.

  • A1und A2halten Sie den Divisor bzw. Dividend am Anfang der Hauptschleife.
  • Die innere Schleife löst sich jeweils ein Stück vom Divisor und der Dividende ab.
    • Der Rest des Divisors, falls vorhanden, geht immer hinein B1.
    • Wenn sowohl der Divisor als auch der Dividend nicht leer waren, geht ein Bit in C1und eins in C3. Der Rest der Dividende fließt in B2.
    • Wenn nur der Divisor nicht leer war, haben wir das Ende der Dividende erreicht und es ist Zeit, den Rest zu drucken. Das Stück vom Teiler geht hinein C2.
    • Wenn nur die Dividende nicht leer war, haben wir das Ende des Divisors erreicht; Es ist Zeit, die Bits in C3oder C2für die Ausgabe zu verarbeiten. Der Rest der Dividende fließt in C4.
  • Befinden sich in den BKollektoren irgendwelche Bits , werden die Inhalte zu den AKollektoren zurückgeführt und in der inneren Schleife fortgesetzt.
  • Sobald die Aund BKollektoren alle leer sind, Cöffnen sich die Kollektoren und wir gehen zur Verarbeitungsstufe über:
    • C1und C4lade ihren Inhalt (den Divisor bzw. die verbleibende Dividende) in D1und D3.
    • Wenn C2leer ist, wird der Quotient immer noch gedruckt.
      • Der Inhalt von wechselt C3nach rechts oben =. Das erste 1Bit geht direkt zu !und wird ausgegeben.
      • Wenn das 1Bit durchgeht, aktiviert es den Schalter nach rechts, wodurch alle nachfolgenden Bits von der Karte gesendet werden.
    • Wenn C2nicht leer, drucken wir den Rest.
      • Das erste Bit von C2wird auf a negiert 0und durch den Switch geleitet. Das 0geht weiter !und wird ausgegeben.
      • Wenn das 0Bit passiert, aktiviert es den Schalter, um nach links zu zeigen. Jetzt gehen alle Bits vom C3Schalter nach links und werden in den umgelenkt !, wobei der gesamte Rest ausgegeben wird.
      • Eine Kopie des ersten Bits von C2wird ebenfalls an gesendet D2.
  • Jetzt Döffnen sich die Sammler.
    • Wenn etwas drin D2ist, bedeutet das, dass wir nur den Rest gedruckt haben. Das Bit von D2trifft das @, was das Programm beendet.
    • Andernfalls wird der Inhalt D1und die D3Schleife wieder in A1und A2starten bzw., und die Hauptschleife über.
DLosc
quelle
das ist großartig
Evan Carslake
"Das Programm nimmt Eingaben in Unary von der Kommandozeile": Das sieht für mich nach Binär aus?
Therealfarfetchd
Hoppla. Da die Ausgabe wie binär aussah, sollte die Eingabe auch sein. Dann las ich den Text. Keine Ursache. : P
therealfarfetchd
15

Brainfuck , 43 41 Bytes

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

Dies verwendet eine modifizierte Version meines Destruktivmodul-Algorithmus auf Esolangs .

Das Programm liest zwei Bytes - d und n , in dieser Reihenfolge - von STDIN und druckt zwei Bytes - n% d und n / d , in dieser Reihenfolge - nach STDOUT. Hierfür ist ein Brainfuck-Interpreter mit einem doppelt unendlichen oder kreisförmigen Band erforderlich, z. B. das auf TIO.

Probieren Sie es online!

Wie es funktioniert

Vor dem Programmstart haben alle Zellen den Wert 0 . Nach dem Lesen von d von STDIN ( ,), einem Schritt nach links ( <) und dem Lesen von n von STDIN ( ,) sieht das Band wie folgt aus.

       v
A      B      C      D      E      F      G      H      J
0      n      d      0      0      0      0      0      0

Unter der Annahme, dass n> 0 ist , betreten wir als nächstes die while-Schleife

[>->+<[>]>>>>+<<<[<+>-]<<[<]>-]

Dadurch wird das Band wie folgt transformiert.

Zuerst >->+<Fortschritte der Zelle C und dekrementiert sie schreitet dann zur Zelle D und erhöht sie, und schließlich geht zurück auf Zelle C . Was als nächstes passiert, hängt davon ab, ob der Wert von Zelle C Null ist oder nicht.

  • Wenn Zelle C einen positiven Wert enthält [>](nach rechts gehen, während die Zelle nicht Null ist), wird zu Zelle E übergegangen .

    >>>>+<<<rückt zu Zelle J vor, um es zu erhöhen, und kehrt dann zu Zelle F zurück .

    Da Zelle F immer 0 enthält , wird die while-Schleife [<+>-]vollständig übersprungen und <<kehrt zu Zelle D zurück .

    Schließlich, da weder D noch C halten 0 , [<](gehen Sie nach links , während die Zelle nicht Null ist) wird zu Zelle retrozedieren A .

  • Wenn die Zelle C hält 0 , die Schleife [>]vollständig übersprungen; >>>>+<<<rückt zu Zelle G vor, um es zu erhöhen, und kehrt dann zu Zelle D zurück .

    An diesem Punkt D hält d (in der Tat die Summe der Werte in C und D wird immer d ), so [<+>-](bei D positive, Inkrement C und Dekrement - D ) wird eingestellt C bis D und D bis 0 .

    Schließlich <<retrozediert zu Zelle B , [<](nach links , während die Zelle nicht Null ist) , weiter nach links zu Zelle A .

In beiden Fällen >-rückt die Zelle B vor und dekrementiert sie, und die Schleife beginnt von vorne, es sei denn, dies löscht sie auf Null.

Nach k Iterationen sieht das Band wie folgt aus.

       v
A      B      C      D      E      F      G      H      J
0      n-k    d-k%d  k%d    0      0      k/d    0      k-k/d

Nach n Iterationen wird B auf Null gesetzt und wir brechen aus der Schleife aus. Die Sollwerte ( n% d und n / d ) werden in den Zellen gespeichert werden , D und G , so >>.>>>.druckt sie.

Dennis
quelle
12

Funktion , 224 108 Bytes

Die Byteanzahl setzt eine UTF-16-Codierung mit Stückliste voraus.

 ┌──┬───┐
┌┴╖╓┴╖ ┌┴╖
│%╟║f╟┐│÷╟┘
╘╤╝╙─╜│╘╤╝
 └────┴─┘

Probieren Sie es online!

Das Obige definiert eine Funktion f, die zwei ganze Zahlen nimmt und sowohl ihre Division als auch ihr Produkt zurückgibt (Funktionen in Funciton können mehrere Ausgänge haben, solange die Summe der Ein- und Ausgänge 4 nicht überschreitet).

Die Verwendung von zwei Eingabewerten für mehrere Zwecke ist eigentlich ziemlich trivial: Sie trennen den Stecker einfach mit einer T-Verzweigung ab, wobei der Wert entlang beider Zweige dupliziert wird, und wir können ihn dann für Division und Modulo getrennt an die eingebauten Werte weitergeben.

Eigentlich habe ich doppelt so lange gebraucht, um herauszufinden, wie das Ergebnis dem Benutzer angezeigt werden soll, als nur, um die Lösung zu implementieren.

Außerdem hat Funciton einen eingebauten DivMod, ÷%und amüsanterweise sind die eingebauten ÷und von %meiner Lösung verwendeten Funktionen in Bezug auf implementiert ÷%. Meine fobige Funktion ist jedoch nicht ganz identisch mit ÷%: Ich musste die Reihenfolge der Eingaben vertauschen, und obwohl es anscheinend einfach sein sollte, dies zu ändern, war ich bisher nicht in der Lage, dies zu tun, ohne die Byteanzahl zu erhöhen .

Martin Ender
quelle
10

JavaScript (ES6), 17 Byte

Vielen Dank an @Arnauld für das Abschlagen eines Bytes

x=>y=>[x/y|0,x%y]

Erhält Eingaben im Format (x) (y)

Ermittelt den Grundwert von x / y durch bitweises Durchführen oder
Ermittelt den Restwert durch x% y
Setzt beide Werte in ein Array, sodass beide zurückgegeben werden können

Probieren Sie es online!

fəˈnəˈtɪk
quelle
10

APL (Dyalog) , 5 Bytes

-2 Bytes dank @ngn

⌊÷,|⍨

Dies ist eine Spitze (2-Zug) einer Gabel (3-Zug), wobei der rechte Zinken der Spitze eine abgeleitete Funktion ist (das Ergebnis eines auf eine Funktion angewendeten Operators):

       result 
         ↑┌──────────┐
         ││    ┌────┐│┌──────┐ (derived function)
         │↓        ↓│↓      │╱
       ┌───┐ ┌───┐ ┌───┐ ╔═══╤═══╗
           ÷   ,   |    
       └───┘ └───┘ └───┘ ╚═══╧═══╝
                              
left argument ┴─────────────────┘  (operator)
                └─────────┴ right argument

 Boden von

÷ Teilung

, verkettet an

| Divisionsrest
 mit vertauschten Argumenten (APL-Modul ist "rückwärts")

Probieren Sie es online!

Adam
quelle
Wie hast du das coole Diagramm gemacht?
Emiflake
2
@WolfgangTS Sorgfältig. Dyalog APL bietet die Möglichkeit, grundlegende Baumdiagramme stillschweigender Funktionen zu erstellen. Probieren Sie es online! Ich habe damit angefangen ...
Adám
Autsch, sieht sehr schwierig aus. Ich fürchte, ich habe nicht die Geduld dafür, haha
emiflake
kürzer:⌊÷,|⍨
ngn
@ngn Autsch, du hast mich erwischt. Freut mich zu sehen, dass du immer noch hier bist.
Adám
7

Brachylog , 6 Bytes

{÷|%}ᶠ

Probieren Sie es online!

Erläuterung

Wir missbrauchen das Metapredikat ᶠ findall, um zwei unterschiedliche Prädikate auf die Eingabeliste mit zwei Argumenten anzuwenden:

{   }ᶠ         Findall for the Input [A,B] :
 ÷               Integer division
  |              Or…
   %             Modulo
Tödlich
quelle
7

MATL , 12 10 Bytes

Qt:ie=&fhq

Eingabe ist adann b. Die Ausgabe ist der Rest, dann der Quotient.

Probieren Sie es online!

Erläuterung

Dies vermeidet sowohl Modulo als auch Division. Stattdessen wird die Umformung von Arrays verwendet :

  1. Erstellen Sie ein Array von a+1Elementen ungleich Null.
  2. Umformen als 2D-Array von bZeilen. Dies wird bei Bedarf automatisch mit Nullen aufgefüllt.
  3. Die Zeilen- und Spaltenindizes des letzten Eintrags ungleich Null, minus 1, sind jeweils der Rest und der Quotient.

Betrachten Sie zum Beispiel a=7, b=3.

Q    % Input a implicitly. Push a+1
     % STACK: 8
t:   % Duplicate. Range from 1 to that
     % STACK: 8, [1 2 3 4 5 6 7 8]
ie   % Input b. Reshape as a matrix with b rows (in column major order)
     % STACK: 8, [1 4 7;
                  2 5 8]
                  3 6 0]
=    % Compare for equality
     % STACK: [0 0 0;
               0 0 1;
               0 0 0]
&f   % Row and column indices (1-based) of nonzero element
     % STACK: 2, 3
hq   % Concatenate. Subtract 1. Implicitly display
     % STACK: [1 2]
Luis Mendo
quelle
2
Dies ist ein gutes Beispiel für Querdenken, gute Arbeit!
Leo
6

Mathematica, 20 bis 18 Bytes

⌊#/#2⌋@Mod@##&

Geringfügiger Missbrauch der flexiblen Ausgaberegeln: Das Ergebnis wird als gegeben div[mod], was unbewertet bleibt. Die einzelnen Nummern können mit result[[0]]und extrahiert werden result[[1]].

Und hey, es ist nur ein Byte länger als das lächerlich benannte eingebaute QuotientRemainder.

Mathematica bietet eine praktische Möglichkeit, mehrere Funktionen auf dieselbe Eingabe anzuwenden, die jedoch drei Byte länger ist:

Through@*{Quotient,Mod}
Martin Ender
quelle
1
Sie wissen, dass es schlecht ist, wenn
Ihre
1
@Fatalize Ist es? Ich finde die eingebauten divmod-Funktionen sehr nützlich, und Mathematica ist bei weitem nicht die einzige Sprache, in der es eine gibt.
Martin Ender
8
@Fatalize, für die Berechnung von Quotienten ist ein Großteil der gleichen Arbeit erforderlich wie für die Berechnung von Resten. Wenn beide Ergebnisse verwendet werden sollen, kann eine ordnungsgemäß ausgeführte integrierte Funktion im quotRemVergleich zum Aufrufen quotund für remsich genommen erheblich Zeit sparen .
Julian Wolf
6

05AB1E , 5 Bytes

÷²¹%‚

Probieren Sie es online!

05AB1E hat einen Fehler, so dass implizite Eingaben nicht funktionieren :( Emigna merkte an, dass Eingaben oft in umgekehrter Reihenfolge erfolgen.

Erik der Outgolfer
quelle
Sie könnten ¹%) für 5 Bytes tun .
Emigna
@Emigna Ich weiß nicht, ob es gültig ist. Warten Sie, wie hat das funktioniert?
Erik der Outgolfer
1
Ich verstehe nicht, warum es nicht gültig wäre. Dies funktioniert, weil implizite Eingaben in umgekehrter Reihenfolge an den Stack gesendet werden, wie Sie dies in solchen Fällen annehmen würden.
Emigna
@Emigna Ich habe OP gefragt, ob ich die Argumente umkehren kann.
Erik der Outgolfer
2
Ich gehe davon aus You may choose any format you like for both input and output, as long as the two numbers are clearly distinguishable, dass Sie entscheiden können, dass die Eingaben als genommen werden divisor, dividend. Sie können divisor, dividendin der Antwort einfach angeben, dass Eingaben als genommen werden , und sie werden klar unterscheidbar sein :)
Emigna
6

Qualle , 14 Bytes

p
m
,|S
% i
Ei

Probieren Sie es online!

Erläuterung

Qualle ist eine schöne Sprache, wenn es darum geht, mehrere Funktionen auf einen Eingang anzuwenden. Die Sprache ist 2D und alle Binärfunktionen suchen nach Süden für einen Eingang und nach Osten für einen anderen. Wenn wir uns also einem Wert von Westen und Norden nähern, können wir ihn zwei Funktionen zuweisen, ohne ihn im Code duplizieren zu müssen.

Die beiden is im Programm werden beim Programmstart durch die beiden Eingabewerte ersetzt. Jetzt %ist die Teilung. Es nimmt eine Eingabe direkt aus dem Osten, und wenn es nach Süden geht, trifft es Edie Umleitungen, die auch nach Osten suchen. Beide Eingaben werden also %als Argumente eingegeben.

| ist das eingebaute Modulo, das im Grunde das Gleiche tut, aber am Ende nach Süden schaut, um beide Puts zu finden.

Wir verknüpfen beide Ergebnisse zu einem Paar mit ,. Dann mfolgt die Floor-Funktion (die wir brauchen, weil %es sich um eine Gleitkommadivision handelt) und schließlich drucken wir das Ergebnis mit p.

Martin Ender
quelle
6

Cubix , 12 13 Bytes

;W@o,I|\S%;O

Welche Karten auf den folgenden Würfel

    ; W
    @ o
, I | \ S % ; O
. . . . . . . .
    . .
    . .

Probieren Sie es hier aus

Erklärung mit ausgeführten Schritten
,I|I,- Beginnt mit einer überflüssigen Ganzzahldivision, holt die erste Ganzzahl von der Eingabe, reflektiert zurück und holt die nächste Ganzzahl von der Eingabe, teilt dann erneut
O;- gibt das Ergebnis der Ganzzahldivision aus und füllt es aus
%- führt den Mod aus. Dies könnte später geschehen, endete aber hier.
S\o- Leerzeichen zum Stapeln hinzufügen, umleiten und Leerzeichen ausgeben.
W;- Nach links verschieben und Leerzeichen aus dem Stapel entfernen.
O|@- Den zuvor berechneten Mod ausgeben , durch den horizontalen Reflektor laufen und anhalten.

MickyT
quelle
Schlagen Sie mich um zwei Minuten. Gute Antwort!
Luke
@ Luke Danke, dachte, ich könnte noch einen bekommen, aber es ist schwer zu
fassen
6

Brain-Flak , 56 54 Bytes

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

Probieren Sie es online!

-2 Bytes dank Wheat Wizard

Erläuterung

Die derzeit bekannteste Ganzzahldivision und das Modulo in Brain-Flak sind sehr ähnlich (tatsächlich ist die derzeit verwendete Ganzzahldivision nur eine Modifikation, die ich auf Feersums Modulo vorgenommen habe).

Vergleich von Modulo und Integer Division:
Modulo:   ({}(<>))<>     {   (({})){({}[()])<>}{} }{}<> ([{}()]{})
Division: ({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><  {}   {} >)

Praktischerweise verwendet das Ganzzahlteilungsprogramm nur den dritten Stapel zum Speichern von Daten, während das Modulo-Programm nur die normalen zwei Stapel zum Speichern von Daten verwendet. Indem sie einfach beide gleichzeitig ausführen, kollidieren sie nicht miteinander.

Kombination von Modulo und Integer Division:
Modulo:   ({}(<>))<>     {   (({})){({}[()])<>}{} }{}<> ([{}()]{})
Division: ({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><  {}   {} >)

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

Schließlich wurden sowohl das Integer-Divisions- als auch das Modulo-Programm, die in dieser Kombination verwendet wurden, so entworfen, dass sie stapelrein sind (keinen Müll auf den Stapeln zurücklassen / nicht von der (Nicht-) Existenz von Werten auf den Stapeln abhängen, außer deren Eingabe), aber das ist nicht notwendig für dieses Problem. So können wir zwei Bytes sparen, indem wir uns nicht die Mühe machen, die Null am Ende der Hauptschleife zu platzieren, und weitere zwei Bytes, indem wir am Anfang nicht die Null drücken, anstatt auf den Nullabstand am Boden der Stapel zu vertrauen.

Dies gibt uns das endgültige Programm:
({}<>)<>([()]{()<(({})){({}[()])<>}{}>}<><([{}()]{})>)

Zur Erklärung des Integer-Divisionsprogramms siehe die Antwort von feersum

Erklärung der Ganzzahldivision in Kürze ...

0 '
quelle
5

Java 8, 18 Bytes

(a,b)->a/b+","+a%b

Dies ist ein Lambda-Ausdruck des Typs BiFunction<Integer, Integer, String>.

Ich bin überrascht ... das ist eigentlich eine ziemlich prägnante Lösung für Java. Gehen Sie Lambda-Ausdrücke!

Sokratischer Phönix
quelle
5

Brain-Flak , 168 148 110 Bytes

Ich denke, ich hätte zuerst das Wiki überprüfen sollen

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

Format:

Input:    Output:
A (18)    remainder (2)
B (4)     division  (4)

Probieren Sie es online!

(({})(<           # Copy A
({}(<             # Pick up A
(({})<>)          # Copy B to the other stack
>))               # Put A on top of a 0 on the second stack
                  # At this point the stacks look like this:   A
                                                               0
                                                             B B
                                                               ^

<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>) # Positive division from the wiki
>))                                          # Put down A on top of a 0
                                             # The stack now: A
                                                              0
                                                            Div B
                                                              ^

<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<>)     # Modulo from the wiki
Riley
quelle
Golf
Wheat Wizard
5

sed, 36 bytes

35 Byte Code, +1 für das -rFlag.

:a;s/^(1+)( 1*)\1/\1\2x/;ta;s/.* //

Nimmt Eingaben in unären, durch Leerzeichen getrennten Formaten vor, wobei die kleinere Zahl an erster Stelle steht. Ausgabe als unär, wobei der Quotient an erster Stelle in 1s und der Rest an zweiter Stelle in stehtx s steht. (Wenn dies nicht akzeptabel ist, lassen Sie es mich wissen und ich werde es 1wie die Eingabe in durch Leerzeichen getrennte s ändern .)

Erläuterung

:a;                                  Define label a
   s/            /     /;            Perform this substitution:
     ^(1+)                           Match the first unary number...
          ( 1*)                      ... followed by a space and 0 or more 1s...
               \1                    ... followed by the the first group again
                  \1\2x              Keep the first two parts unchanged; replace the third
                                     with an x
                         ta;         If the substitution succeeded, goto a
                            s/.* //  After the loop is over, remove the first number
DLosc
quelle
5

Excel 2013, 31 30 26 Bytes

=INT(A1/B1)&","&MOD(A1;B1)

Erläuterung

Die Eingabe erfolgt in Zelle A1und B1. Dies gibt einfach die Rückgabewerte der FLOORund MOD-Funktion zurück, die für die Aufteilung und für den Rest gelten. Diese Werte sind durch ein Komma getrennt.

Luke
quelle
Ich denke du meinst Zelle A1 und B1 nicht A1 und A2
am
Ja dank. Jetzt
Luke
Speichern Sie 1 Byte mit FLOOR(A1/B1;1)anstelle vonQUOTIENT(A1;B1)
Engineer Toast
Da es sich bei der Eingabe immer um eine natürliche Zahl handelt, können Sie sie FLOOR(A1/B1;1)meines Erachtens durch "INT (A1 / B1)" ersetzen , um 4 weitere Bytes zu sparen
Wernisch
4

Gelee , 3 Bytes

:,%

Probieren Sie es online!

Erik der Outgolfer
quelle
Verdammt, ich wollte das hier gerade posten, habe es ein paar Mal getestet und wurde ninja'd :( Gute Arbeit!
HyperNeutrino
4

OIL , 134 106 103 102 Bytes

Übernimmt die Eingabe von stdin, die zwei durch eine neue Zeile getrennten Zahlen. Gibt das Ergebnis der Ganzzahldivision, eine neue Zeile und den Rest aus.

Dies ist eines der kompliziertesten OIL-Programme, die ich je geschrieben habe, da es in OIL keine integrierten Funktionen für Division, Rest, Addition, Subtraktion usw. gibt. Es funktioniert mit der primitiven Art der Division: wiederholte verschachtelte Dekrementierung.

Ich präsentiere den Code in einem kommentierten Format mit Kommentaren im Stil von Skriptsprachen. Vor der Ausführung müssen die Kommentare entfernt werden.

5  # read input into lines 0 and 2

5
2
0  # the zero to compare to (nops)
1  # make a backup of the second input at line 3
2
3
10 # check if the second input is 0. %
4
2
24 # if so, jump to 24 (marked with §)
13 # else, go on
10 # check if the first input is zero &
4

31 # if so, jump to 31 (marked with $)
18 # else, go on
9  # decrement both numbers

9
2
6  # jump to line 8 (marked with %)
8
8  # increment the value in line 1 (initially a zero) §
1
1  # "restore the backup"
3
2
6  # jump to line 13 (marked with &)
13
10 # is the second number zero? $
4
2
42 # if so, jump to 42 (marked with +)
36 # else go on
9  # decrement both the second number and the backup
2
9
3
6  # jump to 31 (marked with $)
31
4  # print the division +
1
11 # a newline
4
3  # and the remainder (from the backup)

edit: 3 weitere Bytes wurden abgeschnitten, indem eine "Konstante" an eine einstellige Stelle verschoben wurde (weniger Bytes als Referenz) und dann 2 Nullstellen impliziert wurden (indem stattdessen eine leere Zeile verwendet wurde. Eine davon hätte ich tun können Vor).

edit: Und noch ein Byte, indem die anfängliche Null implizit gemacht wird. Wir brauchen wirklich nur eine einzige wörtliche Null.

L3viathan
quelle
Gute Arbeit! Das ist genau die Art von Antwort, von der ich gehofft hatte, dass sie diese Herausforderung erhalten würde :) Nur eine Anmerkung: Sie können sicher sein, dass der Teiler immer positiv ist, sodass Sie nicht nach einer Teilung durch 0 suchen müssen;)
Leo
@Leo Ich bin mir sicher, dass der Divisor am Anfang immer streng positiv sein wird . Es funktioniert nicht, wenn ich den Teil durch Null herausnehme. Dieser Fall kann auch dann eintreten, wenn die "tatsächliche" Teilung eine normale ist. Wenn ich mich richtig erinnere, geschieht dies, wenn der Rest Null ist.
L3viathan
Ich spreche von der Prüfung in Zeile 4, nicht der in Zeile 12 ... Wird sie nicht nur einmal beim Start des Programms ausgeführt?
Leo
@Leo Fertig, fast 30 Zeichen weniger, danke!
L3viathan
4

Retina , 14 Bytes

Lassen Sie uns die Eingabe- / Ausgabeformate missbrauchen!

(.*)¶(\1)*
$#2

Nimmt die Eingabe als b\naunär, wobei als unäres Zeichen ein einzelnes Zeichen verwendet wird, das keine Ziffer und kein Zeilenumbruch ist. Gibt den Quotienten als Dezimalzahl aus, unmittelbar gefolgt vom Rest als Unärzahl, wobei dasselbe Zeichen wie die Eingabe verwendet wird.

Probieren Sie es online!

(.*) ¶(\1)*Stimmt mit der ersten Nummer überein, dann mit einer neuen Zeile (¶ ist die Abkürzung von Retina für \ n) und dann mit der ersten Nummer so oft wie möglich. Die Anzahl der Übereinstimmungen der zweiten Gruppe ergibt sich aus der Division, der nicht übereinstimmende Teil ist der Rest.

Mit $#2ersetzen wir alles, was in der vorherigen Zeile abgeglichen wurde, durch die Anzahl der Erfassungen der zweiten Gruppe und erhalten dann unser Ergebnis.

Löwe
quelle
Haha, ganz richtig, ich sollte offensichtlich nicht so spät am Abend Programme schreiben.
FryAmTheEggman
4

ArnoldC , 286 283 Bytes

HEY CHRISTMAS TREE c
YOU SET US UP 0
HEY CHRISTMAS TREE d
YOU SET US UP 0 
GET TO THE CHOPPER c
HERE IS MY INVITATION a
HE HAD TO SPLIT b
ENOUGH TALK
GET TO THE CHOPPER d
HERE IS MY INVITATION a
I LET HIM GO b
ENOUGH TALK
TALK TO THE HAND c
TALK TO THE HAND d
YOU HAVE BEEN TERMINATED

Probieren Sie es online!

Wie es funktioniert

HEY CHRISTMAS TREE c      //DECLARE VARIABLE c = 0
YOU SET US UP 0
HEY CHRISTMAS TREE d      //DECLARE VARIABLE d = 0
YOU SET US UP 0

GET TO THE CHOPPER c      /*
HERE IS MY INVITATION a      SET c = a/b
HE HAD TO SPLIT b         
ENOUGH TALK                */

GET TO THE CHOPPER d      /*
HERE IS MY INVITATION a      SET d = a mod b
I LET HIM GO b
ENOUGH TALK                */

TALK TO THE HAND c        // PRINT c
TALK TO THE HAND d        // PRINT d
YOU HAVE BEEN TERMINATED  //END

Ausgabeformat

a/b
a mod b
Tom291
quelle
3

Labyrinth , 11 Bytes

?:?:}/!\{%!

Probieren Sie es online!

Erläuterung

?:   Read a and duplicate.
?:   Read b and duplicate.
}    Move a copy of b over to the auxiliary stage.
/    Compute a/b.
!    Print it.
\    Print a linefeed.
{    Get back the other copy of b.
%    Compute a%b.
!    Print it.

Die IP stößt dann auf eine Sackgasse, dreht sich um und das Programm wird aufgrund der versuchten Division durch Null beendet, wenn %es erneut ausgeführt wird.

Martin Ender
quelle
3

> <> , 27 26 16 + 1 = 17 Bytes

:r:{%:n','o-$,n;

Hinweis

  • Eingabe unter Verwendung des -vFlags, siehe TIO für ein Beispiel.
  • Dies gibt zuerst den Rest, dann ein Komma und zuletzt die Ganzzahldivision aus.

Probieren Sie es online!

Erläuterung

Beachten Sie, dass der Stapel aufgrund des verwendeten Flags als A, B, wo Aund Bals erste und zweite Eingabe beginnt -v.

:r:{%:n','o-$,n; # Explanation
:r:{             # Do some stack modifications to prepare it for
                 #    next part
                 #    (Stack: B, A, A, B)
    %            # Take the modulo of the top two items
                 #    (Stack: B, A, A%B)
     :           # Duplicate it
                 #    (Stack: B, A, A%B, A%B)
      n          # Pop once and output as number
                 #    (Stack: B, A, A%B)
       ','o      # Print separator
                 #    (Stack: B, A, A%B)
           -     # Subtract the modulo from the first input
                 #    (Stack: B, A-A%B)
            $,   # Swap the two inputs so they are back in order
                 #     and divide, so we get an integer
                 #    (Stack: floor(A/B))
              n; # Output that as a number and finish.
Luke
quelle
Wie können Sie Eingabewerte bis 255 bereitstellen?
Leo
Verwenden Sie einfach höhere ASCII / Unicode-Werte. Auf diese Weise įwird 255.
Luke
Ok, nett :) Übrigens, wäre es nicht kürzer, die Eingaben von der Kommandozeile direkt mit dem Flag -v zu übernehmen?
Leo
Es würde, aber ich konnte das nicht auf TIO arbeiten, also entschied ich mich für diese Lösung. Es würde 8 Bytes - 1 (für das -vFlag) sparen .
Luke
Hier sind Sie :)
Leo
3

C, 21 Bytes

#define f(a,b)a/b,a%b

Ein Makro, das f (a, b) durch zwei durch Kommas getrennte Begriffe ersetzt. Obwohl Sie es besser an eine Funktion übergeben, sonst gibt es keine Möglichkeit, die 2 auseinander zu nehmen.

Probieren Sie es online

Bijan
quelle
3

Haskell , 21 Bytes

a#b=(div a b,mod a b)

Probieren Sie es online! Anwendungsbeispiel: 13#2Rückgabe (6,1). Ja, das ist ziemlich langweilig, allerdings etwas interessanter als das divModBuild-in, das genauso funktioniert.

Während wir gerade dabei sind, gibt es auch quot, remund quotRemdie verhalten sich genauso auf natürliche Zahlen wie div, modund divMod. Bei negativen Eingaben hat das Ergebnis von modjedoch dasselbe Vorzeichen wie der Divisor, während das Ergebnis von remdasselbe Vorzeichen wie die Dividende hat. Oder, wie in der Prelude-Dokumentation beschrieben , quotwird die Ganzzahldivision gegen Null und divdie Ganzzahldivision gegen negative Unendlichkeit abgeschnitten.


Wie wäre es mit Nein divoder modEinbauten?

Keine Einbauten, 36 32 31 Bytes

a#b|a<b=(a,0)|m<-a-b=(+1)<$>m#b

Probieren Sie es online! Anwendungsbeispiel: 13#2Gibt zurück (1,6), dh das modErgebnis ist das erste und das divErgebnis das zweite. Wenn akleiner ist b, dann a mod bist aund a div bist 0, so (a,0)wird zurückgegeben. Ansonsten rekursiv modund divvon a-bund berechnen b, 1zum Divisionsergebnis addieren und den Rest behalten.

Das Addieren von 1 zum Divisionsergebnis wird durch Verwenden von erzielt <$>, das üblicherweise mapzum Abbilden von Funktionen über Listen verwendet wird, aber auch für Tupel funktioniert, die Funktion wird jedoch nur auf das zweite Tupelelement angewendet.

Edit: Dank xnor ein Byte gespeichert!

Laikoni
quelle
2
Ihre zweite Lösung kann ein Byte mit rasiert <$>auf einem Tupel an seinem zweiten Elemente zu handeln: a#b|a<b=(a,0)|m<-a-b=(+1)<$>m#b.
Xnor
3

SWI-Prolog, 109 Bytes

p(A):-print(A).
d(F,S,0,F):-S>F.
d(F,S,D,R):-G is F-S,d(G,S,E,R),D is E+1.
d(F,S):-d(F,S,D,R),p(D),p(-),p(R).

Ausgabe:

?- d(255,25).
10-5
true .
?- d(5,7).
0-5
true .

Beschreibung:

Einfacher rekursiver Algorithmus ohne integrierte Division oder Modulo. Es zählt einfach "wie oft passt die zweite Zahl in die erste?" und meldet das Ergebnis (vereinheitlicht mit D) mit dem Rest (R).

// edit: unnötige Leerzeichen entfernt

Jan Drozen
quelle
Willkommen bei PPCG! Ich habe Prolog noch nie benutzt, aber ich habe bemerkt, dass es :-in der letzten Zeile Leerzeichen gibt, in den anderen jedoch keine. Werden sie dort aus irgendeinem Grund benötigt? Gleiches gilt für die E + 1Zeit F-S, in der keine Leerzeichen erforderlich sind.
Laikoni
Laikoni: Sie haben definitiv Recht! Ich habe gerade die Leerzeichen entfernt und die Anzahl der letzten Bytes aktualisiert.
Jan Drozen
2

MATL, 5 Bytes

/k&G\

Probieren Sie es bei MATL Online aus!

Erläuterung

        % Implicitly grab the two inputs as numbers
/       % Divide them
k       % Round down the result
&G      % Grab the two inputs again
\       % Compute the remainder
Suever
quelle
2

Ouroboros , 15 Bytes

r.r.@/Inao\%n1(

Nimmt die Nummern in umgekehrter Reihenfolge (zB 10 42). Probieren Sie es hier aus.

Erläuterung

r.r.             Read a number, duplicate, read a number, duplicate
    @            Rotate a copy of the first number to the top of the stack
     /I          Divide and truncate to integer
       n         Output as number
        ao       Push 10 and output as character (newline)
          \%     Swap the remaining two values and take the mod
            n    Output as number
             1(  Push 1 and swallow that many characters from the end of the program,
                 halting execution
DLosc
quelle