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 Code-Golf : 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

var QUESTION_ID=114003,OVERRIDE_USER=62393;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={};e.forEach(function(e){var o=e.language;/<a/.test(o)&&(o=jQuery(o).text().toLowerCase()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link,uniq:o}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.uniq>s.uniq?1:e.uniq<s.uniq?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=617d0685f6f3"> <div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table>

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

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.

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.

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 .

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!

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!

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

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]

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}

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.

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.

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.

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

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.

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.

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

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

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

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!

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

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

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.

Python 2 , 20 Bytes

lambda a,b:(a/b,a%b)

Probieren Sie es online!

Eingebaut, 6 Bytes

divmod

Probieren Sie es online!

Gelee , 3 Bytes

:,%

Probieren Sie es online!

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.

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.

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

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.

C 32 Bytes

f(a,b){printf("%d %d",a/b,a%b);}

Probieren Sie es online!

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

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

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!

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

Gol> <> , 11 Bytes

I:I:@$S,N%h

Online-Dolmetscher

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

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