Este desafío, aunque probablemente trivial en la mayoría de los idiomas "estándar", se dirige a aquellos idiomas que son tan esotéricos, de bajo nivel y / o difíciles de usar que rara vez se ven en este sitio. Debería proporcionar un problema interesante para resolver, ¡así que esta es tu ocasión de probar ese lenguaje extraño sobre el que has leído!

La tarea

Tome dos números naturales ay bcomo entrada, y genere otros dos números: el resultado de la división entera a/by el resto de dicha división ( a%b).

Este es el código de golf : ¡la respuesta más corta (en bytes), para cada idioma, gana!

De entrada y salida

• 0 <= a<= 255, 1 <= b<= 255. Cada una de sus entradas (y también las salidas) cabrá en un solo byte.
• Puede elegir cualquier formato que desee para entrada y salida, siempre que los dos números sean claramente distinguibles (por ejemplo, no imprimir los dos resultados juntos sin un delimitador)

Ejemplos

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

Nota: Las construcciones que devuelven tanto el resultado de la división como el resto están prohibidas . Al menos muéstranos cómo tu lenguaje trata de aplicar dos funciones a los mismos argumentos.

Nota 2: Como siempre, una explicación de cómo funciona su código es muy bienvenida, incluso si le parece legible, ¡puede que no lo sea para otra persona!

Tabla de clasificación

Aquí hay un fragmento de pila para generar una descripción general de los ganadores por idioma.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

Acabo de darme cuenta de que una sección completa de mi código original era innecesaria. Enorme reducción!

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

El programa toma la entrada en unario desde la línea de comando, con el divisor primero. Produce el cociente y el resto en unario, separados por a 0. Por ejemplo, aquí está a=11, b=4, a/b=2, a%b=3:

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

Ungolfed, en acción

Aquí está mi computación de versión sin golf a=3, b=5con la animación activada (perdón por la falla):

Intentar una explicación

La explicación se aplica a la versión sin golf. Antes de abordarlo, le recomiendo que lea la página de Esolangs para tener una idea de cómo funciona el lenguaje.

El algoritmo es así:

• Ejecute un bucle externo hasta que finalice el programa.
  • Ejecute un bucle interno sobre los bits del divisor, emparejándolos con los bits del dividendo.
    • Si todos los bits del divisor tienen bits de dividendo coincidentes, genera un solo bit.
    • Si no todos los bits del divisor tienen bits de dividendo coincidentes, envíe el separador 0seguido de los bits de dividendo que haya, luego termine.

El corazón del código son las relaciones entre los coleccionistas (las letras mayúsculas). Puesto que hay múltiples colectores separados con cada letra, vamos a refieren a ellos como A1, A2, B1, B2, etc, la numeración de arriba a abajo.

• A1y A2mantenga el divisor y el dividendo, respectivamente, al comienzo del ciclo principal.
• El bucle interno se despega un bit a la vez desde el divisor y el dividendo.
  • El resto del divisor, si lo hay, siempre entra B1.
  • Si tanto el divisor como el dividendo no estaban vacíos, un bit entra C1y otro dentro C3. El resto del dividendo entra B2.
  • Si solo el divisor no estaba vacío, hemos llegado al final del dividendo, y es hora de imprimir el resto. Entra el bit del divisor C2.
  • Si solo el dividendo no fuera vacío, hemos llegado al final del divisor; Es hora de procesar los bits en C3o C2para la salida. El resto del dividendo entra C4.
• Si hay algún bit en los Brecopiladores, vuelven a colocar su contenido en los Arecopiladores y continúan en el bucle interno.
• Una vez que los colectores Ay Bestán vacíos, los Ccolectores se abren y pasamos a la etapa de procesamiento:
  • C1y C4volcar sus contenidos (el divisor y el dividendo restante, respectivamente) en D1y D3.
  • Si C2está vacío, todavía estamos imprimiendo el cociente.
    • El contenido de C3ir al =interruptor superior derecho . El primer 1bit pasa directamente a !y sale.
    • Cuando el 1bit pasa, activa el interruptor para apuntar hacia la derecha, lo que envía todos los bits posteriores fuera del tablero.
  • Si C2no está vacío, estamos imprimiendo el resto.
    • El primer bit de C2se niega a ay se 0pasa por el interruptor. El 0continúa !y sale.
    • Cuando la 0broca pasa, activa el interruptor para apuntar hacia la izquierda. Ahora todos los bits C3van hacia la izquierda desde el conmutador y se redirigen al interior !, generando todo el resto.
    • C2También se envía una copia del primer bit de D2.
• Ahora los Dcoleccionistas abren.
  • Si hay algo adentro D2, eso significa que acabamos de imprimir el resto. El bit de D2golpea el @, que termina el programa.
  • De lo contrario, el contenido D1y el D3bucle vuelven a A1y A2respectivamente, y el bucle principal comienza de nuevo.

brainfuck , 43 41 bytes

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

Esto usa una versión modificada de mi algoritmo de módulo destructivo en Esolangs .

El programa lee dos bytes - d y n , en ese orden - desde STDIN e imprime dos bytes - n% d y n / d , en ese orden - en STDOUT. Requiere un intérprete de mierda con una cinta doblemente infinita o circular, como la de TIO.

Pruébalo en línea!

Cómo funciona

Antes de que comience el programa, todas las celdas tienen el valor 0 . Después de leer d desde STDIN ( ,), moverse un paso hacia la izquierda ( <) y leer n desde STDIN ( ,), la cinta tiene el siguiente aspecto.

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

Luego, suponiendo que n> 0 , ingresamos el ciclo while

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

que transforma la cinta de la siguiente manera.

En primer lugar, >->+<los avances a célula C y decrementos, a continuación, avanza a la celda D y los incrementos, y finalmente se remonta a la celda C . Lo que sucede a continuación depende de si el valor de la celda C es cero o no.

• Si la celda C mantenga un valor positivo, [>](ir a la derecha, mientras que la célula no es cero) avanzarán a la celda E .

  >>>>+<<<avances a célula J para incrementar, a continuación, se remonta a la célula F .

  Desde célula F siempre tendrá 0 , el bucle while [<+>-]se omite por completo, y <<se remonta a la celda D .

  Por último, ya que ni D ni C tienen 0 , [<](ir a la izquierda mientras que la célula no es cero) se retroceder a la celda A .

• Si la celda C contiene 0 , el bucle [>]se omite por completo; >>>>+<<<avances a célula G para incrementar, a continuación, vuelve a la celda D .

  En este punto, D mantendrá d (de hecho, la suma de los valores en C y D siempre será d ), por lo que [<+>-](mientras D es positivo, el incremento C y la disminución D ) establecerá C en d y D en 0 .

  Finalmente, <<retrocede a célula B , [<](vaya a la izquierda mientras que la célula no es cero) más a la izquierda a la celda A .

En ambos casos, >-avanza a la celda B y la disminuye, y el ciclo comienza de nuevo a menos que esto lo ponga a cero.

Después de k iteraciones, la cinta se ve de la siguiente manera.

       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

Después de n iteraciones, B se pone a cero y salimos del ciclo. Los valores deseados ( n% d y n / d ) se almacenarán en las celdas D y G , por lo que los >>.>>>.imprime.

Funciton , 224 108 bytes

El recuento de bytes supone la codificación UTF-16 con BOM.

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

Pruébalo en línea!

Lo anterior define una función f, que toma dos enteros y devuelve tanto su división como su producto (las funciones en Funciton pueden tener múltiples salidas siempre que la suma de entradas y salidas no exceda de 4).

El uso de dos valores de entrada para múltiples propósitos es realmente bastante trivial: simplemente separa el conector con una unión en T en el valor se duplicará a lo largo de ambas ramas, que luego podemos alimentar por separado a los elementos integrados para la división y el módulo.

En realidad, me llevó el doble de tiempo descubrir cómo mostrar el resultado al usuario que simplemente implementar la solución.

Además, Funciton tiene un divmod incorporado y ÷%, de manera divertida, los incorporados ÷y %los usos de mi solución se implementan en términos de ÷% . Sin embargo, mi función fanterior no es idéntica a ÷%: tuve que cambiar el orden de las entradas y, aunque parece que debería ser fácil cambiar eso, hasta ahora no he podido hacerlo sin aumentar el recuento de bytes .

JavaScript (ES6), 17 bytes

Gracias a @Arnauld por jugar golf en un byte

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

Recibe entrada en formato (x) (y)

Obtiene el piso de x / y realizando bit a bit o
Obtiene el resto en x% y
Coloca ambos valores en una matriz para que ambos puedan devolverse

Pruébalo en línea!

APL (Dyalog) , 5 bytes

-2 bytes gracias a @ngn

⌊÷,|⍨

Este es un tope (2 trenes) de una horquilla (3 trenes), donde el diente derecho del tope es una función derivada (el resultado de un operador aplicado a una función):

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

⌊ piso de

÷ división

, cateado a

| resto de división
⍨ con argumentos intercambiados (el módulo APL está "al revés")

Pruébalo en línea!

Brachylog , 6 bytes

{÷|%}ᶠ

Pruébalo en línea!

Explicación

Abusamos del metapredicado ᶠ findallpara aplicar dos predicados diferentes a la lista de entrada de dos argumentos:

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

MATL , 12 10 bytes

Qt:ie=&fhq

La entrada es a, entonces b. La salida es resto, luego cociente.

Pruébalo en línea!

Explicación

Esto evita tanto el módulo como la división. En su lugar, utiliza la remodelación de la matriz :

1. Construya una matriz de a+1elementos distintos de cero.
2. Reformar como una matriz 2D de bfilas. Esto se rellena automáticamente con ceros si es necesario.
3. Los índices de fila y columna de la última entrada distinta de cero, menos 1, son respectivamente el resto y el cociente.

Consideremos, por ejemplo 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 bytes

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

Abuso menor de las reglas de salida flexible: el resultado se da como div[mod], que permanecerá sin evaluar. Los números individuales se pueden extraer con result[[0]]y result[[1]].

Y oye, es solo un byte más largo que el ridículamente incorporado QuotientRemainder.

Mathematica, en realidad tiene una forma ordenada de aplicar múltiples funciones a la misma entrada, pero es tres bytes más largo:

Through@*{Quotient,Mod}

05AB1E , 5 bytes

÷²¹%‚

Pruébalo en línea!

05AB1E tiene un error, por lo que la entrada implícita no funciona :( Emigna observó que las entradas a menudo se envían en reversa.

Medusa , 14 bytes

p
m
,|S
% i
Ei

Pruébalo en línea!

Explicación

Jellyfish es un lenguaje hermoso cuando se trata de aplicar múltiples funciones a la misma entrada. El lenguaje es 2D y todas las funciones binarias miran al sur para una entrada y al este para otra. Entonces, al acercarnos a un valor desde el oeste y desde el norte, podemos alimentarlo a dos funciones sin tener que duplicarlo en el código.

Los dos is en el programa se reemplazan con los dos valores de entrada cuando se inicia el programa. Ahora %es división. Toma una entrada directamente desde el este, y cuando va hacia el sur, golpea el Eque redirige esa búsqueda también hacia el este. Entonces ambas entradas se alimentan %como argumentos.

| es el módulo incorporado, que básicamente hace lo mismo, pero termina mirando hacia el sur para ambos en puestos.

Concatenamos ambos resultados en un par con ,. Luego mestá la función de piso (que necesitamos porque %es una división de punto flotante) y finalmente imprimimos el resultado con p.

Cubix , 12 13 bytes

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

Que se asigna al siguiente cubo

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

Pruébalo aquí

Explicación con los pasos ejecutados
,I|I,: comienza con una división de enteros superfluo, obtiene el primer entero de la entrada, refleja y obtiene el siguiente entero de la entrada, luego divide de nuevo
O;: genera el resultado de la división de enteros y explótala
%: haz el mod. Esto podría hacerse más tarde, pero terminó aquí
S\o: agregue un carácter de espacio a la pila, redirija hacia arriba y emita espacio
W;. Desplácese hacia la izquierda y saque el espacio de la pila
O|@. Genere el mod previamente calculado, pase a través del reflector horizontal y deténgase.

Brain-Flak , 56 54 bytes

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

Pruébalo en línea!

-2 bytes gracias a Wheat Wizard

Explicación

La división de enteros y el módulo más conocidos actuales en Brain-Flak son muy similares (de hecho, la división de enteros utilizada actualmente es solo una modificación que hice en el módulo de feersum ).

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

Convenientemente, el programa de división entera usa solo la tercera pila para almacenar datos, mientras que el programa de módulo usa solo las dos pilas normales para almacenar datos. Por lo tanto, simplemente ejecutándolos a ambos al mismo tiempo, no chocan entre sí.

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

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

Finalmente, tanto la división de enteros como los programas de módulo utilizados en esta combinación fueron diseñados para ser apilados (no dejar basura en las pilas / no depender de la (no) existencia de valores en las pilas que no sean su entrada) pero eso no es necesario por este problema Por lo tanto, podemos ahorrar dos bytes al no molestarnos en hacer estallar el cero al final del bucle principal y otros dos bytes al no presionar cero al comienzo, sino que confiamos en el relleno de cero en la parte inferior de las pilas.

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

Para la explicación del programa de división entera, vea la respuesta de feersum

Explicación de la división entera próximamente ...

Java 8, 18 bytes

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

Esta es una expresión lambda del tipo BiFunction<Integer, Integer, String>.

Estoy sorprendido ... esta es en realidad una solución bastante concisa para Java. ¡Van las expresiones lambda!

Brain-Flak , 168148110 bytes

Supongo que debería haber consultado primero el Wiki

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

Formato:

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

Pruébalo en línea!

(({})(<           # 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 bytes de código, +1 para la -rbandera.

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

Toma datos en unario, separados por espacios, con el número más pequeño primero. Salidas como unarias, con el cociente primero en 1sy el resto segundo en xs. (Si esto no es aceptable, avíseme y lo cambiaré a 1s separados por espacios como la entrada).

Explicación

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

Explicación

La entrada está en la celda A1y B1. Esto simplemente devuelve los valores de retorno de la función FLOORy MOD, que son para pavimentar la división y para el resto. Estos valores están separados por una coma.

Python 2 , 20 bytes

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

Pruébalo en línea!

Incorporado, 6 bytes

divmod

Pruébalo en línea!

Jalea , 3 bytes

:,%

Pruébalo en línea!

ACEITE , 134 106 103 102 bytes

Toma la entrada de stdin, los dos números separados por una nueva línea. Emite el resultado de la división entera, luego una nueva línea y luego el resto.

Este es uno de los programas OIL más complicados que he escrito, ya que OIL carece de funciones integradas para la división, el resto, la suma, la resta, etc. Funciona con la forma primitiva de hacer la división: decremento anidado repetido.

Presento el código en un formato anotado, con comentarios al estilo de los lenguajes de secuencias de comandos. Antes de ejecutar, los comentarios deben eliminarse.

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)

editar: recorté 3 bytes más moviendo una "constante" a una ubicación de un dígito (menos bytes para referencia), y luego implícitamente 2 ubicaciones cero (usando una línea vacía en su lugar. Una de ellas podría haberlo hecho antes de).

editar: Y otro byte haciendo implícito el cero inicial. Realmente solo necesitamos un único cero literal.

Retina , 14 bytes

¡Abusemos de los formatos de entrada / salida!

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

Toma la entrada como b\na, en unario, utilizando para un dígito unario cualquier carácter que no sea un dígito ni una nueva línea. Emite el cociente en decimal, seguido inmediatamente por el resto en unario, utilizando el mismo carácter que la entrada.

Pruébalo en línea!

(.*) ¶(\1)*coincide con el primer número, luego una nueva línea (¶ es la abreviatura de Retina para \ n), luego el primer número nuevamente tantas veces como sea posible. El número de partidos del segundo grupo será el resultado de la división, y la parte no igualada será el resto.

Con $#2, reemplazamos todo lo que coincidió en la línea anterior con el número de capturas del segundo grupo, y obtenemos nuestro resultado.

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

Pruébalo en línea!

Cómo funciona

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

Formato de salida

a/b
a mod b

Laberinto , 11 bytes

?:?:}/!\{%!

Pruébalo en línea!

Explicación

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

Luego, la IP llega a un punto muerto, se da vuelta y el programa termina debido al intento de división por cero cuando %se ejecuta nuevamente.

C, 32 bytes

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

Pruébalo en línea!

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

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

Nota

• Ingrese usando la -vbandera, vea TIO para un ejemplo.
• Esto genera el resto primero, luego una coma y, por último, la división entera.

Pruébalo en línea!

Explicación

Tenga en cuenta que la pila comienza como A, B, donde Ay Brepresenta la primera y segunda entrada, debido a la -vbandera utilizada.

: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

Una macro que reemplaza f (a, b) con los 2 términos separados por comas. Aunque es mejor que lo pases a una función o de lo contrario no hay forma de separar los 2.

Pruébalo en línea

Haskell , 21 bytes

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

Pruébalo en línea!Ejemplo de uso: 13#2devoluciones (6,1). Sí, esto es bastante aburrido, aunque un poco más interesante que el divModincorporado que funciona igual.

Mientras estamos en eso, también hay quot, remy quotRemque se comportan de la misma manera en números naturales que div, mody divMod. Sin embargo, para entradas negativas, el resultado de modtiene el mismo signo que el divisor, mientras que el resultado de remtiene el mismo signo que el dividendo. O, como se incluye en la documentación del Preludio , quotes la división entera truncada hacia cero y divla división entera truncada hacia el infinito negativo.

¿Qué tal no? div o modincorporados?

Sin complementos, 36 32 31 bytes

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

Pruébalo en línea! Ejemplo de uso: 13#2devuelve (1,6), es decir, el modresultado es primero y el divresultado segundo. Si aes más pequeño b, entonces a mod bes ay a div bes 0, entonces (a,0)se devuelve. De lo contrario, recursivamente calcular mody divdea-b y b, suma 1al resultado de la división y conserva el resto.

Agregar 1 al resultado de la división se logra usando <$> , que se usa comúnmente mappara asignar funciones sobre listas, pero también funciona en tuplas, sin embargo, la función se aplica solo al segundo elemento de tupla.

Editar: ¡Guardado un byte gracias a xnor!

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

Salida:

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

Descripción:

Algoritmo recursivo simple sin división o módulo integrado. Simplemente cuenta "¿cuántas veces cabe el segundo número en el primero?" e informa el resultado (unificado a D) con el resto (R).

// edit: elimina espacios innecesarios

Gol> <> , 11 bytes

I:I:@$S,N%h

Intérprete en línea

MATL, 5 bytes

/k&G\

¡Pruébalo en MATL Online!

Explicación

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

Toma los números en orden inverso (p 10 42. Ej .). Pruébalo aquí

Explicación

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