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 a
e, b
como entrada, e produz dois outros números: o resultado da divisão inteira a/b
e 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 N
está 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>
a b
fornecimentob a
?You may choose any format you like for both input and output, as long as the two numbers are clearly distinguishable
1
.Respostas:
BitCycle ,
1467964 bytesAcabei de perceber que uma seção inteira do meu código original era desnecessária. Enorme redução!
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
:Ungolfed, em ação
Aqui está a minha versão não destruída da computação
a=3
,b=5
com 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:
0
seguido 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.A1
eA2
segure o divisor e o dividendo, respectivamente, no início do loop principal.B1
.C1
e outro entraC3
. O restante do dividendo entra em vigorB2
.C2
.C3
ouC2
na saída. O restante do dividendo entra em vigorC4
.B
coletores, eles retornam seu conteúdo para osA
coletores e continuam no loop interno.A
eB
estão todos vazios, osC
coletores são abertos e prosseguimos para o estágio de processamento:C1
eC4
despejar seu conteúdo (o divisor e o dividendo restante, respectivamente) emD1
eD3
.C2
estiver vazio, ainda estamos imprimindo o quociente.C3
sobe para o=
interruptor superior direito . O primeiro1
bit passa direto para!
e é emitido.1
bit passa, ele ativa o interruptor para apontar para a direita, o que envia todos os bits subsequentes para fora do quadro.C2
não estiver vazio, estamos imprimindo o restante.C2
é negado para a0
e passado pelo comutador. O0
prossegue!
e está de saída.0
bit passa, ele ativa o interruptor para apontar para a esquerda. Agora, todos os bitsC3
vão para a esquerda do comutador e são redirecionados para o!
, gerando o restante inteiro.C2
também é enviada paraD2
.D
colecionadores abrem.D2
, significa que acabamos de imprimir o restante. O bit deD2
atinge o@
, que finaliza o programa.D1
eD3
retornará paraA1
eA2
respectivamente, e o loop principal será reiniciado.fonte
brainfuck ,
4341 bytesIsso 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.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.
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.fonte
Funciton ,
224108 bytesA contagem de bytes assume a codificação UTF-16 com BOM.
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çãof
acima 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 .fonte
JavaScript (ES6), 17 bytes
Obrigado a @Arnauld por jogar um byte
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!
fonte
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):
⌊
andar de÷
divisão,
catenado para|
restante divisão⍨
com argumentos trocados (o módulo APL é "reverso")Experimente online!
fonte
⌊÷,|⍨
Braquilog , 6 bytes
Experimente online!
Explicação
Abusamos o metapredicado
ᶠ findall
para aplicar dois predicados diferentes à lista de entrada de dois argumentos:fonte
MATL ,
1210 bytesA entrada é
a
, entãob
. 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 :
a+1
elementos diferentes de zero.b
linhas. Isso é preenchido automaticamente com zeros, se necessário.1
, são respectivamente o restante e o quociente.Considere, por exemplo
a=7
,b=3
.fonte
Mathematica,
2018 bytesAbuso 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 comresult[[0]]
eresult[[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:
fonte
quotRem
pode economizar tempo significativo com chamadasquot
erem
separadamente.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.fonte
You may choose any format you like for both input and output, as long as the two numbers are clearly distinguishable
que você pode decidir que as entradas são consideradas comodivisor, dividend
. Você poderia apenas especificar "Input são tomadas comodivisor, dividend
" na resposta e eles vão ser claramente distinguíveis :)Água-viva , 14 bytes
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
i
s 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 aE
que 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ãom
é a função floor (que precisamos porque%
é a divisão de ponto flutuante) e, finalmente, imprimimos o resultadop
.fonte
Cubix , 12
13bytesQue mapeia para o cubo a seguir
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 novamenteO;
- 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 aquiS\o
- Adicione o caractere de espaço para empilhar, redirecione para cima e produza espaçoW;
- Shift para a esquerda e pop o espaço da pilhaO|@
- Crie o mod calculado anteriormente, passe pelo refletor horizontal e pare.fonte
Flacidez Cerebral ,
5654 bytesExperimente 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: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: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 ...
fonte
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!
fonte
Flacidez Cerebral ,
168 148110 bytesEu acho que deveria ter verificado o Wiki primeiro
Formato:
Experimente online!
fonte
sed, 36 bytes
35 bytes de código, +1 para o
-r
sinalizador.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
1
seo restante em segundo emx
s. (Se isso não for aceitável, avise-me e alterarei para1
s separados por espaço, como na entrada.)Explicação
fonte
Excel 2013,
31 3026 bytesExplicação
A entrada está na célula
A1
eB1
. Isso simplesmente retorna os valores de retorno da funçãoFLOOR
eMOD
, que são para o revestimento da divisão e para o restante. Esses valores são separados por vírgula.fonte
FLOOR(A1/B1;1)
vez deQUOTIENT(A1;B1)
FLOOR(A1/B1;1)
por `INT (A1 / B1) 'para economizar mais 4 bytesPython 2 , 20 bytes
Experimente online!
6 bytes incorporados
Experimente online!
fonte
Gelatina , 3 bytes
Experimente online!
fonte
ÓLEO ,
134106103102 bytesRetorna 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.
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.
fonte
Retina , 14 bytes
Vamos abusar dos formatos de entrada / saída!
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.fonte
ArnoldC ,
286283 bytesExperimente online!
Como funciona
Formato de saída
fonte
Labirinto , 11 bytes
Experimente online!
Explicação
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.fonte
C, 32 bytes
Experimente online!
fonte
> <> ,
27 2616 + 1 = 17 bytesNota
-v
sinalizador, consulte TIO para um exemplo.Experimente online!
Explicação
Observe que a pilha começa como
A, B
, ondeA
eB
representa a primeira e a segunda entrada, devido ao-v
sinalizador usado.fonte
į
torna-se 255.-v
sinalizador).C, 21 bytes
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
fonte
Haskell , 21 bytes
Experimente online! Exemplo de uso:
13#2
retorna(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
,rem
equotRem
que se comportam da mesma forma em números naturais quediv
,mod
edivMod
. No entanto, para entradas negativas, o resultado demod
tem o mesmo sinal que o divisor, enquanto o resultado derem
tem 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 adiv
divisão inteira truncada em direção ao infinito negativo.Que tal não
div
oumod
build-ins?Sem build-ins,
36 3231 bytesExperimente online! Exemplo de uso:
13#2
retorna(1,6)
, ou seja, omod
resultado é o primeiro e odiv
resultado é o segundo. Sea
for menorb
, entãoa mod b
éa
ea div b
é0
, então(a,0)
é retornado. Caso contrário, recursivamente calculemod
ediv
dea-b
eb
adicione1
ao resultado da divisão e mantenha o restante.A adição de 1 ao resultado da divisão é obtida usando-se
<$>
, geralmente usadomap
para 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!
fonte
<$>
em uma tupla a agir em seu segundo elemento:a#b|a<b=(a,0)|m<-a-b=(+1)<$>m#b
.Prolog SWI, 109 bytes
Saída:
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
fonte
:-
na última linha, mas não nas outras. Eles são necessários lá por algum motivo? O mesmo vale paraE + 1
enquantoF-S
sugerimos que não há espaços necessários.Gol> <> , 11 bytes
Intérprete online
fonte
MATL, 5 bytes
Experimente no MATL Online!
Explicação
fonte
Ouroboros , 15 bytes
Toma os números na ordem inversa (por exemplo
10 42
). Experimente aqui.Explicação
fonte