Aufgabe

Gegeben seien zwei positive ganze Zahlen (divid e nd und divis o r), berechnen die q uotient und die r emainder.
Normalerweise würde es als e = o*q+rwo q*o<=eund berechnet werden 0<=r<o.
Für diese Herausforderung gibt es e = o*q+raber noch q*o>=eund -o<r<=0.
Zum Beispiel e=20und o=3normalerweise wäre es 20/3 -> 20=3*6+2, da 18<=20und 0<=2<3. Hier wird es 20/3 -> 20=3*7-1wo 21>=20und sein-3<-1<=0

Testfälle

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

Du musst nicht damit umgehen o=0.

Python 3 , 39 26 Bytes

Martin Ender sparte 13 Bytes

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

Probieren Sie es online!

Python 2 , 25 Bytes

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

Probieren Sie es online!

Gelee , 3 Bytes

NdN

Probieren Sie es online!

Wie es funktioniert

Missbrauche divmod nochmal \ o /. Schau ma 'kein Unicode!

NdN - Volles Programm / Dyadische Kette. | Beispiel: 7, 20

N - Negiere die erste Eingabe. | -7
 d - Divmod durch den zweiten. | [-1, 13]
  N - Negiere erneut. | [1, -13]

Haskell , 25 Bytes

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

Probieren Sie es online!

Mathematica, 21 Bytes

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

Probieren Sie es online!

05AB1E , 4 Bytes

(s‰(

Probieren Sie es online!

5 Bytes

(‰ćÄJ

Probieren Sie es online!

Wie sie arbeiten

Missbrauch von Pythons Modulo! \Ö/

(s ‰ (| Volles Programm. Sei A und B die beiden Eingänge. | Beispiel: 100, 13.

(| Berechne -A. | -100
 s | Swap (in diesem Fall den Stapel umkehren). | 13, -100
  ‰ | Divmod. | [-8, 4]
   (| Negativ (im Grunde genommen jeweils mit -1 multiplizieren) | [8, -4]

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

(‰ ćÄJ | Volles Programm. Nimmt die Eingabe in umgekehrter Reihenfolge vor.

(| Negativ. Drücken Sie -A.
 ‰ | Divmod
  ć | Drücken Sie den mit dem Kopf extrahierten DivMod (machen Sie den Stapel [Quotient, [Rest]].
   Ä | Absolutwert (arbeitet mit dem Quotienten).
    J | Verbinden Sie den Stapel.

Alice , 15 Bytes

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

Probieren Sie es online!

Erläuterung

Rubys Integer Division und Modulo (auf denen Alice implementiert ist) sind so definiert, dass die Verwendung eines negativen Divisors bereits sozusagen das tut, was wir wollen. Wenn wir den Divisor negieren, erhalten wir automatisch das richtige Modulo und wir erhalten minus dem Quotienten, den wir wollen. Der einfachste Weg, dies zu lösen, besteht darin, eine Reihe von Zahlen zu negieren:

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

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

Probieren Sie es online!

Julia , 18 Bytes

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

Probieren Sie es online!

.-ist eine elementweise Negation und fldmodgibt ein Tupel aus den Ergebnissen der Bodendivision und den entsprechenden Resten zurück.

MATL , 5 4 Bytes

_&\_

Probieren Sie es online!

-1 Byte dank 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 Bytes

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

Dies ist im Wesentlichen die Mathematica-Lösung von Jenny_mathy, die in J umgeschrieben wurde.

Wie es funktioniert:

a=.>.@% Findet die Obergrenze der Aufteilung der linken und rechten Argumente und speichert sie in der Variablen a

,~ verkettet zu (umgekehrt)

([-]*a) Subtrahiert ein * rechtes Argument vom linken Argument

Probieren Sie es online!

R , 31 29 Bytes

-2 Bytes dank Giuseppe

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

Probieren Sie es online!

Common Lisp, 7 Bytes

Die integrierte Funktion ceilinggibt zwei Werte zurück: die Obergrenze des Quotienten und den Rest der Übereinstimmung:

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

JavaScript (ES6), 37 31 29 27 25 Byte

2 Bytes dank @Rod
gespeichert 2 Bytes dank @ETHproductions gespeichert

Übernimmt Eingaben in der Currying-Syntax. Gibt [q, r] zurück .

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

Testfälle

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 Bytes

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

Probieren Sie es online!

4 , 55 50 Bytes

3.711712114001231311141130013513213131211513115154

Probieren Sie es online!

Stellt die Erinnerung durch ihre Negation dar ( 10anstelle von -10), da die Sprache die Byte-Eingabe und -Ausgabe verwendet, die durch den OP-Kommentar als gültig erachtet wird.

Kommentator , 90 Bytes

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

Probieren Sie es online!

Gibt den Rest und dann den Quotienten aus, wobei die Zeilenumbrüche getrennt werden.

C (gcc) , 43 Bytes

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

Verwendung

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

Probieren Sie es online!

Java (OpenJDK 8) , 30 Byte

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

Probieren Sie es online!

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

Add ++ , 35 Bytes

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

Probieren Sie es online!

C (gcc) 41 Bytes

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

Dies kann ein Betrug sein, der zwei Funktionen verwendet und andere Tests nicht bestehen kann.

Probieren Sie es online aus

Schnell , 47 Bytes

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

SNOBOL4 (CSNOBOL4) , 124 123 105 Bytes

 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

Probieren Sie es online!

Nimmt als Eingabe E, dann Ogetrennt, durch eine neue Zeile und druckt Q, dann R, durch eine neue Zeile getrennt werden .

TXR: 8 Bytes

Eingebaute Funktion ceil-rem. ZB (ceil-rem 20 7)ergibt (7 -1).

Sauber , 42 Bytes

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

Probieren Sie es online!

Deorst , 23 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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