Divisão e restante

36

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

Leo
fonte
Posso reverter os argumentos, ou seja, em vez de fornecer o a bfornecimento b a?
Erik the Outgolfer 27/03
@EriktheOutgolfer:You may choose any format you like for both input and output, as long as the two numbers are clearly distinguishable
Emigna 27/03
@ Emigna Sim, eu não tinha certeza se a inversão não os tornava indistinguíveis.
Erik o Outgolfer
@EriktheOutgolfer se você sabe que eles precisam para ser revertidas você não tem nenhum problema em distingui-los :)
Leo
Infelizmente, o algoritmo BF não funciona se o divisor estiver 1.
mbomb007

Respostas:

23

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

Divmod em execução no BitCycle

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.
DLosc
fonte
que é incrível
Evan Carslake
"O programa recebe informações unárias a partir da linha de comando": Isso me parece binário?
therealfarfetchd
Ops. Como a saída parecia binária, achei que a entrada também deveria ser. Então eu li o texto. Deixa pra lá. : P
therealfarfetchd 31/03
15

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.

Dennis
fonte
12

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 .

Martin Ender
fonte
10

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!

fəˈnɛtɪk
fonte
10

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!

Adão
fonte
Como você fez esse diagrama legal?
emiflake
2
@WolfgangTS meticulosamente. O Dyalog APL vem com a capacidade de criar diagramas de árvore básicos de funções tácitas. Experimente online! Comecei com isso ...
Adám 27/03/17
Ai, parece muito difícil. Eu não tenho paciência para que eu tenho medo, haha
emiflake
mais curto:⌊÷,|⍨
ngn 28/03
@ngn Ai, você me pegou. Feliz em ver que você ainda está aqui.
Adám 28/03
7

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
Fatalizar
fonte
7

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]
Luis Mendo
fonte
2
Este é um bom exemplo de pensamento lateral, bom trabalho!
27317 Leo
6

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}
Martin Ender
fonte
1
Você sabe que é ruim quando a linguagem cria embutidos que simplesmente combinam embutidos ...
Fatalize
1
@Fatalize É? Acho que os embutidos do divmod são bastante úteis, e o Mathematica não é de longe a única linguagem a ter um.
Martin Ender
8
@Fatalize, muito do mesmo trabalho é necessário para calcular quocientes, como é necessário para calcular os restantes. Se os dois resultados forem usados, um built-in com engenharia adequada quotRempode economizar tempo significativo com chamadas quote remseparadamente.
Julian Lobo
6

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.

Erik, o Outgolfer
fonte
Você poderia fazer ÷ ²¹%) por 5 bytes.
Emigna
@ Emigna Eu não sei se é válido embora. Espera, como isso funcionou?
Erik the Outgolfer
1
Não vejo por que não seria válido. Funciona porque entradas implícitas são enviadas para a pilha na ordem inversa do que você assumiria em casos como este.
Emigna
@ Emigna, perguntei à OP se posso reverter os argumentos.
Erik the Outgolfer
2
Entendo You may choose any format you like for both input and output, as long as the two numbers are clearly distinguishableque você pode decidir que as entradas são consideradas como divisor, dividend. Você poderia apenas especificar "Input são tomadas como divisor, dividend" na resposta e eles vão ser claramente distinguíveis :)
Emigna
6

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

Martin Ender
fonte
6

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.

MickyT
fonte
Bata-me por dois minutos. Boa resposta!
27417 Luke
@Luke Graças, pensei que eu poderia começar outro fora, mas provando indescritível
MickyT
6

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

Comparação entre módulo e divisão inteira:
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.

Combinação de módulo e divisão inteira:
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.

Isso nos dá o programa final:
({}<>)<>([()]{()<(({})){({}[()])<>}{}>}<><([{}()]{})>)

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

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

0 '
fonte
5

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!

Phoenix socrático
fonte
5

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
Riley
fonte
Golfe
Assistente de trigo
5

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
DLosc
fonte
5

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.

Luke
fonte
Eu acho que você quer dizer a célula A1 e B1 não A1 e A2
fənɛtɪk
Sim obrigado. Corrigido agora
Luke
Economize 1 byte em FLOOR(A1/B1;1)vez deQUOTIENT(A1;B1)
Engineer Toast
Como a entrada é sempre um número natural, acho que você pode substituir FLOOR(A1/B1;1)por `INT (A1 / B1) 'para economizar mais 4 bytes
Wernisch
4

Gelatina , 3 bytes

:,%

Experimente online!

Erik, o Outgolfer
fonte
Droga, eu estava apenas indo para postar isso, eu testei algumas vezes extras e ficou ninja'd :( bom trabalho!
HyperNeutrino
4

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

L3viathan
fonte
Ótimo trabalho! Esse é exatamente o tipo de resposta que eu esperava que esse desafio recebesse :) Apenas uma observação: você tem certeza de que o divisor sempre será estritamente positivo, portanto você não precisa verificar se há uma divisão por 0;)
Leo
@ Leo Estou garantido que o divisor será sempre estritamente positivo no início . Não funcionará se eu separar a divisão com zero partes; nesse caso, pode ocorrer mesmo quando a divisão "real" for normal. Se bem me lembro, isso ocorre quando o restante é zero.
L3viathan
Estou falando da verificação na linha 4, não da linha 12 ... Não é executada apenas uma vez no início do programa?
27317 Leo
@ Leo Feito, quase 30 caracteres a menos, obrigado!
L3viathan
4

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.

Leo
fonte
Haha, com toda a razão, eu claramente não deveria estar escrevendo programas tão tarde da noite.
FryAmTheEggman 30/03
4

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
Tom291
fonte
3

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.

Martin Ender
fonte
3

> <> , 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.
Luke
fonte
Como você pode fornecer valores de entrada de até 255?
27417 Leo
Basta usar valores ASCII / Unicode mais altos. Dessa forma, įtorna-se 255.
Luke
Ok, legal :) Aliás, não seria mais curto receber números de entrada da linha de comando diretamente com o sinalizador -v?
27317 Leo
Seria, mas não consegui que isso funcionasse no TIO, então resolvi usar essa solução. Economizaria 8 bytes - 1 (para o -vsinalizador).
27417 Luke
Aqui você é :)
Leo
3

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

Bijan
fonte
3

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!

Laikoni
fonte
2
Sua segunda solução pode raspar um byte usando <$>em uma tupla a agir em seu segundo elemento: a#b|a<b=(a,0)|m<-a-b=(+1)<$>m#b.
Xnor
3

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

Jan Drozen
fonte
Bem-vindo ao PPCG! Eu nunca usei o Prolog antes, mas notei que há espaços :-na última linha, mas não nas outras. Eles são necessários lá por algum motivo? O mesmo vale para E + 1enquanto F-Ssugerimos que não há espaços necessários.
Laikoni 31/03
Laikoni: Você está definitivamente certo! Acabei de remover os espaços e atualizei a contagem de bytes finais.
Jan Drozen
2

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
Suever
fonte
2

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
DLosc
fonte