Dados enteros N , P > 1, encuentre el entero más grande Mtal que P ^ M ≤ N.

E / S:

La entrada se da como 2 enteros Ny P. La salida será el entero M.

Ejemplos:

4, 5 -> 0
33, 5 -> 2
40, 20 -> 1
242, 3 -> 4 
243, 3 -> 5 
400, 2 -> 8
1000, 10 -> 3

Notas:

La entrada siempre será válida, es decir, siempre serán enteros mayores que 1.

Créditos

El crédito por el nombre va a @cairdcoinheringaahing. Los últimos 3 ejemplos son de @Nitrodon y el crédito por mejorar la descripción va a @Giuseppe.

Brain-Flak , 74 bytes

(({}<>)[()])({()<(({})<({([{}]()({}))([{}]({}))}{})>){<>({}[()])}{}>}[()])

Pruébalo en línea!

Utiliza el mismo concepto que el algoritmo de división de enteros positivo Brain-Flak estándar.

# Push P and P-1 on other stack
(({}<>)[()])

# Count iterations until N reaches zero:
({()<

  # While keeping the current value (P-1)*(P^M) on the stack:
  (({})<

    # Multiply it by P for the next iteration
    ({([{}]()({}))([{}]({}))}{})

  >)

  # Subtract 1 from N and this (P-1)*(P^M) until one of these is zero
  {<>({}[()])}{}

# If (P-1)*(P^M) became zero, there is a nonzero value below it on the stack
>}

# Subtract 1 from number of iterations
[()])

JavaScript (ES6), 22 bytes

Guardado 8 bytes gracias a @Neil

Toma entrada en la sintaxis de curry (p)(n).

p=>g=n=>p<=n&&1+g(n/p)

Pruébalo en línea!

Excel, 18 bytes

=TRUNC(LOG(A1,A2))

Toma la entrada "n" en A1 y la entrada "p" en A2.

Jalea , 3 bytes

bḊL

Esto no utiliza aritmética de punto flotante, por lo que no hay problemas de precisión.

Pruébalo en línea!

Cómo funciona

bḊL  Main link. Left argument: n. Right argument: p

b    Convert n to base p.
 Ḋ   Dequeue; remove the first base-p digit.
  L  Take the length.

Retina 0.8.2 , 35 bytes

.+
$*
+r`1*(\2)+¶(1+)$
#$#1$*1¶$2
#

Pruébalo en línea! Explicación:

.+
$*

Convierta los argumentos a unario.

+r`1*(\2)+¶(1+)$
#$#1$*1¶$2

Si el segundo argumento divide el primero, reemplace el primer argumento con un resultado #más el entero, descartando el resto. Repita esto hasta que el primer argumento sea menor que el segundo.

#

Cuente la cantidad de veces que se ejecutó el ciclo.

Japt, 8 bytes

@<Vp°X}a

Intentalo

Haskell , 30 bytes

n!p=until((>n).(p^).(1+))(1+)0

Pruébalo en línea!

Perl 6 , 13 bytes

&floor∘&log

Pruébalo en línea!

La concatenación que compone el registro y el piso, implícitamente tiene 2 argumentos porque el registro de la primera función espera 2. El resultado es una función.

Haskell , 16 bytes

(floor.).logBase

Pruébalo en línea!

Haskell fue diseñado por matemáticos por lo que tiene un buen conjunto de funciones relacionadas con las matemáticas en Prelude.

R , 25 bytes

function(p,n)log(p,n)%/%1

Pruébalo en línea!

Tome el registro de Pbase Ny haga una división entera con 1, ya que es más corto que floor(). Esto sufre un poco de precisión numérica, por lo que también presento la respuesta a continuación, que no debería, aparte de un posible desbordamiento de enteros.

R , 31 bytes

function(p,n)(x=p:0)[n^x<=p][1]

Pruébalo en línea!

Python 2 , 39 bytes

lambda a,b:math.log(a,b)//1
import math

Pruébalo en línea!

Ruby , 31 bytes

OK, entonces todos esos enfoques basados ​​en registros son propensos a errores de redondeo, por lo que aquí hay otro método que funciona con enteros y está libre de esos problemas:

->n,p{(0..n).find{|i|p**i>n}-1}

Pruébalo en línea!

Pero volviendo a los logaritmos, aunque no está claro hasta qué precisión debemos apoyar la entrada, pero creo que este pequeño truco resolvería el problema de redondeo para todos los números más o menos "realistas":

Ruby , 29 bytes

->n,p{Math.log(n+0.1,p).to_i}

Pruébalo en línea!

C (gcc) + -lm, 24 bytes

f(n,m){n=log(n)/log(m);}

Pruébalo en línea!

Emojicode , 49 48 bytes

🍇i🚂j🚂➡️🚂🍎➖🐔🔡i j 1🍉

Pruébalo en línea!

APL (Dyalog Unicode) , 2 bytes

⌊⍟

Pruébalo en línea!

Muy claro.

⍟ Iniciar sesión

⌊ piso

05AB1E , 6 bytes

Lm¹›_O

Pruébalo en línea!

JavaScript , 40 33 bytes

-3 bytes gracias a DanielIndie

Toma entrada en la sintaxis de curry.

a=>b=>(L=Math.log)(a)/L(b)+.001|0

Pruébalo en línea!

Pari / GP, 6 bytes

logint

(incorporado en la versión 2.7, marzo de 2014. Toma dos argumentos, con una tercera referencia opcional que, si está presente, se establece en la base elevada al resultado)

Python 2, 3, 46 bytes

-1 gracias a Jonathan

def A(a,b,i=1):
 while b**i<=a:i+=1
 return~-i

Python 1, 47 bytes

def A(a,b,i=1):
 while b**i<=a:i=i+1
 return~-i

JavaScript (Node.js) , 22 bytes

m=>f=n=>n<m?0:f(n/m)+1

Pruébalo en línea!

Función recursiva al curry. Usar como g(P)(N). Menos propenso a errores de coma flotante que el usoMath.log , y (creo) el código proporciona valores correctos siempre que ambas entradas sean enteros seguros (debajo 2**52).

Haskell , 35 34 bytes

n!p=last.fst$span((<=n).(p^))[0..]

Gracias @Laikoni por guardar 1 byte

Pruébalo en línea!

J , 5 bytes

<.@^.

Pruébalo en línea!

Wolfram Language (Mathematica) 15 10 Bytes

Floor@*Log 

(requiere orden inverso en la entrada)

Presentación original

⌊#2~Log~#⌋&

Adelante (gforth) , 35 bytes

: f swap s>f flog s>f flog f/ f>s ;

Pruébalo en línea!

Podría ahorrar 5 bytes intercambiando los parámetros de entrada esperados, pero la pregunta especifica que N debe ser primero (se podría argumentar que en un lenguaje de postfijo "Primero" significa la parte superior de la pila, pero me atendré a la letra de las reglas para ahora)

Explicación

swap       \ swap the parameters to put N on top of the stack
s>f flog   \ move N to the floating-point stack and take the log(10) of N
s>f flog   \ move P to the floating-point stack and take the log(10) of P
f/         \ divide log10(N) by log10(P)
f>s        \ move the result back to the main (integer) stack, truncating in the process

Pyth, 6 4 bytes

s.lF

Guardado 2 bytes gracias a Mmenomic
Pruébelo en línea

Cómo funciona

.les log _B (A)
Para ser honesto, no tengo idea de cómo Ffunciona. Pero si funciona, funciona.
strunca un flotante a un int para darnos el entero más alto M.

Maravilla , 9 bytes

|_.sS log

Ejemplo de uso:

(|_.sS log)[1000 10]

Explicación

Versión detallada:

floor . sS log

Este es un estilo escrito sin puntos. sSpasa elementos de la lista como argumentos a una función (en este caso log).

Gforth , 31 bytes

SWAP S>F FLOG S>F FLOG F/ F>S .

Uso

242 3 SWAP S>F FLOG S>F FLOG F/ F>S . 4 OK

Pruébalo en línea!

Explicación

Desafortunadamente, FORTH usa una pila de punto flotante dedicada. Para eso tengo que SWAP(intercambiar) los valores de entrada para que lleguen a la pila de coma flotante en el orden correcto. También tengo que mover los valores a esa pila con S>F. Al mover el resultado de coma flotante de nuevo a entero ( F>S) tengo el beneficio de obtener el truncamiento de forma gratuita.

Versión más corta

Extendiendo los requisitos y proporcionando la entrada en formato flotante y en el orden correcto, hay una versión más corta con 24 bytes.

FLOG FSWAP FLOG F/ F>S .
3e0 242e0 FLOG FSWAP FLOG F/ F>S . 4 OK

Pruébalo en línea!

Casco , 8 7 4 bytes

Lt`B

Pruébalo en línea!

C (gcc) , 61 bytes

i(n,t,l,o,g){for(l=g=0;!g++;g=g>n)for(o=++l;o--;g*=t);g=--l;}

Pruébalo en línea!

Japt , 5 bytes

ìV ÊÉ

Pruébalo en línea!

8 bytes

N£MlXÃäz

Pruébalo en línea!