除法和余数


36

尽管在大多数“标准”语言中可能是微不足道的,但这一挑战是针对那些在本网站上很少见到的深奥,低级和/或难以使用的语言。它应该提供一个有趣的问题来解决,因此这是您尝试阅读的奇怪语言的机会!

任务

取两个自然数ab作为输入,和其它输出两个数字:整数除法的结果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是的,我不确定倒车是否不会使它们难以区分。
暴民埃里克(Erik the Outgolfer)'17

@EriktheOutgolfer,如果您知道需要将其反转,则可以轻松区分它们:)
Leo

不幸的是,如果除数为,则BF算法不起作用1
mbomb007'3

Answers:


23

BitCycle146 79 64字节

刚意识到我的原始代码的整个部分都是不必要的。大大减少!

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

程序从命令行以一元除法输入一元。它输出一元的商和余数,以a分隔0。例如,这里有a=11b=4a/b=2a%b=3

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

空洞的,实际的

这是我的非高尔夫版本计算功能a=3b=5并且启用了动画(对毛刺现象感到抱歉):

Divmod running in BitCycle

尝试解释

该说明适用于非高尔夫版本。在解决此问题之前,强烈建议您阅读Esolangs页面,以了解该语言的工作原理。

该算法如下所示:

  • 运行外部循环,直到程序终止。
    • 对除数的位运行内部循环,将它们与除数的位配对。
      • 如果除数的所有位都具有匹配的除数位,则输出一个位。
      • 如果不是除数的所有位都具有匹配的除数位,则输出分隔符,0然后输出存在的除数位,然后终止。

代码的核心是收集器之间的关系(大写字母)。由于与每个字母多个独立的收藏家,让我们称它们为A1A2B1B2,等,编号从上到下。

  • A1A2在主循环开始时分别保持除数和除数。
  • 内循环一次从除数和除数中剥离一位。
    • 除数的其余部分(如果有的话)总是进入B1
    • 如果除数和除数均为非空,则一位进入C1,一位进入C3。其余的股利将计入B2
    • 如果只有除数是非空的,那么我们就到了分红的尽头,现在该打印余数了。除数的部分变为C2
    • 如果只有股利是非空的,那我们就到了除数的末尾。现在该处理C3C2输出中的位了。其余的股利将计入C4
  • 如果B收集器中有任何位,它们将其内容循环回A收集器并在内部循环中继续。
  • 一旦AB收集器全部为空,C收集器将打开,我们进入处理阶段:
    • C1并将C4其内容(分别除数和剩余的红利)转储到D1和中D3
    • 如果C2为空,我们仍在打印商。
      • 内容C3转到右上角的=开关。第1一位直接通过!并输出。
      • 当该1位通过时,它将激活开关以向右指向,从而将所有后续位发送到板上。
    • 如果C2不为空,我们将打印其余部分。
      • 的第一位C2取反,0并通过开关。在0接着!并输出。
      • 当该0位通过时,它激活开关以指向左。现在,所有来自的位C3都从开关向左移动,并被重定向到中!,输出整个余数。
      • 的第一位副本C2也发送到中D2
  • 现在D收藏家打开了。
    • 如果中有任何内容D2,则表示我们只打印了其余部分。中的位D2点击@,终止程序。
    • 否则,内容D1D3环回A1A2分别与主循环开始。

太棒了
Evan Carslake

“程序从命令行从一元输入”:对我来说,这看起来像二进制吗?
therealfarfetch

哎呀 因为输出看起来像二进制,所以尽管输入也应该如此。然后我读了课文。没关系。:P
therealfarfetch17年

15

脑干43 41字节

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

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

程序从STDIN依次读取两个字节dn,并向STDOUT 打印两个字节n%dn / 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(实际上,CD中的值之和始终为d),因此[<+>-](当D为正时,增量C和减量D)会将C设置为dD设置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%dn / d)将存储在单元格DG中,因此进行>>.>>>.打印。


12

功能可按224 108个字节

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

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

在线尝试!

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

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

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

另外,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

⌊÷,|⍨

这是叉子(3列)的顶部(2列),其中顶部的右叉齿是派生函数(将运算符应用于函数的结果):

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

 的地板

÷ 师

, 链接到

| 除以
 交换参数的余数(APL模数为“向后”)

在线尝试!


您是如何制作出很酷的图表的?
emiflake

2
@WolfgangTS辛苦。Dyalog APL具有创建默认功能的基本树形图的功能。在线尝试!我开始与...
亚当

哎呀,看起来很难。恐怕我没有耐心,哈哈
emiflake

较短: ⌊÷,|⍨
ngn

@ngn Ouch,你懂了。很高兴看到您还在这里。
亚当

7

Brachylog,6个字节

{÷|%}ᶠ

在线尝试!

说明

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

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

7

玛特12个 10字节

Qt:ie=&fhq

输入是a,那么b。输出是余数,然后是商。

在线尝试!

说明

这避免了模和除法。相反,它使用数组重塑

  1. 建立一个数组 a+1非零元素。
  2. 重塑为2D数组 b行。如果需要,这将自动填充零。
  3. 最后一个非零条目的行和列索引,减去 1分别是余数和商。

例如考虑a=7b=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

Mathematica,20个 18字节

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

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

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

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

Through@*{Quotient,Mod}

1
您知道当您的语言创建仅将内置功能组合在一起的内置功能时,这很不好……
Fatalize

1
@Fatalize是吗?我发现divmod内置函数非常有用,而Mathematica并不是唯一拥有该语言的语言。
马丁·恩德

8
@Fatalize,计算商和计算余数需要很多相同的工作。如果这两个结果都被使用,正确设计的quotRem内置可节省显著时间在打电话quotrem分开。
朱利安·沃尔夫

6

05AB1E,5个字节

÷²¹%‚

在线尝试!

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


您可以为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


6

Cubix,12 13字节

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

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

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

在这里尝试

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


打我两分钟 好答案!
路加福音

@Luke谢谢,以为我可以再减一次,但
事实

6

Brain-Flak56 54字节

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

在线尝试!

-2字节归功于Wheat Wizard

说明

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

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

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

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

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

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

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

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

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


5

Java 8、18字节

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

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

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


5

Brain-Flak168148110字节

我想我应该检查维基第一

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

格式:

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个字节的代码,-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

5

Excel 2013,31 30 26字节

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

说明

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


我认为您的意思是单元格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

OIL134个 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个字节(我可以做到其中之一)之前)。

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


做得好!这正是我希望收到的这个挑战的答案:)只需注意:您可以保证除数始终是正数,因此您不需要检查除以0的情况;)
Leo

@Leo我保证除数在开始时始终严格为正。如果我将除以零的部分除掉将不起作用,即使“实际”除法是正常的除法,这种情况也可能发生。如果我没记错的话,这在余数为零时会发生。
L3viathan

我说的是第4行的检查,而不是第12行的检查...它不是在程序开始时执行一次吗?
狮子座

@Leo Done,少了将近30个字符,谢谢!
L3viathan

4

视网膜,14字节

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

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

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

在线尝试!

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

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


哈哈,是的,我显然不应该在深夜编写程序。
FryAmTheEggman

4

ArnoldC286个 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

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



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.

如何提供最大为255的输入值?
狮子座

只需使用较高的ASCII / Unicode值。这样,į就变成255。–
路加福音

好吧,不错:)顺便说一句,用-v标志直接从命令行获取输入数字会更短吗?
狮子座

可以,但是我无法在TIO上使用它,因此我选择了此解决方案。它将节省8个字节-1(用于-v标志)。
路加福音


3

C,21字节

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

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

在线试用


3

Haskell,21个字节

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

在线尝试!用法示例:13#2 return (6,1)。是的,这很无聊,但是比起divMod同样起作用的内置程序稍微有趣些。

虽然我们在这,还有quotremquotRem它们的行为对自然数一样divmoddivMod。但是,对于负输入,的结果mod与除数的符号相同,而的结果与除数rem的符号相同。或者,如Prelude文档中所述quot整数除法被截断为零,div整数除法被截断为负无穷大。


不要吧 divmod内置的怎么样?

没有内置,36 32 31字节

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

在线尝试!用法示例:13#2return (1,6),即mod结果为第一,div结果为第二。如果a较小ba mod b则为aa div b0,因此(a,0)返回。否则,递归计算moddiva-bb,将其1加到除法结果中并保留余数。

通过使用除法将除法结果加1 <$>,这通常用于map将函数映射到列表上,但也可以在元组上使用,但是该功能仅应用于第二个元组元素。

编辑:由于xnor,节省了一个字节!


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:删除不必要的空格


欢迎来到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

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