Bài tập

Cho hai số nguyên dương (chia e nd và divis o r), tính q uotient và r emainder.
Thông thường nó sẽ được tính là e = o*q+rở đâu q*o<=evà 0<=r<o.
Đối với thách thức này nó vẫn e = o*q+rnhưng q*o>=evà -o<r<=0.
Ví dụe=20 và o=3, thông thường nó sẽ là 20/3 -> 20=3*6+2, kể từ 18<=20và 0<=2<3. Đây sẽ là 20/3 -> 20=3*7-1nơi 21>=20và-3<-1<=0

Các trường hợp thử nghiệm

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

Bạn không cần phải xử lý o=0 .

Python 3 , 39 26 byte

Martin Ender đã lưu 13 byte

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

Hãy thử trực tuyến!

Python 2 , 25 byte

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

Hãy thử trực tuyến!

Thạch , 3 byte

NdN

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Lạm dụng divmod một lần nữa \ o /. Nhìn ma 'không có unicode!

NdN - Chương trình đầy đủ / Chuỗi Dyadic. | Ví dụ: 7, 20

N - Phủ định đầu vào đầu tiên. | -7
 d - Divmod bởi cái thứ hai. | [-1, 13]
  N - Phủ định mỗi lần nữa. | [1, -13]

Haskell , 25 byte

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

Hãy thử trực tuyến!

Toán học, 21 byte

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

Hãy thử trực tuyến!

05AB1E , 4 byte

(s‰(

Hãy thử trực tuyến!

5 byte

(‰ćÄJ

Hãy thử trực tuyến!

Chúng hoạt động như thế nào

Lạm dụng modulo của Python! \ o /

(s (| Chương trình đầy đủ. Gọi A và B là hai đầu vào. Ví dụ: 100, 13.

(| Tính -A. | -100
 s | Hoán đổi (đảo ngược ngăn xếp, trong trường hợp này). | 13, -100
  ‰ | Thần thánh. | [-8, 4]
   (| Phủ định (nhân từng số với -1, về cơ bản). | [8, -4]

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

(ĆÄJ | Chương trình đầy đủ. Đưa đầu vào theo thứ tự ngược lại.

(| Tiêu cực. Đẩy -A.
 ‰ | Thần thánh
  ć | Đẩy đầu divmod (tạo ngăn xếp [thương, [phần còn lại]].
   Ä | Giá trị tuyệt đối (hoạt động trên thương số).
    J | Tham gia ngăn xếp.

Alice , 15 byte

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

Hãy thử trực tuyến!

Giải trình

Phân chia số nguyên của Ruby và modulo (trên đó Alice được triển khai) được định nghĩa sao cho sử dụng một ước số âm đã sắp xếp những gì chúng ta muốn. Nếu chúng tôi phủ nhận ước số, chúng tôi sẽ tự động lấy modulo chính xác và chúng tôi sẽ trừ đi thương số mà chúng tôi muốn. Vì vậy, cách dễ nhất để giải quyết điều này là bằng cách phủ định một loạt các số:

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

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

Hãy thử trực tuyến!

Julia , 18 byte

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

Hãy thử trực tuyến!

.-là phần tử phủ định khôn ngoan, và fldmodtrả về một tuple được tạo từ các kết quả của phép ẩn nổi và phần dư tương ứng.

MATL , 5 4 byte

_&\_

Hãy thử trực tuyến!

-1 byte nhờ 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 byte

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

Đây thực chất là giải pháp Mathicala của Jenny_mathy được viết lại trong J.

Làm thế nào nó hoạt động:

a=.>.@% Tìm trần của sự phân chia các đối số trái và phải và lưu nó vào biến a

,~ nối với (đảo ngược)

([-]*a) trừ một đối số * bên phải từ đối số bên trái

Hãy thử trực tuyến!

R , 31 29 byte

-2 byte nhờ Giuseppe

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

Hãy thử trực tuyến!

Lisp thông thường, 7 byte

Hàm tích hợp ceilingtrả về hai giá trị: trần của thương số và phần còn lại để khớp:

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

JavaScript (ES6), 37 31 29 27 25 byte

Đã lưu 2 byte nhờ @Rod
Lưu 2 byte nhờ @ETHproductions

Đưa đầu vào theo cú pháp currying. Trả về [q, r] .

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

Các trường hợp thử nghiệm

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 byte

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

Hãy thử trực tuyến!

4 , 55 50 byte

3.711712114001231311141130013513213131211513115154

Hãy thử trực tuyến!

Đại diện cho lời nhắc bằng cách phủ định ( 10thay vì -10), vì ngôn ngữ sử dụng đầu vào và đầu ra byte, được coi là hợp lệ bởi nhận xét OP.

Bình luận viên , 90 byte

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

Hãy thử trực tuyến!

Đầu ra phần còn lại, sau đó thương số, dòng mới tách ra.

C (gcc) , 43 byte

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

Sử dụng

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

Hãy thử trực tuyến!

Java (OpenJDK 8) , 30 byte

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

Hãy thử trực tuyến!

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

Thêm ++ , 35 byte

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

Hãy thử trực tuyến!

C (gcc) 41 byte

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

Điều này có thể là gian lận, sử dụng hai chức năng và nó có thể thất bại các bài kiểm tra khác?

Dùng thử trực tuyến

Swift , 47 byte

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

SNOBOL4 (CSNOBOL4) , 124 123 105 byte

 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

Hãy thử trực tuyến!

Lấy đầu vào là E, sau đó O, được phân tách bằng một dòng mới và in ra Q, sau đó R, được phân tách bằng một dòng mới.

TXR: 8 byte

Chức năng tích hợp ceil-rem. Ví dụ (ceil-rem 20 7)sản lượng (7 -1).

Sạch , 42 byte

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

Hãy thử trực tuyến!

Deorst , 23 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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