งาน

รับจำนวนเต็มบวกสองตัว ( หารe nd และ divis o r) ให้คำนวณq uotient และr emainder
ปกติมันจะคำนวณเป็นe = o*q+rที่และq*o<=e สำหรับความท้าทายนี้ก็ยังคงแต่และ ตัวอย่างและปกติก็จะเป็นตั้งแต่และ ที่นี่จะเป็นที่ไหนและ0<=r<o
e = o*q+rq*o>=e-o<r<=0
e=20o=320/3 -> 20=3*6+218<=200<=2<320/3 -> 20=3*7-121>=20-3<-1<=0

กรณีทดสอบ

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

o=0คุณไม่จำเป็นต้องจับ

Python 3 , 39 26 ไบต์

Martin Enderบันทึก 13 ไบต์

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

ลองออนไลน์!

Python 2 , 25 ไบต์

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

ลองออนไลน์!

เยลลี่ 3 ไบต์

NdN

ลองออนไลน์!

มันทำงานอย่างไร

การละเมิด divmod อีกครั้ง \ o / ดูสิว่าไม่มียูนิโค้ด!

NdN - โปรแกรมเต็มรูปแบบ / ห่วงโซ่ Dyadic | ตัวอย่าง: 7, 20

N - ลบอินพุตแรก | -7
 d - Divmod โดยอันที่สอง | [-1, 13]
  N - ลบล้างอีกครั้ง | [1, -13]

Haskell , 25 ไบต์

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

ลองออนไลน์!

Mathematica ขนาด 21 ไบต์

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

ลองออนไลน์!

05AB1E , 4 ไบต์

(s‰(

ลองออนไลน์!

5 ไบต์

(‰ćÄJ

ลองออนไลน์!

พวกเขาทำงานอย่างไร

ละเมิดโมดูโลของ Python! \ O /

(s ‰ (| โปรแกรมเต็มให้ A และ B เป็นสองอินพุต) ตัวอย่าง: 100, 13

(| คำนวณ -. | -100
 s | สลับ (กลับสแต็กในกรณีนี้) | 13, -100
  ‰ | Divmod | [-8, 4]
   (| Negative (คูณแต่ละตัวด้วย -1 โดยพื้นฐาน) | [8, -4]

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

(‰ćÄJ | โปรแกรมเต็มใช้อินพุตในลำดับย้อนกลับ

(| เชิงลบกด -
 ‰ | Divmod
  ć | ดันหัวสกัด Divmod (ทำสแต็ค [ความฉลาด, [ส่วนที่เหลือ]]
   Ä | ค่าสัมบูรณ์ (ทำงานกับความฉลาด)
    J | เข้าร่วมสแต็ค

อลิซ 15 ไบต์

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

ลองออนไลน์!

คำอธิบาย

การหารจำนวนเต็มของรูบี้และโมดูโล (ซึ่งมีการนำมาใช้ของอลิซ) นั้นมีการกำหนดไว้ว่าการใช้ตัวหารเชิงลบก็ทำตามที่เราต้องการ ถ้าเราลบล้างตัวหารเราจะได้โมดูโลที่ถูกต้องโดยอัตโนมัติและเราจะได้ผลบวกลบที่เราต้องการ ดังนั้นวิธีที่ง่ายที่สุดในการแก้ปัญหานี้คือการลบตัวเลขจำนวนมาก:

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

Pari / GP , 18 ไบต์

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

ลองออนไลน์!

Juliaอายุ 18 ไบต์

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

ลองออนไลน์!

.-เป็นองค์ประกอบการปฏิเสธที่ชาญฉลาดและfldmodผลตอบแทน tuple ที่ทำจากผลของการแบ่งพื้นและสารตกค้างที่สอดคล้องกัน

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

J , 16 ไบต์

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

นี่เป็นวิธีการแก้ปัญหาทางคณิตศาสตร์ของ Jenny_mathy ที่เขียนใหม่ใน J

มันทำงานอย่างไร:

a=.>.@% ค้นหาเพดานของการหารของอาร์กิวเมนต์ซ้ายและขวาและเก็บไว้ในตัวแปร a

,~ ตัดแบ่งเป็น (กลับด้าน)

([-]*a) ลบอาร์กิวเมนต์ * right ออกจากอาร์กิวเมนต์ซ้าย

ลองออนไลน์!

R , 31 29 ไบต์

-2 ไบต์ขอบคุณ Giuseppe

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

ลองออนไลน์!

Common Lisp ขนาด 7 ไบต์

ฟังก์ชั่นในตัวceilingส่งกลับค่าสองค่า: เพดานของความฉลาดทางและส่วนที่เหลือเพื่อให้ตรงกับ:

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

JavaScript (ES6), 37 31 29 27 25 ไบต์

บันทึก 2 ไบต์ขอบคุณ @Rod
บันทึก 2 ไบต์ขอบคุณ @ETHproductions

รับอินพุตในรูปแบบ 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

Perl 5 , 30 + 1 ( -p) = 31 ไบต์

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

ลองออนไลน์!

4 , 55 50 ไบต์

3.711712114001231311141130013513213131211513115154

ลองออนไลน์!

แสดงให้เห็นถึงการแจ้งเตือนโดยมันปฏิเสธ ( 10แทน-10) เนื่องจากภาษาใช้ byte input และ output ถือว่าถือว่าถูกต้องโดยความคิดเห็น OP

ผู้วิจารณ์ 90 ไบต์

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

ลองออนไลน์!

ส่งออกส่วนที่เหลือจากนั้นหารด้วยหารใหม่ขึ้นบรรทัดใหม่

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);
}

ลองออนไลน์!

Java (OpenJDK 8) , 30 ไบต์

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

ลองออนไลน์!

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

เพิ่ม ++ , 35 ไบต์

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

ลองออนไลน์!

C (gcc) 41 ไบต์

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

นี่อาจเป็นการโกงโดยใช้สองฟังก์ชั่นและอาจล้มเหลวในการทดสอบอื่น ๆ ?

ลองออนไลน์

Swift , 47 ไบต์

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

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คั่นด้วยขึ้นบรรทัดใหม่

TXR: 8 ไบต์

ฟังก์ชั่นในceil-remตัว เช่นอัตราผลตอบแทน(ceil-rem 20 7)(7 -1)

ทำความสะอาด , 42 ไบต์

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

ลองออนไลน์!

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