It seems that many people would like to have this, so it's now a sequel to this challenge!
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. Shortest answer in bytes wins.
Ò: Push list of prime factors (with duplicates) and g: Push length.
\$\endgroup\$
Commented
Jun 21, 2018 at 10:04
f=lambda n,x=2:n%x and f(n,x+1)or n/x<2or-~f(n/x)
Outputs True instead of 1 (as allowed by OP). 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 to the previous question.
factor|sed s/\ //|wc -w work?
\$\endgroup\$
factor|tr -cd \ |wc -c?
\$\endgroup\$
Commented
Jun 21, 2018 at 11:10
factor|awk \$0=NF-1
\$\endgroup\$
Commented
Mar 31, 2021 at 9:40
,|`,$~^%@
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...
1si[dli1+dsi%0<X]dsXx[dli/dli<Y]sYdli<Yzp
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.
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
(%d@)\$*,c'$,io>Av"[""mN*c?*m1*mp*m%*s1"$pN1p:~+p1p%%Np?%~:=/NNp+?1?-%N1?%=p%'$i?w1'%>
Hooray, longer than Java!
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 )
PrimeOmega
Try Attache online! Try Mathematica online!
Simply a builtin for computing the number of prime factors N has.
Since N = pk, Ω(N) = Ω(pk) = k, the desired result.
[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 (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
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.
D,f,@,bUbU$^=
L,dVfbUG$XGRzGGXzÞ{f}bUbU0$:
I don't even know where to begin explaining this mess.
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.
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: 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
(or possibly 6.5 depending on how this meta question shakes out)
+(*'?(*%.(02.
+(*'?(*%.(
(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
!\?___
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)
ƒ
ƒ 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.
A lambda from int to int.
x->{int f=1,c=0;while(x%++f>0);for(;x>1;c++)x/=f;return c;}
sum(x|1) is nearly always shorter than length(x)
\$\endgroup\$
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
An anonymous worksheet function that takes input from cell A1 and outputs to the calling cell
-SUM(-(MOD(A1,SEQUENCE(A1))<1))-1
