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 ⁿ où p est un nombre premier et n est un nombre naturel.

Tâche : Étant donné une puissance première p ⁿ > 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
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:

7

05AB1E , 2 octets

Òg

Essayez-le en ligne!

— Fromage
source

2

Bienvenue chez PPCG!

— Oliver

1

Bienvenue en effet! Pour tous ceux qui lisent ceci:: ÒPush liste des facteurs premiers (avec doublons) et g: Push longueur .

— Kevin Cruijssen

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
source

4

Pyth, 2

Compter les facteurs premiers:

lP

Test en ligne .

— Traumatisme numérique
source

4

Python 2 , 37 octets

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

Essayez-le en ligne!

Compte les facteurs. Apparemment, j'ai écrit le même golf en 2015.

Surpasse de près le non récursif

Python 2 , 38 octets

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

Essayez-le en ligne!

— xnor
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
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
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
source

3

Polyglotte Attache et Wolfram Language (Mathematica) , 10 octets

PrimeOmega

Essayez Attache en ligne! Essayez Mathematica en ligne!

Simplement une fonction intégrée pour calculer le nombre de facteurs premiers N a.

Explication

Puisque N = p ^k , Ω ( N ) = Ω ( p ^k ) = k , le résultat souhaité.

— Conor O'Brien
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
source

2

J, 4 octets

#@q:

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

Essayez-le en ligne!

— Jonas
source

2

R , 37 octets

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

Essayez-le en ligne!

— ngm
source

1

sum(x|1)est presque toujours plus court quelength(x)

— Giuseppe

2

Stax , $\require{cancel}\xcancel 4 3$ octets

|f%

Exécuter et déboguer

Longueur de la factorisation principale.

— wastl
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

Yay, MathJax abuse!

$\text{Yay, 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
source

2

Gelée , 3 2 octets

Æḍ

Essayez-le en ligne!

— Erik le Outgolfer
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
source

2

Brachylog , 2 octets

ḋl

Essayez-le en ligne!

Explication

ḋ        Prime decomposition
 l       Length

— Fatalize
source

1

Python 2 , 62 octets

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

Essayez-le en ligne!

Rien d'extraordinaire ici.

— Chas Brown
source

1

Vous pouvez économiser trois octets en en faisant un programme complet: essayez-le en ligne!

— dylnan

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
source

1

En fait , 2 octets

ol

Essayez-le en ligne!

— Oliver
source

1

Haskell , 27 octets

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

Essayez-le en ligne!

Compte les facteurs. Comparer:

Haskell , 28 octets

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

Essayez-le en ligne!

Haskell , 28 octets

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

Essayez-le en ligne!

Haskell , 30 octets

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

Essayez-le en ligne!

— xnor
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
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
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(p^n) = n \cdot log(p)$ .

— DLosc
source

0

Gaia , 2 octets

ḍl

Essayez-le en ligne!

— M. Xcoder
source

0

JavaScript (ES6), 37 octets

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

Essayez-le en ligne!

— Arnauld
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
source

0

Pari / GP , 8 octets

bigomega

Essayez-le en ligne!

bigomega (x): nombre de diviseurs premiers de x, compté avec multiplicité.

Pari / GP , 14 octets

n->numdiv(n)-1

Essayez-le en ligne!

— alephalpha
source

0

Raquette , 31 octets

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

Essayez-le en ligne!

— Patate
source

0

Perl 6 , 18 octets

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

Essayez-le en ligne!

Bloc de code anonyme qui obtient une liste de facteurs et le contraint à un nombre.

— Jo King
source

0

JavaScript (Node.js) , 29 octets

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

Essayez-le en ligne! Remarque: la pile déborde pour des entrées plus importantes.

— Neil
source

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.

Licensed under cc by-sa 3.0 with attribution required.