Кажется, что многие хотели бы иметь это, так что теперь это продолжение этого вызова !

Определение : простая степень - это натуральное число, которое может быть выражено в виде p ⁿ где p - простое число, а n - натуральное число.

Задача : Учитывая простую степень p ⁿ > 1, вернуть степень n.

Тестовые случаи :

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

Подсчет очков : это код-гольф . Кратчайший ответ в байтах побеждает.

05AB1E , 2 байта

Òg

Попробуйте онлайн!

Python 3 , 49 байт

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

Попробуйте онлайн!

Выходы Trueвместо 1 ( как разрешено OP ). Рекурсивная функция, которая многократно находит наименьший коэффициент и затем снова вызывает функцию со следующей наименьшей степенью, пока не достигнет 1. Это расширение моего ответа на предыдущий вопрос.

Pyth, 2

Подсчитайте основные факторы:

lP

Интернет тест .

Python 2 , 37 байт

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

Попробуйте онлайн!

Считает факторы. Видимо я написал тот же гольф в 2015 году.

Узко выбивает нерекурсивный

Python 2 , 38 байт

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

Попробуйте онлайн!

Утилиты Bash + GNU, 22

• 2 байта сохранены благодаря @ H.PWiz и @Cowsquack

factor|tr -cd \ |wc -c

Попробуйте онлайн!

постоянный ток , 50 41 байт

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

Попробуйте онлайн!

Принимает ввод с вершины стека (в TIO поместите ввод в заголовок, чтобы загрузить его в стек перед выполнением). Выходы в стандартный вывод.

объяснение

Используемые регистры:

i: текущий пробный делитель, пока Xзапущен. Позже делитель мы нашли.

X: макрос dli1+dsi%0<X, который имеет эффект «приращение»i , затем проверьте модуль со значением в стеке (которое будет исходным вводом). Если оно не равно нулю, повторите».

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

лицо , 86 байт

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

Ура, дольше, чем Java!

Попробуйте онлайн!

Мне особенно нравится уловка использования возвращаемого значения sscanf. Обычно возвращаемое значение отбрасывается, но здесь оно всегда будет 1, потому что мы всегда читаем одно число как ввод. Мы можем воспользоваться этим, присвоив ее возвращаемое значение переменной 1, сохранив 2 байта, которые в противном случае потребовались бы 1для явного присвоения 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 )

Полиглот Attache и Wolfram Language (Mathematica) , 10 байт

PrimeOmega

Попробуйте Attache онлайн! Попробуйте Mathematica онлайн!

Просто встроенный для вычисления числа простых факторов N имеет.

объяснение

Поскольку N = p ^k , Ω ( N ) = Ω ( p ^k ) = k , то желаемый результат.

Java 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

Программа останавливается с ошибкой: выход не найден.

Брахилог , 2 байта

ḋl

Попробуйте онлайн!

объяснение

ḋ        Prime decomposition
 l       Length

Python 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

Попробуйте онлайн!

Haskell , 27 байт

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

Попробуйте онлайн!

Считает факторы. Для сравнения:

Haskell , 28 байт

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

Попробуйте онлайн!

Haskell , 28 байт

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

Попробуйте онлайн!

Haskell , 30 байт

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

Попробуйте онлайн!

Октава , 18 байт

@(x)nnz(factor(x))

Попробуйте онлайн!

Делает то, что говорит на банке: количество ненулевых элементов в простой факторизации входных данных.

Cjam, 5 байтов

rimf,

Попробуйте онлайн!

Объяснение:

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

Встроенные - это здорово!

QBasic, 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

Попробуйте онлайн!

JavaScript (ES6), 37 байт

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

Попробуйте онлайн!

Perl 6 , 36 байт

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

Ищет первый фактор (2..*).first: $_%%*, затем вычисляет приблизительное значение (журналы не получат его точно) и округляет его.

Попробуйте онлайн!

Пари / ГП , 8 байт

bigomega

Попробуйте онлайн!

bigomega (x): число простых делителей x, подсчитанное с кратностью.

Пари / ГП , 14 байтов

n->numdiv(n)-1

Попробуйте онлайн!

Ракетка , 31 байт

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

Попробуйте онлайн!

Perl 6 , 18 байт

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

Попробуйте онлайн!

Блок анонимного кода, который получает список факторов и приводит его к числу.

JavaScript (Node.js) , 29 байт

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

Попробуйте онлайн! Примечание: переполнение стека для больших входов.