除法和余数

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

显示代码段

code-golf  arithmetic  division 
— 狮子座
source
我可以颠倒论点，即代替提供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是的，我不确定倒车是否不会使它们难以区分。
— 暴民埃里克（Erik the Outgolfer）'17
@EriktheOutgolfer，如果您知道需要将其反转，则可以轻松区分它们：)
— Leo
不幸的是，如果除数为，则BF算法不起作用1。
— mbomb007'3

Answers:

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取反，0并通过开关。在0接着!并输出。
      • 当该0位通过时，它激活开关以指向左。现在，所有来自的位C3都从开关向左移动，并被重定向到中!，输出整个余数。
      • 的第一位副本C2也发送到中D2。
  • 现在D收藏家打开了。
    • 如果中有任何内容D2，则表示我们只打印了其余部分。中的位D2点击@，终止程序。
    • 否则，内容D1和D3环回A1和A2分别与主循环开始。
— DLosc
source
太棒了
— Evan Carslake
“程序从命令行从一元输入”：对我来说，这看起来像二进制吗？
— therealfarfetch
哎呀 因为输出看起来像二进制，所以尽管输入也应该如此。然后我读了课文。没关系。：P
— therealfarfetch17年
15

脑干，43 41字节

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

这在Esolangs上使用了我的破坏性模量算法的修改版本。

程序从STDIN依次读取两个字节d和n，并向STDOUT 打印两个字节n％d和n / d。它需要带有双重无限或圆形胶带（例如TIO上的胶带）的头脑清醒的解释器。

在线尝试！

怎么运行的

在程序启动之前，所有单元格的值都为0。从STDIN（）读取d,，向左移动（<）并从STDIN（）读取n之后,，磁带看起来如下。

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

接下来，假设n> 0，我们进入while循环

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

如下转换磁带。

首先，>->+<进入到细胞ç和递减它，然后进入细胞d和增量它，最后回到小区Ç。接下来发生的情况取决于单元格C的值是否为零。

  • 如果细胞Ç保持正值，[>]（向右走，而电池是非零）将晋级细胞Ë。

    >>>>+<<<进步细胞Ĵ递增，然后返回到细胞˚F。

    由于细胞˚F将始终保持0，while循环[<+>-]完全跳过，<<可以追溯到细胞d。

    最后，由于既不d也不Ç保持0，[<]（向左走而细胞是非零）将交还到细胞甲。

  • 如果单元格C保持0，则循环[>]将完全跳过；否则，循环将被跳过。>>>>+<<<前进到细胞ģ递增，然后返回到细胞d。

    此时，D将保持d（实际上，C和D中的值之和始终为d），因此[<+>-]（当D为正时，增量C和减量D）会将C设置为d，D设置为0。

    最后，<<retrocedes细胞乙，[<]（向左走而细胞是非零的）还留给细胞甲。

在这两种情况下，都>-前进到单元格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中，因此进行>>.>>>.打印。

— 丹尼斯
source
12

功能可按，224 108个字节

字节数假定使用BOM进行UTF-16编码。

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

在线尝试！

上面定义了一个函数f，该函数接受两个整数并返回它们的除法和乘积（Funciton中的函数可以具有多个输出，只要输入和输出的总和不超过4）。

实际上，将两个输入值用于多个目的是很简单的：您只需用T型结将连接器分开即可，该值将在两个分支上重复，然后我们可以分别将其输入到内置函数中进行除法和取模。

实际上，我花了两倍的时间才弄清楚如何向用户显示结果，而不是仅仅实施解决方案。

另外，Funciton具有内置的divmod，÷%并且有趣的是，这些内置函数÷以及%我的解决方案使用的实现都是基于 ÷%。然而，我的功能f上面是不是很一致÷%：我不得不换的输入的顺序，虽然现在看来似乎应该是很容易改变的是，到目前为止，我还没有能够做到在不增加字节数。

— 马丁·恩德
source
10

JavaScript（ES6），17个字节

感谢@Arnauld高尔夫球了一个字节

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

接收格式为[x] [y）的输入

通过按位执行获取x / y的下限，或
通过x％y获取余数
将两个值都放入数组中，以便它们都可以返回

在线尝试！

— fəˈnɛtɪk
source
10

APL（Dyalog），5个字节

-2个字节，感谢@ngn

⌊÷,|⍨

这是叉子（3列）的顶部（2列），其中顶部的右叉齿是派生函数（将运算符应用于函数的结果）：

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

⌊ 的地板

÷ 师

, 链接到

| 除以
⍨ 交换参数的余数（APL模数为“向后”）

在线尝试！

— 亚当
source
您是如何制作出很酷的图表的？
— emiflake
2
@WolfgangTS辛苦。Dyalog APL具有创建默认功能的基本树形图的功能。在线尝试！我开始与...
— 亚当
哎呀，看起来很难。恐怕我没有耐心，哈哈
— emiflake
较短： ⌊÷,|⍨
— ngn
@ngn Ouch，你懂了。很高兴看到您还在这里。
— 亚当
7

Brachylog，6个字节

{÷|%}ᶠ

在线尝试！

说明

我们滥用元ᶠ findall谓词将两个不同的谓词应用于两个参数的输入列表：

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

玛特，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]
— 路易斯·门多
source
2
这是横向思考的好例子，做得好！
— 狮子座
6

Mathematica，20个 18字节

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

轻微滥用了灵活的输出规则：结果为div[mod]，将保持未评估状态。可以使用result[[0]]和提取单个数字result[[1]]。

嘿，它只比可笑的内建长一个字节QuotientRemainder。

Mathematica实际上有一种巧妙的方法将多个函数应用于相同的输入，但是要长三个字节：

Through@*{Quotient,Mod}
— 马丁·恩德
source
1
您知道当您的语言创建仅将内置功能组合在一起的内置功能时，这很不好……
— Fatalize
1
@Fatalize是吗？我发现divmod内置函数非常有用，而Mathematica并不是唯一拥有该语言的语言。
— 马丁·恩德
8
@Fatalize，计算商和计算余数需要很多相同的工作。如果这两个结果都被使用，正确设计的quotRem内置可节省显著时间在打电话quot和rem分开。
— 朱利安·沃尔夫
6

05AB1E，5个字节

÷²¹%‚

在线尝试！

05AB1E有一个错误，因此隐式输入不起作用:( Emigna指出输入经常被反向推。

— 暴民埃里克
source
您可以为5个字节做÷²¹％）。
— Emigna
@Emigna我不知道这是否有效。等等，那是怎么工作的？
— 暴民埃里克
1
我不明白为什么它无效。之所以起作用，是因为隐式输入以与在这种情况下假定的相反顺序被推入堆栈。
— Emigna '17
@Emigna我问过OP是否可以颠倒论点。
— 暴民埃里克
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

在线尝试！

说明

在将多个功能应用于同一输入时，水母是一种优美的语言。该语言为2D，所有二进制函数将向南输入一个输入，向东输入另一个。因此，通过从西方和北方接近一个值，我们可以将其提供给两个函数，而不必在代码中重复它。

两个i程序启动，当s在程序与两个输入值代替。现在%是分裂。它直接从东部获取一个输入，而在向南移动时，它命中了E，从而也将搜索向东重定向。所以两个输入都被馈送到%作为参数。

| 是模数的内置函数，基本上做同样的事情，但最终看跌期权都向南看。

我们将两个结果与配对,。然后m是floor函数（我们需要它，因为它%是浮点除法），最后用来打印结果p。

— 马丁·恩德
source
6

Cubix，12 13字节

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

哪个映射到以下多维数据集

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

在这里尝试

用已执行的步骤进行解释
,I|I,-从一个多余的整数除法开始，从输入中获取第一个整数，反射回来，从输入中获取下一个整数，然后再次
O;除法-输出整数除法的结果并弹出它
%-执行mod。可以稍后执行此操作，但在此处结束
S\o-向堆栈中添加空格字符，向上重定向并输出空间
W;-向左移动并从堆栈中弹出空间
O|@-输出先前计算的mod，通过水平反射器并停止。

— 米奇
source
打我两分钟 好答案！
— 路加福音
@Luke谢谢，以为我可以再减一次，但
— 事实
6

Brain-Flak，56 54字节

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

在线尝试！

-2字节归功于Wheat Wizard

说明

当前最知名的整数除法和Brain-Flak的模数非常相似（事实上，当前使用的整数除法只是我对feersum所做的修改的模）。

模和整数除法的比较： 
Modulo:   ({}(<>))<>     {   (({})){({}[()])<>}{} }{}<> ([{}()]{})
Division: ({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><  {}   {} >)

方便地，整数除法程序仅使用第三堆栈来存储数据，而模运算程序仅使用普通的两个堆栈来存储数据。因此，通过简单地同时运行它们，它们不会相互碰撞。

模和整数除法的组合： 
Modulo:   ({}(<>))<>     {   (({})){({}[()])<>}{} }{}<> ([{}()]{})
Division: ({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><  {}   {} >)

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

最后，此组合中使用的整数除法和取模程序都被设计为堆栈干净的（不会在堆栈上留下垃圾/不依赖于堆栈的值（输入）以外的（不）存在），但这不是必需的对于这个问题。因此，我们可以节省两个字节，而不用在主循环的末尾弹出零，而另外两个字节则可以避免在开始时不推零，而是依靠堆栈底部的零填充。

这给了我们最终的程序： 
({}<>)<>([()]{()<(({})){({}[()])<>}{}>}<><([{}()]{})>)

有关整数除法程序的说明，请参见feersum的答案。

整数部分说明即将推出...

— 0'
source
5

Java 8、18字节

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

这是类型的lambda表达式BiFunction<Integer, Integer, String>。

我很惊讶……这实际上是一个针对Java的简洁解决方案。去lambda表达式！

— 苏格拉底凤凰
source
5

Brain-Flak，168148110字节

我想我应该检查维基第一

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

格式：

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
— 赖利
source
— 小麦巫师
5

sed，36个字节

35个字节的代码，-r标志+1 。

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

一元输入，以空格分隔，以较小的数字开头。输出为一元数，商为1s，其余为s。x s。（如果这是不可接受的，请让我知道，我将其更改为以空格分隔1的，例如输入。）

说明

: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
— DLosc
source
5

Excel 2013，31 30 26字节

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

说明

输入在单元格A1和中B1。这仅返回FLOOR和MOD函数的返回值，这些值用于分隔除法和余数。这些值用逗号分隔。

— 路加
source
我认为您的意思是单元格A1和B1不是单元格A1和A2
— fəˈnɛtɪk
是啊谢谢。立即修复
— 路加福音
使用FLOOR(A1/B1;1)而不是保存1个字节QUOTIENT(A1;B1)
— Engineer Toast'Mar
因为输入始终是自然数，所以我认为您可以替换FLOOR(A1/B1;1)为“ INT（A1 / B1）”以节省4个字节
— Wernisch
4

OIL，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)

编辑：通过将“常量”移动到一个数字位置（要引用的较少字节），然后再隐式地将2个零位置（通过使用空行代替），可以减少3个字节（我可以做到其中之一）之前）。

编辑：和另一个字节，通过使初始零隐式。我们实际上只需要一个文字零即可。

— L3viathan
source
做得好！这正是我希望收到的这个挑战的答案：)只需注意：您可以保证除数始终是正数，因此您不需要检查除以0的情况；）
— Leo
@Leo我保证除数在开始时始终严格为正。如果我将除以零的部分除掉将不起作用，即使“实际”除法是正常的除法，这种情况也可能发生。如果我没记错的话，这在余数为零时会发生。
— L3viathan
我说的是第4行的检查，而不是第12行的检查...它不是在程序开始时执行一次吗？
— 狮子座
@Leo Done，少了将近30个字符，谢谢！
— L3viathan
4

视网膜，14字节

让我们滥用输入/输出格式！

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

将输入形式为b\na，以一元形式使用，一元数字使用任何单个非数字，非换行符。使用与输入相同的字符输出以十进制表示的商，然后立即以一进制形式输出余数。

在线尝试！

(.*) ¶(\1)*匹配第一个数字，然后匹配换行符（¶是Retina的\ n的简写），然后再次匹配第一个数字。第二组的匹配数将是除法的结果，而未匹配的部分将是余数。

使用$#2，我们用第二组的捕获数量替换上一行中匹配的所有内容，然后得到我们的结果。

— 狮子座
source
哈哈，是的，我显然不应该在深夜编写程序。
— 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
— 汤姆291
source
3

迷宫，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然后陷入死胡同，转过身来，由于%再次执行时试图除以零而终止程序。

— 马丁·恩德
source
3

> <>，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.
— 路加
source
如何提供最大为255的输入值？
— 狮子座
只需使用较高的ASCII / Unicode值。这样，į就变成255。–
— 路加福音
好吧，不错:)顺便说一句，用-v标志直接从命令行获取输入数字会更短吗？
— 狮子座
可以，但是我无法在TIO上使用它，因此我选择了此解决方案。它将节省8个字节-1（用于-v标志）。
— 路加福音
— Leo
3

C，21字节

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

用两个逗号分隔的f（a，b）替换的宏。尽管最好将其传递给函数，否则无法将2分开。

在线试用

— 比扬
source
3

Haskell，21个字节

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

在线尝试！用法示例：13#2 return (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#2return (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，节省了一个字节！

— 莱科尼
source
2
您的第二个解决方案可以<$>在元组上使用一个字节来对其第二个元素起作用：a#b|a<b=(a,0)|m<-a-b=(+1)<$>m#b。
— xnor
3

SWI Prolog，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）。

// edit：删除不必要的空格

— 扬·德罗森（Jan Drozen）
source
欢迎来到PPCG！我以前从未使用过Prolog，但是注意到:-最后一行周围有空格，但其他行上没有。是否出于某种原因需要它们？这同样适用于E + 1同时F-S建议没有必要的空间。
— Laikoni '17
莱科尼：你绝对是对的！我刚刚删除了空格并更新了最终字节数。
— Jan Drozen
2

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
— Suever
source
2

衔尾蛇，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
— DLosc
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.