36
\$\begingroup\$

This challenge, while probably trivial in most "standard" languages, is addressed to those languages which are so esoteric, low-level, and/or difficult to use that are very rarely seen on this site. It should provide an interesting problem to solve, so this is your occasion to try that weird language you've read about!

The task

Take two natural numbers a and b as input, and output two other numbers: the result of the integer division a/b, and the remainder of such division (a%b).

This is : shortest answer (in bytes), for each language, wins!

Input/Output

  • 0<=a<=255, 1<=b<=255. Each of your inputs (and outputs too) will fit in a single byte.
  • You may choose any format you like for both input and output, as long as the two numbers are clearly distinguishable (e.g. no printing the two results together without a delimiter)

Examples

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

Note: Builtins that return both the result of the division and the remainder are forbidden. At least show us how your language deals with applying two functions to the same arguments.

Note 2: As always, an explanation of how your code works is very welcome, even if it looks readable to you it may not be so for someone else!


Leaderboard

Here is a Stack Snippet to generate an overview of winners by language.

To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:

# Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:

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

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:

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

You can also make the language name a link which will then show up in the leaderboard snippet:

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

\$\endgroup\$
  • \$\begingroup\$ Can I reverse the arguments, i.e. instead of providing a b providing b a instead? \$\endgroup\$ – Erik the Outgolfer Mar 27 '17 at 13:29
  • \$\begingroup\$ @EriktheOutgolfer: You may choose any format you like for both input and output, as long as the two numbers are clearly distinguishable \$\endgroup\$ – Emigna Mar 27 '17 at 13:30
  • \$\begingroup\$ @Emigna Yeah, I was not sure if reversing didn't make them indistinguishable though. \$\endgroup\$ – Erik the Outgolfer Mar 27 '17 at 13:32
  • \$\begingroup\$ @EriktheOutgolfer if you know that they need to be reversed you have no problem in distinguishing them :) \$\endgroup\$ – Leo Mar 27 '17 at 13:45
  • \$\begingroup\$ Unfortunately, the BF algorithm doesn't work if the divisor is 1. \$\endgroup\$ – mbomb007 Mar 27 '17 at 13:45

71 Answers 71

2
\$\begingroup\$

Ruby, 27 bytes

a,b=$<.map &:to_i
p a/b,a%b

Reads from standard input, stops when it reaches EOF, and only considers the two integers on the first two lines of its input.

\$\endgroup\$
  • 2
    \$\begingroup\$ You don't have to use stdin and stdout for I/O. Typically, the golfiest Ruby solutions are anonymous lambdas: try ->a,b{[a/b,a%b]} for 16 bytes! \$\endgroup\$ – m-chrzan Mar 27 '17 at 21:25
2
\$\begingroup\$

dc, 12 bytes

?sadla/rla%f

Explanation:

?            # Read input as space-separated integers, push to stack
 sa          # Store second to register a
   d         # Duplicate first
    la       # Load second
      /      # Push first / second
       r     # Swap (stack now first/second, first)
        la   # Load second
          %  # Push first % second
           f # Print stack (first/second, first%second, but in reverse)

Try it online!

With builtins, it's just ?~f. I also tried reading each integer on its own line, but it's the same length (?d?dsa/rla%f).

\$\endgroup\$
2
\$\begingroup\$

Alice, 12 10 bytes

 \%.\
O:io

Try it online!

Explanation

Alice does have a divmod built-in, which would allow a solution in at most 7 bytes:

</
iMOP

(The P could be any character whatsoever, so I thought I'd put the image of Apple-branded cleaning products in your head. You're welcome.)

But without that built-in, things certainly get a bit more interesting.

Since Alice also has separate built-ins for division and modulo, the program is entirely linear, but the instruction pointer takes a fairly tricky path through the code. Here is the breakdown of the program flow:

\    Reflect to NE. Switch to Ordinal
     Reflect off boundary --> SE.
i    Read all input as a string.
     Reflect off boundary --> NE.
.    Duplicate the input string.
     Reflect off boundary --> SE.
     Reflect off corner --> NW.
.    Duplicate the input string. (Irrelevant)
     Reflect off boundary --> SW.
i    Try to read more input, but that just pushes "".
     Reflect off boundary --> NW.
\    Reflect to S. Switch to Cardinal.
:    Implicitly discard the empty string and convert a copy of the input 
     to the two integers it contains and compute the result of their integer division.
     IP wraps back to the first line.
\    Reflect to NW. Switch to Ordinal.
     Reflect off boundary --> SW.
O    Implicitly convert the division result to a string and print it with a 
     trailing linefeed.
     Reflect off corner --> NE.
\    Reflect to E. Switch to Cardinal.
%    Implicitly convert a copy of the input to the two integers it contains
     and compute the result of their modulo.
.    Duplicate the modulo result. (Irrelevant)
\    Reflect to NE. Switch to Ordinal.
     Reflect off corner --> SW.
o    Implicitly convert the modulo reuslt to a string and print it without a
     trailing linefeed.

At this point we're basically done. The IP does a few more rounds through the code and pushes and prints a few more empty strings, but none of that affects the output. Eventually, the code will attempt a division by zero which terminates the program. The instructions executed by Alice after the last meaningful o are:

%::%o\\i..i\:

The exact movement of the IP through the grid and what exactly these commands do to the stack are left as an exercise to the reader...

\$\endgroup\$
  • \$\begingroup\$ I'm glad you wrote this answer :) I've tried to play with the layout and came up with this alternative solution for the same byte count (but maybe a weirder flow) \$\endgroup\$ – Leo Apr 11 '17 at 21:04
  • \$\begingroup\$ @Leo Ah nice. I had some earlier solutions using 1,, but they were longer. Also, nice work figuring out 1, (as opposed to ~) on your own! :D \$\endgroup\$ – Martin Ender Apr 11 '17 at 21:22
1
\$\begingroup\$

Batch, 37 bytes

@set/ad=%1/%2,m=%1%%%2
@echo %d% %m%
\$\endgroup\$
  • \$\begingroup\$ Dang, I'm happy Peter gave me a golf, or this would've been shorter than PowerShell and I would've been embarrassed! :D \$\endgroup\$ – AdmBorkBork Mar 27 '17 at 18:35
1
\$\begingroup\$

Microscript, 11 bytes

ivissCl/pl%
\$\endgroup\$
1
\$\begingroup\$

brainfuck, 47 bytes

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

Input/output in byte-values.

Try it online! - Computes 109,10->10,9, which in characters corresponds to m,\n->\n,\t

This is simply the esolang brainfuck divmod algorithm, with a wrapper for doing input/output and dealing with the case where divisor=1. I'm sure that someone could modify the algorithm to make it work with any input without the need for my boilerplate, but at least now there's a brainfuck answer^^

\$\endgroup\$
1
\$\begingroup\$

Cardinal, 34 32 31 bytes

%:~:v
,0.M#
-
-
>8\ < <
^+/'Jx^

Try it online!

Input is in the format b first, a second
Output is in the format a%b, a/b

Explanation:

%:~:v
    #

Sets second input as active value, first input as inactive value then sends this pointer in two directions

,0.M

Gets the active value mod inactive value, outputs then outputs a space

  .
-
-
>8\ < <
^+/'Jx^

Counts the number of times the inactive value can be subtracted from the active value before it falls to <=0 before outputting the count.

\$\endgroup\$
1
\$\begingroup\$

Pyke, 3 bytes

'f%

Try it online!

\$\endgroup\$
1
\$\begingroup\$

QBIC, 12 bytes

::?a'\`b,a%b

Explanation:

::     Gets two integers from the command line, a and b
?      PRINT
 a'\`b   Integer division in QBasic is '\', however, '\' is the command for ELSE in QBIC
         To tell QBIC not to swap in ELSE at the '\', we need a code literal.
         Everything from the ' to the `is passed on to QBasic without being parsed.
 ,a%b    Also print a MOD b
\$\endgroup\$
1
\$\begingroup\$

ReRegex, 75 Bytes.

#import math
div<(_*),\1_+(,(_*))?>/$3/s(\d+),(\d+)e/$1\/$2,$1%$2/s#input
e

Explination

This is made up of the following regex match and replaces...

  • div<(_*),\1_*(,(_*))?> / $3
  • s(\d+),(\d+)e / $1/$2,$1%$2

And the code line is simply

s(?#input)e.

The s...e takes the input in the form of 123,123 and wraps it, so we know to execute a function on it. In particular, line 2, which changes 123,456 to 123/456,123%456. Then, almost all of it is taken care of by the math library, However, the latest version contains an issue with the fact that integer division is actually ceiling, instead of floor'd division. So the first replacement corrects that.

Currently no TIO, but the GitHub is available.

\$\endgroup\$
1
\$\begingroup\$

J, 9 bytes

(<.@%,|~)

Usage:

   5 (<.@%,|~) 7
0 5
   5 (<.@%,|~) 1
5 0
   18 (<.@%,|~) 4
4 2
   255 (<.@%,|~) 25
10 5

Explanation:

In J a verb is like a function. Verbs are monadic (f x) or dyadic (x f y) and builtin verbs share the same symbol for different monadic and dyadic cases (e.g. x % y is division, % x is reciprocal).

(<.@% , |~) is a train of 3 verbs (fork in J terminology). A fork is: x (f g h) y = (x f y) g (x h y). Our verbs are:

  • |~ - | is modulo in J, but arguments are for some reason reverse to what you'd expect. We need the adverb ~ to reverse the arguments: x f~ y = y f x

  • <. @ % - x % y is division. @ is a conjunction denoting function composition: x (f @ g) y = f (x g y) (J applies right-to-left). <. x is floor.

  • , - Append.

The parenthesis are needed to form the 3-verb train. No parenthesis would parse as x <.@% (, (|~ y)).

\$\endgroup\$
1
\$\begingroup\$

QBasic 4.5, 23 bytes

INPUT a,b
?a\b,a MOD b

This speaks for itself: get two numbers (input needs to be separated by comma) and print their integer division and modulo. QBasic doesn't have a shorthand for MOD, the %symbol is reserved for defining integers.

\$\endgroup\$
1
\$\begingroup\$

I, 5 bytes

/.m,%

/ divide the arguments

.m apply minimum

,% append modulus

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Mathematica, 32 31 bytes

Thanks to Martin Ender for calming the code down to the tune of 1 byte!

0@#2//.a_@b_/;b>=#:>(a+1)[b-#]&

Just to mess with the language. Pure function taking the two positive integer arguments in the opposite (counterintuitive) order, and returning the quotient q and the remainder r in the same style, q[r], as in Martin Ender's Mathematica answer. While that answer is shorter, this one is ... more contrary? It implements repeated subtraction on expressions of the form a[b].

\$\endgroup\$
1
\$\begingroup\$

Forth, 4 bytes

/MOD

Top of stack will be the quotient, then the remainder.

\$\endgroup\$
1
\$\begingroup\$

TI-Basic (TI-84 Plus CE): 18 bytes

Prompt A
Prompt B
{int(A/B),remainder(A,B

Prompt, A, B, newline, {, int(, /, ,, and ) are all one-byte tokens, but remainder( is a two-byte token.

Prompt prompts you for the numbers.

int(A/B) computes the floored division of A and B

remainder(A,B computes remainder when A is divided by B

{ causes the values of int(A/B) and remainder(A,B) to be stored to a list. This list is implicitly returned, as it is the last evaluated value in the program.

The returned list is printed as {divison remainder}, with a space between the numbers.

Note: TI-Basic does not require closing parentheses or brackets in most cases; one exception being here with int(A/B): the ) is needed so as not to pass the value after the comma as a second argument to int( (which would raise an Error: Syntax).

\$\endgroup\$
  • \$\begingroup\$ You can save 2 bytes with Prompt A,B:int({A/B,remainder(A,B \$\endgroup\$ – lirtosiast Apr 6 '17 at 18:42
1
\$\begingroup\$

Pip, 8 bytes

Pa//ba%b

Try it online!

Explanation:

           The input is read automatically into the vars a and b
     a%b   calculate a%b. Since this is the last thing we do, this is printed implicitly.
 a//b      We also want to show a // b (double slashes is integer div).
P          So we need an explicit PRINT command.
\$\endgroup\$
1
\$\begingroup\$

NO!, 118 bytes

It is too insane to do this challenge with NO! which is why it's non-competing (not really, the language is too young to compete in the bloodthirsty arena known as PPCG)

NOOOOOOOOOOOO?NOOOOOOOOOOO
NOOOOOOOOOOOO?NOOOOOOOOOOO
NOOOOO?yes!yess
NOOOOOOOOOOOOOOOOO?yes!yess
NOOOOOOOO?nooo!noooo

Please say you don't want an explanation (one added anyway)

NOOOOOOOOOOOO?                   Create an integer from 
              NOOOOOOOOOOO                              STDIN

NOOOOOOOOOOOO?                   Create an integer from 
              NOOOOOOOOOOO                              STDIN

NOOOOO?                          Divide               by 
       yes!                             line 1 result
           yess                                          line 2 result

NOOOOOOOOOOOOOOOOO?              Modulo               by
                   yes!                 line 1 result
                       yess                              line 2 result

NOOOOOOOO?                       Output               and
          nooo!                         line 3 result
               noooo                                      line 4 result

A yes is used to denote a line number (number determined by number of ss) but the output command takes either numbers or line numbers as arguments and noo!nooo is shorter than yess!yesss

\$\endgroup\$
1
\$\begingroup\$

Triangular, 21 19 bÿtes

$\:A@$U.vS/p%_<%mp<

Prints the result of division, a newline, then the remainder. Formats into this triangle:

     $
    \ :
   A @ $
  U . v S
 / p % _ <
% m p < ÿ ÿ

ÿ is the no-op that is automaticallÿ inserted when there is no code to fill the smallest possible triangle.

Trÿ it online!

Explanation:

I don't know whÿ \ is the first character... Removed it and managed to save two bÿtes. Still don't know whÿ it was there in the first place. ಠ_ಠ

Directionals:

     .
    \ .
   . . .
  . . v .
 / . . . <
. . . <

This is how the interpreter sees the code, without directionals:

$:$S_%pUA@pm%
  • $: reads integer input to the stack and duplicates it. Stack contains input1 input1.
  • $S reads another input to the stack, then stashes it in memorÿ. Stack contains input1 input1 input2, and memorÿ contains input2.
  • _ divides the top two stack values. Now the stack contains input1 input1/input2.
  • % prints the top of stack as an integer.
  • p pops the top of stack. Now the stack contains input1.
  • U pulls memorÿ onto the stack. Now the stack contains input1 input2.
  • A pushes 10 to the stack. Stack contains input1 input2 10.
  • @ prints it as ASCII (newline).
  • p pops it - stack contains input1 input2.
  • m performs modulus on the top two stack values. Stack now contains input1%input2.
  • % prints the top of stack as an integer.
  • the IP then runs off the plaÿing field, and the program terminates.
\$\endgroup\$
1
\$\begingroup\$

Implicit, 9 bytes

$$|/%;_@9

Try it online!

$$|/%;_@9
$$         read two integer inputs
  |        duplicate stack
   /       division
    %      print
     ;     pop
      _    modulus
       @9  print HTAB (delimiter)
\$\endgroup\$
1
\$\begingroup\$

Whispers v2, 77 bytes

> Input
> Input
>> 1÷2
>> ⌊3⌋
>> 1%2
>> Output 4
>> Output 5
>> Then 6 7

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Keg, 12 10 bytes

Other than the creator, I think only I am actively using it. Therefore it is rarely seen on this site; in addition it is esoteric.

Takes 2 inputs separated with newlines.

¿¿:^:"$/"%

Explanation

¿¿#          Takes 2 integer inputs: e.g.     stack [1, 2]
  :#         Duplicate the top item.          stack [1, 2, 2]
   ^#        Reverse the stack.               stack [2, 2, 1]
    :#       Duplicate the stack.             stack [2, 2, 1, 1]
     "#      Right shifts (put top to bottom) stack [1, 2, 2, 1]
      $#     Swap top two items               stack [1, 2, 1, 2]
       /#    Divide top two                   stack [1, 2, 0.5]
         "#  Right shifts                     stack [0.5, 1, 2]
          %# Modulos top two items            stack [0.5, 1]

# Stack is implicitly outputted

TIO

\$\endgroup\$
1
\$\begingroup\$

33, 11 bytes

OcOcsdoilro

Try it online!

Explanation

OcOc        | Harvest input from user
    s       | Store "a" for later use
     doi    | Print the integer division followed by a newline
        l   | Get "a" back
         ro | Print the remainder of the division
\$\endgroup\$
0
\$\begingroup\$

Wonder, 13 bytes

@@[/#1#0%#1#0

Usage:

((@@[/#1#0%#1#0)10)5

Simply a curried lambda that returns a list with both the division and modulus. I'm looking for a golfier way to do this, something that doesn't involve lambdas.

Be sure to do tK1000 beforehand to view list items in the output.

\$\endgroup\$
0
\$\begingroup\$

PHP, 35 Bytes

[,$a,$b]=$argv;echo$a/$b^0,_,$a%$b;
\$\endgroup\$
0
\$\begingroup\$

Forth, 25 bytes

: f 2dup / -rot mod ;

Try it online

Input like a b, output like remainder quotient.

\$\endgroup\$
0
\$\begingroup\$

Elixir, 24 bytes

&{div(&1,&2),rem(&1,&2)}

Anonymous function which uses the capture operator and returns a tuple containing the results.

Full program with test cases (and yes, the . in the function call is required!):

f =
&{div(&1,&2),rem(&1,&2)}

# test cases:
IO.inspect f.(5,7)      # 0,5
IO.inspect f.(5,1)      # 5,0
IO.inspect f.(18,4)     # 4,2
IO.inspect f.(255,25)   # 10,5

Try it online on Elixir Playground.

\$\endgroup\$
0
\$\begingroup\$

PowerShell, 38 31 bytes

$a,$b=$args;($a-$a%$b)/$b;$a%$b

Try it online!

Sheesh, this is icky. So, PowerShell (helpfully) returns floating point values when doing division if it doesn't divide evenly. Sometimes, this is a Good Thing, but other times (like here) it's very not. So, you'd figure "Oh, let's just toss an [int] cast and call it good, right?" Nope. Casting from a [double] to an [int] in PowerShell does banker's rounding, so for input 5, 7 we would get 1 back, not 0. As a result, we need to subtract the remainder (from the modulo), then calculate the division, and then calculate the modulo again. Yay!

Both results are left on the pipeline, and output is implicit.

Saved 7 bytes thanks to PeterTaylor being smarter than me.

\$\endgroup\$
  • \$\begingroup\$ ($a-$a%$b)/$b? \$\endgroup\$ – Peter Taylor Mar 27 '17 at 14:09
  • \$\begingroup\$ @PeterTaylor Oh. Right. facepalm \$\endgroup\$ – AdmBorkBork Mar 27 '17 at 14:41
0
\$\begingroup\$

CJam, 7 bytes

q_~/n~%

Try it online!

n = print with trailing newline

-2 thanks to Martin Ender.
-3 thanks to Peter Taylor and Basic Sunset.I was thinking eval first then the rest.

\$\endgroup\$
  • 2
    \$\begingroup\$ You can save a few bytes by duplicating the input string before evaling it: q_~/n~% \$\endgroup\$ – Business Cat Mar 27 '17 at 14:12
0
\$\begingroup\$

GolfScript, 6 bytes

.~/p~%

Try it online!

I'm literally on an answer spree!

-3 thanks to Peter Taylor.

\$\endgroup\$
  • 2
    \$\begingroup\$ Why evaluate so early if it forces you into such complicated stack manipulations? .~/p~% and similarly for CJam. \$\endgroup\$ – Peter Taylor Mar 27 '17 at 14:12
  • \$\begingroup\$ @PeterTaylor That is very cool. \$\endgroup\$ – Erik the Outgolfer Mar 27 '17 at 14:41

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.