32

Dejar ny bser enteros positivos mayores que 1.

Salida de la distancia desde nla siguiente potencia de b.

Para n=5y b=3, la siguiente potencia de 3from 5es 9( 3^2 = 9), entonces la salida es 9 - 5 = 4.

Para n=8y b=2, la siguiente potencia de 2from 8es 16( 2^4 = 16), entonces la salida es 16 - 8 = 8. Tenga en cuenta que nes un poder de 2en este ejemplo.

Casos de prueba:

Este es el código de golf . La respuesta más corta en bytes gana. Se aplican lagunas estándar .

code-golf arithmetic

— Monja permeable
fuente

16

Gelatina , 4 3 bytes

ạæċ

Un enlace diádico que toma na la izquierda y ba la derecha y devuelve el resultado.

Pruébalo en línea!

¿Cómo?

ạæċ - Link: number n, number b | n,b ∈ ℕ
 æċ - ceiling n to the next power of b
ạ   - absolute difference between n and that

— Jonathan Allan
fuente

44

Tachado 4 sigue siendo regular 4; (

— Uriel

2

@Uriel But  ;)

— HyperNeutrino

tfw su pensamiento inicial inicial es "¡oh, es æċ!" en lugar de "oww esto es tan difícil ..."

— Erik the Outgolfer

Oh, puede que no exista en la historia, pero cambié de un byte 4. Eraæċ_⁸

— Jonathan Allan

@JonathanAllan Como no estaba en la historia, no tenía sentido y por eso lo edité.

— Erik the Outgolfer

8

Asamblea x86-64 ( Convención de llamadas de Windows x64 ), 14 13 bytes

Un enfoque iterativo ineficiente (¡pero esbelto!) (Con crédito a @Neil por inspiración):

               HowFarAway PROC
6A 01             push   1
58                pop    rax         ; temp = 1
               Loop:
0F AF C2          imul   eax, edx    ; temp *= b
39 C8             cmp    eax, ecx
72 F9             jb     Loop        ; keep looping (jump) if temp < n
29 C8             sub    eax, ecx    ; temp -= n
C3                ret                ; return temp
               HowFarAway ENDP

La función anterior toma dos parámetros enteros, n(pasados en el ECXregistro) y b(pasados en el EDXregistro), y devuelve un único resultado entero (en el EAXregistro). Para llamarlo desde C, usaría el siguiente prototipo:

unsigned HowFarAway(unsigned n, unsigned b);

Esto está limitado al rango de un entero de 32 bits. Se puede modificar fácilmente para admitir enteros de 64 bits mediante el uso de registros largos completos, pero costaría más bytes codificar esas instrucciones. :-)

— Cody Gray
fuente

Entonces, ¿no puede establecer eax en 1 en menos de 4 bytes?

— Neil

Hmm ... No de ninguna de las formas normales que usaría un programador cuerdo , pero puedes hacer push 1+ pop raxen solo 3 bytes. Pero ... entonces no tendrías que saltarte la multiplicación, por lo que aún sería un ahorro razonable porque podrías dejar el jmp.

— Cody Gray

¡Ah, sabía que tenía que haber una manera de jugar golf!

— Neil

Puede hacer lo mismo con la convención de llamadas SysV en Linux, con una demostración de TIO .

— Trauma digital

Por supuesto que puede. Puede hacerlo con cualquier convención de llamada que pase al menos los dos primeros parámetros enteros en los registros. Sistema V, Win x64, Win32 __fastcall, etc. Los registros simplemente cambian, y tuve que elegir uno. La moneda apareció "Windows".

— Cody Gray

6

C (gcc) , 39 35 bytes

Nuevo comportamiento indefinido gracias a Erik

f(n,b,i){for(i=b;b<=n;b*=i);n=b-n;}

Pruébalo en línea!

— cleblanc
fuente

f(n,b,i){for(i=b;b<n;b*=i);n=b-n;}ahorra 5 bytes y es compatible con gcc

— Erik the Outgolfer

@EriktheOutgolfer ¿por qué no b-=n?

— Leaky Nun

@LeakyNun Porque es el primer argumento en el que debe guardar el valor de retorno.

— Erik the Outgolfer

Umm, no actualizaste el código.

— Erik the Outgolfer

¿Puedes hacerlo b-=nsi intercambias el orden de by n?

— Zacharý

6

Dyalog APL, 10 bytes

2 bytes guardados gracias a @ZacharyT

⊢-⍨⊣*1+∘⌊⍟

Pruébalo en línea!

Toma ncomo argumento de la derecha y bcomo argumento de la izquierda.

Calcula .b^{⌊log_bn + 1⌋} - n

— Uriel
fuente

Bien, estaba a punto de publicar esta solución exacta

— Kritixi Lithos el

@KritixiLithos Tuve dificultades con el truco del piso. ¿Crees que podría convertirse en un tren?

— Uriel

Sí, se puede: ⊣-⍨⊢*1+∘⌊⍟⍨.

— Zacharý

@ZacharyT agradable!

— Uriel

Obtengo ⊢-⍨⊣*1+∘⌊⍟10 bytes pero con argumentos intercambiados, así que ese nes el argumento correcto y bel argumento izquierdo. Usé el truco de ZacharyT 1+∘⌊para llegar hasta aquí.

— Kritixi Lithos

6

R , 38 34 bytes

pryr::f({a=b^(0:n)-n;min(a[a>0])})

Función anónima. Almacena todos los valores de b a la potencia de todo en el rango [0, n], resta n de cada uno, los subconjuntos en valores positivos y devuelve el mínimo.

TIO tiene una versión no pryr, llamada como f(n,b); Esta versión debe llamarse como f(b,n).

Ahorré 4 bytes gracias a Jarko Dubbeldam, quien luego me superó.

Pruébalo en línea!

— BLT
fuente

Agradable, mucho más corto que la recursión que tenía en mente.

— JAD

pryr::f({a=b^(0:n)-n;min(a[a>0])})es unos pocos bytes más corto.

— JAD

Gracias. He tenido mala suerte al usar pryr::fcuando defino una nueva variable en la función; Parece que funciona aquí.

— BLT

2

Hmm, siempre vale la pena comprobarlo :) Lo que me molesta es si tienes algo así sapply(x, sum)o lo que sea, que se suma suma los argumentos.

— JAD

4

Cubix , 24 20 bytes

-4 bytes gracias a MickyT

Pwp.I|-.;)^0@O?|uq;<

Lee en entrada como n,b

Se adapta a un cubo de 2x2x2:

    P w
    p .
I | - . ; ) ^ 0
@ O ? | u q ; <
    . .
    . .

Explicación:

I|I0 : lee la entrada, empuja 0 (contador) a la pila

^w coloca la IP en el lugar correcto para el bucle:

Pp-: calcular b^(counter), mover na la parte superior de la pila, calcularb^(counter) - n
? : girar a la izquierda si es negativo, recto si es 0, a la derecha si es positivo
- Positivo:: O@salida de la parte superior de la pila (distancia) y salida.
- Negativo: |?proceder como si la parte superior de la pila fuera cero
<;qu;): apunta la IP en la dirección correcta, abre la parte superior de la pila (número negativo / cero), muévete nal final de la pila, gira en U, abre la parte superior de la pila ( b^(counter)) e incrementa el contador
IP está en ^wy el programa continúa.

¡Míralo en línea!

Pruébalo en línea!

— Giuseppe
fuente

1

Usando el mismo procedimiento, solo un camino diferentePwp.I|-.;)^0@O?|uq;<

— MickyT

@MickyT genio! Siento que cada vez que envío una respuesta de cubix, vienes y recortas cuatro o cinco bytes ...

— Giuseppe

3

Haskell , 20 bytes

n%b=until(>n)(*b)1-n

Pruébalo en línea!

until salvar el dia

— xnor
fuente

Augh, sabía que debía haber una construcción para eso. Agradable.

— vroomfondel

2

05AB1E , 9 8 bytes

sLmʒ‹}α¬

Pruébalo en línea!

Explicación

s         # swap order of the inputs
 L        # range [1 ... n]
  m       # raise b to each power
   ʒ‹}    # filter, keep only the elements greater than n
      α   # calculate absolute difference with n for each
       ¬  # get the first (smallest)

— Emigna
fuente

1

Me ganaste por un minuto. Eso es exactamente lo que escribí, pero usé en ćlugar de ¬.

— Riley

@Riley: también funciona con filtro, pero desafortunadamente no guarda ningún byte.

— Emigna

1

@Emigna lamentablemente no guarda ningún byte * guarda byte (s) *

— Erik the Outgolfer

@EriktheOutgolfer: Sí, bueno. Fue un cambio adicional que utiliza la extraña forma en que funciona la entrada implícita que salvó un byte :)

— Emigna

1

@carusocomputing: sí. De hecho, ahorra un byte tenerlos en el orden "incorrecto" , ya que puedo reutilizarlos nimplícitamente, tanto en la comparación del filtro como en el cálculo de la diferencia absoluta.

— Emigna

2

Java (OpenJDK 8) , 42 bytes

Basado en la respuesta C de @ GovindParmar .

n->b->{for(int o=b;n>=b;b*=o);return b-n;}

Pruébalo en línea!

— Bashful Beluga
fuente

2

MAT , 10 9 bytes

yy:YAn^w-

Pruébalo en línea!

Explicación

Considere las entradas 694y 3como ejemplo.

y    % Implicitly take two inputs. Duplicate from below
     % STACK: 694, 3, 694
y    % Duplicate from below
     % STACK: 694, 3, 694, 3
:    % Range
     % STACK: 694, 3, 694, [1 2 3]
YA   % Base conversion (of 694 with "digits" given by [1 2 3]
     % STACK: 694, 3, [3 3 2 3 1 2]
n    % Number of elements
     % STACK: 694, 3, 6
^    % Power
     % 694, 729
w    % Swap
     % STACK: 729, 694
-    % Subtract. Implicitly display
^    % 35

— Luis Mendo
fuente

2

JavaScript (ES6), 29 bytes

Muy similar al enfoque de Rick, pero publicado con su permiso (y algo de ayuda para guardar un byte).

n=>b=>g=(x=b)=>x>n?x-n:g(x*b)

Intentalo

f=
n=>b=>g=(x=b)=>x>n?x-n:g(x*b)
oninput=_=>o.value=f(+i.value)(+j.value)()
o.value=f(i.value=324)(j.value=5)()

*{font-family:sans-serif;}
input{margin:0 5px 0 0;width:50px;}

<label for=i>n: </label><input id=i type=number><label for=j>b: </label><input id=j type=number><label for=o>= </label><input id=o>

Expandir fragmento

— Lanudo
fuente

2

Mathematica, 24 bytes

#2^⌊1/#~Log~#2⌋#2-#&

gracias Martin

I / O

[343, 7]

2058

— J42161217
fuente

Puedes usar 1/Log@##o #2~Log~#. O incluso mejor intercambie el orden de las entradas y use Log@##.

— Martin Ender

Y luego #^Floor[...]#es más corto que #^(Floor[...]+1). Y también están los operadores Unicode Floor.

— Martin Ender

Sí, sí, por supuesto. Estoy trabajando en todo esto. ¡Eres rápido!

— J42161217

No se olvide Log@##! En realidad, si intercambias el orden de los argumentos, ¡ #^⌊Log@##⌋#-#2&debería ser posible para -5 bytes (creo)!

— CalculatorFeline

2

C, 42 40 bytes

Gracias al comentarista @Steadybox por el consejo

o;p(n,b){for(o=b;n>=b;)b*=o;return b-n;}

— Govind Parmar
fuente

2

Usar en forlugar de whileo;p(n,b){for(o=b;n>=b;)b*=o;return b-n;}

— guardar

Sugerir en n/blugar den>=b

— ceilingcat

2

R, 30 bytes

pryr::f(b^floor(log(n,b)+1)-n)

Evalúa la función.

function (b, n) 
b^floor(log(n, b) + 1) - n

Que toma la primera potencia mayor o igual que n, y luego resta nde ese valor.

Cambiado ceiling(power)a floor(power+1)para garantizar que si nes un poder de b, tomamos el siguiente poder.

— JAD
fuente

1

JavaScript (ES6), 31 bytes

f=(n,b,i=b)=>b>n?b-n:f(n,b*i,i)

Casos de prueba:

Mostrar fragmento de código

f=(n,b,i=b)=>b>n?b-n:f(n,b*i,i)

console.log(f(212, 2)) // 44
console.log(f(563, 5)) // 62
console.log(f(491, 5)) // 134
console.log(f(424, 3)) // 305
console.log(f(469, 8)) // 43
console.log(f(343, 7)) // 2058
console.log(f(592, 7)) // 1809
console.log(f(289, 5)) // 336
console.log(f(694, 3)) // 35
console.log(f(324, 5)) // 301

Expandir fragmento

— Rick Hitchcock
fuente

Puede guardar un byte por currying (que no importa si he intentado ganarse tanto ny bo simplemente n), debido a que se evita tener que pasar nde forma recursiva.

— Neil

Gracias @Neil, pero tengo problemas para descubrir cómo hacer eso (?)

— Rick Hitchcock

Las dos versiones que se me ocurrieron fueron n=>g=(b,p=b)=>p>n?p-n:g(b,p*b)y n=>b=>(g=p=>p>n?p-n:g(p*b))(b).

— Neil

¿ f=(n,i)=>g=(b=i)=>b>n?b-n:g(b*i)Funcionaría por 30 bytes? Tendría que ser llamado de esta manera: f(324,5)(). EDITAR: Ah, @Neil me ganó.

— Shaggy

@Neil, gracias, necesito más práctica con el curry.

— Rick Hitchcock

1

Octava , 32 bytes

@(n,b)b^(fix(log(n)/log(b))+1)-n

Pruébalo en línea!

— Luis Mendo
fuente

1

Octava, 26 bytes

@(n,b)b^sum(b.^(0:n)<=n)-n

¡Verifique todos los casos de prueba!

— rahnema1
fuente

1

Rubí , 38 bytes.

Dos enfoques diferentes:

->(n,b){p b**(Math.log(n,b).to_i+1)-n}

Pruébalo en línea!

->(n,b){p b**(0..n).find{|x|b**x>n}-n}

Pruébalo en línea!

— Nnnes
fuente

1

Haskell , 31 bytes

f n b=[b^x-n|x<-[1..],b^x>n]!!0

Pruébalo en línea!

— vroomfondel
fuente

1

Perl 6 , 31 30 29 bytes

->\n,\b{(b,b* *...*>n).tail -n}

Pruébalo (31)

->\n,\b{b**(log(n,b).Int+1)-n}

Pruébalo (30)

{$^b**(log($^a,$b).Int+1)-$a}

Pruébalo (29)

{($^b,$b* *...*>$^a).tail-$a}

Pruébalo (29)

— Brad Gilbert b2gills
fuente

1

PARI / GP , 26 24 bytes

f(n,b)=b^logint(b*n,b)-n

— Charles
fuente

1

Japt , 9 bytes

_q}a@nVpX

¡Pruébelo en línea!

Explicación

_  q}a@  nVpX
Z{Zq}aX{UnVpX}  // Ungolfed
                // Implicit: U, V = input integers
     aX{     }  // For each integer X in [0...1e9), take
          VpX   //   V to the power of X
        Un      //   minus U,
Z{  }           // and return the first one Z where
  Zq            //   Math.sqrt(Z) is truthy.
                //   Math.sqrt returns NaN for negative inputs, and 0 is falsy, so this is
                //   truthy iff Z is positive. Therefore, this returns the first positive
                //   value of V**X - U.
                // Implicit: output result of last expression

— ETHproducciones
fuente

1

... Espere. ¿Qué?

— Shaggy

@ Shaggy He agregado una explicación, espero que esto ayude.

— ETHproductions

1

Python , 42 41 bytes

f=lambda a,b,v=1:(a<v)*(v-a)or f(a,b,v*b)

Una función recursiva que, comenzando con v=1, se multiplica repetidamente por bhasta que excede estrictamente ay luego devuelve la diferencia.

Pruébalo en línea!

Nota: El resultado nunca será cero, por lo que a>=v and f(a,b,v*b)or v-apuede reemplazarse (a<v)*(v-a)or f(a,b,v*b)sin causar errores de recursión.

Python 3, 37 bytes?

Usando una idea de ...

f=lambda n,b:(n<b)*(b-n)or b*f(n/b,b)

que utiliza aritmética de coma flotante (por lo tanto, los resultados pueden desviarse de su verdadera distancia),
intente aquí .

— Jonathan Allan
fuente

tio.run/… es un poco más corto, pero tener que generar el resultado con el formato "% .0f" probablemente sea una trampa.

— rici

@rici Bien, creo que puede estar bien usar aritmética de coma flotante. Lo agregaré como alternativa (se puede guardar otro byte al cambiar de formulario porque b-nnunca es cero al mismo tiempo que n<bes cierto).

— Jonathan Allan

1

Brachylog , 7 bytes

^ʰ↙X>₁-

Pruébalo en línea!

Toma la entrada como una lista [b, n].

    >₁     n is strictly less than
^ ↙X       some power of
 ʰ         b,
      -    and their difference is
           the output.

— Cadena no relacionada
fuente

0

PHP> = 7.1, 46 bytes

for([,$n,$b]=$argv;0>=$d=$b**$i++-$n;);echo$d;

PHP Sandbox en línea

— Jörg Hülsermann
fuente

0

Lua, 74 73 Byte

Una solución directa, estoy usando 10 bytes para asegurar que los argumentos se traten como números y no como cadenas. Salidas a STDIN.

Editar: olvidé eliminar el espacio w=1 n=n+0, guarda un byte

n,b=...b=b+0p=b w=1n=n+0while p<=n do p=math.pow(b,w)w=w+1 end print(p-n)

Explicado

Pruébalo en línea!

n,b=...           -- unpack the argument into the variable n and b
b=b+0             -- set b's type to number
n=n+0             -- set n's type to number
p=b               -- set a variable to track the current value of the powered b
w=1               -- set the nth power
while p<=n        -- iterate untill the current power is greater or equals to n
do
  p=math.pow(b,w) -- raise b to the power w
  w=w+1           -- increment w
end
print(p-n)        -- outputs p minus the following power of b

— Katenkyo
fuente

No sé Lua tan bien, pero es el espacio entre 1y endnecesaria?

— Zacharý

@ZacharyT En Lua, los números hexadecimales se pueden insertar si comienzan con un número, 1endcomenzarían a interpretarse como el número y 1eluego arrojarían un error porque 1enno es un valor hexadecimal válido. Esto solo ocurre cuando la letra que sigue al número es [abcdef]porque otras letras no pueden interpretarse como valor hexadecimal -> w=1whileno arroja un error.

— Katenkyo

Bienvenido de nuevo a PPCG!

— Leaky Nun

0

QBIC , 23 bytes

{p=:^q~p>:|_xp-b|\q=q+1

Toma el parámetro bprimero, luego n.

Explicación

{       DO
p=:^q   SET p to input b (read as 'a' by QBIC fromt he cmd line) ** q (starts as 1)
~p>:    IF p exceeds 'n' (read as 'b' by QBIC fromt he cmd line)
|_xp-b| THEN QUIT, printing p minus b
\q=q+1  ELSE increase q, re-run

— Steenbergh
fuente

0

Python 2 , 48 41 bytes

¡La simplificación del bucle de @ Rod ahorró 7 bytes!

Programa completo sin recursividad o bit twiddling:

i=1;n,b=input()
while n>=i:i*=b
print i-n

Pruébalo en línea!

Formato de entrada: n, b.

— Sr. Xcoder
fuente

Puede simplificar el ciclo para reducir 7 bytes

— Rod

@ Rod nunca habría pensado en eso :). ¡Muchas gracias!

— Sr. Xcoder

0

Python 3 , 50 48 bytes

^{¡Gracias a EriktheOutgolfer por guardar 2 bytes!}

lambda n,b:b**-~int(math.log(n,b))-n
import math

Pruébalo en línea!

Python no tiene ningún registro sofisticado o techos incorporados, así que seguí con el enfoque obvio con un poco de estilo de golf.

— notjagan
fuente

import math;lambda n,b:b**-~int(math.log(n,b))-nguarda dos bytes y está permitido por meta consenso.

— Erik the Outgolfer

@EriktheOutgolfer ceilno funcionaría.

— Leaky Nun

@EriktheOutgolfer No estaba usando ceilporque no funciona para poderes de b, pero como @Uriel señaló que importar antes todavía guarda un byte.

— notjagan

Puede reformatearlo para que esté completamente bien: ¡ Pruébelo en línea! . Simplemente coloque el importdespués de la lambda y agregue f=el encabezado.

— Sr. Xcoder

@ Mr.Xcoder Ah, tienes razón! No sé por qué eso no se me ocurrió.

— notjagan

0

Lisp común, 73 bytes

(defun f(n b)(setq a b)(loop(when(> b n)(return(- b n)))(setq b(* b a))))

Pruébalo en línea!

— Steadybox
fuente

¿A qué distancia está n del siguiente poder de b?

Gelatina , 4 3 bytes

¿Cómo?

Asamblea x86-64 ( Convención de llamadas de Windows x64 ), 14 13 bytes

C (gcc) , 39 35 bytes

Dyalog APL, 10 bytes

R , 38 34 bytes

Cubix , 24 20 bytes

Explicación:

Haskell , 20 bytes

05AB1E , 9 8 bytes

Java (OpenJDK 8) , 42 bytes

MAT , 10 9 bytes

Explicación

JavaScript (ES6), 29 bytes

Intentalo

Mathematica, 24 bytes

C, 42 40 bytes

R, 30 bytes

JavaScript (ES6), 31 bytes

Octava , 32 bytes

Octava, 26 bytes

Rubí , 38 bytes.

Haskell , 31 bytes

Perl 6 , 31 30 29 bytes

PARI / GP , 26 24 bytes

Japt , 9 bytes

Explicación

Python , 42 41 bytes

Python 3, 37 bytes?

Brachylog , 7 bytes

PHP> = 7.1, 46 bytes

Lua, 74 73 Byte

Explicado

QBIC , 23 bytes

Explicación

Python 2 , 48 41 bytes

Python 3 , 50 48 bytes

Lisp común, 73 bytes