Logaritmi interi

12

Dati numeri interi N , P > 1, trova il numero intero più grande Mtale che P ^ M ≤ N.

I / O:

L'input è dato come 2 numeri interi Ne P. L'output sarà l'intero M.

Esempi:

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

Appunti:

L'input sarà sempre valido, ovvero sarà sempre un numero intero maggiore di 1.

Titoli di coda:

Il merito del nome va a @cairdcoinheringaahing. Gli ultimi 3 esempi sono di @Nitrodon e il merito per aver migliorato la descrizione va a @Giuseppe.

code-golf math number arithmetic

— Muhammad Salman
fonte

3

So che noi (la comunità PPCG) possiamo sembrare troppo pignoli su cose veramente piccole, ma commenti come il mio sono davvero destinati, in buona fede, a migliorare la sfida! Ora che è stato risolto, ho felicemente votato e cancellato i miei commenti precedenti.

— Giuseppe,

9

Questo è un altro motivo per cui suggeriamo di pubblicare prima le sfide in The Sandbox , in modo da poter ricevere feedback utili, pubblicare una grande sfida e ottenere molte risposte di alta qualità, con molta meno confusione (come voti ravvicinati e negativi). :)

— Giuseppe,

2

Puoi sempre pubblicare post nella chatroom generale di PPCG chiedendo feedback sulle sfide del tuo sandbox per attirare un po 'più di attenzione.

— Giuseppe,

12

Quasi tutte le risposte attuali basate sulla matematica in virgola mobile producono risultati errati anche per casi semplici come (1000, 10) a causa dell'errore di arrotondamento, quindi ho aggiunto un altro caso di test.

— nwellnhof,

3

@MPW tutte le risposte sono state eliminate e i suggerimenti che ho fatto sono stati modificati nel post, quindi non erano più pertinenti.

— Giuseppe,

Risposte:

8

Brain-Flak , 74 byte

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

Provalo online!

Questo utilizza lo stesso concetto dell'algoritmo standard di divisione di numeri interi positivi 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 byte

8 byte salvati grazie a @Neil

Accetta input nella sintassi del curry (p)(n).

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

Provalo online!

— Arnauld
fonte

6

Excel, 18 byte

=TRUNC(LOG(A1,A2))

Accetta l'ingresso "n" in A1 e l'ingresso "p" in A2.

— qoou
fonte

Penso che puoi usare la INTfunzione invece di TRUNCsalvare 2 byte.

— pajonk,

4

Gelatina , 3 byte

bḊL

Questo non usa l'aritmetica in virgola mobile, quindi non ci sono problemi di precisione.

Provalo online!

Come funziona

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 byte

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

Provalo online! Spiegazione:

.+
$*

Converti gli argomenti in unari.

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

Se il secondo argomento divide il primo, sostituire il primo argomento con un risultato #più il numero intero, scartando il resto. Ripeti fino a quando il primo argomento è inferiore al secondo.

Contare il numero di volte in cui il ciclo è stato eseguito.

— Neil
fonte

3

Japt, 8 byte

@<Vp°X}a

— ispido
fonte

Questo è davvero pulito, non ho ancora visto un buon uso dei metodi di funzione in Japt, questo è un buon esempio.

— Nit

@Nit, mi ci è voluto un bel po 'di tempo per capire anche loro - solo di recente ha iniziato a capire gli usi per F.g()- ma sono incredibilmente utili.

— Shaggy,

3

Haskell , 30 byte

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

Provalo online!

— Czyborra romano
fonte

1

Sia until((>n).(p^))(1+)0-1o until(\x->p^x*p>n)(1+)0si scende a 27 byte.

— Lynn,

3

Perl 6 , 13 byte

&floor∘&log

Provalo online!

La concatenazione che compone log e floor ha implicitamente 2 argomenti poiché il primo log delle funzioni prevede 2. Il risultato è una funzione.

— Phil H
fonte

3

Per argomenti 1000, 10questo restituisce 2.

— Sean,

@Sean: Huh, interessante problema di precisione lì

— Phil H

3

Haskell , 16 byte

(floor.).logBase

Provalo online!

Haskell è stato progettato da matematici, quindi ha un bel set di funzioni matematiche in Prelude.

— totallyhuman
fonte

6

Non funziona per (1000, 10) a causa dell'errore di arrotondamento.

— nwellnhof,

3

R , 25 byte

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

Provalo online!

Prendi il registro di Pbase Ned esegui la divisione intera con 1, poiché è più breve di floor(). Questo soffre un po 'di precisione numerica, quindi presento anche la risposta di seguito, che non dovrebbe, a parte l'eventuale overflow dei numeri interi.

R , 31 byte

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

Provalo online!

— Giuseppe
fonte

1

Non so quanto sia severa la sfida che ci richiede di essere in errore di arrotondamento, ma per esempio, f (243,3) è uguale a 4 quando probabilmente deve essere 5.

— JDL

@JDL questo è un punto giusto; Credo che una risposta perfettamente precisa sarebbe ~ 31 byte.

— Giuseppe,

1

Penso che puoi sostituire pcon una p+.1risposta da 25 byte e starai ancora bene, per 28 byte

— JDL

Un'altra soluzione da 28 byte senza problemi di precisione numerica.

— Robin Ryder,

2

Python 2 , 39 byte

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

Provalo online!

— FlipTack
fonte

3

1000,10 come input dà 2 come output.

— Floris,

2

Rubino , 31 byte

OK, quindi tutti quegli approcci basati su log sono inclini a errori di arrotondamento, quindi ecco un altro metodo che funziona con numeri interi ed è privo di questi problemi:

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

Provalo online!

Ma tornando ai logaritmi, anche se non è chiaro fino a che precisione dobbiamo supportare l'input, ma penso che questo piccolo trucco risolverebbe il problema di arrotondamento per tutti i numeri più o meno "realistici":

Rubino , 29 byte

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

Provalo online!

— Kirill L.
fonte

2

C (gcc) + `-lm`, 24 byte

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

Provalo online!

— betseg
fonte

So long longma ma cos'è bytes bytes? : P

— totalmente umano il

Inoltre i flag non si aggiungono più al conteggio dei byte, quindi ho modificato per riflettere questo.

— totalmente umano il

5

Non funziona per (1000, 10) a causa dell'errore di arrotondamento.

— nwellnhof,

f(n,m){n=(float)log(n)/log(m);}sembra funzionare @ 31 byte

— GPS

2

Emojicode , 49 48 byte

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

Provalo online!

— betseg
fonte

2

APL (Dyalog Unicode) , 2 byte

⌊⍟

Provalo online!

Abbastanza diretto.

⍟ Login

⌊ pavimento

— J. Sallé
fonte

Fai diadico per salvare un byte:⌊⍟

— Adám,

Mi vergogno leggermente che tu abbia dovuto dirmi che>.> Grazie, però!

— J. Sallé,

2

05AB1E , 6 byte

Lm¹›_O

Provalo online!

— Emigna
fonte

questo sembra ingiusto a tutti gli altri

— Floris,

1

@Floris Le competizioni sono tra invii in ogni lingua e non tra lingue, giusto?

— user202729,

@ user202729 sì e no. Nella mia mente, alla fine, "vince il codice più corto". Ma ho notato che c'era una soluzione a 2 byte più in basso ... Queste lingue da golf mi fanno impazzire.

— Floris,

1

@Floris "Non lasciare che i linguaggi del golf di codice ti scoraggino dal pubblicare risposte con linguaggi non codegolfing. Cerca di trovare una risposta il più breve possibile per" qualsiasi "linguaggio di programmazione."

— user202729,

1

@Floris Inoltre ... anche Excel può farlo in 2 builtin . Le lingue del golf possono farlo anche in 2 built-in, solo i nomi incorporati sono più brevi. Niente da sorprendere.

— user202729,

2

JavaScript , 40 33 byte

-3 byte grazie a DanielIndie

Accetta input nella sintassi del curry.

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

Provalo online!

— Oliver
fonte

29 byte

— DanielIndie,

1

28 byte e forse se vuoi il metodo al curry

— DanielIndie,

@nwellnhof tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/R1i7J1k7Dx9Y3sSRDLyc/…

— NoOneIsHere

Non funziona per (999, 10) (dovrebbe essere in uscita 2)

— Herman L

4

La toStringsoluzione funziona solo per basi fino a 36.

— nwellnhof,

2

Pari / GP, 6 byte

logint

(integrato nella versione 2.7, marzo 2014. Accetta due argomenti, con un terzo riferimento facoltativo che, se presente, è impostato sulla base elevata al risultato)

— Danaj
fonte

@StewieGriffin logint (x, y) sia da Pari / GP sia da Perl / ntheory danno i risultati corretti per i 7 esempi attualmente mostrati, incluso '3' per 1000,10.

— DanaJ,

+1, ma lo conterei come 6 byte.

— Charles,

2

Non ti è permesso usare input hardcoded, quindi questa deve essere una funzione (es. Come lambda o definizione). Tuttavia, è possibile utilizzare solo ciò logintche è valido e conta 5 byte in meno.

— ბიმო

2

Python 2, 3, 46 byte

-1 grazie a jonathan

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

Python 1, 47 byte

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

— Vedant Kandoi
fonte

n~-iè un byte più breve di n i-1.

— Jonathan Frech,

Inoltre, si prega di indicare la versione di Python.

— Jonathan Frech,

Funzionerà in qualsiasi versione, no?

— Vedant Kandoi,

Non funzionerà in Python 1.

— Jonathan Frech,

2

JavaScript (Node.js) , 22 byte

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

Provalo online!

Funzione ricorsiva al curry. Usa come g(P)(N). Meno incline agli errori in virgola mobile rispetto all'utilizzoMath.log e (credo) il codice fornisce valori corretti purché entrambi gli input siano numeri interi sicuri (sotto 2**52).

— bubbler
fonte

1

Haskell , 35 34 byte

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

Grazie @Laikoni per aver salvato 1 byte

Provalo online!

— Angs
fonte

1

J , 5 byte

<.@^.

Provalo online!

— Galen Ivanov
fonte

1

Wolfram Language (Mathematica) 15 10 byte

Floor@*Log

(richiede un ordine inverso in ingresso)

Presentazione originale

⌊#2~Log~#⌋&

— Kelly Lowder
fonte

⌊Log@##⌋&è più corto di un byte

— Lukas Lang

@ Mathe172, questo è un carattere più corto, ma su questo conto 13 byte. Il piano sinistro e il piano destro contano come 3 byte ciascuno in UTF-8.

— Kelly Lowder,

@StewieGriffin% [10.1000] fornisce 3. Gli input vengono trattati come numeri interi anziché come numeri macchina, a meno che non si inserisca una posizione decimale dopo di essi.

— Kelly Lowder,

1

Forth (gforth) , 35 byte

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

Provalo online!

Potrebbe salvare 5 byte scambiando i parametri di input previsti, ma la domanda specifica che N deve essere il primo (si potrebbe argomentare che in un linguaggio postfisso "Primo" significa top-of-stack, ma mi atterrò alla lettera delle regole per adesso)

Spiegazione

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

Pyth, 6 4 byte

s.lF

Salvato 2 byte grazie a Mmenomic
Provalo online

Come funziona

.lè log _B (A)
Ad essere sincero, non ho idea di come Ffunzioni. Ma se funziona, funziona.
stronca un float a un int per darci il numero intero più alto per M.

— fortraan
fonte

2

1000,10 come ingressi danno 2 come uscita

— Stewie Griffin

Un'altra soluzione simile è/FlM

— RK.

1

Meraviglia , 9 byte

|_.sS log

Esempio di utilizzo:

(|_.sS log)[1000 10]

Spiegazione

Versione dettagliata:

floor . sS log

Questo è uno stile senza punti. sSpassa gli elementi dell'elenco come argomenti a una funzione (in questo caso, log).

— Mama Fun Roll
fonte

1

Gforth , 31 byte

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

Provalo online!

Spiegazione

Sfortunatamente FORTH utilizza uno stack in virgola mobile dedicato. Per questo devo SWAP(scambiare) i valori di input in modo che arrivino allo stack in virgola mobile nel giusto ordine. Devo anche spostare i valori in quello stack con S>F. Quando si sposta il risultato in virgola mobile su intero ( F>S) ho il vantaggio di ottenere il troncamento gratuitamente.

Versione più corta

Estendendo i requisiti e fornendo l'input in formato float e nel giusto ordine, esiste una versione più corta con 24 byte.

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

Provalo online!

— Kitana
fonte

Generalmente per le risposte di CodeGolf, i frammenti sono vietati (se non diversamente indicato nella sfida). Questa risposta dovrebbe essere racchiusa in una funzione (Word in Forth) : f .... ;o convertita in un programma che accetta input usando KEYoACCEPT

— reffu

@reffu Che cos'è uno snippet? A mio avviso, un piccolo codice parte per mostrare qualcosa che, tuttavia, non fa nulla di significativo per se stesso. D'altra parte, il codice che ho fornito funziona senza modifiche su "Provalo online!". Dovremmo andare meta?

— Kitana,

In questo caso particolare, il codice che hai pubblicato genererà effettivamente uno stack underflow a meno che tu non inserisca i parametri prima di esso. Le risposte al code golf dovrebbero generalmente essere un programma o una funzione autonomi che producono il risultato atteso se chiamati in seguito. Se segui il link al meta post nel mio commento precedente, menziona esplicitamente che lo standard è che le risposte siano un programma o una funzione, di cui il tuo non è nessuno dei due. Per risolverlo occorrerebbero solo altri 4 byte

— reffu

1

Buccia , 8 7 4 byte

Lt`B

Provalo online!

— Fyr
fonte

1

C (gcc) , 61 byte

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

Provalo online!

— Jonathan Frech
fonte

1

Japt , 5 byte

ìV ÊÉ

Provalo online!

8 byte

N£MlXÃäz

Provalo online!

— Oliver
fonte

1

Stava per pubblicare la stessa cosa usando ìinvece di scome sfallirà se V>36.

— Shaggy,

@Shaggy Buona chiamata V>36.

— Oliver,

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.