Recupera la potenza dalla potenza primaria

16

Sembra che molte persone vorrebbero avere questo, quindi ora è il seguito di questa sfida !

Definizione : un potere primo è un numero naturale che può essere espresso nella forma p n dove p è un numero primo e n è un numero naturale.

Compito : data una potenza primaria p n > 1, restituisce la potenza n.

Test :

input output
9     2
16    4
343   3
2687  1
59049 10

Punteggio : questo è code-golf . Vince la risposta più breve in byte.

code-golf  number  arithmetic  primes 
— Perdente Suora
fonte
2
Nota : questa sfida potrebbe essere banale in alcune lingue del golf, ma non è così banale per alcune lingue tradizionali, così come la lingua di giugno 2018, QBasic.
— Erik the Outgolfer,
Possiamo produrre True invece di 1? In alternativa, float anziché ints?
— Jo King,
1
@JoKing sì, sì.
— Leaky Nun,
@EriktheOutgolfer Challenge accettata : D
— DLosc,

Risposte:

5

Python 3 , 49 byte

f=lambda n,x=2:n%x and f(n,x+1)or n/x<2or-~f(n/x)

Provalo online!

Uscite Trueanziché 1 ( come consentito dall'OP ). Funzione ricorsiva che trova ripetutamente il fattore più basso e quindi richiama nuovamente la funzione con la potenza più bassa successiva fino a quando non raggiunge 1. Questa è un'estensione della mia risposta alla domanda precedente.

— Jo King
fonte
3

dc , 50 41 byte

1si[dli1+dsi%0<X]dsXx[dli/dli<Y]sYdli<Yzp

Provalo online!

Prende l'input dalla parte superiore dello stack (in TIO, inserisci l'input nell'intestazione per caricarlo nello stack prima dell'esecuzione). Emette su stdout.

Spiegazione

Registri utilizzati:

i: l'attuale divisore di prova, mentre X è in esecuzione. Più tardi, il divisore che abbiamo trovato.

X: la macro dli1+dsi%0<X, che ha l'effetto "incrementoi , quindi controlla il modulo con il valore nello stack (che sarà l'input originale). Se non è zero, ripeti".

Y: la macro dli/dli<Y, che ha l'effetto "Aggiungi allo stack una copia della parte superiore dello stack corrente, divisa peri . Ripeti fino a iraggiungere".

Programma completo:

1si                 Initialize i
[dli1+dsi%0<X]dsXx  Define and run X
[dli/dli<Y]sY       Define Y
dli<Y               Run Y, but only if needed (if the input wasn't just i)
z                   The stack is i^n, i^(n-1), ... ,i, so print the stack depth
— Sophia Lechner
fonte
Ho trovato una soluzione molto migliore! Modifica ora ...
— Sophia Lechner,
3

faccia , 86 byte

(%d@)\$*,c'$,io>Av"[""mN*c?*m1*mp*m%*s1"$pN1p:~+p1p%%Np?%~:=/NNp+?1?-%N1?%=p%'$i?w1'%>

Evviva, più a lungo di Java!

Provalo online!

Sono particolarmente affezionato al trucco di usare il valore di ritorno di sscanf. Normalmente il valore restituito verrebbe scartato, ma qui sarà sempre 1, perché leggiamo sempre un singolo numero come input. Possiamo trarne vantaggio assegnando il suo valore restituito alla variabile 1, salvando i 2 byte che altrimenti sarebbero necessari per assegnare 1esplicitamente a 1.

(%d@)

\$*,c'$,io>  ( setup - assign $ to "%d", * to a number, o to stdout )
Av"[""mN*    ( set " to input and allocate space for N for int conversion )
c?*          ( calloc ?, starting it at zero - this will be the output )
m1*          ( allocate variable "1", which gets the value 1 eventually )
mp*m%*       ( p is the prime, % will be used to store N mod p )

s1"$pN       ( scan " into N with $ as format; also assigns 1 to 1 )

1p:~         ( begin loop, starting p at 1 )
  +p1p       ( increment p )
  %%Np       ( set % to N mod p )
?%~          ( repeat if the result is nonzero, so that we reach the factor )

:=           ( another loop to repeatedly divide N by p )
  /NNp       ( divide N by p in-place )
  +?1?       ( increment the counter )
  -%N1       ( reuse % as a temp variable to store N-1 )
?%=          ( repeat while N-1 is not 0 -- i.e. break when N = 1 )

p%'$i?       ( sprintf ? into ', reusing the input format string )
w1'%>        ( write to stdout )
— Maniglia
fonte
2

Java 8, 59 byte

Un lambda da inta int.

x->{int f=1,c=0;while(x%++f>0);for(;x>1;c++)x/=f;return c;}

Provalo online

— Jakob
fonte
2

MATL , 3 byte

Yfz

Provalo online!

Spiegazione:

     % Implicit input: 59049
Yf   % Factorize input [3, 3, 3, 3, 3, 3, 3, 3, 3, 3]
  z  % Number of non-zero elements: 10
     % Implicit output
— Stewie Griffin
fonte
2

Spazio bianco, 141 byte

[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_number][T    T   T   _Retrieve][S S S T  N
_Push_1][N
S S N
_Create_Label_LOOP_1][S S S T   N
_Push_1][T  S S S _Add][S N
S _Duplicate][S T   S S T   S N
_Copy_2nd_input][S N
T   _Swap_top_two][T    S T T   _Modulo][N
T   S S N
_If_0_Jump_to_Label_BREAK_1][N
S N
N
_Jump_to_Label_LOOP_1][N
S S S N
_Create_Label_BREAK_1][S S S N
_Push_0][S T    S S T   S N
_Copy_2nd_input][N
S S T   N
_Create_Label_LOOP_2][S N
S _Duplicate_input][S S S T N
_Push_1][T  S S T   _Subtract][N
T   S S S N
_If_0_Jump_to_Label_BREAK_2][S N
T   _Swap_top_two][S S S T  N
_Push_1][T  S S S _Add][S N
T   _Swap_top_two][S T  S S T   S N
Copy_2nd_factor][T  S T S _Integer_divide][N
S N
T   N
_Jump_to_Label_LOOP_2][N
S S S S N
_Create_Label_BREAK_2][S N
N
_Discard_top][T N
S T _Print_as_number]

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Provalo online (solo con spazi non elaborati, schede e nuove righe).

Spiegazione in pseudo-codice:

Integer n = STDIN as input
Integer f = 1
Start LOOP_1:
  f = f + 1
  if(n modulo-f == 0)
    Call function BREAK_1
  Go to next iteration of LOOP_1

function BREAK_1:
  Integer r = 0
  Start LOOP_2:
    if(n == 1)
      Call function BREAK_2
    r = r + 1
    n = n integer-divided by f
    Go to next iteration of LOOP_2

function BREAK_2:
  Print r as number to STDOUT
  Program stops with an error: Exit not defined

Esempio di esecuzione: input = 9

Command    Explanation                    Stack           Heap    STDIN   STDOUT   STDERR

SSSN       Push 0                         [0]
SNS        Duplicate top (0)              [0,0]
TNTT       Read STDIN as number           [0]             {0:9}   9
TTT        Retrieve                       [9]             {0:9}
SSSTN      Push 1                         [9,1]           {0:9}
NSSN       Create Label_LOOP_1            [9,1]           {0:9}
 SSSTN     Push 1                         [9,1,1]         {0:9}
 TSSS      Add top two (1+1)              [9,2]           {0:9}
 SNS       Duplicate top (2)              [9,2,2]         {0:9}
 STSSTSN   Copy 2nd from top              [9,2,2,9]       {0:9}
 SNT       Swap top two                   [9,2,9,2]       {0:9}
 TSTT      Modulo top two (9%2)           [9,2,1]         {0:9}
 NTSSN     If 0: Jump to Label_BREAK_1    [9,2]           {0:9}
 NSNN      Jump to Label_LOOP_1           [9,2]           {0:9}

 SSSTN     Push 1                         [9,2,1]         {0:9}
 TSSS      Add top two (2+1)              [9,3]           {0:9}
 SNS       Duplicate top (3)              [9,3,3]         {0:9}
 STSSTSN   Copy 2nd                       [9,3,3,9]       {0:9}
 SNT       Swap top two                   [9,3,9,3]       {0:9}
 TSTT      Modulo top two (9%3)           [9,3,0]         {0:9}
 NTSSN     If 0: Jump to Label_BREAK_1    [9,3]           {0:9}
NSSSN      Create Label_BREAK_1           [9,3]           {0:9}
SSSN       Push 0                         [9,3,0]         {0:9}
STSSTSN    Copy 2nd from top              [9,3,0,9]       {0:9}
NSSTN      Create Label_LOOP_2            [9,3,0,9]       {0:9}
 SNS       Duplicate top (9)              [9,3,0,9,9]     {0:9}
 SSSTN     Push 1                         [9,3,0,9,9,1]   {0:9}
 TSST      Subtract top two (9-1)         [9,3,0,9,8]     {0:9}
 NTSSSN    If 0: Jump to Label_BREAK_2    [9,3,0,9]       {0:9}
 SNT       Swap top two                   [9,3,9,0]       {0:9}
 SSSTN     Push 1                         [9,3,9,0,1]     {0:9}
 TSSS      Add top two (0+1)              [9,3,9,1]       {0:9}
 SNT       Swap top two                   [9,3,1,9]       {0:9}
 STSSTSN   Copy 2nd from top              [9,3,1,9,3]     {0:9}
 TSTS      Integer-divide top two (9/3)   [9,3,1,3]       {0:9}
 NSNTN     Jump to Label_LOOP_2           [9,3,1,3]       {0:9}

 SNS       Duplicate top (3)              [9,3,1,3,3]     {0:9}
 SSSTN     Push 1                         [9,3,1,3,3,1]   {0:9}
 TSST      Subtract top two (3-1)         [9,3,1,3,2]     {0:9}
 NTSSSN    If 0: Jump to Label_BREAK_2    [9,3,1,3]       {0:9}
 SNT       Swap top two                   [9,3,3,1]       {0:9}
 SSSTN     Push 1                         [9,3,3,1,1]     {0:9}
 TSSS      Add top two (1+1)              [9,3,3,2]       {0:9}
 SNT       Swap top two                   [9,3,2,3]       {0:9}
 STSSTSN   Copy 2nd from top              [9,3,2,3,3]     {0:9}
 TSTS      Integer-divide top two (3/3)   [9,3,2,1]       {0:9}
 NSNTN     Jump to Label_LOOP_2           [9,3,2,1]       {0:9}

 SNS       Duplicate top (1)              [9,3,2,1,1]     {0:9}
 SSSTN     Push 1                         [9,3,2,1,1,1]   {0:9}
 TSST      Subtract top two (1-1)         [9,3,2,1,0]     {0:9}
 NTSSSN    If 0: Jump to Label_BREAK_2    [9,3,2,1]       {0:9}
NSSSSN     Create Label_BREAK_2           [9,3,2,1]       {0:9}
 SNN       Discard top                    [9,3,2]         {0:9}
 TNST      Print as integer               [9,3]           {0:9}           2
                                                                                    error

Il programma si interrompe con un errore: nessuna uscita trovata.

— Kevin Cruijssen
fonte
1

Cjam, 5 byte

rimf,

Provalo online!

Spiegazione:

ri      take the input and convert it to an int
  mf    factors the input
    ,   take the length of the list

I builtin sono fantastici!

— Cromo
fonte
Gli invii devono essere programmi o funzioni per impostazione predefinita e non consideriamo questa una funzione . Sia rimf,(programma completo) che {mf,}(funzione) sarebbero validi.
— Dennis,
@Dennis Sì, penso di essere un po 'confuso. Ho anche guardato prima lo stardard io e mi chiedevo cosa avrei dovuto effettivamente presentare ... Volevo davvero fare una domanda su meta. Ma lo hai confermato, quindi grazie!
— Chromium,
1

QBasic, 51 byte

INPUT x
p=2
WHILE x/p>x\p
p=p+1
WEND
?LOG(x)/LOG(p)

Utilizza lo stesso algoritmo della soluzione "Ripristina il primo" per trovare la base, quindi utilizza le regole dei logaritmi per ottenere l'esponente:log(pn)=n⋅log(p).

— DLosc
fonte
0

Perl 6 , 36 byte

{round .log/log (2..*).first: $_%%*}

Cerca il primo fattore (2..*).first: $_%%*, quindi da lì calcola il valore approssimativo (i registri non lo renderanno esatto) e lo arrotonda.

Provalo online!

— Phil H
fonte
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.