많은 사람들이 이것을 갖고 싶어하는 것 같습니다. 이제이 도전 의 속편입니다 !

정의 : 소수 는 자연수이며 p ⁿ 형식으로 표현할 수있는 ^{자연수입니다.} 여기서 p는 소수이고 n은 자연수입니다.

작업 : 주요 전력 p ⁿ > 1이 주어지면 전력 n을 반환합니다.

테스트 케이스 :

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

채점 : 이것은 code-golf 입니다. 바이트 단위의 최단 답변이 이깁니다.

05AB1E , 2 바이트

Òg

온라인으로 사용해보십시오!

파이썬 3 , 49 바이트

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

온라인으로 사용해보십시오!

True1 대신 출력OP 허용되는 . 그것은이의 확장 (1)에 도달 할 때까지 반복적으로 다음으로 낮은 전력으로 기능을 다시 가장 낮은 요인을 발견하고 호출 재귀 함수 내 대답은 앞의 질문에.

피스, 2

소인수를 세십시오 :

lP

온라인 테스트 .

파이썬 2 , 37 바이트

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

온라인으로 사용해보십시오!

계수를 계산합니다. 분명히 나는 2015 년에 같은 골프 를 .

비 재귀를 획기적으로 능가

파이썬 2 , 38 바이트

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

온라인으로 사용해보십시오!

배쉬 + GNU 유틸리티, 22

• @ H.PWiz 및 @Cowsquack 덕분에 2 바이트 절약

factor|tr -cd \ |wc -c

온라인으로 사용해보십시오!

dc , 50 41 바이트

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

온라인으로 사용해보십시오!

스택 맨 위에서 입력을 가져옵니다 (TIO에서는 입력을 헤더에 넣어 실행 전에 스택에로드합니다). stdout으로 출력합니다.

설명

사용 된 레지스터 :

i: X실행중인 현재 평가판 제수 입니다. 나중에, 우리가 찾은 약수.

X: 매크로 dli1+dsi%0<X는 "증가"효과를 가지며 i스택의 값으로 원래 계수를 확인합니다 (원래 입력이 됨). 0이 아닌 경우 반복합니다.

Y: 매크로 : dli/dli<Y"스택에 스택의 현재 상단 사본을 i. 으로 나눈 값에 추가 합니다. i에 도달 할 때까지 반복 합니다."효과가 있습니다.

전체 프로그램 :

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

face , 86 바이트

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

Java보다 긴 Hooray!

온라인으로 사용해보십시오!

나는의 반환 값을 사용하는 트릭을 특히 좋아합니다 sscanf. 일반적으로 반환 값은 버려지지만 항상 단일 숫자를 입력으로 읽으므로 항상 1이됩니다. 반환 값을 변수 1에 할당 1하여 명시 적으로 지정 해야하는 2 바이트를 저장하여 이를 활용할 수 있습니다 .

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

Attache and Wolfram Language (Mathematica) 폴리 글롯, 10 바이트

PrimeOmega

온라인 첨부 파일을보십시오! Mathematica를 온라인으로 사용해보십시오!

다수의 주요 요소 N 을 계산하기위한 내장 기능 이 가지고있는 있습니다.

설명

이후 N = P는 ^K , Ω ( N ) = Ω ( P는 ^K ) = K , 원하는 결과.

자바 8, 59 바이트

발 람다 int로 int.

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

온라인 시도

J, 4 바이트

#@q:

q:주요 요인의 목록을 제공하고 목록의 #길이를 제공합니다.

온라인으로 사용해보십시오!

R , 37 바이트

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

온라인으로 사용해보십시오!

Stax ,$\require{cancel}\xcancel 4 3$ 바이트

|f%

실행 및 디버깅

소인수 분해 길이.

MATL , 3 바이트

Yfz

온라인으로 사용해보십시오!

설명:

     % 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

젤리 , 3 2 바이트

Æḍ

온라인으로 사용해보십시오!

공백, 141 바이트

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

문자 S(공백), T(탭) 및 N(줄 바꾸기)가 강조 표시로만 추가되었습니다.
[..._some_action]설명으로 만 추가되었습니다.

온라인으로 시도하십시오 (원시 공백, 탭 및 줄 바꾸기 만).

의사 코드의 설명 :

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

예제 실행 : 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

프로그램이 오류와 함께 중지됩니다 : 종료를 찾을 수 없습니다.

Brachylog , 2 바이트

ḋl

온라인으로 사용해보십시오!

설명

ḋ        Prime decomposition
 l       Length

파이썬 2 , 62 바이트

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

온라인으로 사용해보십시오!

여기서 멋진 것은 없습니다.

Japt , 3 바이트

k l

온라인으로 사용해보십시오!

설명:

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

실제로 2 바이트

ol

온라인으로 사용해보십시오!

하스켈 , 27 바이트

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

온라인으로 사용해보십시오!

계수를 계산합니다. 비교:

하스켈 , 28 바이트

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

온라인으로 사용해보십시오!

하스켈 , 28 바이트

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

온라인으로 사용해보십시오!

하스켈 , 30 바이트

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

온라인으로 사용해보십시오!

옥타브 , 18 바이트

@(x)nnz(factor(x))

온라인으로 사용해보십시오!

주석에 표시되는 내용 : 입력의 소인수 분해에서 0이 아닌 요소의 수.

잼, 5 바이트

rimf,

온라인으로 사용해보십시오!

설명:

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

내장은 훌륭합니다!

Q 기본, 51 바이트

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

"소수점 복구"솔루션 과 동일한 알고리즘 을 사용하여 밑을 찾은 다음 로그 규칙을 사용하여 지수를 얻습니다.$log(p^n) = n \cdot log(p)$.

Gaia , 2 바이트

ḍl

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 37 바이트

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

온라인으로 사용해보십시오!

펄 6 , 36 바이트

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

첫 번째 요인 (2..*).first: $_%%*을 찾은 다음 근사값을 계산하고 (로그가 정확하지 않음) 반올림합니다.

온라인으로 사용해보십시오!

Pari / GP , 8 바이트

bigomega

온라인으로 사용해보십시오!

bigomega (x) : x로 소수의 제수를 곱한 수입니다.

Pari / GP , 14 바이트

n->numdiv(n)-1

온라인으로 사용해보십시오!

라켓 , 31 바이트

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

온라인으로 사용해보십시오!

펄 6 , 18 바이트

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

온라인으로 사용해보십시오!

요인 목록을 가져와 숫자로 강제 변환하는 익명 코드 블록입니다.

자바 스크립트 (Node.js) , 29 바이트

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

온라인으로 사용해보십시오! 참고 : 입력이 클수록 스택 오버플로가 발생합니다.