Récupérez la puissance de la puissance principale

16

Il semble que beaucoup de gens aimeraient l'avoir, c'est donc maintenant une suite à ce défi !

Définition : une puissance première est un nombre naturel qui peut être exprimé sous la forme p n où p est un nombre premier et n est un nombre naturel.

Tâche : Étant donné une puissance première p n > 1, renvoyez la puissance n.

Testcases :

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

Notation : Il s'agit du code-golf . La réponse la plus courte en octets l'emporte.

code-golf number arithmetic primes Leaky Nun
la source
2
Remarque : Ce défi peut être trivial dans certaines langues de golf, mais il n'est pas si trivial pour certaines langues traditionnelles, ainsi que la langue de juin 2018, QBasic.
Erik the Outgolfer
Pouvons-nous sortir True au lieu de 1? Alternativement, flotter au lieu de pouces?
Jo King
1
@JoKing oui, oui.
Leaky Nun
@EriktheOutgolfer Challenge accepté : D
DLosc

Réponses:

5

Python 3 , 49 octets

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

Essayez-le en ligne!

Sorties Trueau lieu de 1 ( comme autorisé par OP ). Fonction récursive qui trouve à plusieurs reprises le facteur le plus bas, puis appelle à nouveau la fonction avec la puissance la plus faible suivante jusqu'à ce qu'elle atteigne 1. Ceci est une extension de ma réponse à la question précédente.

Jo King
la source
4

Utilitaires Bash + GNU, 22

  • 2 octets enregistrés grâce à @ H.PWiz et @Cowsquack
factor|tr -cd \ |wc -c

Essayez-le en ligne!

Traumatisme numérique
la source
1
Ça factor|sed s/\ //|wc -wmarche?
H.PWiz
1
Et alors factor|tr -cd \ |wc -c?
Kritixi Lithos
3

dc , 50 41 octets

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

Essayez-le en ligne!

Prend l'entrée du haut de la pile (dans TIO, placez l'entrée dans l'en-tête pour la charger sur la pile avant l'exécution). Sorties vers sortie standard.

Explication

Registres utilisés:

i: le diviseur d'essai actuel, en Xcours d'exécution. Plus tard, le diviseur que nous avons trouvé.

X: la macro dli1+dsi%0<X, qui a pour effet "incrémenter i, puis vérifier le module avec la valeur sur la pile (qui sera l'entrée d'origine). Si ce n'est pas zéro, répéter".

Y: la macro dli/dli<Y, qui a pour effet "Ajouter à la pile une copie du sommet actuel de la pile, divisé pari . Répéter jusqu'à ce que isoit atteint."

Programme complet:

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
la source
J'ai trouvé une bien meilleure solution! Montage en cours ...
Sophia Lechner
3

face , 86 octets

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

Hourra, plus longtemps que Java!

Essayez-le en ligne!

J'aime particulièrement l'astuce d'utiliser la valeur de retour de sscanf. Normalement, la valeur de retour serait ignorée, mais ici, elle sera toujours 1, car nous lisons toujours un seul nombre en entrée. Nous pouvons en profiter en affectant sa valeur de retour à la variable 1, en économisant les 2 octets qui seraient autrement nécessaires pour affecter 1explicitement à 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 )
Poignée de porte
la source
2

Java 8, 59 octets

Un lambda de intà int.

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

Essayez-le en ligne

Jakob
la source
2

J, 4 octets

#@q:

q:donne la liste des facteurs premiers, #donne la longueur de la liste.

Essayez-le en ligne!

Jonas
la source
2

R , 37 octets

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

Essayez-le en ligne!

ngm
la source
1
sum(x|1)est presque toujours plus court quelength(x)
Giuseppe
2

Stax ,43 octets

|f%

Exécuter et déboguer

Longueur de la factorisation principale.

wastl
la source
5
Ahh .. vous cassez le barré 4 est toujours régulier 4; ( meme.; P (Il vieillissait quand même .. Si bien fait je suppose)
Kevin Cruijssen
1
Ouais, MathJax abuse!Mais n'oubliez pas de mettre la croix avant le décompte réel, sinon l'extrait du classement peut ne pas être en mesure de le reconnaître.
user202729
2

MATL , 3 octets

Yfz

Essayez-le en ligne!

Explication:

     % 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
la source
2

Espace, 141 octets

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

Lettres S(espace), T(tabulation) et N(nouvelle ligne) ajoutées uniquement en surbrillance.
[..._some_action]ajouté à titre d'explication uniquement.

Essayez-le en ligne (avec des espaces bruts, des tabulations et des nouvelles lignes uniquement).

Explication en pseudo-code:

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

Exemple d'exécution: 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

Le programme s'arrête avec une erreur: aucune sortie trouvée.

Kevin Cruijssen
la source
1

Japt , 3 octets

k l

Essayez-le en ligne!

Explication:

k l
k     Get the prime factors of the input
  l   Return the length
Oliver
la source
1

Octave , 18 octets

@(x)nnz(factor(x))

Essayez-le en ligne!

Fait ce qu'il dit sur l'étain: Nombre d'éléments non nuls dans la factorisation principale de l'entrée.

Stewie Griffin
la source
1

Cjam, 5 octets

rimf,

Essayez-le en ligne!

Explication:

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

Les Builtins sont super!

Chrome
la source
Les soumissions doivent être des programmes ou des fonctions par défaut, et nous ne considérons pas cela comme une fonction . Les deux rimf,(programme complet) et {mf,}(fonction) seraient valides.
Dennis
@ Dennis Ouais, je pense que je suis un peu confus là-dessus. J'ai également examiné le stardard autorisé io auparavant et je me suis demandé ce que je devrais réellement soumettre ... Je voulais en fait poser une question sur les méta à ce sujet. Mais vous l'avez confirmé, alors merci!
Chromium
1

QBasic, 51 octets

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

Utilise le même algorithme que la solution "Récupérer le premier" pour trouver la base, puis utilise des règles de logarithmes pour obtenir l'exposant:log(pn)=n⋅log(p).

DLosc
la source
0

Perl 6 , 36 octets

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

Recherche le premier facteur (2..*).first: $_%%*, puis calcule la valeur approximative (les journaux ne l'obtiendront pas exactement) et l'arrondit.

Essayez-le en ligne!

Phil H
la source