49
\$\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!


The Catalogue

The Stack Snippet at the bottom of this post generates the catalogue from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.

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

## [><>](https://esolangs.org/wiki/Fish), 121 bytes

/* Configuration */

var QUESTION_ID = 114003; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 8478; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    else console.log(body);
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    lang = jQuery('<a>'+lang+'</a>').text();
    
    languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}
body {
  text-align: left !important;
  display: block !important;
}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 500px;
  float: left;
}

table thead {
  font-weight: bold;
}

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="https://cdn.sstatic.net/Sites/codegolf/all.css?v=ffb5d0584c5f">
<div id="language-list">
  <h2>Shortest Solution 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>
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

\$\endgroup\$
21
  • \$\begingroup\$ Can I reverse the arguments, i.e. instead of providing a b providing b a instead? \$\endgroup\$ Commented Mar 27, 2017 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
    Commented Mar 27, 2017 at 13:30
  • \$\begingroup\$ @Emigna Yeah, I was not sure if reversing didn't make them indistinguishable though. \$\endgroup\$ Commented Mar 27, 2017 at 13:32
  • \$\begingroup\$ @EriktheOutgolfer if you know that they need to be reversed you have no problem in distinguishing them :) \$\endgroup\$
    – Leo
    Commented Mar 27, 2017 at 13:45
  • \$\begingroup\$ Unfortunately, the BF algorithm doesn't work if the divisor is 1. \$\endgroup\$
    – mbomb007
    Commented Mar 27, 2017 at 13:45

97 Answers 97

3
\$\begingroup\$

x86-16 machine code, 5 bytes (non-competing?)

88 1E 0105  MOV  BYTE PTR[AAM1+1], BL   ; modify second byte of AAM opcode for divisor
        AAM1:
D4 ?        AAM                         ; ASCII Adjust AX After Multiply

Input numbers in AL and BL. Output division in AH, remainder in AL.

This "abuses" the x86 "ASCII adjust after multiply" instruction intended to facilitate multiplication of binary coded decimal values (BCD), to convert results to base-10 values. These instructions were deprecated in x64, however as an under-documented feature this behavior can be altered by using self-modifying code to perform arbitrary base conversion of variable input data.

Caveat:

The challenge does state Builtins that return both the result of the division and the remainder are forbidden. These operations are always done at the same time in x86 machine code so not clear if this would disqualify the platform. This answer, however, does not use the x86's DIV instruction. Question posed to OP. :)

\$\endgroup\$
3
\$\begingroup\$

Whitespace, 68 bytes

[S S S N
_Push_0][S N
S _Dupe_0][T    N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve_input1][S N
S _Dupe_input1][S N
S _Dupe_input1][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve_input2][T S T S _Integer_divide][T    N
S T _Print_as_integer][S S S T  S T S N
_Push_10_newline][T N
S S _Print_as_character][S S S N
_Push_0][T  T   T   _Retrieve_input1][S N
S _Dupe_input1][T   T   T   _Retrieve_input2][T S T T   _Modulo][T  N
S T _Print_as_integer]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.

Try it online (with raw spaces, tabs and new-lines only).

Prints with a newline delimiter (could alternatively be a tab for the same byte-count).

Explanation in pseudo-code:

Integer a = STDIN as integer
Integer b = STDIN as integer
Print a integer-divided by b
Print "\n"
Print a modulo-b

Example program flow (inputs 255 and 25):

Command   Explanation              Stack          Heap                STDIN  STDOUT  STDERR

SSSN      Push 0                   [0]
SNS       Duplicate 0              [0,0]
TNTT      Read STDIN as integer    [0]            [{0:255}]           255
TTT       Retrieve from heap #0    [255]          [{0:255}]
SNS       Duplicate 255            [255,255]      [{0:255}]
SNS       Duplicate 255            [255,255,255]  [{0:255}]
TNTT      Read STDIN as integer    [255,255]      [{0:255},{255:25}]  25
TTT       Retrieve from heap #255  [255,25]       [{0:255},{255:25}]
TSTS      Integer divide (255/25)  [10]           [{0:255},{255:25}]
TNST      Print as integer         []             [{0:255},{255:25}]         10
SSSTSTSN  Push 10                  [10]           [{0:255},{255:25}]
TNSS      Print as character       []             [{0:255},{255:25}]         \n
SSSN      Push 0                   [0]            [{0:255},{255:25}]
TTT       Retrieve from heap #0    [255]          [{0:255},{255:25}]
SNS       Duplicate 255            [255,255]      [{0:255},{255:25}]
TTT       Retrieve from heap #255  [255,25]       [{0:255},{255:25}]
TSTT      Modulo (255%25)          [5]            [{0:255},{255:25}]
TNST      Print as integer         []             [{0:255},{255:25}]         5
                                                                                     error

Program stops with an error because no exit is defined.

Since the inputs are guaranteed to be non-negative, I'm using the first input as heap-address to store the second input to save bytes.

\$\endgroup\$
3
+100
\$\begingroup\$

Grok, 19 bytes

:Yp:Y%zp/Yp1%-I,Wzq

This outputs remainder,division. Additionally, inputs must be passed through STDIN; it can't be piped from another command.

Explanation:

:Yp                    # Takes the first integer from STDIN and duplicates it.
   :Y                  # Takes the second integer from STDIN and duplicates it to the register.
     %z                # Modulos the two numbers and outputs the remainder.
       p               # Moves the second number from the register to the Document (stack).
        /              # Performs float division on the two numbers.
         Yp1%-         # Floor function shamelessly stolen from https://stackoverflow.com/a/5123037/10363591
              I,W      # Pushes , to the stack and outputs it.
                 zq    # Outputs quotient and terminates.
\$\endgroup\$
1
  • \$\begingroup\$ Bounty started! \$\endgroup\$ Commented Apr 12, 2021 at 17:00
3
\$\begingroup\$

Piet + ascii-piet, 18 bytes (14×2=28 codels)

TABlIiIAQJICSBqKkk

Try Piet online!

Separates by \x01.

-22 bytes thanks to Aiden Chow

\$\endgroup\$
3
  • \$\begingroup\$ 32 bytes \$\endgroup\$
    – Aiden Chow
    Commented Jul 1, 2022 at 21:02
  • \$\begingroup\$ 28 bytes \$\endgroup\$
    – Aiden Chow
    Commented Jul 1, 2022 at 21:11
  • \$\begingroup\$ 18 bytes by rotating the entire program 90 degrees. \$\endgroup\$
    – Aiden Chow
    Commented Jul 1, 2022 at 21:20
3
\$\begingroup\$

ReRegex, 75 49 Bytes.

#import math
s(\d+),(\d+)e/$1\/$2,$1%$2/s#input
e

Explanation

This simply performs the following Regex Substitution

  • s(\d+),(\d+)e / $1/$2,$1%$2

And the input 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, all of it is taken care of by the math library.

Try it online!

\$\endgroup\$
3
\$\begingroup\$

TypeScript's Type System, 78 bytes

//@ts-ignore
type M<A,B,T=[]>=A extends[...B,...infer I]?M<I,B,[...T,1]>:[T,A]

Try it at the TypeScript Playground!

This submission is a generic type taking in two numbers in unary and outputting a tuple of two unary numbers, the first being the division and the second the remainder.

Explanation:

//@ts-ignore           // ignore any compiler errors in this type
type M<
  A,                   // A is the numerator
  B,                   // B is the denominator
  T = []               // T is the # of times recursed (division result)
> =
  A extends [...B,     // if B fits in A (A >= B):
    ...infer I         //   set I to the difference (A - B)
  ] ? M<               //   recurse with:
        I,             //     I as the numerator
        B,             //     B as the denominator
        [...T, 1]      //     T with 1 appended (i.e. increment)
      >
    : [T, A]           // otherwise return [T, A]

This uses tail recursion to increase the maximum recursion depth from 50 to 999.

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

Thunno 2, 3 bytes

禌

Try it online!

  • ç: Apply two commands parallelly:
    • ¦: swapped integer division
    • Œ: swapped modulo
\$\endgroup\$
2
\$\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\$
2
  • 1
    \$\begingroup\$ ($a-$a%$b)/$b? \$\endgroup\$ Commented Mar 27, 2017 at 14:09
  • \$\begingroup\$ @PeterTaylor Oh. Right. facepalm \$\endgroup\$ Commented Mar 27, 2017 at 14:41
2
\$\begingroup\$

Gol><>, 11 bytes

I:I:@$S,N%h

Online interpreter

\$\endgroup\$
2
\$\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\$
2
\$\begingroup\$

Pyke, 3 bytes

'f%

Try it online!

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

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
\$\endgroup\$
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\$
1
  • 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
    Commented Mar 27, 2017 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\$

I, 5 bytes

/.m,%

/ divide the arguments

.m apply minimum

,% append modulus

Try it online!

\$\endgroup\$
2
\$\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\$
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\$
2
  • \$\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
    Commented Apr 11, 2017 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\$ Commented Apr 11, 2017 at 21:22
2
\$\begingroup\$

MathGolf, 4 bytes

‼/%]

Inputs in the order b a, output as a list containing two integers.

Try it online.

Explanation:

‼   # Apply the following two commands to the stack separately:
 /  #  Division (which will be integer division if the given arguments are integers)
 %  #  Modulo
    #  (both builtins will use the implicit input-integers for their two required arguments)
  ] # Then wrap all values on the stack into a list
    # (after which the entire stack joined together is output implicitly as result)

For an actual character-separated string, we could use one of these instead for 5 bytes: ‼/% \ (space separator); ‼/%n\ or ‼/%]n (newline separator); ‼/%⌂\ (* separator).

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

Haskell, 20 bytes

(<*>).(<*>)[div,mod]

Arguments are passed as singleton lists, for example: ((<*>).(<*>)[div,mod]) [10] [3] returns [3,1].

The <*> operator takes a list of function and a list of values, and applies each function to each value. This function puts div and mod in a list, and then passes two arguments to them using <*>.
Haskell also has the builtin divMod which does the same thing (it takes two integers and returns a tuple).

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

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
\$\endgroup\$
0
2
\$\begingroup\$

J-uby, 10 bytes

-[+:/,+:%]

Attempt This Online!

Explanation

The built-in way would be :divmod (7 bytes) but since that’s forbidden we have:

-[ +:/, +:% ]

-[    ,     ]  # Apply each function to the input and return an array of the results
   +:/         # Divide (`+` splats an array into separate arguments)
        +:%    # Modulo
\$\endgroup\$
2
\$\begingroup\$

Japt, 7 bytes

£rYguiz

Try it

£rYguiz     :Implicit input of array U
£           :Map each element at index Y
 r          :  Reduce U by
  Yg        :    Index Y into
    uiz     :      prepend "z" (floor division) to "u" (modulo)
\$\endgroup\$
2
\$\begingroup\$

Thunno DK, 4 bytes

(Actually \$4\log_{256}(96)\approx\$ 3.29 bytes but the leaderboard doesn't take decimals)

|X$x

Attempt This Online!

Explanation

|X   # Integer division, store in X
  $x # Modulus, push X
     # Implicit output of the stack
\$\endgroup\$
2
\$\begingroup\$

ARBLE, 14 bytes

a//b..","..a%b

6 bytes longer than I'd like, but I couldn't find a shorter way to deliminate the two as a//b,a%b simply returns the two functions.

Try it online!

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

Scratch, 60 bytes

Scratchblocks Syntax:

define(x)(y
say(join(join([floor v]of((x)/(y)))[,])((x)mod(y

+12 bytes due to an error reported by xigoi

\$\endgroup\$
2
  • \$\begingroup\$ Doesn't this perform float division rather than integer division? \$\endgroup\$
    – xigoi
    Commented Mar 22, 2023 at 12:26
  • 1
    \$\begingroup\$ You're right; Although Scratch doesn't do float division when the remainder is 0, it does do that when the remainder is not 0. I'll fix it right away \$\endgroup\$ Commented Mar 25, 2023 at 5:12
2
\$\begingroup\$

Uiua, 4 bytes

⌊⊃÷◿

Try it!

⌊⊃÷◿
 ⊃    # fork (in this case apply two functions to the same two arguments)
   ◿  # mod
  ÷   # divide
⌊     # floor
\$\endgroup\$
1
\$\begingroup\$

GolfScript, 6 bytes

.~/p~%

Try it online!

I'm literally on an answer spree!

-3 thanks to Peter Taylor.

\$\endgroup\$
2
  • 2
    \$\begingroup\$ Why evaluate so early if it forces you into such complicated stack manipulations? .~/p~% and similarly for CJam. \$\endgroup\$ Commented Mar 27, 2017 at 14:12
  • \$\begingroup\$ @PeterTaylor That is very cool. \$\endgroup\$ Commented Mar 27, 2017 at 14:41
1
\$\begingroup\$

Batch, 37 bytes

@set/ad=%1/%2,m=%1%%%2
@echo %d% %m%
\$\endgroup\$
1
  • \$\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\$ Commented Mar 27, 2017 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\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

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