Given a positive integer, return the product of its divisors, including itself.
This is sequence A007955 in the OEIS.
1: 1 2: 2 3: 3 4: 8 5: 5 6: 36 7: 7 8: 64 9: 27 10: 100 12: 1728 14: 196 24: 331776 25: 125 28: 21952 30: 810000
This is code-golf, so the shortest answer in each language wins!
â ×
â × // implicit integer input
â // get integer divisors
× // get product of array
â and × when writing this answer
\$\endgroup\$
Commented
Jul 8, 2017 at 6:38
(1,k)[i%k<1] is equivalent to k**(i%k<1)
\$\endgroup\$
Commented
Jul 8, 2017 at 6:14
/o
\i@/Bdt&*
This is just the regular framework for decimal I/O:
/o
\i@/...
Then the program is:
B Get all divisors of the input.
dt Get the stack depth minus 1.
&* Multiply the top two stack elements that many times, folding multiplication
over the stack.
[ dup [1,b] [ dupd divisor? ] count 2 / ^ ]
Uses the formula n^((number of divisors of n)/2).
Usually mod 0 = (7 bytes) is shorter than divisor? (8 bytes), but the latter is used here to auto-load math.functions to disambiguate ^ (which happens to appear in a regex lib). Auto-use is weird. The unambiguous alternative to ^ exists (fpow), but it's longer.
[ ! anonymous lambda
dup [1,b] ! ( n {1..n} )
[ ... ] count ! count the elements that satisfy the predicate...
dupd ! ( n i -- n n i )
divisor? ! ( n ? ) tests if i is a divisor of n
2 / ^ ! halve the divisor count and raise n to the power
]
USE: math.primes.factors
[ divisors product ]
Uses divisors built-in, but obviously the library import is expensive.
31 C9 8D 71 01 89 F8 FF C1 99 F7 F9 85 D2 75 03 0F AF F1 39 F9 7C EE 89 F0 C3
The above code defines a function that takes a single parameter (the input value, a positive integer) in EDI (following the System V AMD64 calling convention used on Gnu/Unix), and returns a single result (the product of divisors) in EAX.
Internally, it computes the product of divisors using an (extremely inefficient) iterative algorithm, similar to pizzapants184's C submission. Basically, it uses a counter to loop through all of the values between 1 and the input value, checking to see if the current counter value is a divisor of the input. If so, it multiplies that into the running total product.
Ungolfed assembly language mnemonics:
; Parameter is passed in EDI (a positive integer)
ComputeProductOfDivisors:
xor ecx, ecx ; ECX <= 0 (our counter)
lea esi, [rcx + 1] ; ESI <= 1 (our running total)
.CheckCounter:
mov eax, edi ; put input value (parameter) in EAX
inc ecx ; increment counter
cdq ; sign-extend EAX to EDX:EAX
idiv ecx ; divide EDX:EAX by ECX
test edx, edx ; check the remainder to see if divided evenly
jnz .SkipThisOne ; if remainder!=0, skip the next instruction
imul esi, ecx ; if remainder==0, multiply running total by counter
.SkipThisOne:
cmp ecx, edi ; are we done yet? compare counter to input value
jl .CheckCounter ; if counter hasn't yet reached input value, keep looping
mov eax, esi ; put our running total in EAX so it gets returned
ret
The fact that the IDIV instruction uses hard-coded operands for the dividend cramps my style a bit, but I think this is pretty good for a language that has no built-ins but basic arithmetic and conditional branches!
Prompt X
1
For(A,1,X
If not(remainder(X,A
AAns
End
Full program: prompts user for input; returns output in Ans, a special variable that (basically) stores the value of the latest value calculated.
Explanation:
Prompt X # 3 bytes, Prompt user for input, store in X
1 # 2 bytes, store 1 in Ans for use later
For(A,1,X # 7 bytes, for each value of A from 1 to X
If not(remainder(X,A # 8 bytes, If X is divisible by A...
AAns # 3 bytes, ...store (A * Ans) in Ans
End # 1 byte, end For( loop
p,a;f(x){for(p=1,a=x;a;a--)p*=x%a?1:a;return p;}
-4 bytes thanks to Cody Gray
A function that takes in an integer and returns the product of it's divisors.
Ungolfed:
int proddiv(int input) {
int total = 1, loopvar;
for(loopvar = input; loopvar > 0; --loopvar) {
// for loopvar from input down to 1...
total *= (input % loopvar) ? 1 : loopvar;
// ...If the loopvar is a divisor of the input, multiply the total by loopvar;
}
return total;
}
p*= expression, and (3) putting a statement in the body of the for loop to drop a comma. I also like to use global vars, rather than adding extra parameters. This avoids undefined behavior, without costing any bytes. Final version: p,a;f(x){for(p=1,a=x;a;--a)p*=x%a?1:a;return p;}
\$\endgroup\$
Commented
Jul 8, 2017 at 15:13
return p; with p=p; and save five bytes.
\$\endgroup\$
Commented
Sep 19, 2017 at 6:08
p,a;f(x) with f(x,p,a).
\$\endgroup\$
Commented
Sep 19, 2017 at 6:09
return p; and save not five, but nine bytes. (TIO)
\$\endgroup\$
Commented
Sep 19, 2017 at 6:14
.
Ajax,.
Puck,.
Page,.
Act I:.
Scene I:.
[Enter Ajax and Puck]
Ajax:
You cat
Puck:
Listen to thy heart
[Exit Ajax]
[Enter Page]
Scene II:.
Puck:
You sum you cat
Page:
Is Ajax nicer I?If so, is remainder of the quotient Ajax I nicer zero?If not, you product you I.Is Ajax nicer I?If so, let us return to scene II
Scene III:.
Page:
Open thy heart
[Exeunt]
Ungolfed version:
The Tragedy of the Product of a Moor's Factors in Venice.
Othello, a numerical man.
Desdemona, a product of his imagination.
Brabantio, a senator, possibly in charge of one Othello's factories.
Act I: In which tragedy occurs.
Scene I: Wherein Othello and Desdemona have an enlightened discussion.
[Enter Othello and Desdemona]
Othello:
Thou art an angel!
Desdemona:
Listen to thy heart.
[Exit Othello]
[Enter Brabantio]
Scene II: Wherein Brabantio expresses his internal monologue to Desdemona.
Desdemona:
Thou art the sum of thyself and the wind!
Brabantio:
Is Othello jollier than me?
If so, is the remainder of the quotient of Othello and I better than nothing?
If not, thou art the product of thyself and me.
IS Othello jollier than me?
If so, let us return to scene II!
Scene III: An Epilogue.
Brabantio:
Open thy heart!
[Exeunt]
I'm using this SPL compiler to run the program.
Run with:
$ python splc.py product-of-divisors.spl > product-of-divisors.c
$ gcc product-of-divisors.c -o pod.exe
$ echo 30 | ./pod
810000
n=>g=(i=n)=>i?i**!(n%i)*g(i-1):1
Saved a couple of bytes by borrowing Leaky's tip on musicman's Python solution.
o.innerText=(f=
n=>g=(i=n)=>i?i**!(n%i)*g(i-1):1
)(i.value=1)();oninput=_=>o.innerText=f(+i.value)()<input id=i type=number><pre id=o>n=>g=(i=n)=>i?(n%i?1:i)*g(i-1):1
(n%i?1:i)? (This wouldn't save any byte, though.)
\$\endgroup\$
Saved 1 byte thanks to lirtosiast
:√(Ans^sum(not(fPart(Ans/randIntNoRep(1,Ans
func p(n int)int{p,i:=1,1
for;i<=n;i++{if n%i<1{p*=i}}
return p}
==0 for <1 (@Steffan)func product(s []int) int {
p := 1
for _,e := range s {
p *= e
}
return p
}
func divisors(n int) (d []int) {
for i := 1; i <= n; i++ {
if n % i == 0 {
d = append(d, i)
}
}
return d
}
n%i<1 instead of n%i==0
\$\endgroup\$
[:|~b/a=b'\`a|q=q*a}?q
[:| FOR a = 1; a <= input (b); a++
b/a=b'\`a 'a' is a proper divisor if integer division == float division
~ | IF that's true
q=q*a THEN multiply running total q (starts as 1) by that divsor
} NEXT
?q Print q
m*=n%i>0 or ii=n=input()
m=1
while i:m*=n%i>0 or i;i-=1
print m
for those who can't view deleted answers (DavidC's answer), this is the code in Mathematica with the help of @MartinEnder
1##&@@Divisors@#&
lambda _:_**(sum(_%-~i<1for i in range(_))/2)
Let x be a number. Both y and z will be divisors of x if y * z = x. Therefore, y = x / z. Let's say a number d has 6 divisiors, due to this observation the divisors will be a, b, c, d / a, d / b, d / b. If we multiply all these numbers (the point of the puzzle), we obtain d * d * d = d ^ 3. In general, for e with a number of f divisors, the product of said divisors will be e ^ (f / 2), which is what the lambda does.
Hex:
1A 3A 54 27
Explanation:
1A - Input as an integer
3A - Factors
54 - Product
27 - Output (with newline)
