Calcule el Divmod superior

13

Tarea

Dados dos números enteros positivos (divId e nd y divis o r), calculan la q uotient y el r emainder.
Normalmente se calcularía como e = o*q+rdónde q*o<=ey 0<=r<o.
Para este desafío sigue siendo e = o*q+rpero q*o>=ey -o<r<=0.
Por ejemplo , e=20y o=3normalmente sería 20/3 -> 20=3*6+2, ya que 18<=20y 0<=2<3. Aquí será 20/3 -> 20=3*7-1donde 21>=20y-3<-1<=0

Casos de prueba

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

No necesitas manejarlo o=0.

code-golf arithmetic number-theory division

— varilla
fuente

3

Lo llamó por ser una variante trivial de divmod regular.

— Neil

¿Es aceptable dar salida rcomo la negación de lo real rpara los idiomas que usan bytes sin firmar para almacenar datos o asumir un desbordamiento? ( -1→ 1/ 255)

— Uriel

@Uriel sí, pero agregue una nota sobre esto en la respuesta

— Rod

Respuestas:

8

Python 3 , 39 26 bytes

Martin Ender ahorró 13 bytes

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

Pruébalo en línea!

Python 2 , 25 bytes

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

Pruébalo en línea!

— Halvard Hummel
fuente

Creo que puedes hacer x%-ypara obtener el resto.

— Martin Ender

En realidad, ¿por qué no ir hasta el final ...(-(x//-y),x%-y)

— Martin Ender

@MartinEnder Eso es realmente bueno

— Halvard Hummel

@ Mr.Xcoder Incluye ambos

— Halvard Hummel

8

Jalea , 3 bytes

NdN

Pruébalo en línea!

Cómo funciona

Abusando de divmod nuevamente \ o /. Mira ma 'no unicode!

NdN - Programa completo / cadena diádica. El | Ejemplo: 7, 20

N: niega la primera entrada. El | -7
 d - Divmod por el segundo. El | [-1, 13]
  N - Niega cada vez más. El | [1, -13]

— Sr. Xcoder
fuente

6

Haskell , 25 bytes

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

Pruébalo en línea!

— totalmente humano
fuente

5

Mathematica, 21 bytes

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

Pruébalo en línea!

— J42161217
fuente

¿Puedes agregar una explicación, por favor?

— Rod

2

@Rod ⌈#/#2⌉calcula el límite máximo de su división, y lo almacena en una variable s, y luego resta el argumento 2 * s del argumento 1.

— Sr. Xcoder

1

@ Mr.Xcoder eres rápido!

— J42161217

5

05AB1E , 4 bytes

(s‰(

Pruébalo en línea!

5 bytes

(‰ćÄJ

Pruébalo en línea!

Cómo trabajan ellos

Abusa del módulo de Python! \ o /

(s ‰ (| Programa completo. Sean A y B las dos entradas. | Ejemplo: 100, 13.

(| Calcular -A. | -100
 s | Intercambiar (invertir la pila, en este caso). El | 13, -100
  ‰ | Divmod. El | [-8, 4]
   (| Negativo (multiplica cada uno por -1, básicamente). | [8, -4]

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

(‰ ćÄJ | Programa completo. Toma la entrada en orden inverso.

(| Negativo. Presione -A.
 ‰ | Divmod
  ć | Empuje la cabeza extraída divmod (haga la pila [cociente, [resto]].
   Ä | Valor absoluto (opera en el cociente).
    J | Únete a la pila.

— Sr. Xcoder
fuente

Ah sí, olvidé que el divmod funciona con números negativos :)

— Emigna

Y también, esa es una nueva funcionalidad de J¿no? Nunca he visto eso antes. Definitivamente podría ser útil.

— Emigna

@Emigna Se describe como Join. Presione '' .join (a) si a es una lista; De lo contrario, presione '' .join (pila) . Creo que es la nueva funcionalidad, aunque nunca la he usado Jantes: P

— Mr. Xcoder

Definitivamente es nuevo. Probé en mi versión local de agosto y 5)6da ['5']6:)

— Emigna

4

Alice , 15 bytes

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

Pruébalo en línea!

Explicación

La división de enteros y el módulo de Ruby (en los que se implementan los de Alice) se definen de tal manera que usar un divisor negativo ya hace lo que queremos. Si negamos el divisor, obtenemos automáticamente el módulo correcto, y obtenemos menos el cociente que queremos. Entonces, la forma más fácil de resolver esto es negando un montón de números:

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

4

Pari / GP , 18 bytes

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

Pruébalo en línea!

— alephalpha
fuente

3

Julia , 18 bytes

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

Pruébalo en línea!

.-es una negación sabia del elemento, y fldmoddevuelve una tupla hecha de los resultados de la división con piso y el residuo correspondiente.

— Uriel
fuente

3

MATL , 5 4 bytes

_&\_

Pruébalo en línea!

-1 byte gracias 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
fuente

2

J , 16 bytes

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

Esta es esencialmente la solución de Mathematica de Jenny_mathy reescrita en J.

Cómo funciona:

a=.>.@% Encuentra el límite máximo de la división de los argumentos izquierdo y derecho y lo almacena en la variable a

,~ concatenado a (invertido)

([-]*a) resta un * argumento derecho del argumento izquierdo

Pruébalo en línea!

— Galen Ivanov
fuente

2

R , 31 29 bytes

-2 bytes gracias a Giuseppe

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

Pruébalo en línea!

— usuario2390246
fuente

1

Creo que puedes hacer un byter 29 con-c(e%/%-o,-e%%o)

— Giuseppe

2

Lisp común, 7 bytes

La función incorporada ceilingdevuelve dos valores: el techo del cociente y el resto para que coincida:

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

— Kaz
fuente

2

JavaScript (ES6), 37 31 29 27 25 bytes

Saved 2 bytes thanks to @Rod
Saved 2 bytes thanks to @ETHproductions

Takes input in currying syntax. Returns [q,r].

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

Test cases

Show code snippet

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
fuente

You can probably q=(a+b-1)/b+|0 instead q=a/b+.9|0

— Rod

@ETHproductions Sounds like a plan. ;)

— Arnauld

1

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

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

— Xcali
fuente

1

4, 55 50 bytes

3.711712114001231311141130013513213131211513115154

Representa el recordatorio por su negación (en 10lugar de -10), ya que el lenguaje utiliza la entrada y salida de bytes, considerada válida por el comentario de OP.

— Uriel
fuente

1

Comentarista , 90 bytes

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

Pruébalo en línea!

Emite el resto, luego el cociente, nueva línea separada.

— caird coinheringaahing
fuente

0

C (gcc) , 43 bytes

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

Pruébalo en línea!

— Giacomo Garabello
fuente

0

Java (OpenJDK 8) , 30 bytes

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

Pruébalo en línea!

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

— Bernat
fuente

0

Agregar ++ , 35 bytes

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

Pruébalo en línea!

— caird coinheringaahing
fuente

0

C (gcc) 41 bytes

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

Esto puede ser trampa, utilizando dos funciones y puede fallar otras pruebas?

Pruébalo en línea

— PrincePolka
fuente

0

Swift , 47 bytes

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

— Herman L
fuente

0

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

Pruébalo en línea!

Toma datos como E, entonces O, separados por una nueva línea e imprime Q, luego R, separados por una nueva línea.

— Giuseppe
fuente

0

TXR: 8 bytes

Construido en función ceil-rem. Por ejemplo, (ceil-rem 20 7)rendimientos (7 -1).

— Kaz
fuente

0

Limpio , 42 bytes

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

Pruébalo en línea!

— Οurous
fuente

0

Deorst , 23 bytes

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

Pruébalo en línea!

Cómo funciona

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

— caird coinheringaahing
fuente

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.

Licensed under cc by-sa 3.0 with attribution required.