Поділ та залишок


36

Ця проблема, хоча ймовірно тривіальна у більшості "стандартних" мов, стосується тих мов, які настільки езотеричні, низького рівня та / або важкі у використанні, що дуже рідко зустрічаються на цьому веб-сайті. Це повинно створити цікаву проблему для вирішення, тому це ваш привід спробувати ту дивну мову, про яку ви читали!

Завдання

Візьміть два натуральних числа 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: Як завжди, пояснення того, як працює ваш код, дуже вітається, навіть якщо він здається вам читабельним, це може бути не таким для когось іншого!


Таблиця лідерів

Ось фрагмент стека для створення огляду переможців за мовою.

Щоб переконатися, що ваша відповідь відображається, будь ласка, почніть свою відповідь із заголовка, використовуючи наступний шаблон Markdown:

# 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


Чи можу я змінити аргументи, тобто замість a bнадання b aнатомість?
Ерік Аутгольфер

@EriktheOutgolfer:You may choose any format you like for both input and output, as long as the two numbers are clearly distinguishable
Emigna

@Emigna Так, я не був впевнений, що задні ходи не змусили їх розрізнитись.
Ерік Аутгольфер

@EriktheOutgolfer, якщо ви знаєте, що їх потрібно змінити, у вас немає проблем розрізнити їх :)
Лев

На жаль, алгоритм BF не працює, якщо дільник 1.
mbomb007

Відповіді:


23

BitCycle , 146 79 64 байт

Щойно зрозумів, що цілий розділ мого оригінального коду був непотрібним. Величезне скорочення!

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

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

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

Безумовно, в дії

Ось моя обчислювальна версія без перешкод a=3, b=5з увімкненою анімацією (вибачте за глюкозу):

Divmod running in BitCycle

Спроба пояснення

Пояснення стосується версії, що не має волі. Перш ніж вирішити цю проблему, я настійно рекомендую прочитати сторінку 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заперечується на a 0і передається через комутатор. 0Продовжує !і виводиться.
      • Коли 0біт проходить крізь нього, він активує перемикач на точку вліво. Тепер усі біти C3переходять ліворуч від комутатора і перенаправляються навколо в !, виводячи всю залишок.
      • C2Також надсилається копія першого біта з D2.
  • Зараз Dколектори відкриваються.
    • Якщо щось є D2, це означає, що ми лише надрукували решту. Біт від D2хітів @, який завершує програму.
    • В іншому випадку вміст D1і D3цикл повертаються в відповідно A1і A2відповідно, і основний цикл починається заново.

це приголомшливо
Еван Карслайк

"Програма приймає введення в командному рядку уніар": Це для мене схоже на бінарне?
therealfarfetchd

Уопс. Оскільки вихід був схожий на двійковий, я хоч і вхід повинен бути занадто. Потім я прочитав текст. Не звертай уваги. : P
therealfarfetchd

15

мозковий ебать , 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 тримати позитивне значення, [>](йти прямо , поки клітина не нуль) просуне до осередку Е .

    >>>>+<<<аванси клітин J , щоб збільшити його, а потім повертається в осередок F .

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

    Нарешті, оскільки ні D, ні З тримати 0 , [<](йти наліво в той час як клітина не дорівнює нулю) буде retrocede до осередку А .

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

    У цьому пункті D утримуватиме d (насправді сума значень у C і D завжди буде d ), тому [<+>-](поки D позитивний, приріст C і декремент D ) встановлять C на d, а D на 0 .

    Нарешті, <<ретросед до клітини B , [<](ліворуч в той час як клітина не дорівнює нулю) додатково зліва осередки A .

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

Після к ітерацій стрічка виглядає наступним чином.

       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 , тому >>.>>>.друкує їх.


12

Функсітон , 224 108 байт

Кількість байтів передбачає кодування UTF-16 з BOM.

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

Спробуйте в Інтернеті!

Сказане визначає функцію f , яка приймає два цілих числа і повертає як їх поділ, так і їх добуток (функції у Funciton можуть мати декілька виходів, доки сума входів і виходів не перевищує 4).

Використання двох вхідних значень для декількох цілей насправді досить тривіально: ви просто розділите з'єднувач з Т-переходом, коли значення буде дублюватися по обох гілках, які ми можемо подавати окремо до вбудованих модулів для поділу та модуля.

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

Крім того, у Funciton є вбудований divmod, ÷%і забавно вбудовані модулі, ÷і %що моє рішення використовує реалізовано з точки зору ÷% . Однак моя функція fвище не зовсім ідентична ÷%: мені довелося поміняти порядок входів, і хоча здається, що це слід легко змінити, поки що я не зміг це зробити, не збільшуючи кількість байтів .


10

JavaScript (ES6), 17 байт

Дякуємо @Arnauld за те, що ти граєш на байт

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

Отримує введення у форматі (x) (y)

Отримує підлогу x / y, виконуючи побіжно або
Отримує залишок на x% y
Вкладає обидва значення в масив, щоб їх можна було повернути

Спробуйте в Інтернеті!


10

APL (Dyalog) , 5 байт

-2 байти завдяки @ngn

⌊÷,|⍨

Це на вершині (2 поїзда) вила (3 поїзда), де правий зубчик на вершині - це похідна функція (результат оператора, застосованого до функції):

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

 пол

÷ поділ

, катенований до

| поділ залишок
 з заміненими аргументами (модуль APL "назад")

Спробуйте в Інтернеті!


Як ви склали цю круту діаграму?
emiflake

2
@WolfgangTS Безстрашно. Dyalog APL має можливість складати основні діаграми дерева негласних функцій. Спробуйте в Інтернеті! Я почав з цього ...
Адама

Так, виглядає дуже складно. Я не маю терпіння для цього, боюся, ха-ха
emiflake

коротше:⌊÷,|⍨
ngn

@ngn Ой, ти мене отримав. Радий побачити, що ти все ще тут.
Адам


7

MATL , 12 10 байт

Qt:ie=&fhq

Вхід є a, значить b. Вихід залишок, а потім коефіцієнт.

Спробуйте в Інтернеті!

Пояснення

Це дозволяє уникнути як модуля, так і поділу. Замість цього використовується перестановка масиву :

  1. Побудувати масив a+1ненульових елементів.
  2. Змініть форму як двовимірний масив 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]

2
Це прекрасний приклад бічного мислення, приємна робота!
Лев

6

Математика, 20 18 байт

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

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

І ей, це лише на один байт довше, ніж смішно названа вбудована QuotientRemainder.

Mathematica насправді має чіткий спосіб застосувати кілька функцій до одного входу, але це на три байти довше:

Through@*{Quotient,Mod}

1
Ви знаєте, що це погано, коли мова створює вбудовані модулі, які просто поєднують вбудовані модулі…
Fatalize

1
@Fatalize Це? Мені здається, що вбудовані модулі divmod є досить корисними, і Mathematica - це далеко не єдина мова, яка має.
Мартін Ендер

8
@Fatalize, для того, щоб обчислити коефіцієнти, потрібно багато тієї ж роботи, як і для обчислення залишків. Якщо потрібно використовувати обидва результати, quotRemвбудований належним чином інженер може заощадити значний час на виклик quotта remокремо.
Джуліан Вовк

6

05AB1E , 5 байт

÷²¹%‚

Спробуйте в Інтернеті!

05AB1E має помилку, тому неявне введення не працює :( Емінья зазначила, що введення часто натискають у зворотному напрямку.


Ви можете зробити ÷ ²¹%) за 5 байт.
Емінья

@Emigna Я не знаю, якщо це дійсно. Зачекайте, як це працювало?
Ерік Аутгольфер

1
Я не бачу, чому це було б невірно. Це працює, тому що неявні введення висуваються до стеку у зворотному порядку, ніж ви б припустили у таких випадках.
Емінья

@Emigna Я запитав ОП, чи можу я змінити аргументи.
Ерік Аутгольфер

2
Я You may choose any format you like for both input and output, as long as the two numbers are clearly distinguishableмаю на увазі, що ви можете вирішити, що дані приймаються як divisor, dividend. Ви можете просто вказати у відповіді "Введення прийнято як divisor, dividend", і вони будуть чітко відрізнені :)
Emigna

6

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

p
m
,|S
% i
Ei

Спробуйте в Інтернеті!

Пояснення

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

Два iпрограми в програмі замінюються двома вхідними значеннями при запуску програми. Зараз %є поділ. Він бере один вхід прямо зі сходу, а при переході на південь він потрапляє на той, Eякий переспрямовує, що шукає і схід. Тож обидва входи подаються %як аргументи.

| - це вбудований модуль, який в основному робить те саме, але закінчується дивлячись на південь для обох в путах.

Ми об'єднуємо обидва результати в пару з ,. Потім mвиконується функція підлоги (яка нам потрібна через %поділ з плаваючою комою) і, нарешті, ми друкуємо результат p.


6

Cubix , 12 13 байт

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

Яка карта на наступний куб

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

Спробуйте тут

Пояснення з виконаними кроками
,I|I,- починається з нечистого цілого поділу, отримує перше ціле число з введення, відбиває назад і отримує наступне ціле число від введення, потім ділиться знову
O;- Виведіть результат цілого поділу і випустіть його
%- зробіть мод. Це можна зробити пізніше, але закінчилося тут
S\o- Додати пробільний символ для складання, перенаправити вгору та вивести простір
W;- Зсуньте вліво та виведіть простір зі стека
O|@- Виведіть попередньо обчислений мод, пройдіть через горизонтальний відбивач та зупиніть.


Побийте мене на дві хвилини. Гарна відповідь!
Лука

@Luke Спасибі, подумав, що можу отримати ще один, але виявився невловимим
MickyT

6

Мозг-Флак , 56 54 байти

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

Спробуйте в Інтернеті!

-2 байти завдяки майстру пшениці

Пояснення

Поточний найбільш відомий цілочисельний поділ і модуль у Brain-Flak дуже схожий (насправді використовуваний в даний час цілий поділ - це лише модифікація, яку я зробив на feersum ).

Порівняння модульного та цілого поділу:
Modulo:   ({}(<>))<>     {   (({})){({}[()])<>}{} }{}<> ([{}()]{})
Division: ({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><  {}   {} >)

Зручно, що програма для цілого поділу використовує лише третій стек для зберігання даних, тоді як програма модуля використовує лише два звичайних стека для зберігання даних. Таким чином, просто запускаючи їх обох одночасно, вони не стикаються один з одним.

Поєднання модуля і цілого поділу:
Modulo:   ({}(<>))<>     {   (({})){({}[()])<>}{} }{}<> ([{}()]{})
Division: ({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><  {}   {} >)

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

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

Це дає нам остаточну програму:
({}<>)<>([()]{()<(({})){({}[()])<>}{}>}<><([{}()]{})>)

Пояснення програми цілочисельного поділу див . Відповідь feersum

Роз'яснення підрозділу цілочислення незабаром ...


5

Java 8, 18 байт

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

Це лямбда-вираз типу BiFunction<Integer, Integer, String>.

Я здивований ... це насправді досить стисле рішення для Java. Перейдіть лямбда-вирази!


5

Мозг-Флак , 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


5

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

5

Excel 2013, 31 30 26 байт

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

Пояснення

Введення знаходиться в комірці A1та B1. Це просто повертає зворотні значення функції FLOORта MODфункції, які призначені для підлоги поділу та для решти. Ці значення розділені комою.


Я думаю, ви маєте на увазі комірки A1 і B1, а не A1 та A2
fəˈnɛtɪk

Так дякую. Виправлено зараз
Лука

Збережіть 1 байт, FLOOR(A1/B1;1)а не QUOTIENT(A1;B1)
інженер

Оскільки вхід завжди є натуральним числом, я думаю, ви можете замінити FLOOR(A1/B1;1)на `INT (A1 / B1) ', щоб зберегти ще 4 байти
Wernisch



4

OIL, 134 106 103 102 bytes

Бере вхід зі stdin, два числа, відокремлені новим рядком. Виводить результат на ціле ділення, потім новий рядок, а потім решту.

Це одна з найскладніших програм 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 нульові місця (За допомогою цього порожнього рядка. Одне з них я міг би зробити перед).

edit: І ще один байт, зробивши початковий нуль неявним. Нам дійсно потрібен лише один буквальний нуль.


Чудова робота! Саме таку відповідь я сподівався отримати цей виклик :) Просто зауважте: вам гарантовано, що дільник завжди буде суворо позитивним, тому вам не потрібно перевіряти поділ на 0;)
Лев,

@Leo I'm guaranteed that the divisor will always be strictly positive at the beginning. It won't work if I take the division by zero part out, this case can happen even when the "actual" division is a normal one. If I remember correctly this occurs when the remainder is zero.
L3viathan

Я говорю про перевірку на рядку 4, а не про лінію 12 ... Чи не виконується вона лише один раз на початку програми?
Лев

@Leo Готово, майже на 30 символів менше, дякую!
L3viathan

4

Сітківка, 14 bytes

Давайте зловживаємо форматами введення / виведення!

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

Приймає введення як b\naуніар, використовуючи для одинакової цифри будь-який один нецифровий символ, який не є новим рядком. Виводить коефіцієнт у десятковій формі, одразу після цього залишок унарний, використовуючи той самий символ, що і вхідний.

Спробуйте в Інтернеті!

(.*) ¶(\1)*відповідає першому номеру, потім новому рядку (¶ це скорочення Ретіни для \ n), а потім перше число знову якомога більше разів. Кількість матчів другої групи буде результатом поділу, а частина, що не відповідає, буде залишком.

З $#2, ми замінюємо все, що було узгоджено в попередньому рядку, на кількість захоплень другої групи, і отримуємо тоді наш результат.


Ха-ха, цілком правильно, я, очевидно, не повинен писати програми пізно ввечері.
FryAmTheEggman

4

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

3

Labyrinth, 11 bytes

?:?:}/!\{%!

Try it online!

Explanation

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

The IP then hits a dead end, turns around and the program terminates due to the attempted division by zero when % is executed again.



3

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

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

Note

  • Input using the -v flag, see TIO for an example.
  • This outputs the remainder first, then a comma and lastly the integer division.

Try it online!

Explanation

Note that the stack starts as A, B, where A and B represent the first and second input, because of the -v flag used.

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

How can you provide input values up to 255?
Leo

Just use higher ASCII/Unicode values. That way, į becomes 255.
Luke

Ok, nice :) By the way, wouldn't it be shorter to take input numbers from command line directly with the -v flag?
Leo

It would, but I couldn't get that to work on TIO, so I settled with this solution. It would save 8 bytes - 1 (for the -v flag).
Luke


3

C, 21 bytes

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

A macro that replaces f(a,b) with the 2 terms comma separated. Though you'd better be passing it to a function or else there's no way to pick the 2 apart.

Try It Online


3

Haskell, 21 bytes

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

Try it online! Example usage: 13#2 returns (6,1). Yes, this is pretty boring, however slightly more interesting than the divMod build-in which works the same.

While we are at it, there is also quot, rem and quotRem which behave the same on natural numbers as div, mod and divMod. However, for negative inputs the result of mod has the same sign as the divisor, while the result of rem has the same sign as the dividend. Or, as it is put in the Prelude documentation, quot is integer division truncated toward zero and div is integer division truncated toward negative infinity.


How about no div or mod build-ins?

No build-ins, 36 32 31 bytes

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

Try it online! Example usage: 13#2 returns (1,6), that is the mod result is first and the div result second. If a is smaller b, then a mod b is a and a div b is 0, so (a,0) is returned. Otherwise recursively compute mod and div of a-b and b, add 1 to the division result and keep the remainder.

Adding 1 to the division result is achieved by using <$>, which is commonly used as map to map functions over lists, but works on tuples too, however the function is applied to the second tuple element only.

Edit: Saved one byte thanks to xnor!


2
Your second solution can shave a byte using <$> on a tuple to act on its second element :a#b|a<b=(a,0)|m<-a-b=(+1)<$>m#b.
xnor

3

SWI Prolog, 109 bytes

p(A):-print(A).
d(F,S,0,F):-S>F.
d(F,S,D,R):-G is F-S,d(G,S,E,R),D is E+1.
d(F,S):-d(F,S,D,R),p(D),p(-),p(R).

Output:

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

Description:

Simple recursive algorithm without builtin division or modulo. It simply counts "how many times fits the Second number into the First one?" and reports the result (unified to D) with the remainder (R).

//edit: removed unnecessary spaces


Welcome to PPCG! I have never used Prolog before, but noticed there are spaces around :- in the last line but not on the others. Are they required there for some reason? The same goes for E + 1 while F-S suggest there are no spaces needed.
Laikoni

Laikoni: You are definitely right! I've just removed the spaces and updated final byte count.
Jan Drozen


2

MATL, 5 bytes

/k&G\

Try it out at MATL Online!

Explanation

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

2

Ouroboros, 15 bytes

r.r.@/Inao\%n1(

Takes the numbers in reverse order (e.g. 10 42). Try it here.

Explanation

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
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.