Logaritmos de número inteiro

12

Dados inteiros N , P > 1, encontre o maior número inteiro Mtal que P ^ M ≤ N.

E / S:

A entrada é fornecida como 2 números inteiros Ne P. A saída será o número inteiro M.

Exemplos:

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

Notas:

A entrada sempre será válida, ou seja, sempre serão números inteiros maiores que 1.

Créditos:

O crédito para o nome vai para @cairdcoinheringaahing. Os últimos 3 exemplos são de @Nitrodon e os créditos para melhorar a descrição vão para @Giuseppe.

code-golf  math  number  arithmetic 
— Muhammad Salman
fonte
3
Eu sei que nós (a comunidade PPCG) podemos parecer muito exigentes quanto a coisas realmente pequenas, mas comentários como o meu são realmente destinados, de boa fé, a melhorar o desafio! Agora que isso foi resolvido, votei alegremente e excluí meus comentários anteriores.
— Giuseppe
9
Essa é outra razão pela qual sugerimos postar desafios no The Sandbox primeiro, para que você possa receber feedback útil, postar um grande desafio e obter muitas respostas de alta qualidade, com muito menos problemas (como votos de perto e de baixo). :)
— Giuseppe
2
Você sempre pode postar no PPCG Chatroom geral solicitando feedback sobre os desafios do seu sandbox para obter um pouco mais de atenção.
— Giuseppe
12
Quase todas as respostas atuais baseadas em matemática de ponto flutuante produzem resultados errados, mesmo em casos simples como (1000, 10) por causa de erro de arredondamento, por isso adicionei outro caso de teste.
— Nwellnhof 18/04/19
3
@MPW todas as respostas foram excluídas e as sugestões que fiz foram editadas na postagem, para que não fossem mais relevantes.
— 19418 Giuseppe

Respostas:

8

Flacidez Cerebral , 74 bytes

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

Experimente online!

Isso usa o mesmo conceito que o algoritmo padrão de divisão inteira positiva Brain-Flak.

# 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
[()])
— Nitrodon
fonte
7

JavaScript (ES6), 22 bytes

Guardado 8 bytes graças a @Neil

Recebe entrada na sintaxe de currying (p)(n).

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

Experimente online!

— Arnauld
fonte
6

Excel, 18 bytes

=TRUNC(LOG(A1,A2))

Pega a entrada "n" em A1 e a entrada "p" em A2.

— qoou
fonte
Eu acho que você pode usar a INTfunção em vez de TRUNCsalvar 2 bytes.
— Pajonk
4

Geléia , 3 bytes

bḊL

Isso não usa aritmética de ponto flutuante; portanto, não há problemas de precisão.

Experimente online!

Como 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.
— Dennis
fonte
3

Retina 0.8.2 , 35 bytes

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

Experimente online! Explicação:

.+
$*

Converta os argumentos em unário.

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

Se o segundo argumento dividir o primeiro, substitua o primeiro por um #mais o resultado inteiro, descartando o restante. Repita isso até que o primeiro argumento seja menor que o segundo.

#

Conte o número de vezes que o loop foi executado.

— Neil
fonte
3

Japonês, 8 bytes

@<Vp°X}a

Tente

— Shaggy
fonte
Isso é realmente legal, ainda não vi um bom uso dos métodos de função no Japt, este é um bom exemplo.
— Nit
@Nit, levei um bom tempo para lidar com eles também - apenas recentemente comecei a descobrir usos para F.g()- mas eles são incrivelmente úteis.
— Shaggy
3

Perl 6 , 13 bytes

&floor∘&log

Experimente online!

A concatenação que compõe o log e o piso tem implicitamente 2 argumentos porque o primeiro log da função espera 2. O resultado é uma função.

— Phil H
fonte
3
Para argumentos, 1000, 10isso retorna 2.
— Sean
@Sean: Huh, assuntos de precisão interessante lá
— Phil H
3

R , 25 bytes

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

Experimente online!

Pegue o log de Pbase Ne faça a divisão inteira com 1, pois é mais curto que floor(). Isso sofre um pouco com a precisão numérica, por isso apresento a resposta abaixo também, que não deveria, além de possivelmente um excesso de número inteiro.

R , 31 bytes

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

Experimente online!

— Giuseppe
fonte
1
Eu não sei como estrito o desafio obriga-nos a estar no erro de arredondamento mas, por exemplo, f (243,3) é igual a 4 quando ele provavelmente é necessário para ser 5.
— JDL
@JDL esse é um ponto justo; Acredito que uma resposta perfeitamente precisa seria ~ 31 bytes.
— Giuseppe
1
Eu acho que você pode substituir ppor p+.1na resposta 25 byte e você ainda vai ficar bem, por 28 bytes
— JDL
Outra solução de 28 bytes sem problemas de precisão numérica.
— Robin Ryder
2

Ruby , 31 bytes

OK, todas essas abordagens baseadas em log são propensas a erros de arredondamento, então aqui está outro método que funciona com números inteiros e está livre desses problemas:

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

Experimente online!

Mas voltando aos logaritmos, embora não esteja claro até que precisão devemos apoiar a entrada, mas acho que esse pequeno truque resolveria o problema de arredondamento para todos os números mais ou menos "realistas":

Ruby , 29 bytes

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

Experimente online!

— Kirill L.
fonte
2

05AB1E , 6 bytes

Lm¹›_O

Experimente online!

— Emigna
fonte
isso só parece injusto para todos os outros
— Floris
1
As competições @Floris são entre envios em cada idioma e não entre idiomas, certo?
— usar o seguinte comando
@ user202729 sim e não. Na minha opinião, no final, "o código mais curto vence". Mas notei que havia uma solução de 2 bytes mais abaixo ... Esses idiomas de golfe me surpreendem.
— quer
1
@Floris "Não deixe que as linguagens de código-golfe desencorajem você a postar respostas com linguagens que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação".
— usar o seguinte comando
1
@Floris Também ... até o Excel pode fazê-lo em 2 embutidos . Os idiomas de golfe também podem fazer isso em 2 embutidos, apenas os nomes internos são mais curtos. Nada a surpreender.
— usar o seguinte comando
2

Pari / GP, 6 bytes

logint

(interno adicionado na versão 2.7, março de 2014. Leva dois argumentos, com uma terceira referência opcional que, se presente, é definida como a base elevada para o resultado)

— DanaJ
fonte
O logon do @StewieGriffin (x, y) de Pari / GP e Perl / ntheory fornece os resultados corretos para os 7 exemplos mostrados atualmente, incluindo '3' para 1000,10.
— precisa saber é
+1, mas eu contaria isso como 6 bytes.
— Charles
2
Você não tem permissão para usar entradas codificadas, por isso deve ser uma função (por exemplo, como lambda ou definição). No entanto, você pode apenas usar o logintque é válido e conta 5 bytes a menos.
— ბიმო
2

JavaScript (Node.js) , 22 bytes

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

Experimente online!

Função recursiva com curry. Use como g(P)(N). Menos propenso a erros de ponto flutuante do que o usoMath.log e (acredito) o código fornece valores corretos desde que ambas as entradas sejam números inteiros seguros (abaixo 2**52).

— Bubbler
fonte
1

Wolfram Language (Mathematica) 15 10 bytes

Floor@*Log

(requer ordem inversa na entrada)

Submissão original

⌊#2~Log~#⌋&
— Kelly Lowder
fonte
⌊Log@##⌋&é um byte menor
— Lukas Lang
@ Mathe172, esse é um caractere menor, mas conto 13 bytes nisso. O piso esquerdo e o direito contam como 3 bytes cada em UTF-8.
— 21418 Kelly Lowder
@StewieGriffin% [10,1000] fornece 3. As entradas são tratadas como números inteiros em vez de números de máquinas, a menos que você coloque uma casa decimal após elas.
— 21418 Kelly Lowder
1

Quarto (gforth) , 35 bytes

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

Experimente online!

Poderia economizar 5 bytes trocando os parâmetros de entrada esperados, mas a pergunta especifica que N deve ser o primeiro (um argumento pode ser feito que, em uma linguagem pós-fixada, "Primeiro" significa o topo da pilha, mas vou seguir a letra das regras para agora)

Explicação

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
— reffu
fonte
1

Pitão, 6 4 bytes

s.lF

Economizou 2 bytes graças ao Mmenomic
Experimente online

Como funciona

.lé o log B (A)
Para ser sincero, não tenho ideia de como Ffunciona. Mas se funcionar, funciona.
strunca um float para um int para nos fornecer o número inteiro mais alto para M.

— fortraan
fonte
2
1000,10 como entradas dá como saída 2
— Stewie Griffin
Outra solução semelhante é/FlM
— RK.
1

Maravilha , 9 bytes

|_.sS log

Exemplo de uso:

(|_.sS log)[1000 10]

Explicação

Versão detalhada:

floor . sS log

Este é um estilo sem ponto escrito. sSpassa os itens da lista como argumentos para uma função (neste caso, log).

— Mama Fun Roll
fonte
1

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

Experimente online!

Explicação

Infelizmente, o FORTH usa uma pilha de ponto flutuante dedicada. Para isso, tenho que SWAP(trocar) os valores de entrada para que eles cheguem à pilha de ponto flutuante na ordem certa. Eu também tenho que mover os valores para essa pilha com S>F. Ao mover o resultado de ponto flutuante de volta para inteiro ( F>S), tenho o benefício de obter o truncamento gratuitamente.

Versão mais curta

Ampliando os requisitos e fornecendo a entrada no formato flutuante e na ordem correta, existe uma versão mais curta com 24 bytes.

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

Experimente online!

— Kitana
fonte
Geralmente, para as respostas do CodeGolf, os snippets não são permitidos (a menos que indicado de outra forma no desafio). Esta resposta deveria ser ou envolvido com uma função (Palavra em diante) : f .... ;ou uma convertida para um programa que recebe a entrada usando KEYouACCEPT
— reffu
@reffu O que é um trecho? Na minha opinião, um pequeno código parte para mostrar algo que, no entanto, não faz nada significativo para si. Por outro lado, o código que forneci funciona sem alterações em "Experimente online!". Devemos ir meta?
— Kitana
Nesse caso em particular, o código que você postou lançará um estouro de pilha a menos que você coloque os parâmetros antes dele. As respostas de código de golfe geralmente devem ser um programa ou função independente que produz o resultado esperado se chamado posteriormente. Se você seguir o link para o meta post no meu comentário anterior, ele explicitamente menciona que o padrão é que as respostas sejam um programa ou uma função, das quais a sua também não é. Para corrigi-lo exigiria apenas mais 4 bytes
— reffu
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.