Ce défi, bien que probablement trivial dans la plupart des langages "standard", concerne les langages si ésotériques, de bas niveau et / ou difficiles à utiliser qui sont très rarement vus sur ce site. Cela devrait fournir un problème intéressant à résoudre, c’est donc votre occasion d’essayer ce langage étrange que vous avez lu!

La tâche

Prendre deux nombres naturels aet ben entrée et sortir deux autres nombres: le résultat de la division entière a/bet le reste de cette division ( a%b).

C'est du code-golf : la réponse la plus courte (en octets), pour chaque langue, gagne!

Entrée sortie

• 0 <= a<= 255, 1 <= b<= 255. Chacune de vos entrées (et de vos sorties aussi) tiendra dans un seul octet.
• Vous pouvez choisir le format de votre choix pour les entrées et les sorties, à condition que les deux nombres soient clairement distinguables (par exemple, aucune impression simultanée des deux résultats sans séparateur)

Exemples

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

Remarque: Les fonctions intégrées qui renvoient à la fois le résultat de la division et le reste sont interdites . Montrez au moins comment votre langage traite de l’application de deux fonctions aux mêmes arguments.

Note 2: Comme toujours, une explication du fonctionnement de votre code est la bienvenue, même s'il vous semble lisible, cela ne le sera peut-être pas pour quelqu'un d'autre!

Classement

Voici un extrait de pile permettant de générer un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

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

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

# [><>](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 octets

Je viens de me rendre compte que toute une partie de mon code original n'était pas nécessaire. Énorme réduction!

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

Le programme prend des entrées unaires à partir de la ligne de commande, avec le diviseur en premier. Il sort le quotient et le reste en unaire, séparés par un 0. Par exemple, voici a=11, b=4, a/b=2, a%b=3:

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

Ungolfed, en action

Voici ma version informatique non-golfée a=3, b=5avec animation activée (désolé pour le problème):

Tentative d'explication

L'explication s'applique à la version non-golfée. Avant de vous attaquer au problème, je vous recommande vivement de lire la page Esolangs pour avoir une idée du fonctionnement de la langue.

L'algorithme va comme ceci:

• Exécutez une boucle externe jusqu'à ce que le programme soit terminé.
  • Exécutez une boucle interne sur les bits du diviseur, en les associant à des bits du dividende.
    • Si tous les bits du diviseur ont des bits de dividende correspondants, générez un seul bit.
    • Si tous les bits du diviseur n'ont pas des bits de dividende correspondants, indiquez le séparateur 0suivi de quels bits de dividende il y avait, puis terminez.

Le cœur du code est constitué par les relations entre les collectionneurs (les lettres majuscules). Comme il existe plusieurs collecteurs séparés avec chaque lettre, nous allons les appellent A1, A2, B1, B2, etc., au nombre de haut en bas.

• A1et A2maintenez le diviseur et le dividende, respectivement, au début de la boucle principale.
• La boucle interne se détache un par un du diviseur et du dividende.
  • Le reste du diviseur, s'il y en a, va toujours dans B1.
  • Si le diviseur et le dividende n'étaient pas vides, un bit entre C1et un dans C3. Le reste du dividende va dans B2.
  • Si seul le diviseur était non vide, nous aurons atteint la fin du dividende et il est temps d'imprimer le reste. Le bit du diviseur va dans C2.
  • Si seulement le dividende était non vide, nous avons atteint la fin du diviseur; il est temps de traiter les bits dans C3ou C2pour la sortie. Le reste du dividende va dans C4.
• S'il y a des bits dans les Bcollecteurs, ils retournent leur contenu aux Acollecteurs et continuent dans la boucle interne.
• Une fois que le Aet les Bcollecteurs sont tous vides, les Ccollecteurs s'ouvrent et nous passons à l'étape de traitement:
  • C1et C4vider leur contenu (le diviseur et le dividende restant, respectivement) dans D1et D3.
  • Si C2est vide, nous imprimons toujours le quotient.
    • Le contenu de C3monte en haut à droite du =commutateur. Le premier 1bit passe directement à !et est sorti.
    • Lorsque le 1bit passe, il active le commutateur pour pointer vers la droite, ce qui envoie tous les bits suivants de la carte.
  • Si C2n'est pas vide, nous imprimons le reste.
    • Le premier bit de C2est inversé 0et passé à travers le commutateur. La 0passe à !et est sortie.
    • Lorsque le 0bit passe à travers, il active le commutateur pour pointer vers la gauche. Maintenant, tous les bits de C3gauche à partir du commutateur et sont redirigés dans la !, la sortie entière restante.
    • Une copie du premier bit de C2est également envoyée dans D2.
• Maintenant les Dcollectionneurs s'ouvrent.
  • S'il y a quelque chose dedans D2, cela signifie que nous venons d'imprimer le reste. Le bit de D2frappe le @, qui termine le programme.
  • Sinon, le contenu de D1and D3loop back in A1et A2respectivement, et la boucle principale recommence.

brainfuck , 43 41 octets

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

Ceci utilise une version modifiée de mon algorithme de module destructif sur Esolangs .

Le programme lit deux octets - d et n , dans cet ordre - de STDIN et imprime deux octets - n% d et n / d , dans cet ordre - vers STDOUT. Cela nécessite un interprète fou avec une bande doublement infinie ou circulaire, comme celle sur TIO.

Essayez-le en ligne!

Comment ça marche

Avant le démarrage du programme, toutes les cellules contiennent la valeur 0 . Après avoir lu d dans STDIN ( ,), un pas vers la gauche ( <) et n dans STDIN ( ,), la bande se présente comme suit.

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

Ensuite, en supposant que n> 0 , nous entrons dans la boucle while

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

qui transforme la bande comme suit.

Tout d' abord, les >->+<progrès à la cellule C et décrémente, puis avances à la cellule D et incrémente, et enfin remonte à la cellule C . Ce qui se passe ensuite dépend de si la valeur de la cellule C est zéro ou non.

• Si la cellule C détiennent une valeur positive, [>](allez à droite alors que la cellule est non nul) avancera à la cellule E .

  >>>>+<<<avances à la cellule J pour incrémenter, puis retourne à la cellule F .

  Puisque la cellule F aura toujours 0 , la boucle while [<+>-]est entièrement ignorée, et <<remonte à la cellule D .

  Enfin, étant donné que ni D ni C détiennent 0 , [<](aller à gauche tandis que la cellule est non nul) rétrocédera à la cellule A .

• Si la cellule C contient 0 , la boucle [>]est entièrement ignorée; >>>>+<<<avances à cellules G pour incrémenter, puis retourne à la cellule D .

  À ce stade, D tiendra D (en fait, la somme des valeurs dans C et D sera toujours d ), ainsi [<+>-](si D est positif, incrémenter C et décrémenter D ) mettra C à d et D à 0 .

  Enfin, <<rétrocède à cellules B , [<](prendre à gauche tandis que la cellule est non nul) plus à gauche à la cellule A .

Dans les deux cas, >-avance vers la cellule B et la décrémente, et la boucle recommence à moins que cela ne la réinitialise.

Après k itérations, la bande se présente comme suit.

       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

Après n itérations, B est mis à zéro et nous sortons de la boucle. Les valeurs souhaitées ( n% d et n / d ) seront stockées dans les cellules D et G , afin de les >>.>>>.imprimer.

Fonction , 224 108 octets

Le nombre d'octets suppose le codage UTF-16 avec la nomenclature.

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

Essayez-le en ligne!

Ce qui précède définit une fonction fqui prend deux entiers et retourne à la fois leur division et leur produit (les fonctions de Funciton peuvent avoir plusieurs sorties tant que la somme des entrées et des sorties n’excède pas 4).

Utiliser deux valeurs d'entrée à des fins multiples est en fait assez simple: vous séparez simplement le connecteur avec une jonction en T à la valeur qui sera dupliquée le long des deux branches, que nous pourrons ensuite alimenter séparément les fonctions intégrées pour la division et le modulo.

En fait, il m'a fallu deux fois plus de temps pour comprendre comment afficher le résultat à l'utilisateur que pour simplement mettre en œuvre la solution.

En outre, Funciton a un divmod intégré et ÷%, de façon amusante, les éléments intégrés ÷et les utilisations %que ma solution utilise sont implémentés en termes de ÷% . Cependant, ma fonction fci-dessus n'est pas tout à fait identique à ÷%: j'ai dû permuter l'ordre des entrées et bien qu'il semble facile de changer cela, jusqu'à présent, je n'ai pas pu le faire sans augmenter le nombre d'octets. .

JavaScript (ES6), 17 octets

Merci à @Arnauld pour le golf d'un octet

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

Reçoit une entrée au format (x) (y)

Obtient le plancher de x / y en effectuant une opération au niveau du bit ou
Obtient le reste de x% y
Place les deux valeurs dans un tableau afin qu'elles puissent être renvoyées.

Essayez-le en ligne!

APL (Dyalog) , 5 octets

-2 octets grâce à @ngn

⌊÷,|⍨

Il s'agit d'un sommet d'une fourche (3 trains), où la dent droite du sommet est une fonction dérivée (le résultat d'un opérateur appliqué à une fonction):

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

⌊ étage de

÷ division

, catenated à

| reste de la division
⍨ avec arguments échangés (le module APL est "en arrière")

Essayez-le en ligne!

Brachylog , 6 octets

{÷|%}ᶠ

Essayez-le en ligne!

Explication

Nous abusons du métaprédicat ᶠ findallpour appliquer deux prédicats différents à la liste Input de deux arguments:

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

MATL , 12 à 10 octets

Qt:ie=&fhq

L'entrée est a, alors b. La sortie est le reste, puis le quotient.

Essayez-le en ligne!

Explication

Cela évite à la fois le modulo et la division. Au lieu de cela, il utilise un remodelage de tableau :

1. Construire un tableau d' a+1éléments non nuls.
2. Remodelez comme un tableau 2D de blignes. Cela compresse automatiquement avec des zéros si nécessaire.
3. Les indices de ligne et de colonne de la dernière entrée non nulle, moins 1, sont respectivement le reste et le quotient.

Considérons par exemple 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 18 octets

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

Abus mineur des règles de sortie flexibles: le résultat est donné sous la forme div[mod]qui ne sera pas évaluée. Les numéros individuels peuvent être extraits avec result[[0]]et result[[1]].

Et hé, il n’ya qu’un octet de plus que l’intégré ridiculement nommé QuotientRemainder.

Mathematica propose en fait une méthode simple pour appliquer plusieurs fonctions à la même entrée, mais sa longueur est de trois octets:

Through@*{Quotient,Mod}

05AB1E , 5 octets

÷²¹%‚

Essayez-le en ligne!

05AB1E a un bogue, donc les entrées implicites ne fonctionnent pas :( Emigna a noté que les entrées sont souvent inversées.

Méduse , 14 octets

p
m
,|S
% i
Ei

Essayez-le en ligne!

Explication

Jellyfish est un beau langage pour appliquer plusieurs fonctions à la même entrée. La langue est 2D et toutes les fonctions binaires sont orientées vers le sud pour une entrée et vers l’est pour une autre. Donc, en approchant une valeur de l'ouest et du nord, nous pouvons lui attribuer deux fonctions sans avoir à la dupliquer dans le code.

Les deux is du programme sont remplacés par les deux valeurs d’entrée au démarrage du programme. Maintenant %c'est la division. Il faut une entrée directement de l’Est, et quand on va au Sud, cela renvoie aussi la Erecherche vers l’Est. Donc, les deux entrées sont alimentées %en arguments.

| est la fonction intégrée pour modulo, qui fait fondamentalement la même chose, mais finit par regarder vers le sud pour les deux options de vente.

Nous concaténons les deux résultats en une paire avec ,. Vient ensuite mla fonction floor (dont nous avons besoin car il %s’agit d’une division en virgule flottante) et nous imprimons le résultat avec p.

Cubix , 12 à 13 octets

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

Quels mappages sur le cube suivant

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

Essayez-le ici

Explication avec les étapes exécutées
,I|I,- commence par une division d’entier superflue, récupère le premier entier de l’entrée, réfléchit en arrière et récupère le prochain entier de l’entrée, puis divise à nouveau
O;- Affiche le résultat de la division d’entier et le décompresse
%- effectue le mod. Cela pourrait être fait plus tard, mais fini ici
S\o- Ajouter un caractère d’espace à empiler, rediriger et sortir de l’espace
W;- Décaler vers la gauche et extraire l’espace de la pile
O|@- Afficher le mod calculé précédemment, passer à travers le réflecteur horizontal et s’arrêter.

Brain-Flak , 56 à 54 octets

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

Essayez-le en ligne!

-2 octets grâce à Wheat Wizard

Explication

La division entière la plus connue et le modulo actuels dans Brain-Flak sont très similaires (en fait, la division entière actuellement utilisée n’est qu’une modification que j’ai apportée au modulo de feersum ).

Modulo:   ({}(<>))<>     {   (({})){({}[()])<>}{} }{}<> ([{}()]{})
Division: ({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><  {}   {} >)

De manière pratique, le programme de division de nombres entiers utilise uniquement la troisième pile pour stocker des données, tandis que le programme modulo utilise uniquement les deux piles normales pour stocker des données. Ainsi, en les exécutant simplement en même temps, ils ne se heurtent pas.

Modulo:   ({}(<>))<>     {   (({})){({}[()])<>}{} }{}<> ([{}()]{})
Division: ({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><  {}   {} >)

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

Enfin, les programmes de division entière et modulo utilisés dans cette combinaison ont été conçus pour être propres (ne pas laisser de déchets sur les piles / ne pas dépendre de la (non) existence de valeurs sur les piles autres que leur entrée), mais cela n'est pas nécessaire. pour ce problème. Ainsi, nous pouvons économiser deux octets en ne prenant pas la peine de faire apparaître le zéro à la fin de la boucle principale et deux autres octets en n’appuyant pas sur zéro au début, mais en nous appuyant sur le remplissage à zéro situé au bas des piles.

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

Pour l'explication du programme de division entière, voir la réponse de Feersum

Explication de la division entière à venir ...

Java 8, 18 octets

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

C'est une expression lambda du type BiFunction<Integer, Integer, String>.

Je suis surpris ... c'est en fait une solution assez concise pour Java. Allez expressions lambda!

Brain-Flak , 168 148 110 octets

Je suppose que je devrais avoir vérifié le Wiki premier

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

Format:

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

Essayez-le en ligne!

(({})(<           # 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 octets

35 octets de code, +1 pour le -rdrapeau.

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

Prend les entrées unaires, séparées par des espaces, avec le nombre le plus petit en premier. Les sorties sont unaires, avec le quotient premier dans 1s et le reste second dans xs. (Si cela n’est pas acceptable, faites-le moi savoir et je le changerai en 1s séparés par des espaces, comme pour l’entrée).

Explication

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

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

Explication

L'entrée est dans la cellule A1et B1. Ceci retourne simplement les valeurs de retour de la fonction FLOORet MOD, qui sont utilisées pour la division du revêtement de sol et pour le reste. Ces valeurs sont séparées par une virgule.

Python 2 , 20 octets

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

Essayez-le en ligne!

Intégré, 6 octets

divmod

Essayez-le en ligne!

Gelée , 3 octets

:,%

Essayez-le en ligne!

OIL , 134 106 103 102 octets

Prend l'entrée de stdin, les deux nombres séparés par une nouvelle ligne. Renvoie le résultat de la division entière, puis une nouvelle ligne, puis le reste.

C’est l’un des programmes OIL les plus compliqués que j’ai jamais écrit, car OIL manque d’intégrations pour la division, le reste, l’addition, la soustraction, etc. Cela fonctionne avec la méthode primitive de division: la décrémentation imbriquée répétée.

Je présente le code dans un format annoté, avec des commentaires dans le style des langages de script. Avant de les exécuter, les commentaires doivent être supprimés.

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: Supprimez 3 octets supplémentaires en déplaçant une "constante" vers un emplacement à un chiffre (moins d'octets à référencer), puis en implicitant 2 emplacements nuls (en utilisant une ligne vide à la place. J'aurais pu le faire avant).

edit: Et un autre octet en rendant implicite le zéro initial. Nous n'avons vraiment besoin que d'un seul zéro littéral.

Rétine , 14 octets

Abusons les formats d'entrée / sortie!

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

Prend la saisie comme b\na, de manière unaire, en utilisant pour un chiffre unaire un caractère unique, sans chiffres ni nouvelles lignes. Affiche le quotient en décimal, immédiatement suivi du reste en unaire, en utilisant le même caractère que l’entrée.

Essayez-le en ligne!

(.*) ¶(\1)*correspond au premier numéro, puis une nouvelle ligne (¶ est le raccourci de Retina pour \ n), puis le premier numéro à nouveau autant de fois que possible. Le nombre de matchs du deuxième groupe sera le résultat de la division et la partie non appariée sera le reste.

Avec $#2, nous remplaçons tout ce qui a été mis en correspondance dans la ligne précédente par le nombre de captures du deuxième groupe et obtenons ensuite notre résultat.

ArnoldC , 286 283 octets

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

Essayez-le en ligne!

Comment ça marche

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

Format de sortie

a/b
a mod b

Labyrinthe , 11 octets

?:?:}/!\{%!

Essayez-le en ligne!

Explication

?:   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.

L'IP frappe ensuite une impasse, se retourne et le programme se termine en raison de la tentative de division par zéro lorsqu'il %est exécuté à nouveau.

C, 32 octets

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

Essayez-le en ligne!

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

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

Remarque

• Saisie à l'aide de l' -vindicateur, voir TIO pour un exemple.
• Cela affiche le reste en premier, puis une virgule et enfin la division entière.

Essayez-le en ligne!

Explication

Notez que la pile commence par A, B, où Aet Breprésente les première et deuxième entrées, à cause du -vdrapeau utilisé.

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

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

Une macro qui remplace f (a, b) par les 2 termes séparés par une virgule. Bien que vous fassiez mieux de le transmettre à une fonction ou sinon, il n'y a aucun moyen de séparer les 2.

Essayez-le en ligne

Haskell , 21 octets

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

Essayez-le en ligne! Exemple d'utilisation: 13#2return (6,1). Oui, c’est plutôt ennuyeux, mais légèrement plus intéressant que l’ divModintégration qui fonctionne de la même manière.

Pendant que nous y sommes, il y en a aussi quot, remet quotRemqui se comportent de la même manière que div, modet divMod. Cependant, pour les entrées négatives, le résultat de moda le même signe que le diviseur, alors que le résultat de rema le même signe que le dividende. Ou, comme il est indiqué dans la documentation Prelude , la quotdivision entière est tronquée vers zéro et la divdivision entière tronquée vers l'infini négatif.

Que diriez-vous de non divou de modbuild-ins?

Pas d'intégration, 36 32 31 octets

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

Essayez-le en ligne! Exemple d'utilisation: 13#2renvoie (1,6), le modrésultat est premier et le divrésultat deuxième. Si aest plus petit b, alors a mod best aet a div best 0, ainsi (a,0)est retourné. Sinon, calculer récursivement modet divde a-bet b, ajouter 1au résultat de la division et conserver le reste.

L'ajout de 1 au résultat de la division est obtenu en utilisant <$>, qui est couramment utilisé mappour mapper des fonctions sur des listes, mais fonctionne également sur des n-uplets; toutefois, la fonction est appliquée uniquement au deuxième élément du tuple.

Edit: Un octet enregistré grâce à xnor!

SWI Prolog, 109 octets

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

Sortie:

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

La description:

Algorithme récursif simple sans division intégrée ni modulo. Il compte simplement "combien de fois le deuxième nombre correspond-il au premier?" et rapporte le résultat (unifié à D) avec le reste (R).

// edit: espaces inutiles supprimés

Gol> <> , 11 octets

I:I:@$S,N%h

Interprète en ligne

MATL, 5 octets

/k&G\

Essayez-le sur MATL Online!

Explication

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

r.r.@/Inao\%n1(

Prend les nombres dans l'ordre inverse (par exemple 10 42). Essayez ici.

Explication

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