Recupera el poder del primer poder

16

Parece que a muchas personas les gustaría tener esto, ¡así que ahora es una secuela de este desafío !

Definición : una potencia prima es un número natural que puede expresarse en la forma p n donde p es un número primo yn es un número natural.

Tarea : Dada una potencia principal p n > 1, devuelve la potencia n.

Casos de prueba :

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

Puntuación : Este es el código de golf . La respuesta más corta en bytes gana.

code-golf number arithmetic primes Monja permeable
fuente
2
Nota : Este desafío puede ser trivial en algunos idiomas de golf, pero no es tan trivial para algunos idiomas convencionales, así como el idioma de junio de 2018, QBasic.
Erik the Outgolfer
¿Podemos generar True en lugar de 1? Alternativamente, ¿flotar en lugar de int?
Jo King
1
@JoKing sí, sí.
Leaky Nun
@EriktheOutgolfer Challenge aceptado : D
DLosc

Respuestas:

5

Python 3 , 49 bytes

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

Pruébalo en línea!

Salidas en Truelugar de 1 ( según lo permitido por OP ). Función recursiva que encuentra repetidamente el factor más bajo y luego llama a la función nuevamente con la siguiente potencia más baja hasta que alcanza 1. Esta es una extensión de mi respuesta a la pregunta anterior.

Jo King
fuente
4

Bash + GNU utilidades, 22

  • 2 bytes guardados gracias a @ H.PWiz y @Cowsquack
factor|tr -cd \ |wc -c

Pruébalo en línea!

Trauma digital
fuente
1
Funciona factor|sed s/\ //|wc -w?
H.PWiz
1
¿Qué hay de factor|tr -cd \ |wc -c?
Kritixi Lithos
3

dc , 50 41 bytes

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

Pruébalo en línea!

Toma la entrada desde la parte superior de la pila (en TIO, coloque la entrada en el encabezado para cargarla en la pila antes de la ejecución). Salidas a stdout.

Explicación

Registros utilizados:

i: el divisor de prueba actual, mientras se Xestá ejecutando. Más tarde, el divisor que hemos encontrado.

X: la macro dli1+dsi%0<X, que tiene el efecto "incremento i, luego verifique el módulo con el valor en la pila (que será la entrada original). Si no es cero, repita".

Y: la macro dli/dli<Y, que tiene el efecto "Agregar a la pila una copia de la parte superior actual de la pila, dividida por i. Repita hasta que ise alcance".

Programa 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
fuente
¡Encontré una solución mucho mejor! Editando ahora ...
Sophia Lechner
3

cara , 86 bytes

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

¡Hurra, más largo que Java!

Pruébalo en línea!

Soy particularmente aficionado al truco de usar el valor de retorno de sscanf. Normalmente, el valor de retorno se descartaría, pero aquí siempre será 1, porque siempre estamos leyendo un solo número como entrada. Podemos aprovechar esto asignando su valor de retorno a la variable 1, guardando los 2 bytes que de otro modo serían necesarios para asignar 1a 1 explícitamente.

(%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 )
Pomo de la puerta
fuente
2

Java 8, 59 bytes

Una lambda de inta int.

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

Pruébalo en línea

Jakob
fuente
2

R , 37 bytes

length(numbers::primeFactors(scan()))

Pruébalo en línea!

ngm
fuente
1
sum(x|1)es casi siempre más corto quelength(x)
Giuseppe
2

Stax ,4 43 bytes

|f%

Ejecutar y depurarlo

Duración de la factorización prima.

wastl
fuente
55
Ahh ... estás rompiendo el tachado 4 sigue siendo regular 4; ( meme.; P (Sin embargo, se estaba haciendo viejo de todos modos ... Tan bien hecho, supongo)
Kevin Cruijssen
1
¡Sí, abuso de MathJax!Pero recuerde poner la cruz antes del conteo real, de lo contrario, el fragmento de la tabla de clasificación puede no ser capaz de reconocerlo.
user202729
2

MATL , 3 bytes

Yfz

Pruébalo en línea!

Explicación:

     % 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
fuente
2

Espacio en blanco, 141 bytes

[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]

Se agregaron letras S(espacio), T(tabulación) y N(nueva línea) solo como resaltado.
[..._some_action]agregado solo como explicación.

Pruébelo en línea (solo con espacios en bruto, pestañas y nuevas líneas).

Explicación en pseudocódigo:

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

Ejemplo de ejecución: 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

El programa se detiene con un error: no se encontró ninguna salida.

Kevin Cruijssen
fuente
1

Octava , 18 bytes

@(x)nnz(factor(x))

Pruébalo en línea!

Hace lo que dice en la lata: Número de elementos distintos de cero en la factorización prima de la entrada.

Stewie Griffin
fuente
1

Cjam, 5 bytes

rimf,

Pruébalo en línea!

Explicación:

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

Los builtins son geniales!

Cromo
fuente
Los envíos deben ser programas o funciones por defecto, y no consideramos que esto sea una función . Ambos rimf,(programa completo) y {mf,}(función) serían válidos.
Dennis
@ Dennis Sí, creo que estoy un poco confundido con eso. También miré antes a stardard io permitido y me pregunté qué debería enviar en realidad ... En realidad quería hacer una pregunta sobre meta al respecto. Pero lo confirmaste, ¡así que gracias!
Cromo
1

QBasic, 51 bytes

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

Utiliza el mismo algoritmo que la solución "Recuperar el primer" para encontrar la base, luego usa reglas de logaritmos para obtener el exponente:losol(pagnorte)=norte⋅losol(pag).

DLosc
fuente
0

Perl 6 , 36 bytes

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

Busca el primer factor (2..*).first: $_%%* , luego calcula el valor aproximado (los registros no lo harán exacto) y lo redondea.

Pruébalo en línea!

Phil H
fuente
0

Perl 6 , 18 bytes

{+grep($_%%*,^$_)}

Pruébalo en línea!

Bloque de código anónimo que obtiene una lista de factores y los obliga a un número.

Jo King
fuente