计算上限Divmod

13

任务

给定两个正整数（DIVID Ë次和divis ö R），计算q uotient和- [R emainder。
通常，它将被计算为e = o*q+rwhere q*o<=e和0<=r<o。
对于这个挑战，它仍然e = o*q+r不过q*o>=e和-o<r<=0。
例如e=20和o=3，通常是20/3 -> 20=3*6+2，因为18<=20和0<=2<3。这将是20/3 -> 20=3*7-1地方21>=20和-3<-1<=0

测试用例

Input -> Output
20, 3 -> 7, -1
10, 5 -> 2, 0
7, 20 -> 1, -13
100, 13 -> 8, -4

您不需要处理o=0。

code-golf arithmetic number-theory division

— 竿
source

3

称它为常规divmod的琐碎变体。

— 尼尔，

对于使用无符号字节存储数据或假设发生溢出的语言，将其输出r为实数的取反是否可以接受r？（-1→ 1/ 255）

— Uriel

@Uriel是的，但请在答案上添加注释

— Rod

Answers:

8

Python 3中，39 26个字节

Martin Ender保存了13个字节

lambda x,y:(-(x//-y),x%-y)

在线尝试！

Python 2，25个字节

lambda x,y:(-(x/-y),x%-y)

在线尝试！

— 哈佛哈默尔
source

我想您可以做得到x%-y其余的。

— 马丁·恩德

其实，为什么不走一路呢？(-(x//-y),x%-y)

— Martin Ender

@MartinEnder那真的很好

— Halvard Hummel

@ Mr.Xcoder都包含在内

— Halvard Hummel，

8

果冻，3个字节

NdN

在线尝试！

怎么运行的

再次滥用divmod \ o /。看，没有unicode！

NdN-完整程序/双向链。| 示例：7、20

N-否定第一个输入。| -7
 d-第二个Divdiv。| [-1、13]
  N-再次取反。| [1 -13]

— Xcoder先生
source

6

Haskell，25个字节

n#k=[-div(-n)k,mod n(-k)]

在线尝试！

— 全人类
source

5

Mathematica，21个字节

{s=⌈#/#2⌉,#-#2s}&

在线尝试！

— J42161217
source

请您补充一下说明？

— Rod

2

@Rod ⌈#/#2⌉计算它们的分裂的天花板上，并且将其存储在一个变量中s，然后减去参数2 * S从参数1

— Xcoder先生

1

@ Mr.Xcoder您很快！

— J42161217

5

05AB1E，4个字节

(s‰(

在线尝试！

5字节

(‰ćÄJ

在线尝试！

他们如何工作

滥用Python的模数！\ o /

（s‰（|完整程序。令A和B为两个输入。|示例：100，13。

（|计算-A。| -100
 s | 交换（在这种情况下，请反转堆栈）。| 13-100
  ‰| Divmod。| [-8、4]
   （|负数（基本上每个都乘以-1）。| [8，-4]

-------------------------------------------------- -

（‰ćÄJ|完整程序。以相反的顺序输入。

（|负。按-A。
 ‰| Divmod
  ć| 推头提取divmod（使堆栈[商，[余数]]。
   Ä| 绝对值（以商为准）。
    J | 加入堆栈。

— Xcoder先生
source

嗯，是的，忘记了divmod使用负数:)

— Emigna '17

而且，这是的新功能J吗？以前从未见过。绝对是有用的。

— Emigna '17

@Emigna被描述为Join。如果列表是a，则按''.join（a）; 否则，按''.join（stack）。我认为这是新功能，尽管我从未使用J过：P

— Xcoder先生17年

绝对是新的。从8月起尝试使用我的本地版本，并5)6给出了['5']6:)

— Emigna '17

4

爱丽丝，15字节

/O.
\io/R%e,R:R

在线尝试！

说明

Ruby的整数除法和取模（在其上实现了Alice的定义）的定义使得使用负除数已经可以满足我们的要求。如果我们除以除数，我们将自动获得正确的模，并且得到减去所需商的商。因此，解决此问题的最简单方法是取一堆数字：

/   Switch to Ordinal mode.
i   Read all input as a string "e o".
.   Duplicate the string.
/   Switch to Cardinal mode.
R   Implicitly convert the top string to the two integer values it
    contains and negate o.
%   Compute e%-o.
e,  Swap the remainder with the other copy of the input string. We can't
    use the usual ~ for swapping because that would convert the string 
    to the two numbers first and we'd swap e%-o in between e and o instead
    of to the bottom of the string.
R   Negate o again.
:   Compute e/-o.
R   Negate the result again.
\   Switch to Ordinal mode.
O   Output -(e/-o) with a trailing linefeed.
o   Output e%-o.

    The code now bounces through the code for a while, not doing much except
    printing a trailing linefeed when hitting O again. Eventually, the IP
    reaches : and attempts a division by zero which terminates the program.

— 马丁·恩德
source

4

Pari / GP，18字节

x->y->-[-x\y,-x%y]

在线尝试！

— Alephalpha
source

3

朱莉娅 18字节

x$y=.-fldmod(-x,y)

在线尝试！

.-是元素明智的否定，并fldmod返回由下限除法和相应残差的结果组成的元组。

— 乌里尔
source

3

MATL，5 4字节

_&\_

在线尝试！

-1字节感谢Luis Mendo

      # implicit input
_     # unary minus (negates first input, o)
&\    # alternative output mod, returns remainder, quotient, implicitly takes e
_     # unary minus, takes the opposite of the quotient.
      # implicit output, prints stack as remainder
                                         quotient

— 朱塞佩
source

2

J，16字节

([-]*a),~a=.>.@%

这本质上是用J重写的Jenny_mathy的Mathematica解决方案。

怎么运行的：

a=.>.@% 查找左右参数除法的上限并将其存储到变量a中

,~ 串联到（反向）

([-]*a) 从left参数减去a * right参数

在线尝试！

— 加伦·伊万诺夫（Galen Ivanov）
source

2

R，31 29字节

-2个字节，感谢Giuseppe

function(e,o)-c(e%/%-o,-e%%o)

在线尝试！

— 用户名
source

1

我认为您可以通过-c(e%/%-o,-e%%o)

— Giuseppe

2

Common Lisp，7个字节

内置函数ceiling返回两个值：商的上限，以及要匹配的余数：

$ clisp -q
[1]> (ceiling 20 7)
3 ;
-1

— 卡兹
source

2

JavaScript（ES6），37 31 29 27 25字节

@Rod 保存2个字节感谢@ETHproductions
保存2个字节

以currying语法输入。返回[q，r]。

a=>b=>[q=~-a/b+1|0,a-q*b]

测试用例

显示代码段

let f =

a=>b=>[q=~-a/b+1|0,a-q*b]

console.log(JSON.stringify(f(20)(3)))   // -> 7, -1
console.log(JSON.stringify(f(10)(5)))   // -> 2, 0
console.log(JSON.stringify(f(7)(20)))   // -> 1, -13
console.log(JSON.stringify(f(100)(13))) // -> 8, -4

— Arnauld
source

您可能可以q=(a+b-1)/b+|0代替q=a/b+.9|0

— Rod

@ETHproductions听起来像是一个计划。;）

— Arnauld

1

Perl 5，30 +1（`-p`）= 31字节

say+($_-($\=$_%-($"=<>)))/$"}{

在线尝试！

— Xcali
source

1

4，55 50个字节

3.711712114001231311141130013513213131211513115154

在线尝试！

由于它使用否定（10而不是-10）来表示提醒，因为该语言使用字节输入和输出，被OP注释视为有效。

— 乌里尔
source

1

评论者，90字节

//
;{- -}
{-{-//-}e#<!-}
;{-{-{- -}-}-}
{-{-{-e#-}
;{-{- -}-}
{-%e#*/-}#          /*-}e#*/

在线尝试！

输出余数，然后除以商号，换行符。

— 开斋节
source

0

C（gcc），43个字节

f(x,y,z)int*x;{for(z=0;*x>0;*x-=y)z++;y=z;}

用法

main(){
    int a=7,b=20,c; 
    c=f(&a,b); 
    printf("%d %d\n",c,a);
}

在线尝试！

— 贾科莫·加拉贝洛
source

0

Java（OpenJDK 8），30字节

(i,j)->(i+j-1)/j+","+(i%j-j)%j

在线尝试！

7,-1
2,0
1,-13
8,-4

— 伯纳特
source

0

加++，35字节

L*,@0$_$2D2D%V/1B]b\GLVB]-1Gx$pBcB*

在线尝试！

— 开斋节
source

0

C（gcc）41字节

f(a,b){b=(a+b-1)/b;}g(a,b){b=a-f(a,b)*b;}

使用两个函数可能会作弊，并且可能无法通过其他测试？

— 波尔卡王子
source

0

迅捷，47字节

func f(a:Int,b:Int){print((a+b-1)/b,(a%b-b)%b)}

— 赫尔曼·L
source

0

SNOBOL4（CSNOBOL4），124个 123 105字节

 E =INPUT
 O =INPUT
 Q =E / O
 R =E - Q * O
 EQ(0,R) :S(A)
 R =R - O
 Q =Q + 1
A OUTPUT =Q
 OUTPUT =R
END

在线尝试！

将输入取为E，然后O用换行符分隔Q，然后输出，然后R，用换行符分隔。

— 朱塞佩
source

0

TXR：8个字节

内置功能ceil-rem。例如(ceil-rem 20 7)产量(7 -1)。

— 卡兹
source

0

干净，42字节

import StdEnv
f a b#c=(a-1)/b+1
=(c,a-c*b)

在线尝试！

— 巨大
source

0

Deorst，23个字节

@l0-%z]@l0-,l0-@l0-miE_

在线尝试！

怎么运行的

@                       - Swap the inputs
 l0-                    - Negate
    %                   - Modulo
     z]                 - Push the inputs
       @                - Swap
        l0-             - Negate
           ,            - Integer divide
            l0-         - Negate
               @        - Swap
                l0-     - Negate
                   miE_ - Print

— 开斋节
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.