Calcola il Divmod superiore

13

Compito

Dati due numeri interi positivi (divid e n e div o r), calcola il q uotient e il r emainder.
Normalmente sarebbe calcolato come e = o*q+rdove q*o<=ee 0<=r<o.
Per questa sfida è ancora e = o*q+rma q*o>=ee -o<r<=0.
Ad esempio e=20e o=3, normalmente lo sarebbe 20/3 -> 20=3*6+2, poiché 18<=20e 0<=2<3. Qui sarà 20/3 -> 20=3*7-1dove 21>=20e-3<-1<=0

Casi test

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

Non è necessario gestire o=0.

code-golf arithmetic number-theory division

— asta
fonte

3

L'ho definita una banale variante del normale divmod.

— Neil,

È accettabile l'output rcome negazione del reale rper le lingue che utilizzano byte non firmati per archiviare dati o presupporre un overflow? ( -1→ 1/ 255)

— Uriel l'

@Uriel sì, ma aggiungi una nota al riguardo sulla risposta

— Rod,

Risposte:

8

Python 3 , 39 26 byte

Martin Ender ha salvato 13 byte

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

Provalo online!

Python 2 , 25 byte

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

Provalo online!

— Halvard Hummel
fonte

Penso che puoi fare solo x%-yper ottenere il resto.

— Martin Ender,

In realtà, perché non andare fino in fondo ...(-(x//-y),x%-y)

— Martin Ender l'

@MartinEnder Questo è davvero buono

— Halvard Hummel l'

@ Mr.Xcoder Incluso entrambi

— Halvard Hummel l'

8

Gelatina , 3 byte

NdN

Provalo online!

Come funziona

Abuso di nuovo divmod \ o /. Guarda ma nessun unicode!

NdN - Programma completo / Catena diadica. | Esempio: 7, 20

N - Annulla il primo input. | -7
 d - Divmod dal secondo. | [-1, 13]
  N: annulla di nuovo ciascuno di essi. | [1, -13]

— Mr. Xcoder
fonte

6

Haskell , 25 byte

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

Provalo online!

— totallyhuman
fonte

5

Mathematica, 21 byte

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

Provalo online!

— J42161217
fonte

Puoi aggiungere una spiegazione, per favore?

— Rod,

2

@Rod ⌈#/#2⌉calcola il massimale della loro divisione e lo memorizza in una variabile s, quindi sottrae l'argomento 2 * s dall'argomento 1.

— Mr. Xcoder

1

@ Mr.Xcoder sei veloce!

— J42161217,

5

05AB1E , 4 byte

(s‰(

Provalo online!

5 byte

(‰ćÄJ

Provalo online!

Come funzionano

Abusa del modulo di Python! \ O /

(s ‰ (| Programma completo. Sia A e B i due ingressi. | Esempio: 100, 13.

(| Calcola -A. | -100
 s | Scambia (inverti la pila, in questo caso). | 13, -100
  ‰ | Divmod. | [-8, 4]
   (| Negativo (moltiplicare ciascuno per -1, in sostanza). | [8, -4]

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

(‰ ćÄJ | Programma completo. Accetta l'inserimento nell'ordine inverso.

(| Negativo. Push -A.
 ‰ | divmod
  ć | Divmod estratto dalla testa di spinta (crea lo stack [quoziente, [resto]].
   Ä | Valore assoluto (opera sul quoziente).
    J | Unisciti allo stack.

— Mr. Xcoder
fonte

Ah sì, ho dimenticato che il divmod funziona con numeri negativi :)

— Emigna l'

E anche, questa è la nuova funzionalità di Jnon è vero? Non l'ho mai visto prima. Potrebbe sicuramente essere utile.

— Emigna,

@Emigna È descritto come Join. Premi '' .join (a) se a è un elenco; Altrimenti, premi '' .join (pila) . Penso che sia la nuova funzionalità, anche se non ho mai usato Jprima: P

— Mr. Xcoder l'

È decisamente nuovo. Ho provato la mia versione locale da agosto e 5)6dà ['5']6:)

— Emigna l'

4

Alice , 15 byte

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

Provalo online!

Spiegazione

La divisione intera e il modulo di Ruby (su cui sono implementati quelli di Alice) sono definiti in modo tale che l'uso di un divisore negativo fa già quello che vogliamo. Se annulliamo il divisore otteniamo automaticamente il modulo corretto e otteniamo meno il quoziente che vogliamo. Quindi il modo più semplice per risolvere questo è negando un mucchio di numeri:

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

— Martin Ender
fonte

4

Pari / GP , 18 byte

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

Provalo online!

— alephalpha
fonte

3

Julia , 18 byte

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

Provalo online!

.-è una saggia negazione dell'elemento e fldmodrestituisce una tupla fatta dei risultati del divison pavimentato e del residuo corrispondente.

— Uriel
fonte

3

MATL , 5 4 byte

_&\_

Provalo online!

-1 byte grazie a 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

— Giuseppe
fonte

2

J , 16 byte

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

Questa è essenzialmente la soluzione Mathematica di Jenny_mathy riscritta in J.

Come funziona:

a=.>.@% Trova il massimale della divisione degli argomenti sinistro e destro e lo memorizza nella variabile a

,~ concatenato a (invertito)

([-]*a) sottrae un argomento * destro dall'argomento sinistro

Provalo online!

— Galen Ivanov
fonte

2

R , 31 29 byte

-2 byte grazie a Giuseppe

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

Provalo online!

— user2390246
fonte

1

Penso che tu possa fare un 29 byte con-c(e%/%-o,-e%%o)

— Giuseppe,

2

Lisp comune, 7 byte

La funzione integrata ceilingrestituisce due valori: il massimale del quoziente e il resto da abbinare:

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

— Kaz
fonte

2

JavaScript (ES6), 37 31 29 27 25 byte

Salvato 2 byte grazie a @Rod
Salvato 2 byte grazie a @ETHproductions

Accetta input nella sintassi del curry. Restituisce [q, r] .

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

Casi test

Mostra snippet di codice

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
fonte

Probabilmente puoi q=(a+b-1)/b+|0inveceq=a/b+.9|0

— Rod

@ETHproductions Sembra un piano. ;)

— Arnauld il

1

Perl 5 , 30 + 1 ( `-p`) = 31 byte

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

Provalo online!

— Xcali
fonte

1

4 , 55 50 byte

3.711712114001231311141130013513213131211513115154

Provalo online!

Rappresenta il promemoria in base alla sua negazione ( 10anziché a -10), poiché la lingua utilizza input e output byte, considerati validi dal commento OP.

— Uriel
fonte

1

Commentatore , 90 byte

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

Provalo online!

Emette il resto, quindi il quoziente, newline separati.

— caird coinheringaahing
fonte

0

C (gcc) , 43 byte

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

uso

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

Provalo online!

— Giacomo Garabello
fonte

0

Java (OpenJDK 8) , 30 byte

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

Provalo online!

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

— Bernat
fonte

0

Aggiungi ++ , 35 byte

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

Provalo online!

— caird coinheringaahing
fonte

0

C (gcc) 41 byte

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

Questo potrebbe essere un imbroglio, usando due funzioni e potrebbe fallire altri test?

— PrincePolka
fonte

0

Rapido , 47 byte

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

— Herman L
fonte

0

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

Provalo online!

Prende l'input come E, quindi O, separato da una nuova riga e stampa Q, quindi R, separato da una nuova riga.

— Giuseppe
fonte

0

TXR: 8 byte

Funzione integrata ceil-rem. Ad esempio (ceil-rem 20 7)rese (7 -1).

— Kaz
fonte

0

Pulito , 42 byte

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

Provalo online!

— Οurous
fonte

0

Deorst , 23 byte

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

Provalo online!

Come funziona

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

— caird coinheringaahing
fonte

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.

Licensed under cc by-sa 3.0 with attribution required.