[Question]
  [
It seems that many people would like to have this, so it's now a sequel to [this challenge](https://codegolf.stackexchange.com/questions/167106/recover-the-prime-from-the-prime-power)!
**Definition**: a *prime power* is a natural number that can be expressed in the form pn where p is a prime and n is a natural number.
**Task**: Given a prime power pn > 1, return the power n.
**Testcases**:
```
input output
9     2
16    4
343   3
2687  1
59049 10
```
**Scoring**: This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). Shortest answer in bytes wins.
  
[Answer]
# [Python 2](https://docs.python.org/2/), 37 bytes
```
f=lambda n,i=2:i/n or(n%i<1)+f(n,i+1)
```
[Try it online!](https://tio.run/##DYpBCsIwFAX3nuJthIQGa1KpWuxJxEXVFj80P@EnXfT0MQOzGSbu@RfYFfIxSEba06F6SnOW@bNJosArecrKniu6LOM6@fd3Ahsa3UAtI4jiIz2sbhZVa2PrFQQMYjydwd3A9gbdpTNw/e36GhCFOKPuuvwB "Python 2 – Try It Online")
Counts factors. Apparently I wrote the [same golf](https://codegolf.stackexchange.com/a/64948/20260) in 2015.
Narrowly beats out the non-recursive
**[Python 2](https://docs.python.org/2/), 38 bytes**
```
lambda n:sum(n%i<1for i in range(1,n))
```
[Try it online!](https://tio.run/##FchBCoMwFAXAq7yNkMDfJEpaRU/Suoi0qQF9SrQLTx/JLGe/znmjzWF458Wv08eD3fFfFavYm7AlREQief6@ygi1ziVZ8mUFrcA4Qd3UAuuej7HDniJPBEWdbw "Python 2 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 2 bytes
```
Òg
```
[Try it online!](https://tio.run/##MzBNTDJM/f//8KT0//9NLQ1MLAE "05AB1E – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 49 bytes
```
f=lambda n,x=2:n%x and f(n,x+1)or n/x<2or-~f(n/x)
```
[Try it online!](https://tio.run/##DYtBDoIwFAX3nOJtTNpYBQqiEDmJcVEFYhP4Je03KRuvjn3JLGaSt278cVTtdlmdZ4QtZIlzGNmP768P1tFsF8uiLNLkPvWzWV6DAanY644OEYYGTCL5sZTOg/J4186ffqnlMT1SY1jCo1UoG4WqrhR0c7sqXNqibp9dBqzeEotJsJT7Hw "Python 3 – Try It Online")
Outputs `True` instead of 1 ([as allowed by OP](https://codegolf.stackexchange.com/questions/167199/recover-the-power-from-the-prime-power#comment404175_167199)). Recursive function that repeatedly finds the lowest factor and then calls the function again with the next lowest power until it reaches 1. This is an extension of [my answer](https://codegolf.stackexchange.com/a/167125/76162) to the previous question.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), \$\require{cancel}\xcancel 4 3\$ bytes
```
|f%
```
[Run and debug it](https://staxlang.xyz/#c=%7Cf%25&i=9%0A16%0A343%0A2687%0A59049&a=1&m=2)
Length of prime factorization.
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + GNU utilities, 22
* 2 bytes saved thanks to @H.PWiz and @Cowsquack
```
factor|tr -cd \ |wc -c
```
[Try it online!](https://tio.run/##RYpBCsIwEEX3c4pP0WVBba2GgifpJs5MSUEaSQa6yd1jEcS/erz3nz6HuoXlpUjqBabZ2GcdIZGw752W1WY0R0H7QIPD7/GtyiH@FQqmOnu2mIoltCyYUDbeqUpctTo6D9T1HV2G@42u7tQ7@gA "Bash – Try It Online")
[Answer]
# [R](http://cran.r-project.org) 22 bytes
Power `n` is the number of multiples of `p` in `p^n` when `p` is prime:
```
sum(!(b<-scan())%%2:b)
```
[Try it online!](https://tio.run/##K/r/v7g0V0NRI8lGtzg5MU9DU1NV1cgqSfO/5X8A "R – Try It Online")
[Answer]
## [Nibbles](http://golfscript.com/nibbles) 5 bytes
```
,|`,$~^%@
```
This is 9 nibbles each of which is encoded in a half byte in the binary form. I think this is the shortest solution that doesn't use built in factoring.
Translation:
```
,      length
 |     filter
  `,$  0..input
  ~    not \x->
   ^   pow (so that 0 which would have been 0 from the mod isn't)
    %  mod
     @ input
     implicit $ (x)
    implicit $ (x) 
```
It works by just counting the number of numbers the input divides evenly
You could run it passing in a list of numbers to process in stdin or as a command line arg. Nibbles isn't on TIO.run yet...
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), ~~50~~ 41 bytes
```
1si[dli1+dsi%0<X]dsXx[dli/dli<Y]sYdli<Yzp
```
[Try it online!](https://tio.run/##S0n@b2j@37A4MzolJ9NQO6U4U9XAJiI2pTiiAiSiD8Q2kbHFkWC6quD/fwA "dc – Try It Online")
Takes input from the top of the stack (in TIO, put the input in the header to load it onto the stack before execution). Outputs to stdout.
# Explanation
**Registers used:**
`i`: the current trial divisor, while `X` is running. Later, the divisor we've found. 
`X`: the macro `dli1+dsi%0<X`, which has the effect "increment `i`, then check the modulus with the value on the stack (which will be the original input). If it's not zero, repeat".
`Y`: the macro `dli/dli<Y`, which has the effect "Add to the stack a copy of the current top of the stack, divided by `i`. Repeat until `i` is reached."
Full 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
```
[Answer]
# Pyth, 2
Count prime factors:
```
lP
```
[Online test](https://pyth.herokuapp.com/?code=lP&input=59049&test_suite=1&test_suite_input=9%0A16%0A343%0A2687%0A59049&debug=0).
[Answer]
# [face](https://github.com/KeyboardFire/face), 86 bytes
```
(%d@)\$*,c'$,io>Av"[""mN*c?*m1*mp*m%*s1"$pN1p:~+p1p%%Np?%~:=/NNp+?1?-%N1?%=p%'$i?w1'%>
```
Hooray, longer than Java!
[Try it online!](https://tio.run/##BcFBCoNADAXQuwzzmTZaakAXCpr2ArlAu5GpgovBgNDuvHr63jrnxf2Cz@P6jlTnFOttn57f8AqhKGWhwlSMCujgEE3ZhrMyNkBNcA7jXdUqYblBWTAaUtzkxwmTu3d90/Z/)
I am particularly fond of the trick of using the return value of `sscanf`.
Normally the return value would be discarded,
but here it will always be 1,
because we're always reading a single number as input.
We can take advantage of this
by assigning its return value to the variable `1`,
saving the 2 bytes that would otherwise be required
to assign `1` to 1 explicitly.
```
(%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 )
```
[Answer]
# [Attache](https://github.com/ConorOBrien-Foxx/Attache) and [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/) polyglot, 10 bytes
```
PrimeOmega
```
[Try Attache online!](https://tio.run/##SywpSUzOSP2fpmBlq/A/oCgzN9U/NzU98b9fampKcbRKQUFyeiwXUDyvJCS1uMQ5sTi1ODpNRyHaUkfB0ExHwdjEWEfByMzCXEfB1NLAxDI29j8A "Attache – Try It Online") [Try Mathematica online!](https://tio.run/##y00syUjNTSzJTE78n6Zgq/A/oCgzN9U/NzU9EcTMK4n2TSyITtNRqLbUUTA001EwNjHWUTAyszDXUTC1NDCxrI2N/Q8A "Wolfram Language (Mathematica) – Try It Online")
Simply a builtin for computing the number of prime factors **N** has.
## Explanation
Since **N** = **p***k*, Ω(**N**) = Ω(**p***k*) = *k*, the desired result.
[Answer]
# Whitespace, 141 bytes
```
[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]
```
Letters `S` (space), `T` (tab), and `N` (new-line) added as highlighting only.  
`[..._some_action]` added as explanation only.
[Try it online](https://tio.run/##TYxLCoAwEEPXySnmDvVCIgXdCQoef5p0urAfyGRe8p3X2597P3pmRFAXhI8mkLYsPFrCT5T2mK4QGov6tTfI6VS08o79yrBgrMbZYiUZyGxbGw) (with raw spaces, tabs and new-lines only).
**Explanation in 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
```
**Example run: [`input = 9`](https://tio.run/##TYxLCoBADEPXySl6DY8jMjDuBAWPX5N2Fs4H0vQl7zyfcV/7MTIjgrogfDSBtGXh0RJ@orRHuUJoLPr33iDL6WjnHfuVYcFYjdViJRnI3D4)**
```
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 stops with an error: No exit found.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 2 bytes
```
ḋl
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//@GO7pz//y3/RwEA "Brachylog – Try It Online")
### Explanation
```
ḋ        Prime decomposition
 l       Length
```
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), ~~8~~ 2 bytes
```
≢⍭
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/P@1R24RHnYse9a4FshUsudIUDM2AhLGJMZA0MrMwB1KmlgYmlgA "APL (Dyalog Extended) – Try It Online")
`⍭` finds factors, `≢` counts how many of them there are.
[Answer]
# [Add++](https://github.com/cairdcoinheringaahing/AddPlusPlus), 42 bytes
```
D,f,@,bUbU$^=
L,dVfbUG$XGRzGGXzÞ{f}bUbU0$:
```
[Try it online!](https://tio.run/##S0xJKSj4/99FJ03HQScpNClUJc6Wy0cnJSwtKdRdJcI9qMrdPaLq8LzqtFqQrIGK1X@VnMTcpJREBUM7ey7///8NzQA "Add++ – Try It Online")
I don't even know where to begin explaining this mess.
## Explained
```
D,f,@,bUbU$^=
D,f,@,        ; a helper function f that given a list [number, [x, y]]
      bUbU$^  ;   returns whether x ^ y
            = ;   equals number
L,dVfbUG$XGRzGGXzÞ{f}bUbU0$:
L,                            ; a lambda that
  dV                          ; places its input into the register
    fbU                       ; and gets the prime factor of the input. This is guaranteed to be a single item because the input is a prime raised to a power.
       G$X                    ; push a list of input copies of that power
          GRz                 ; and zip that with the range [1...input]
             GGX              ; also, push input copies of the input
                z             ; and zip that with our big list. I'm calling it a big list because it is what it is.
                 Þ{f}         ; filter that list based on the results of the helper function f
                     bUbU0$:  ; get the power out of the many nested lists returned.
```
[Answer]
# QBasic, ~~51~~ 41 bytes
```
INPUT n
FOR i=2TO n
f=f-(n/i=n\i)
NEXT
?f
```
-10 bytes by copying the approach from [Darren Smith's Nibbles answer](https://codegolf.stackexchange.com/a/240635/16766): For a prime power input, the desired output equals the number of integers between 1 (exclusive) and the input (inclusive) that evenly divide the input.
```
INPUT number
FOR testFactor = 2 TO number
  ' number is divisible by testFactor if their float division equals
  ' their int division
  isDivisible = (number / testFactor = number \ testFactor)
  ' Truthy is -1 in QBasic, so we subtract rather than add to the tally
  numFactors = numFactors - isDivisible
NEXT testFactor
PRINT numFactors
```
[Answer]
# [HBL](https://github.com/dloscutoff/hbl), 7 bytes
*(or possibly 6.5 depending on how [this meta question](https://codegolf.meta.stackexchange.com/q/24251/16766) shakes out)*
```
+(*'?(*%.(02.
```
[Try it!](https://dloscutoff.github.io/hbl/?f=0&p=KygqJz8oKiUuKC0yMC4_&a=ODE_)
### Explanation
```
+(*'?(*%.(
         (0    Inclusive range
           2    from 2
            .   to the argument
     (*        Map over each value x in that list:
       %.       Argument mod x
 (*            Map over each value in that list:
   '?           Logical negation
               The result is a list containing 1 for each number that divides
               the argument, 0 otherwise
+              Take its sum
```
[Answer]
# [Risky](https://github.com/Radvylf/risky), 3 bytes
```
!\?___
```
[Try it online!](https://radvylf.github.io/risky?p=WyIhXFw_X19fIiwiWzI1Nl0iLDBd)
---
A basically built-in solution for now, working on a non-trivial version (might not be possible given Risky's heavy investment in specific operators, and generally awful control flow).
```
!      Count
 \     Prime factors
  ?    Input
   ___ (Padding)
```
[Answer]
# [Nekomata](https://github.com/AlephAlpha/Nekomata), 1 byte
```
ƒ
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70iLzU7PzexJHFZtJJurlLsgqWlJWm6FouOTVpSnJRcDOUu2GzJZWjGZWxizGVkZmHOZWppYGIJkQIA)
`ƒ` factorizes the input number, and returns a list of unique prime factors and a list of exponents.
Only the top of the stack will be printed, which is the list of exponents. Since the input is a prime power, this will be a singleton list.
[Answer]
# Java 8, 59 bytes
A lambda from `int` to `int`.
```
x->{int f=1,c=0;while(x%++f>0);for(;x>1;c++)x/=f;return c;}
```
[Try It Online](https://tio.run/##XU7PT4MwFD7DX/EuJiV0FdycYoWjiQdPO5rF1K7FYldIWzYWwt@OnXIyecn73sv3q2Entmo7YZrD99z1n1px4Jo5B29MGRjjaHk6z3xYUhmmoQkq0nuliewN96o15GUBz6/Gi1pYDAuoQEI5D6tqVMaDLHPMy4yev5QWaLhJU1llCZWtRXSocsrTNBluS0mt8L01wOk0RzT@X@PUqgMcQ0O081aZ@n0PzNYuuRaOghmgaxhnTnzAExhxhnAH0lhgyLcY1ps1hrvt4wOG@yLbFNOfMtpdnBdH0vaedMHXa4MkYV2nL@jXLElooE1xmCmefwA)
[Answer]
# J, 4 bytes
```
#@q:
```
`q:` gives the list of prime factors, `#` gives the length of the list.
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/lR0Krf5rcnGlJmfkK6QpWCoYmikYmxgrGJlZmCuYWhqYWHJx/QcA "J – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 37 bytes
```
length(numbers::primeFactors(scan()))
```
[Try it online!](https://tio.run/##K/r/Pyc1L70kQyOvNDcptajYyqqgKDM31S0xuSS/qFijODkxT0NTU/O/oZHFfwA "R – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), 3 bytes
```
Yfz
```
[Try it online!](https://tio.run/##y00syfn/PzKt6v9/U0sDE0sA "MATL – Try It Online")
### Explanation:
```
     % 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
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~3~~ 2 bytes
```
Æḍ
```
[Try it online!](https://tio.run/##y0rNyan8//9w28Mdvf///ze1NDCxBAA "Jelly – Try It Online")
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `l`, 1 byte
```
ǐ
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=l&code=%C7%90&inputs=9&header=&footer=)
-1 byte thx to @lyxal
Length of the prime factors, the flags are cheaty+awesome
[Answer]
# MS Excel, 33 bytes
An anonymous worksheet function that takes input from cell `A1` and outputs to the calling cell
```
-SUM(-(MOD(A1,SEQUENCE(A1))<1))-1
```
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2) `L`, 1 [byte](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md)
```
f
```
[Try it online!](https://Not-Thonnu.github.io/run#aGVhZGVyPSZjb2RlPWYmZm9vdGVyPSZpbnB1dD01OTA0OSZmbGFncz1M)
Push the prime `f`actors of the input then take the `L`ength of the list.
[Answer]
# [Python 2](https://docs.python.org/2/), 62 bytes
```
def f(n,p=2,i=0):
	while n%p:p+=1
	while n>p**i:i+=1
	return i
```
[Try it online!](https://tio.run/##K6gsycjPM/r/PyU1TSFNI0@nwNZIJ9PWQNOKi7M8IzMnVSFPtcCqQNvWEM63K9DSyrTKBAsVpZaUFuUpZP4vKMrMKwEaYGxirPn/PwA "Python 2 – Try It Online")
Nothing fancy here.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 3 bytes
```
k l
```
[Try it online!](https://tio.run/##y0osKPn/P1sh5/9/U0sDE0sA "Japt – Try It Online")
## Explanation:
```
k l
k     Get the prime factors of the input
  l   Return the length
```
[Answer]
# [Actually](https://github.com/Mego/Seriously), 2 bytes
```
ol
```
[Try it online!](https://tio.run/##S0wuKU3Myan8/z8/5/9/U0sDE0sA "Actually – Try It Online")
]