Görünüşe göre birçok insan buna sahip olmak istiyor, bu yüzden şimdi bu zorluğun devamı var !

Tanım : asal güç , p'nin asal ve n'nin doğal bir sayı olduğu p ⁿ şeklinde ifade edilebilen doğal bir sayıdır.

Görev : Birinci güç p ⁿ > 1 verildiğinde , n gücünü geri verin.

Testcases :

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

Puanlama : Bu kod golfü . Bayt cinsinden en kısa cevap kazanır.

05AB1E , 2 bayt

Òg

Çevrimiçi deneyin!

Python 3 , 49 bayt

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

Çevrimiçi deneyin!

True1 yerine çıkışlar ( OP tarafından izin verildiği gibi ). Tekrar tekrar en düşük faktörü bulan ve daha sonra 1'e ulaşana kadar bir sonraki en düşük güçle fonksiyonu çağıran özyinelemeli işlev. Bu, önceki soruya verdiğim yanıtın bir uzantısıdır .

Pyth, 2

Asal faktörleri say:

lP

Çevrimiçi test .

Python 2 , 37 bayt

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

Çevrimiçi deneyin!

Faktörleri sayar. Görünüşe göre 2015'te aynı golfü yazdım .

Yinelemeli olmayanları dar bir şekilde yener

Python 2 , 38 bayt

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

Çevrimiçi deneyin!

Bash + GNU yardımcı programları, 22

• @ H.PWiz ve @Cowsquack sayesinde 2 bayt tasarruf edildi

factor|tr -cd \ |wc -c

Çevrimiçi deneyin!

dc , 50 41 bayt

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

Çevrimiçi deneyin!

Yığının üstünden girdi alır (TIO'da, yürütmeden önce girişi yığına yüklemek için başlığa koyun). Stdout'a çıkışlar.

açıklama

Kullanılan kayıtlar:

i: geçerli deneme bölen, Xçalışırken. Daha sonra bulduğumuz bölen.

X: dli1+dsi%0<X"artış i, daha sonra, yığın üzerindeki değerle modülü (orijinal girdi olacak) kontrol edin makro . Sıfır değilse, tekrar".

Y: "Yığına dli/dli<Y, yığının geçerli üst kısmının kopyasını bölüi . Tekrar iulaşılana kadar tekrarlayın ."

Tam program:

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

yüz , 86 bayt

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

Yaşasın, Java'dan daha uzun!

Çevrimiçi deneyin!

Özellikle dönüş değerini kullanma hilesinden hoşlanıyorum sscanf. Normalde dönüş değeri atılır, ancak burada her zaman 1 olur, çünkü her zaman giriş olarak tek bir sayı okuyoruz. Geri dönüş değerini değişkene atayarak, 1aksi takdirde 11'e açıkça atanması gereken 2 baytı kaydederek bundan faydalanabiliriz.

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

Ataşe ve Wolfram Dili (Mathematica) çok dilli, 10 bayt

PrimeOmega

Attache'yi çevrimiçi deneyin! Mathematica'yı çevrimiçi deneyin!

Sadece asal faktörlerin sayısını hesaplamak için bir yerleşik N'nin sahip .

açıklama

Bu yana , N = p ^k , Q ( K ) = Q ( p ^k ) = k , arzu edilen sonucu.

Java 8, 59 bayt

A lambda intiçin int.

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

Çevrimiçi Deneyin

J, 4 bayt

#@q:

q: asal faktörlerin listesini verir, # uzunluğunu verir.

Çevrimiçi deneyin!

R , 37 bayt

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

Çevrimiçi deneyin!

$\require{cancel}\xcancel 4 3$

|f%

Çalıştır ve hata ayıkla

Asal çarpanlarına ayırma uzunluğu.

MATL , 3 bayt

Yfz

Çevrimiçi deneyin!

Açıklama:

     % 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

Jöle , 3 2 bayt

Æḍ

Çevrimiçi deneyin!

Boşluk, 141 bayt

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

Harfler S(boşluk), T(sekme) ve N(yeni satır) yalnızca vurgulama olarak eklendi.
[..._some_action]yalnızca açıklama olarak eklendi.

Çevrimiçi deneyin (yalnızca ham alanlar, sekmeler ve yeni satırlarla).

Sahte kodda açıklama:

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

Örnek çalışma: 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

Program bir hatayla duruyor: Çıkış bulunamadı.

Brachylog , 2 bayt

ḋl

Çevrimiçi deneyin!

açıklama

ḋ        Prime decomposition
 l       Length

Python 2 , 62 bayt

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

Çevrimiçi deneyin!

Burada süslü bir şey yok.

Japt , 3 bayt

k l

Çevrimiçi deneyin!

Açıklama:

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

Aslında 2 bayt

ol

Çevrimiçi deneyin!

Haskell , 27 bayt

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

Çevrimiçi deneyin!

Faktörleri sayar. Karşılaştırmak:

Haskell , 28 bayt

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

Çevrimiçi deneyin!

Haskell , 28 bayt

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

Çevrimiçi deneyin!

Haskell , 30 bayt

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

Çevrimiçi deneyin!

Oktav , 18 bayt

@(x)nnz(factor(x))

Çevrimiçi deneyin!

Kalayda söylediklerini yapar: Girdinin asal çarpanlarına ayırmasında sıfır olmayan elemanların sayısı.

Cjam, 5 bayt

rimf,

Çevrimiçi deneyin!

Açıklama:

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

Yapı harika!

QBasic, 51 bayt

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

Tabanı bulmak için "Prime'ı Kurtar" çözümü ile aynı algoritmayı kullanır, sonra üssü almak için logaritma kurallarını kullanır:$log(p^n) = n \cdot log(p)$

Gaia , 2 bayt

ḍl

Çevrimiçi deneyin!

JavaScript (ES6), 37 bayt

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

Çevrimiçi deneyin!

Perl 6 , 36 bayt

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

İlk faktörü arar (2..*).first: $_%%*, sonra oradan yaklaşık değeri hesaplar (günlükler kesin olarak elde edilmez) ve yuvarlar.

Çevrimiçi deneyin!

Pari / GP , 8 bayt

bigomega

Çevrimiçi deneyin!

bigomega (x): x'in çokluk ile sayılan başlıca bölenlerinin sayısı.

Pari / GP , 14 bayt

n->numdiv(n)-1

Çevrimiçi deneyin!

Raket , 31 bayt

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

Çevrimiçi deneyin!

Perl 6 , 18 bayt

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

Çevrimiçi deneyin!

Faktörlerin listesini alan ve bir sayıya zorlayan anonim kod bloğu.

JavaScript (Node.js) , 29 bayt

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

Çevrimiçi deneyin! Not: Daha büyük girişler için yığın taşmaları.