Division et reste


36

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

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


Puis-je inverser les arguments, c'est-à-dire au lieu de fournir a bfournir à la b aplace?
Erik l'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 Ouais, je n'étais pas sûr si l'inversion ne les rendait pas indiscernables.
Erik l'Outgolfer

@EriktheOutgolfer si vous savez qu'ils doivent être inversés, vous pouvez les distinguer sans problème :)
Leo

Malheureusement, l'algorithme BF ne fonctionne pas si le diviseur est 1.
mbomb007

Réponses:


23

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

Divmod s'exécutant dans BitCycle

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.

c'est génial
Evan Carslake

"Le programme prend des entrées unaires à partir de la ligne de commande": Cela me semble binaire?
therealfarfetchd

Oups. Parce que la sortie ressemblait à du binaire, j’ai pensé que l’entrée devrait l'être aussi. Puis j'ai lu le texte. Ça ne fait rien. : P
therealfarfetchd

15

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.


12

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


10

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!


10

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!


Comment as-tu créé ce diagramme sympa?
emiflake

2
@WolfgangTS Soigneusement. Dyalog APL permet de créer des arborescences de base de fonctions tacites. Essayez-le en ligne! J'ai commencé avec ça ...
Adám

Aïe, a l'air très difficile. J'ai bien peur que je n'aie pas la patience, haha
emiflake

plus court:⌊÷,|⍨
ngn

@ngn Aïe, tu m'as eu. Heureux de voir que tu es toujours là.
Adám

7

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

7

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]

2
C'est un bel exemple de pensée latérale, beau travail!
Leo

6

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}

1
Vous savez que c'est mauvais lorsque votre langue crée des fonctions intégrées qui les combinent simplement…
Fatalize

1
@ Fatalize Est-ce? Je trouve que les fonctions intégrées de divmod sont très utiles et Mathematica n'est de loin pas la seule langue à en avoir.
Martin Ender

8
@Fatalize, le calcul du quotient est aussi important que celui nécessaire pour calculer les restes. Si les deux résultats doivent être utilisés, une architecture quotRemintégrée correctement conçue peut vous faire gagner un temps considérable sur les appels quotet remséparément.
Julian Wolf

6

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.


Vous pouvez faire ÷ ²¹%) pour 5 octets.
Emigna

@ Emigna Je ne sais pas si c'est valide cependant. Attends, comment ça a marché?
Erik the Outgolfer

1
Je ne vois pas pourquoi cela ne serait pas valide. Cela fonctionne parce que les entrées implicites sont placées dans la pile dans l'ordre inverse de ce que vous supposeriez dans de tels cas.
Emigna

@ Emigna, j'ai demandé à OP si je pouvais inverser les arguments.
Erik the Outgolfer

2
Je suppose You may choose any format you like for both input and output, as long as the two numbers are clearly distinguishableque cela signifie que vous pouvez décider que les entrées sont prises telles quelles divisor, dividend. Vous pouvez simplement spécifier "Les entrées sont considérées comme divisor, dividend" dans la réponse et elles seront clairement distinguables :)
Emigna

6

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.


6

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.


Battez-moi de deux minutes. Bonne réponse!
Luc

@Luke Merci, pensais que je pouvais en obtenir un autre, mais que je ne
réussissais pas

6

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

Comparaison de la division modulo et entière:
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.

Combinaison de la division modulo et entière:
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.

Cela nous donne le programme final:
({}<>)<>([()]{()<(({})){({}[()])<>}{}>}<><([{}()]{})>)

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

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


5

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!


5

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


5

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

5

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.


Je pense que vous globulaire moyen A1 et B1 pas A1 et A2
fənɛtɪk

Oui merci. Réparé maintenant
Luke

Économisez 1 octet avec FLOOR(A1/B1;1)au lieu deQUOTIENT(A1;B1)
Ingénieur Toast

Comme l'entrée est toujours un nombre naturel, je pense que vous pouvez remplacer FLOOR(A1/B1;1)par «INT (A1 / B1)» pour économiser 4 octets supplémentaires
Wernisch



4

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.


Bon travail! C'est exactement le genre de réponse que j'espérais recevoir avec ce défi :) Juste une remarque: vous avez la garantie que le diviseur sera toujours strictement positif, vous n'avez donc pas besoin de vérifier la division par 0;)
Leo

@Leo Je suis assuré que le diviseur sera toujours strictement positif au début . Cela ne fonctionnera pas si je retire la division par zéro, ce cas peut se produire même lorsque la division "réelle" est normale. Si je me souviens bien, cela se produit lorsque le reste est égal à zéro.
L3viathan

Je parle de la vérification de la ligne 4, pas de celle de la ligne 12 ... Ne s’exécute-t-elle qu’une fois au début du programme?
Leo

@Leo Done, presque 30 caractères de moins, merci!
L3viathan

4

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.


Haha, c'est vrai, je ne devrais clairement pas écrire de programmes aussi tard dans la soirée.
FryAmTheEggman

4

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

3

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.



3

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

Comment pouvez-vous fournir des valeurs d'entrée allant jusqu'à 255?
Leo

Utilisez simplement des valeurs ASCII / Unicode plus élevées. De cette façon, įdevient 255.
Luke

Ok, gentil :) Au fait, ne serait-il pas plus court de prendre les numéros d'entrée directement en ligne de commande avec le drapeau -v?
Leo

Ce serait le cas, mais je ne pouvais pas obtenir cela pour TIO, alors je me suis installé avec cette solution. Cela économiserait 8 octets - 1 (pour le -vdrapeau).
Luc


3

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


3

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!


2
Votre deuxième solution peut raser un octet en utilisant <$>sur une ligne à agir sur son deuxième élément: a#b|a<b=(a,0)|m<-a-b=(+1)<$>m#b.
Xnor

3

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


Bienvenue chez PPCG! Je n'ai jamais utilisé Prolog auparavant, mais j'ai remarqué qu'il y avait des espaces autour :-de la dernière ligne mais pas sur les autres. Sont-ils requis pour une raison quelconque? La même chose vaut pour E + 1tout F-Ssuggèrent qu'il n'y a pas de places nécessaires.
Laikoni

Laikoni: Vous avez certainement raison! Je viens de supprimer les espaces et mis à jour le nombre d'octets final.
Jan Drozen


2

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

2

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
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.