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 n > 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:

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
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
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:euog(pn)=n⋅euog(p).

— DLosc
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
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.