Esse desafio, embora provavelmente trivial na maioria dos idiomas "padrão", é direcionado aos idiomas que são tão esotéricos, de baixo nível e / ou difíceis de usar que raramente são vistos neste site. Ele deve fornecer um problema interessante a ser resolvido, portanto, é a sua ocasião para experimentar a linguagem estranha sobre a qual você leu!

A tarefa

Tome dois números naturais ae, bcomo entrada, e produz dois outros números: o resultado da divisão inteira a/be o restante dessa divisão ( a%b).

Este é o código-golfe : a resposta mais curta (em bytes), para cada idioma, vence!

Entrada / Saída

• 0 <= a<= 255, 1 <= b<= 255. Cada uma de suas entradas (e saídas também) caberá em um único byte.
• Você pode escolher qualquer formato que desejar para entrada e saída, desde que os dois números sejam claramente distinguíveis (por exemplo, sem imprimir os dois resultados juntos sem um delimitador)

Exemplos

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

Nota: Builtins que retornam o resultado da divisão e o restante são proibidos . Pelo menos, mostre-nos como seu idioma lida com a aplicação de duas funções nos mesmos argumentos.

Nota 2: Como sempre, uma explicação de como seu código funciona é muito bem-vinda, mesmo que pareça legível para você, pode não ser o mesmo para outra pessoa!

Entre os melhores

Aqui está um snippet de pilha para gerar uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet da tabela de classificação:

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

Acabei de perceber que uma seção inteira do meu código original era desnecessária. Enorme redução!

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

O programa recebe a entrada unária na linha de comando, com o divisor primeiro. Ele gera o quociente e o restante em unário, separados por a 0. Por exemplo, aqui está a=11, b=4, a/b=2, a%b=3:

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

Ungolfed, em ação

Aqui está a minha versão não destruída da computação a=3, b=5com a animação ativada (desculpe pela falha):

Tentativa de explicação

A explicação se aplica à versão não destruída. Antes de resolver, recomendo que você leia a página da Esolangs para ter uma ideia de como o idioma funciona.

O algoritmo é assim:

• Execute um loop externo até o programa terminar.
  • Execute um loop interno sobre os bits do divisor, combinando-os com os bits do dividendo.
    • Se todos os bits do divisor tiverem bits de dividendo correspondentes, produza um único bit.
    • Se nem todos os bits do divisor tiverem bits de dividendo correspondentes, produza o separador 0seguido pelos bits de dividendo que existem e termine.

O coração do código são os relacionamentos entre os coletores (as letras maiúsculas). Uma vez que existem vários coletores separados com cada letra, vamos referir a eles como A1, A2, B1, B2, etc., numeração de cima para baixo.

• A1e A2segure o divisor e o dividendo, respectivamente, no início do loop principal.
• O loop interno se desprende um pouco de cada vez do divisor e do dividendo.
  • O restante do divisor, se houver, sempre entra B1.
  • Se o divisor e o dividendo não forem vazios, um bit entra C1e outro entra C3. O restante do dividendo entra em vigor B2.
  • Se apenas o divisor não fosse vazio, chegamos ao final do dividendo e é hora de imprimir o restante. A parte do divisor entra C2.
  • Se apenas o dividendo não fosse vazio, chegamos ao final do divisor; é hora de processar os bits na saída C3ou C2na saída. O restante do dividendo entra em vigor C4.
• Se houver algum bit nos Bcoletores, eles retornam seu conteúdo para os Acoletores e continuam no loop interno.
• Quando os coletores Ae Bestão todos vazios, os Ccoletores são abertos e prosseguimos para o estágio de processamento:
  • C1e C4despejar seu conteúdo (o divisor e o dividendo restante, respectivamente) em D1e D3.
  • Se C2estiver vazio, ainda estamos imprimindo o quociente.
    • O conteúdo de C3sobe para o =interruptor superior direito . O primeiro 1bit passa direto para !e é emitido.
    • Quando o 1bit passa, ele ativa o interruptor para apontar para a direita, o que envia todos os bits subsequentes para fora do quadro.
  • Se C2não estiver vazio, estamos imprimindo o restante.
    • O primeiro bit de C2é negado para a 0e passado pelo comutador. O 0prossegue !e está de saída.
    • Quando o 0bit passa, ele ativa o interruptor para apontar para a esquerda. Agora, todos os bits C3vão para a esquerda do comutador e são redirecionados para o !, gerando o restante inteiro.
    • Uma cópia do primeiro bit de C2também é enviada para D2.
• Agora os Dcolecionadores abrem.
  • Se houver alguma coisa D2, significa que acabamos de imprimir o restante. O bit de D2atinge o @, que finaliza o programa.
  • Caso contrário, o conteúdo de D1e D3retornará para A1e A2respectivamente, e o loop principal será reiniciado.

brainfuck , 43 41 bytes

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

Isso usa uma versão modificada do meu algoritmo de módulo destrutivo em Esolangs .

O programa lê dois bytes - d e n , nessa ordem - de STDIN e imprime dois bytes - n% d e n / d , nessa ordem - para STDOUT. Exige um intérprete com uma fita duplamente infinita ou circular, como a do TIO.

Experimente online!

Como funciona

Antes do programa iniciar, todas as células mantêm o valor 0 . Depois de ler d de STDIN ( ,), mover um passo para a esquerda ( <) e ler n de STDIN ( ,), a fita é a seguinte.

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

A seguir, assumindo que n> 0 , inserimos o loop while

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

que transforma a fita da seguinte maneira.

Em primeiro lugar, >->+<os avanços para a célula C e diminui-la, então avança para a célula D e incrementos lo e, finalmente, passa de volta para a célula C . O que acontece a seguir depende se o valor da célula C é zero ou não.

• Se a célula C manter um valor positivo, [>](ir para a direita enquanto a célula é diferente de zero) vai avançar para celular E .

  >>>>+<<<avanços a célula J para incrementar que, em seguida, volta para a célula F .

  Desde célula F terá sempre 0 , o loop while [<+>-]é ignorada inteiramente, e <<remonta a célula D .

  Finalmente, uma vez que nem D nem C segurar 0 , [<](ir para a esquerda enquanto a célula é diferente de zero) irá retroceder para celular A .

• Se a célula C contiver 0 , o loop [>]será ignorado completamente; >>>>+<<<avanços para células L para incrementar que, em seguida, volta para a célula D .

  Nesse ponto, D manterá d (na verdade, a soma dos valores em C e D sempre será d ), portanto [<+>-](enquanto D for positivo, o incremento C e o decremento D ) definirão C como d e D como 0 .

  Finalmente, <<retrocede para a célula B , [<](ir para a esquerda enquanto que a célula é diferente de zero) mais esquerda para a célula A .

Nos dois casos, >-avança para a célula B e a diminui, e o loop recomeça, a menos que isso seja zerado.

Após k iterações, a fita fica da seguinte maneira.

       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

Após n iterações, B é zerado e saímos do loop. Os valores desejados ( n% d e n / d ) serão armazenados nas células D e G , para >>.>>>.imprimi-los.

Funciton , 224 108 bytes

A contagem de bytes assume a codificação UTF-16 com BOM.

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

Experimente online!

O acima define uma função f item que aceita dois números inteiros e retorna sua divisão e seu produto (as funções no Funciton podem ter várias saídas, desde que a soma de entradas e saídas não exceda 4).

O uso de dois valores de entrada para vários propósitos é realmente bastante trivial: você simplesmente separa o conector com uma junção T, pois o valor será duplicado nos dois ramos, e então podemos alimentar separadamente os componentes internos para divisão e módulo.

Na verdade, levei o dobro do tempo para descobrir como exibir o resultado para o usuário do que apenas implementar a solução.

Além disso, o Funciton possui um divmod interno e ÷%, de maneira divertida, os embutidos ÷e %que minha solução usa são implementados em termos de ÷% . No entanto, minha função facima não é idêntica a ÷%: tive que trocar a ordem das entradas e, embora pareça fácil mudar isso, até agora não consegui fazer isso sem aumentar a contagem de bytes .

JavaScript (ES6), 17 bytes

Obrigado a @Arnauld por jogar um byte

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

Recebe entrada no formato (x) (y)

Obtém o piso de x / y executando bit a bit ou
Obtém o restante em x% y
Coloca os dois valores em uma matriz para que ambos possam ser retornados

Experimente online!

APL (Dyalog) , 5 bytes

-2 bytes graças a @ngn

⌊÷,|⍨

Este é o topo (2 trens) de uma bifurcação (3 trens), em que o dente direito do topo é uma função derivada (o resultado de um operador aplicado a uma função):

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

⌊ andar de

÷ divisão

, catenado para

| restante divisão
⍨  com argumentos trocados (o módulo APL é "reverso")

Experimente online!

Braquilog , 6 bytes

{÷|%}ᶠ

Experimente online!

Explicação

Abusamos o metapredicado ᶠ findallpara aplicar dois predicados diferentes à lista de entrada de dois argumentos:

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

MATL , 12 10 bytes

Qt:ie=&fhq

A entrada é a, então b. A saída é restante, depois quociente.

Experimente online!

Explicação

Isso evita o módulo e a divisão. Em vez disso, usa a remodelagem da matriz :

1. Crie uma matriz de a+1elementos diferentes de zero.
2. Remodelar como uma matriz 2D de blinhas. Isso é preenchido automaticamente com zeros, se necessário.
3. Os índices de linha e coluna da última entrada diferente de zero, menos 1 , são respectivamente o restante e o quociente.

Considere, por exemplo 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 das regras de saída flexíveis: o resultado é dado como div[mod], o qual permanecerá sem avaliação. Os números individuais podem ser extraídos com result[[0]]e result[[1]].

E ei, é apenas um byte a mais do que o ridiculamente nomeado embutido QuotientRemainder.

O Mathematica, na verdade, tem uma maneira elegante de aplicar várias funções à mesma entrada, mas possui três bytes a mais:

Through@*{Quotient,Mod}

05AB1E , 5 bytes

÷²¹%‚

Experimente online!

05AB1E tem um erro, portanto, entradas implícitas não funcionam :( Emigna observou que as entradas são frequentemente pressionadas ao contrário.

Água-viva , 14 bytes

p
m
,|S
% i
Ei

Experimente online!

Explicação

A água-viva é uma linguagem bonita quando se trata de aplicar várias funções à mesma entrada. A linguagem é 2D e todas as funções binárias olham para o sul para uma entrada e para o leste para outra. Portanto, ao abordar um valor do oeste e do norte, podemos alimentá-lo com duas funções sem precisar duplicá-lo no código.

Os dois is no programa são substituídos pelos dois valores de entrada quando o programa é iniciado. Agora %é divisão. Ele pega uma entrada diretamente do leste e, ao ir para o sul, atinge a Eque redireciona essa pesquisa também para o leste. Então, ambas as entradas são alimentadas para% como argumentos.

| é o módulo embutido para o módulo, que basicamente faz a mesma coisa, mas acaba olhando para o sul para ambos os putos.

Concatenamos ambos os resultados em um par com ,. Então mé a função floor (que precisamos porque %é a divisão de ponto flutuante) e, finalmente, imprimimos o resultado p.

Cubix , 12 13 bytes

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

Que mapeia para o cubo a seguir

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

Experimente aqui

Explicação com as etapas executadas
,I|I,- começa com uma divisão de número supérfluo, obtém o primeiro número inteiro da entrada, reflete de volta e obtém o próximo número inteiro da entrada e depois divide novamente
O;- Saída do resultado da divisão do número inteiro e pop
%- faça o mod. Isso pode ser feito mais tarde, mas acabou aqui
S\o- Adicione o caractere de espaço para empilhar, redirecione para cima e produza espaço
W;- Shift para a esquerda e pop o espaço da pilha
O|@- Crie o mod calculado anteriormente, passe pelo refletor horizontal e pare.

Flacidez Cerebral , 56 54 bytes

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

Experimente online!

-2 bytes graças ao Assistente de Trigo

Explicação

A atual divisão inteira e o módulo conhecido no Brain-Flak são muito semelhantes (na verdade, a divisão inteira atualmente usada é apenas uma modificação que fiz no feersum módulo do ).

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

Convenientemente, o programa de divisão inteira usa apenas a terceira pilha para armazenar dados, enquanto o programa módulo usa apenas as duas pilhas normais para armazenar dados. Assim, simplesmente executando os dois ao mesmo tempo, eles não colidem um com o outro.

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

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

Finalmente, os programas de divisão inteira e módulo usados ​​nessa combinação foram projetados para serem limpos da pilha (não deixar lixo nas pilhas / não depender da (não) existência de valores nas pilhas que não sejam as entradas), mas isso não é necessário para este problema. Assim, podemos salvar dois bytes não nos incomodando em zerar o zero no final do loop principal e outros dois bytes não pressionando zero no início, contando com o preenchimento zero na parte inferior das pilhas.

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

Para a explicação do programa de divisão inteira, veja a resposta do feersum

Explanação da Divisão Inteira Em Breve ...

Java 8, 18 bytes

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

Esta é uma expressão lambda do tipo BiFunction<Integer, Integer, String>.

Estou surpreso ... esta é realmente uma solução bastante concisa para Java. Vá expressões lambda!

Flacidez Cerebral , 168 148 110 bytes

Eu acho que deveria ter verificado o Wiki primeiro

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

Formato:

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

Experimente online!

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

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

<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<>)     # Modulo from the wiki

sed, 36 bytes

35 bytes de código, +1 para o -rsinalizador.

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

Recebe entrada em unário, separado por espaço, com o número menor primeiro. Saídas como unárias, com o quociente primeiro em 1seo restante em segundo em xs. (Se isso não for aceitável, avise-me e alterarei para 1s separados por espaço, como na entrada.)

Explicação

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

Explicação

A entrada está na célula A1e B1. Isso simplesmente retorna os valores de retorno da função FLOORe MOD, que são para o revestimento da divisão e para o restante. Esses valores são separados por vírgula.

Python 2 , 20 bytes

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

Experimente online!

6 bytes incorporados

divmod

Experimente online!

Gelatina , 3 bytes

:,%

Experimente online!

ÓLEO , 134 106 103 102 bytes

Retorna a entrada de stdin, os dois números separados por uma nova linha. Gera o resultado da divisão inteira, uma nova linha e o restante.

Este é um dos programas OIL mais complicados que já escrevi, pois o OIL não possui recursos internos para divisão, restante, adição, subtração e assim por diante. Ele trabalha com a maneira primitiva de fazer divisão: decrementação aninhada repetida.

Apresento o código em um formato anotado, com comentários no estilo das linguagens de script. Antes de executar, os comentários devem ser removidos.

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: Raspei mais 3 bytes movendo uma "constante" para um local de um dígito (menos bytes para referência) e, em seguida, implicando 2 locais zero (usando uma linha vazia. Um deles eu poderia ter feito antes).

edit: E outro byte, tornando o zero inicial implícito. Nós realmente precisamos apenas de um único zero literal.

Retina , 14 bytes

Vamos abusar dos formatos de entrada / saída!

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

Recebe a entrada como b\na, em unário, usando para dígito unário qualquer caractere que não seja um dígito ou uma nova linha. Gera o quociente em decimal, seguido imediatamente pelo restante em unário, usando o mesmo caractere da entrada.

Experimente online!

(.*) ¶(\1)*corresponde ao primeiro número, depois uma nova linha (¶ é a abreviação de Retina para \ n) e, em seguida, o primeiro número novamente quantas vezes for possível. O número de partidas do segundo grupo será o resultado da divisão e a parte não correspondida será o restante.

Com $#2, substituímos tudo o que foi correspondido na linha anterior pelo número de capturas do segundo grupo e obtemos o 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

Experimente online!

Como 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 saída

a/b
a mod b

Labirinto , 11 bytes

?:?:}/!\{%!

Experimente online!

Explicação

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

O IP atinge então um beco sem saída, gira e o programa termina devido à tentativa de divisão por zero quando %é executado novamente.

C, 32 bytes

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

Experimente online!

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

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

Nota

• Entrada usando o -vsinalizador, consulte TIO para um exemplo.
• Isso gera o restante primeiro, depois uma vírgula e, finalmente, a divisão inteira.

Experimente online!

Explicação

Observe que a pilha começa como A, B, onde Ae Brepresenta a primeira e a segunda entrada, devido ao -vsinalizador usado.

: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

Uma macro que substitui f (a, b) pelos 2 termos separados por vírgula. Embora seja melhor você passá-lo para uma função, ou então não há como separar os 2.

Experimente Online

Haskell , 21 bytes

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

Experimente online! Exemplo de uso: 13#2retorna (6,1). Sim, isso é muito chato, porém um pouco mais interessante que odivMod build-in que funciona da mesma maneira.

Enquanto estamos nisso, há também quot, reme quotRemque se comportam da mesma forma em números naturais que div, mode divMod. No entanto, para entradas negativas, o resultado de modtem o mesmo sinal que o divisor, enquanto o resultado de remtem o mesmo sinal que o dividendo. Ou, como é colocado na documentação do Prelude , quoté a divisão inteira truncada em direção a zero e a divdivisão inteira truncada em direção ao infinito negativo.

Que tal não divou modbuild-ins?

Sem build-ins, 36 32 31 bytes

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

Experimente online! Exemplo de uso: 13#2retorna (1,6), ou seja, o modresultado é o primeiro e o divresultado é o segundo. Se afor menor b, então a mod bé ae a div bé 0, então (a,0)é retornado. Caso contrário, recursivamente calcule mode divde a-be badicione 1ao resultado da divisão e mantenha o restante.

A adição de 1 ao resultado da divisão é obtida usando-se <$>, geralmente usado mappara mapear funções em listas, mas funciona também em tuplas, no entanto, a função é aplicada apenas ao segundo elemento da tupla.

Edit: Salvo um byte graças ao xnor!

Prolog SWI, 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).

Saída:

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

Descrição:

Algoritmo recursivo simples sem divisão ou módulo embutido. Simplesmente conta "quantas vezes cabe o segundo número no primeiro?" e relata o resultado (unificado para D) com o restante (R).

// edit: espaços desnecessários removidos

Gol> <> , 11 bytes

I:I:@$S,N%h

Intérprete online

MATL, 5 bytes

/k&G\

Experimente no MATL Online!

Explicação

        % 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 os números na ordem inversa (por exemplo 10 42). Experimente aqui.

Explicação

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