Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It only takes a minute to sign up.
Sign up to join this community
In this challenge, your input is an integer value. Your task is to find the sum of the range of the sum of the range of n.
Examples:
Input -> Output
1 -> 1
2 -> 6
3 -> 21
4 -> 55
5 -> 120
6 -> 231
7 -> 406
8 -> 666
9 -> 1035
10 -> 1540
This challenge should be fairly simple to complete in most languages :)
Have fun!
With unsequenced modification and access to n
f(n){n*=~n;n=--n*n/8;}
With unsequenced modification and access to n
f(n){n*=~n;return--n*n/8;}
f(n){n*=~n;return(n-2)*n/8;}
f(n){n*=~n;return--n*n/8;} // function which takes and returns an integer
n*=~n; // n *= -(n + 1); here (n = -(n*n + n))
--n // decrement n; here (n = -(n*n + n + 1))
return n*n/8; // return (n*n + n + 1)^2 / 8
#@*#&@Tr@*Range
-1 byte from @att
(f=Tr@*Range)@*f
Anonymous tacit prefix function.
+/∘⍳⍣2
+/ the sum
∘ of
⍳ the range
⍣2 twice
({({}[()])()}{})
({({}[()])()}{})
(The newline isn't needed, but is included because it makes the answer pretty)
Polygonal numbers are one of the things that brain-flak uniquely excels at. This is just the code that calculates the N-th triangular number, repeated twice.
# Push (the sum of...)
(
# While the top of stack is not 0...
{
# Decrement the top of the stack by 1
# This adds n-1 to the running counter
({}[()])
# Plus 1 (to the running counter)
()
}
# Pop the stack (which should contain a 0 now)
{}
)
g.g
g n=sum[1..n]
Just implementing the definition seems to be shorter than arithmetical expressions such as
21 bytes
f n=((n^2+n+1)^2-1)/8
With floats:
17 bytes
g.g
g n=n*(n+1)/2
+,+,
+,+,$
$ Input number (implicit)
, Range from 1 to that number
+ Sum
, Range from 1 to that number
+ Sum
01000001 11001110 10000101 01100001 10010000 00000101 10011111 01110010
11110111 10110000 00001110 01011110 11010000 10110001 00000100 00010
Encodes the following lambda term:
main = 2 rangesum where
succ = \n f x. f (n f x)
pair = \x y f. f x y
snd = \p. p (\x y. y)
update = \p. p (\x y f. f (succ x) (x succ y))
rangesum = \n. snd (n update (pair 1 0))
This is a function that takes a positive integer in Church numeral and outputs the answer in the same form. The numbers that appear in the Haskell-like code above are also Church numerals, e.g. 2 = \f x. f (f x).
Ｉ÷⍘12320Ｎ⁸
Try it online! Link is to verbose version of code. Explanation:
12320 Literal string `12320`
⍘ Interpret as base
Ｎ First input as a number
÷ Integer divide by
⁸ Literal integer `8`
Ｉ Cast to string
Implicitly print
The boring solution is 8 bytes:
ＩΣ…·Σ…·Ｎ
Try it online! Link is to verbose version of code. Explanation: InclusiveRange prefers two arguments, but fortunately we can arrange to use the one-argument version (twice, saving two bytes).
Ｎ First input as a number
…· Inclusive range from `1` to that
Σ Take the sum
…· Inclusive range from `1` to that
Σ Take the sum
Ｉ Cast to string
Implcitly print
LOLO
Try it online or verify all test cases.
Explanation:
L # Push a list in the range [1, (implicit) input-integer]
O # Sum this list together
L # Pop and push a list in the range [1, sum]
O # Sum this list together again
# (after which the result is output implicitly)
Laughing Out Loud! Out??
An equal-bytes alternative could be: 2FLO, where 2F is loop 2 times:
Try it online or verify all test cases.
ɾ∑ɾ∑
Uses the straightforward approach: ɾ gets the range from 1 through its argument, and ∑ sums. Rinse and repeat.
sSsS
sSsSQ # implicitly add Q
# implicitly assign Q = eval(input())
SQ # range 1 to Q
s # sum
S # range 1 to result
s # sum
Extra nice since when pronounced out loud it is the sound a python makes.
,[>+>+>+<<<-]>>>[-[>+>+<<-]>>[-<<+>>]<<[-<+>]>[-<+>]<]<[>+>+>+<<<-]>>>[-[>+>+<<-]>>[-<<+>>]<<[-<+>]>[-<+>]<]<.
Probably not the shortest implementation but I'm too lazy to make this shorter lol...
Like most other b****fuck programs, it doesn't output the answer. Instead, it prints the ascii character corresponding to the numeric answer.
Check this out to see the running process.
n->(n=n*n-~n)*n/8
Port of @tsh' JavaScript answer, so make sure to upvote him/her as well.
-1 byte thanks to @tsh.
(n=n*n-~n) could alternatively be (n+=n*n+1) for the same byte-count:
Try it online.
Explanation:
n-> // Method with integer as both parameter and return-type
(n= // Replace `n` with:
n*n // `n` squared
-~n) // `+n+1`
*n // Square that new `n`
/8 // Integer-divide that by 8 to get the result
A literal implementation would be 56 bytes in comparison:
n->{int t=0;for(;n>0;)t+=n--;for(;t>0;)n+=t--;return n;}
Explanation:
n->{ // Method with integer as both parameter and return-type
int t=0; // Temp-integer, starting at 0
for(;n>0;) // Loop `n` down until it's 0:
t+=n // Add the current `n` to the temp-integer `t`
--; // And then decrease `n` by 1
// (at this point, `n=0`)
for(;t>0;) // Now loop `t` down until it's 0:
n+=t // Add the current `t` to `n`
--; // And then decrease `t` by 1
return n;} // Return the modified `n` as result
n->(1+n^2+n)^2>>3 works.
\$\endgroup\$
00000000: 8ad8 43f6 e340 f7e0 b103 d3e8 c3 ..C..@.......
Listing:
8A D8 MOV BL, AL ; BL = x
43 INC BX ; BL = x + 1
F6 E3 MUL BL ; AX = x * (x + 1)
40 INC AX ; AX = x * (x + 1) + 1
F7 E0 MUL AX ; AX = AX * AX
B1 03 MOV CL, 3
D3 E8 SHR AX, CL ; AX = AX >> 3
C3 RET ; return to caller
Callable with input n in AL, output in AX.
Uses the formula (x*(x+1)+1)^2>>3.
shr ax, 3 (3 bytes). (If you meant to stick to a tighter restriction of only 8088/8086 instructions, I assume you would have said that instead of x86-16, which includes modern x86 in 16-bit mode.)
\$\endgroup\$
May 19 at 8:42
~A is "types that have underlying type A"). Try running your own port and look at the compiler error.
\$\endgroup\$
May 17 at 15:23
f(n){int i=10;for(;i>1;)n+=i--;for(;n>1;)i+=n--;printf("%d",i);}
main(){int i=0,n=10;for(;n>0;)i+=n--;for(;i>0;)n+=i--;printf("%d\n",n);}
main(n){int i=10;for(;i>1;)n+=i--;for(;n>1;)i+=n--;printf("%d\n",i);}
i:1+*2,:1+*2,n;
Just the triangle number formula copied twice
i:1+*:2+*8,n; using the formula expanded as n(n+1)(n(n+1)+2)/8.
\$\endgroup\$
S flag and drop the last S.
\$\endgroup\$
May 16 at 16:56
print((...^2-~...)^2//8)
Based off tsh's answer, though it's been modified a bit to better fit Lua.
