Эта проблема, хотя, вероятно, тривиальна в большинстве «стандартных» языков, адресована тем языкам, которые настолько эзотеричны, низкоуровневы и / или трудны в использовании, что очень редко встречаются на этом сайте. Это должно обеспечить интересную проблему для решения, так что это ваш шанс попробовать тот странный язык, о котором вы читали!

Задание

Возьмите два натуральных числа aи в bкачестве входных данных и выведите два других числа: результат целочисленного деления a/bи остаток от такого деления ( a%b).

Это код-гольф : самый короткий ответ (в байтах), для каждого языка, выигрывает!

Ввод, вывод

• 0 <= a<= 255, 1 <= b<= 255. Каждый из ваших входов (и выходов тоже) будет помещаться в один байт.
• Вы можете выбрать любой формат для ввода и вывода, при условии, что эти два числа четко различимы (например, нет распечатки двух результатов без разделителя)

Примеры

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

Примечание. Встроенные функции, которые возвращают как результат деления, так и остаток, запрещены . По крайней мере покажите нам, как ваш язык работает с применением двух функций к одним и тем же аргументам.

Примечание 2. Как всегда, приветствуется объяснение того, как работает ваш код, даже если он выглядит читабельным для вас, для кого-то это может быть не так!

Leaderboard

Вот фрагмент стека, чтобы составить обзор победителей по языкам.

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

# Language Name, N bytes

где Nразмер вашего представления. Если вы улучшите свой счет, вы можете сохранить старые результаты в заголовке, вычеркнув их. Например:

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

Если вы хотите включить в заголовок несколько чисел (например, потому что ваш результат равен сумме двух файлов или вы хотите перечислить штрафы за флаг интерпретатора отдельно), убедитесь, что фактический результат является последним числом в заголовке:

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

Вы также можете сделать название языка ссылкой, которая затем будет отображаться во фрагменте списка лидеров:

# [><>](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 байта

Просто понял, что целый раздел моего исходного кода был излишним. Огромное сокращение!

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

Программа принимает унарный ввод из командной строки, сначала делитель. Он выводит частное и остаток в одинарных, разделенных символом 0. Например, вот a=11, b=4, a/b=2, a%b=3:

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

Ungolfed, в действии

Вот моя версия ungolfed вычислений a=3, b=5с анимацией включен (извините о glitchiness):

Попытка объяснения

Объяснение применимо к негольфированной версии. Прежде чем заняться этим, я настоятельно рекомендую прочитать страницу Esolangs, чтобы понять, как работает язык.

Алгоритм выглядит так:

• Запустите внешний цикл, пока программа не будет завершена.
  • Выполните внутренний цикл над битами делителя, соединяя их с битами из дивиденда.
    • Если все биты делителя имеют совпадающие биты дивиденда, выведите один бит.
    • Если не все биты делителя имеют совпадающие биты дивидендов, выведите разделитель, 0за которым следуют биты дивидендов, а затем завершите.

Сердцем кода являются отношения между коллекционерами (заглавными буквами). Поскольку существует множество отдельных коллекторов с каждой буквой, давайте относиться к ним , как A1, A2, B1, B2и т.д., нумерация сверху вниз.

• A1и A2держите делитель и дивиденд, соответственно, в начале основного цикла.
• Внутренний цикл отслаивается по одному за раз от делителя и дивиденда.
  • Остальная часть делителя, если таковая имеется, всегда входит в B1.
  • Если и делитель, и дивиденд были непустыми, один бит входит в, C1а другой - в C3. Остальная часть дивидендов идет в B2.
  • Если бы только делитель был непустым, мы достигли конца дивиденда, и пришло время напечатать остаток. Бит из делителя входит в C2.
  • Если бы только дивиденд был непустым, мы достигли конца делителя; пришло время , чтобы обработать биты C3или C2для вывода. Остальная часть дивидендов идет в C4.
• Если в Bколлекторах есть какие-либо биты , они возвращают свое содержимое обратно в Aколлекторы и продолжают во внутреннем цикле.
• После того , как Aи Bколлекторы пусты, то Cколлекторы открыть , и мы переходим к стадии обработки:
  • C1и C4сбросьте их содержимое (делитель и оставшийся дивиденд соответственно) в D1и D3.
  • Если C2пусто, мы все еще печатаем частное.
    • Содержимое C3перейдите к верхнему правому =переключателю. Первый 1бит проходит прямо через! и выводится.
    • Когда 1бит проходит, он активирует переключатель, указывающий вправо, который отправляет все последующие биты с платы.
  • Если C2 не пусто, мы печатаем остаток.
    • Первый бит C2обнуляется 0и передается через переключатель. 0Продолжает! и выводится.
    • Когда 0бит проходит, он активирует переключатель, чтобы указать влево. Теперь все биты C3идут от переключателя влево и перенаправляются в! , выводя весь остаток.
    • Копия первого бита из C2также отправляется в D2.
• Теперь Dколлекционеры открыты.
  • Если что-то есть D2, это означает, что мы просто напечатали остаток. Бит из D2хитов @, завершающий программу.
  • В противном случае содержимое D1и D3цикл возвращается в A1и A2соответственно, и основной цикл начинается заново.

бред , 43 41 байт

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

Это использует модифицированную версию моего алгоритма деструктивного модуля на Esolangs .

Программа читает два байта - d и n в этом порядке - из STDIN и печатает два байта - n% d и n / d в этом порядке - в STDOUT. Требуется интерпретатор мозгового штурма с дважды бесконечной или круглой лентой, такой как на TIO.

Попробуйте онлайн!

Как это работает

Перед запуском программы все ячейки сохраняют значение 0 . После считывания d из STDIN ( ,), перемещения на один шаг влево ( <) и считывания n из STDIN ( ,) лента выглядит следующим образом.

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

Далее, предполагая, что n> 0 , мы входим в цикл while

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

который преобразует ленту следующим образом.

Во- первых, >->+<прогресс в ячейку C и уменьшает его, а затем переходит в ячейку D и увеличивает его, и , наконец , возвращается в ячейку C . Что будет дальше, зависит от того, равно ли значение ячейки C нулю или нет.

• Если ячейка C держать положительное значение, [>](идти прямо , пока клетка не ноль) продвинет к ячейке Е .

  >>>>+<<<авансы клеток J , чтобы увеличить его, а затем возвращается в ячейку F .

  Так как ячейка F всегда будет иметь 0 , то время цикла [<+>-]пропускается полностью, и <<возвращается в ячейку D .

  Наконец, так как ни D , ни С держать 0 , [<](идти налево в то время как клетка не равно нулю) будет retrocede к ячейке А .

• Если ячейка C содержит 0 , цикл [>]полностью пропускается; >>>>+<<<авансы клетки G , чтобы увеличить его, а затем возвращается в ячейку D .

  В этот момент D будет удерживать d (на самом деле сумма значений в C и D всегда будет d ), поэтому [<+>-](пока D положительно, приращение C и уменьшение D ) установит C в d, а D в 0 .

  И, наконец, <<retrocedes к ячейке B , [<](налево в то время как клетка не равно нулю) дополнительно слева ячейки A .

В обоих случаях происходит >-переход в ячейку B и ее уменьшение, и цикл начинается заново, если только это не обнуляет его.

После k итераций лента выглядит следующим образом.

       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

После n итераций B обнуляется и мы вырываемся из цикла. Желаемые значения ( n% d и n / d ) будут храниться в ячейках D и G , поэтому >>.>>>.печатает их.

Funciton , 224 108 байт

Число байтов предполагает кодировку UTF-16 с BOM.

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

Попробуйте онлайн!

Выше определяется функция f, которая принимает два целых числа и возвращает их деление и произведение (функции в Funciton могут иметь несколько выходов, если сумма входов и выходов не превышает 4).

Использование двух входных значений для разных целей на самом деле довольно тривиально: вы просто отсоединяете соединитель с Т-образным соединением, при этом значение будет дублироваться по обеим ветвям, которые мы затем можем подавать отдельно во встроенные модули для деления и по модулю.

На самом деле мне понадобилось вдвое больше времени, чтобы понять, как отобразить результат для пользователя, чем просто реализовать решение.

Кроме того , Funciton имеет встроенный divmod, ÷%и занятно встроенные модули ÷и %что мое решение использует реализованы в терминах ÷% . Тем не менее, моя функция fвыше не совсем идентична÷% : мне пришлось поменять местами порядок входов, и, хотя кажется, что это легко изменить, пока я не смог сделать это без увеличения количества байтов. ,

JavaScript (ES6), 17 байт

Спасибо @Arnauld за игру в один байт

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

Получает входные данные в формате (х) (у)

Получает пол x / y, выполняя побитовое выполнение или
Получая остаток по x% y,
помещает оба значения в массив так, чтобы они оба могли быть возвращены

Попробуйте онлайн!

APL (Dyalog) , 5 байтов

-2 байта благодаря @ngn

⌊÷,|⍨

Это вершина (2 поезда) вилки (3 поезда), где правый палец вершины является производной функцией (результат оператора, примененного к функции):

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

⌊ пол

÷ деление

, опрокинутый до

| остаток от деления
⍨  с замененными аргументами (модуль APL «назад»)

Попробуйте онлайн!

Брахилог , 6 байт

{÷|%}ᶠ

Попробуйте онлайн!

объяснение

Мы злоупотребляем метапредикатом, ᶠ findallчтобы применить два разных предиката к списку ввода из двух аргументов:

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

MATL , 12 10 байт

Qt:ie=&fhq

Вклад a, то b. Выходной остаток, затем частное.

Попробуйте онлайн!

объяснение

Это позволяет избежать как модуля, так и деления. Вместо этого он использует изменение формы массива :

1. Построить массив a+1 ненулевых элементов.
2. Изменить форму как 2D массив b строк. Это автоматически дополняется нулями при необходимости.
3. Индексы строки и столбца последней ненулевой записи, минус 1, являются соответственно остатком и частным.

Рассмотрим, например 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 байт

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

Незначительное злоупотребление гибкими правилами вывода: результат дается как div[mod], который останется без оценки. Отдельные номера можно извлечь с помощью result[[0]]и result[[1]].

И, эй, он всего на один байт длиннее, чем смешно названный встроенный QuotientRemainder.

Mathematica, на самом деле, имеет отличный способ применить несколько функций к одному входу, но это на три байта длиннее:

Through@*{Quotient,Mod}

05AB1E , 5 байтов

÷²¹%‚

Попробуйте онлайн!

05AB1E имеет ошибку, поэтому неявный ввод не работает :( Эминья заметил, что вводы часто проталкиваются в обратном порядке.

Медуза , 14 байт

p
m
,|S
% i
Ei

Попробуйте онлайн!

объяснение

Медуза - прекрасный язык, когда речь идет о применении нескольких функций к одному входу. Язык 2D и все бинарные функции смотрят на юг для одного входа и на восток для другого. Таким образом, приближаясь к одному значению с запада и с севера, мы можем передать его двум функциям, не дублируя его в коде.

Два is в программе заменяются двумя входными значениями при запуске программы. Сейчас %это разделение. Он принимает один вход непосредственно с востока, а когда идет на юг, он попадает в тот, Eкоторый также перенаправляет поиск на восток. Таким образом, оба входа используются в %качестве аргументов.

| это встроенный модуль по модулю, который в основном делает то же самое, но в конечном итоге смотрит на юг для обоих путов.

Мы объединяем оба результата в пару с ,. Затем mвыполняется функция floor (которая нам нужна, потому что %это деление с плавающей запятой), и, наконец, мы выводим результат с помощью p.

Cubix , 12 13 байтов

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

Который отображается на следующий куб

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

Попробуй здесь

Объяснение с выполненными шагами
,I|I,- начинается с лишнего целочисленного деления, получает первое целое число от ввода, отражает обратно и получает следующее целое число от ввода, затем снова делит
O;- Выводит результат целочисленного деления и извлекает его
%- делает мод. Это можно было сделать позже, но все закончилось здесь
S\o- добавьте пробел в стек, перенаправьте вверх и выведите пробел
W;- сдвиньте влево и вытяните пробел из стека
O|@- выведите мод, рассчитанный ранее, пропустите горизонтальный рефлектор и остановите.

Brain-Flak , 56 54 байта

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

Попробуйте онлайн!

-2 байта благодаря Wheat Wizard

объяснение

В настоящее время наиболее известные целочисленное деление и деление по модулю в Brain-Flak очень похожи (на самом деле используемое в настоящее время целочисленное деление - это просто модификация, которую я сделал в feersum модулю ).

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

Удобно, программа целочисленного деления использует только третий стек для хранения данных, в то время как программа по модулю использует только два обычных стека для хранения данных. Таким образом, просто запуская их одновременно, они не сталкиваются друг с другом.

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

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

Наконец, и программы с целочисленным делением, и программы по модулю, используемые в этой комбинации, были спроектированы так, чтобы быть чистыми в стеке (не оставлять мусор в стеках / не зависеть от (не) наличия значений в стеках, отличных от их ввода), но это не является необходимым для этой проблемы. Таким образом, мы можем сохранить два байта, не утруждая себя нулями в конце основного цикла, и еще два байта, не нажимая ноль в начале, вместо этого полагаясь на заполнение нулями в нижней части стеков.

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

Объяснение программы целочисленного деления смотрите в ответе feersum.

Объяснение целочисленного деления скоро будет ...

Java 8, 18 байт

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

Это лямбда-выражение типа BiFunction<Integer, Integer, String>.

Я удивлен ... это на самом деле довольно краткое решение для Java. Иди лямбда-выражения!

Brain-Flak , 168 148 110 байт

Я думаю, что я должен был проверить вики первым

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

Формат:

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

Попробуйте онлайн!

(({})(<           # 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 байт

35 байт кода, +1 за -rфлаг.

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

Принимает ввод в одинарном, пробел, с меньшим номером в первую очередь. Выводится как одинарный, с частным первым в 1s и оставшимся вторым в xs. (Если это неприемлемо, дайте мне знать, и я изменю его на разделенные пробелами 1s, такие как ввод.)

объяснение

: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 байт

=INT(A1/B1)&","&MOD(A1;B1)

объяснение

Вход находится в ячейке A1и B1. Это просто возвращает возвращенные значения FLOORи MODфункции, которые для напольных покрытий разделения и для остальные. Эти значения разделяются запятой.

Python 2 , 20 байт

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

Попробуйте онлайн!

Встроенный, 6 байтов

divmod

Попробуйте онлайн!

Желе , 3 байта

:,%

Попробуйте онлайн!

НЕФТЬ , 134 106 103 102 байта

Принимает ввод из стандартного ввода, два числа разделены новой строкой. Выводит результат целочисленного деления, затем новую строку, а затем остаток.

Это одна из самых сложных программ OIL, которые я когда-либо писал, поскольку в OIL отсутствуют встроенные функции для деления, остатка, сложения, вычитания и так далее. Он работает с примитивным способом деления: многократным вложенным декрементом.

Я представляю код в аннотированном формате с комментариями в стиле скриптовых языков. Перед выполнением комментарии должны быть удалены.

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)

редактирование: сбрил еще 3 байта, переместив «константу» в однозначное местоположение (меньше байтов для ссылки), а затем неявно указав 2 нулевых местоположения (используя вместо этого пустую строку. Один из них я мог бы сделать до).

редактировать: и еще один байт, делая начальный ноль неявным. Нам действительно нужен только один буквальный ноль.

Сетчатка , 14 байт

Давайте злоупотреблять форматами ввода / вывода!

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

Принимает ввод как b\na, в унарном, используя для одинарной цифры любой нецифровый, не символ новой строки. Выводит частное в десятичном виде, за которым сразу следует остаток в унарном виде, используя тот же символ, что и для ввода.

Попробуйте онлайн!

(.*) ¶(\1)*соответствует первому числу, затем новой строке (¶ - сокращение от Retina для \ n), затем первое число снова столько раз, сколько возможно. Количество совпадений второй группы будет результатом деления, а оставшаяся часть не соответствует.

С помощью $#2мы заменим все совпадения в предыдущей строке на количество захватов второй группы и получим наш результат.

ArnoldC , 286 283 байта

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

Попробуйте онлайн!

Как это работает

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

Выходной формат

a/b
a mod b

Лабиринт , 11 байт

?:?:}/!\{%!

Попробуйте онлайн!

объяснение

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

Затем IP попадает в тупик, оборачивается и программа завершается из-за попытки деления на ноль при %повторном выполнении.

C, 32 байта

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

Попробуйте онлайн!

> <> , 27 26 16 + 1 = 17 байт

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

Заметка

• Ввод с использованием -vфлага, см. TIO для примера.
• Сначала выводится остаток, затем запятая и, наконец, целочисленное деление.

Попробуйте онлайн!

объяснение

Обратите внимание, что стек начинается как A, B, где Aи Bпредставляет первый и второй входные данные из-за используемого -vфлага.

: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 байт

#define f(a,b)a/b,a%b

Макрос, который заменяет f (a, b) двумя разделенными запятыми членами. Хотя вам лучше передать его в функцию, иначе нет возможности выделить 2.

Попробуйте онлайн

Haskell , 21 байт

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

Попробуйте онлайн! Пример использования: 13#2возврат (6,1). Да, это довольно скучно, но немного интереснее, чем divModвстроенная программа, которая работает так же.

В то время как мы на это, есть также quot, remи quotRemкоторые ведут себя так же на натуральных числах , как div, modи divMod. Однако для отрицательных входных данных результат modимеет тот же знак, что и делитель, а результат remимеет тот же знак, что и дивиденд. Или, как это указано в документации Prelude , quotцелочисленное деление усекается до нуля, а divцелочисленное деление усекается до отрицательной бесконечности.

Как насчет нет divилиmod встраивания?

Нет встроенных модулей, 36 32 31 байт

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

Попробуйте онлайн! Пример использования: 13#2возвращает (1,6), то естьmod результат первый, а divрезультат второй. Если aменьше b, то a mod bесть aи a div bесть 0, так (a,0)что возвращается. В противном случае рекурсивно вычислить modи divиз a-bи bдобавить 1к результату деления и сохранить оставшуюся часть .

Добавление 1 к результату деления достигается использованием <$>, которое обычно используется какmap для отображения функций по спискам, но также работает и для кортежей, однако функция применяется только ко второму элементу кортежа.

Изменить: Сохраненный один байт благодаря xnor!

SWI Пролог, 109 байт

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

Выход:

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

Описание:

Простой рекурсивный алгоритм без встроенного деления или по модулю. Он просто считает "сколько раз вписывает второе число в первое?" и сообщает результат (объединенный в D) с остатком (R).

// редактировать: удалены ненужные пробелы

Gol> <> , 11 байт

I:I:@$S,N%h

Онлайн переводчик

MATL, 5 байтов

/k&G\

Попробуйте это в MATL Online!

объяснение

        % Implicitly grab the two inputs as numbers
/       % Divide them
k       % Round down the result
&G      % Grab the two inputs again
\       % Compute the remainder

Уроборос , 15 байт

r.r.@/Inao\%n1(

Принимает числа в обратном порядке (например, 10 42 ). Попробуй это здесь.

объяснение

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