Recupere a energia da energia primária

16

Parece que muitas pessoas gostariam de ter isso, então agora é uma sequência deste desafio !

Definição : uma potência primária é um número natural que pode ser expresso na forma p ^{n, em} que p é uma primária e n é um número natural.

Tarefa : Dada uma potência principal p ⁿ > 1, retorne a potência n.

Casos de teste :

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

Pontuação : Este é o código-golfe . A resposta mais curta em bytes vence.

code-golf number arithmetic primes Freira Furada
fonte

2

Nota : Esse desafio pode ser trivial em alguns idiomas de golfe, mas não é tão trivial em alguns idiomas tradicionais, como no idioma de junho de 2018, o QBasic.

Erik the Outgolfer

Podemos produzir True em vez de 1? Como alternativa, flutuar em vez de ints?

Jo rei

1

@ JoKing sim, sim.

Leaky Nun

@EriktheOutgolfer Desafio aceito : D

DLosc

Respostas:

7

05AB1E , 2 bytes

Òg

Experimente online!

Queijo
fonte

2

Bem-vindo ao PPCG!

Oliver

1

Bem-vindo de fato! Para quem estiver lendo isso:: ÒEmpurre a lista de fatores primos (com duplicatas) e g: Empurre o comprimento .

Kevin Cruijssen

5

Python 3 , 49 bytes

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

Experimente online!

Saídas True vez de 1 ( conforme permitido pelo OP ). Função recursiva que encontra repetidamente o fator mais baixo e depois chama a função novamente com a próxima potência mais baixa até atingir 1. Essa é uma extensão da minha resposta à pergunta anterior.

Brincadeira
fonte

4

Pitão, 2

Contar fatores primos:

lP

Trauma Digital
fonte

4

Python 2 , 37 bytes

f=lambda n,i=2:i/n or(n%i<1)+f(n,i+1)

Experimente online!

Conta fatores. Aparentemente eu escrevi o mesmo golfe em 2015.

Estreitamente supera o não recursivo

Python 2 , 38 bytes

lambda n:sum(n%i<1for i in range(1,n))

Experimente online!

xnor
fonte

4

Utilitários Bash + GNU, 22

2 bytes salvos graças a @ H.PWiz e @Cowsquack

factor|tr -cd \ |wc -c

Experimente online!

Trauma Digital
fonte

1

Funciona factor|sed s/\ //|wc -w?

H.PWiz

1

Que tal factor|tr -cd \ |wc -c?

Kritixi Lithos

3

dc , 50 41 bytes

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

Experimente online!

Pega entrada da parte superior da pilha (em TIO, coloque a entrada no cabeçalho para carregá-la na pilha antes da execução). Saídas para stdout.

Explicação

Registradores utilizados:

i: o divisor de avaliação atual, enquanto Xestá em execução. Mais tarde, o divisor que encontramos.

X: a macro dli1+dsi%0<X, que tem o efeito "incremento i, verifique o módulo com o valor na pilha (que será a entrada original). Se não for zero, repita".

Y: a macro dli/dli<Y, que tem o efeito "Adicione à pilha uma cópia da parte superior atual da pilha, dividida por i. Repita até iser atingido."

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
fonte

Encontrei uma solução muito melhor! Editando agora ...

Sophia Lechner

3

face , 86 bytes

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

Viva, mais que Java!

Experimente online!

Gosto particularmente do truque de usar o valor de retorno de sscanf. Normalmente, o valor de retorno seria descartado, mas aqui sempre será 1, porque estamos sempre lendo um único número como entrada. Podemos tirar vantagem disso atribuindo seu valor de retorno à variável 1, salvando os 2 bytes que seriam necessários para atribuir 1a 1 explicitamente.

(%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 )

Maçaneta da porta
fonte

3

Poliglota da linguagem Attache e Wolfram (Mathematica) , 10 bytes

PrimeOmega

Experimente o Attache online! Experimente o Mathematica online!

Simplesmente integrado para calcular o número de fatores primos N possui.

Explicação

Como N = p ^k , Ω ( N ) = Ω ( p ^k ) = k , o resultado desejado.

Conor O'Brien
fonte

2

Java 8, 59 bytes

Um lambda de intpara int.

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

Experimente Online

Jakob
fonte

2

J, 4 bytes

#@q:

q: fornece a lista de fatores principais, # fornece o comprimento da lista.

Experimente online!

Jonah
fonte

2

R , 37 bytes

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

Experimente online!

ngm
fonte

1

sum(x|1)é quase sempre mais curto quelength(x)

Giuseppe

2

$\require{cancel}\xcancel 4 3$

|f%

Execute e depure

Comprimento da fatoração principal.

wastl
fonte

5

Ahh .. você está quebrando o riscado 4 ainda é regular 4; ( meme; p (Estava ficando de qualquer maneira antiga embora .. tão bem feito eu acho).

Kevin Cruijssen

1

Yay, MathJax abuse!

$\text{Yay, MathJax abuse!}$

2

MATL , 3 bytes

Yfz

Experimente online!

Explicação:

     % 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

Geléia , 3 2 bytes

Æḍ

Experimente online!

Erik, o Outgolfer
fonte

2

Espaço em branco, 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]

Letras S(espaço), T(tabulação) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Experimente online (apenas com espaços brutos, guias e novas linhas).

Explicação em pseudo-có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

Exemplo de execução: 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

O programa para com um erro: Nenhuma saída encontrada.

Kevin Cruijssen
fonte

2

Braquilog , 2 bytes

ḋl

Experimente online!

Explicação

ḋ        Prime decomposition
 l       Length

Fatalizar
fonte

1

Python 2 , 62 bytes

def f(n,p=2,i=0):
	while n%p:p+=1
	while n>p**i:i+=1
	return i

Experimente online!

Nada extravagante aqui.

Chas Brown
fonte

1

Você pode salvar três bytes, tornando-o um programa completo: Experimente online!

dylnan

1

Japonês , 3 bytes

k l

Experimente online!

Explicação:

k l
k     Get the prime factors of the input
  l   Return the length

Oliver
fonte

1

Na verdade , 2 bytes

ol

Experimente online!

Oliver
fonte

1

Haskell , 27 bytes

f n=sum$(0^).mod n<$>[2..n]

Experimente online!

Conta fatores. Comparar:

Haskell , 28 bytes

f n=sum[1|0<-mod n<$>[2..n]]

Experimente online!

Haskell , 28 bytes

f n=sum[0^mod n i|i<-[2..n]]

Experimente online!

Haskell , 30 bytes

f n=sum[1|i<-[2..n],mod n i<1]

Experimente online!

xnor
fonte

1

Oitava , 18 bytes

@(x)nnz(factor(x))

Experimente online!

Faz o que diz no estanho: Número de elementos diferentes de zero na fatoração primária da entrada.

Stewie Griffin
fonte

1

Cjam, 5 bytes

rimf,

Experimente Online!

Explicação:

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

Builtins são ótimos!

Crómio
fonte

Os envios devem ser programas ou funções por padrão, e não consideramos isso uma função . Ambos rimf,(programa completo) e {mf,}(função) seriam válidos.

Dennis

@ Dennis Sim, acho que estou meio confuso com isso. Eu também olhei para o permitido stardard io antes e me perguntei sobre o que realmente deveria enviar ... Na verdade, eu queria fazer uma pergunta sobre meta sobre isso. Mas você confirmou isso, então obrigado!

Chromium

1

QBasic, 51 bytes

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

Usa o mesmo algoritmo da solução "Recuperar o principal" para encontrar a base e, em seguida, usa regras de logaritmos para obter o expoente: $log(p^n) = n \cdot log(p)$ .

DLosc
fonte

0

Gaia , 2 bytes

ḍl

Experimente online!

Mr. Xcoder
fonte

0

JavaScript (ES6), 37 bytes

f=(n,k=2)=>n%k?n>1&&f(n,k+1):1+f(n/k)

Experimente online!

Arnauld
fonte

0

Perl 6 , 36 bytes

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

Procura o primeiro fator e (2..*).first: $_%%*, a partir daí, calcula o valor aproximado (os logs não serão precisos) e o arredonda.

Experimente online!

Phil H
fonte

0

Pari / GP , 8 bytes

bigomega

Experimente online!

bigomega (x): número de divisores primos de x, contados com multiplicidade.

Pari / GP , 14 bytes

n->numdiv(n)-1

Experimente online!

alefalpha
fonte

0

Raquete , 31 bytes

(car(cdr(perfect-power(read))))

Experimente online!

batata
fonte

0

Perl 6 , 18 bytes

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

Experimente online!

Bloco de código anônimo que obtém uma lista de fatores e a obriga a um número.

Brincadeira
fonte

0

JavaScript (Node.js) , 29 bytes

f=(n,k=n)=>--k&&!(n%k)+f(n,k)

Experimente online! Nota: A pilha transborda para entradas maiores.

Neil
fonte