처음 10 개의 자연수의 제곱의 합은 $1^2 + 2^2 + \dots + 10^2 = 385$

처음 10 개의 자연수의 합의 제곱은

$(1 + 2 + ... + 10)^2 = 55^2 = 3025$

따라서 처음 10 개의 자연수의 제곱의 합과 합계의 제곱의 차이는

$3025 − 385 = 2640$

주어진 입력 n에 대해 첫 번째 n 자연수의 제곱의 합과 합의 제곱의 차이를 찾으십시오.

테스트 사례

1       => 0
2       => 4
3       => 22
10      => 2640
24      => 85100
100     => 25164150

이 과제는 프로젝트 오일러 # 6 에서 처음 발표되었습니다 .

승리 기준

• 음수 또는 제로 입력의 동작에 대한 규칙은 없습니다.

• 가장 짧은 답변이 이깁니다.

젤리 ,  5  4 바이트

Ḋ²ḋṖ

온라인으로 사용해보십시오!

어떻게?

구현 $\sum_{i=2}^n{(i^2(i-1))}$ ...

Ḋ²ḋṖ - Link: non-negative integer, n
Ḋ    - dequeue (implicit range)       [2,3,4,5,...,n]
 ²   - square (vectorises)            [4,9,16,25,...,n*n]
   Ṗ - pop (implicit range)           [1,2,3,4,...,n-1]
  ḋ  - dot product                    4*1+9*2+16*3+25*4+...+n*n*(n-1)

파이썬 3 ,  28  27 바이트

xnor 덕분에 -1

lambda n:(n**3-n)*(n/4+1/6)

온라인으로 사용해보십시오!

구현 $n(n-1)(n+1)(3n+2)/12$

파이썬 2,  29  28 바이트 :lambda n:(n**3-n)*(3*n+2)/12

APL (Dyalog Unicode) , 10 바이트

1⊥⍳×⍳×1-⍨⍳

온라인으로 사용해보십시오!

작동 원리

1⊥⍳×⍳×1-⍨⍳
  ⍳×⍳×1-⍨⍳  Compute (x^3 - x^2) for 1..n
1⊥          Sum

"합계의 제곱"이 "큐브의 합"과 동일하다는 사실을 사용합니다.

TI 기본 (TI-83 시리즈), 12 11 바이트

sum(Ans² nCr 2/{2,3Ans

구현 $\binom{n^2}{2}(\frac12 + \frac1{3n})$. 에서의 입력을 받아Ans, 예를 들어, 실행10:prgmX입력에 대한 결과를 계산합니다10.

Brain-Flak , 74 72 68 64 바이트

((([{}])){({}())}{})([{({}())({})}{}]{(({}())){({})({}())}{}}{})

온라인으로 사용해보십시오!

몇 가지 까다로운 변화로 그것을하는 아주 간단한 방법입니다. 바라건대 누군가가 이것을 더 짧게 만들기 위해 더 많은 트릭을 찾을 것입니다.

숯 , 12 10 바이트

ＩΣＥＮ×ιＸ⊕ι²

$( \sum_1^n x )^2 = \sum_1^n x^3$ so $( \sum_1^n x )^2 - \sum_1^n x^2 = \sum_1^n (x^3 - x^2) = \sum_1^n (x - 1)x^2 = \sum_0^{n-1} x(x + 1)^2$.

   Ｎ        Input number
  Ｅ         Map over implicit range i.e. 0 .. n - 1
        ι   Current value
       ⊕    Incremented
         ²  Literal 2
      Ｘ     Power
     ι      Current value
    ×       Multiply
 Σ          Sum
Ｉ           Cast to string
            Implicitly print

Perl 6, 22 bytes

{sum (1..$_)>>²Z*^$_}

Try it online!

Uses the construction $\sum_{i=1}^n {(i^2(i-1))}$

Japt -x, 9 8 5 4 bytes

õ²í*

Try it

Explanation

õ        :Range [1,input]
 ²       :Square each
  í      :Interleave with 0-based indices
   *     :Reduce each pair by multiplication
         :Implicit output of the sum of the resulting array

JavaScript, 20 bytes

f=n=>n&&n*n*--n+f(n)

Try it online

APL(Dyalog), 17 bytes

{+/(¯1↓⍵)×1↓×⍨⍵}⍳

(Much longer) Port of Jonathan Allan's Jelly answer.

Try it online!

APL (Dyalog), 16 bytes

((×⍨+/)-(+/×⍨))⍳

Try it online!

 (×⍨+/)            The square (× self) of the sum (+ fold)
       -           minus
        (+/×⍨)     the sum of the square
(             )⍳   of [1, 2, … input].

Mathematica, 21 17 bytes

^{-4 bytes thanks to alephalpha.}

(3#+2)(#^3-#)/12&

Pure function. Takes an integer as input and returns an integer as output. Just implements the polynomial, since Sums, Ranges, Trs, etc. take up a lot of bytes.

Java (JDK), 23 bytes

n->(3*n+2)*(n*n*n-n)/12

Try it online!

dc, 16 bytes

?dd3^r-r3*2+*C/p

Implements $(n^3-n)(3n+2)/12$

Try it online!

05AB1E, 8 bytes

ÝDOnsnO-

Explanation:

ÝDOnsnO-     //Full program
Ý            //Push [0..a] where a is implicit input
 D           //Duplicate top of stack
  On         //Push sum, then square it
    s        //Swap top two elements of stack
     nO      //Square each element, then push sum
       -     //Difference (implicitly printed)

Try it online!

C, C++, 46 40 37 bytes ( #define ), 50 47 46 bytes ( function )

-1 byte thanks to Zacharý

-11 bytes thanks to ceilingcat

Macro version :

#define F(n)n*n*~n*~n/4+n*~n*(n-~n)/6

Function version :

int f(int n){return~n*n*n*~n/4+n*~n*(n-~n)/6;}

Thoses lines are based on thoses 2 formulas :

Sum of numbers between 1 and n = n*(n+1)/2
Sum of squares between 1 and n = n*(n+1)*(2n+1)/6

So the formula to get the answer is simply (n*(n+1)/2) * (n*(n+1)/2) - n*(n+1)*(2n+1)/6

And now to "optimize" the byte count, we break parenthesis and move stuff around, while testing it always gives the same result

(n*(n+1)/2) * (n*(n+1)/2) - n*(n+1)*(2n+1)/6 => n*(n+1)/2*n*(n+1)/2 - n*(n+1)*(2n+1)/6 => n*(n+1)*n*(n+1)/4 - n*(n+1)*(2n+1)/6

Notice the pattern p = n*n+1 = n*n+n, so in the function, we declare another variable int p = n*n+n and it gives :

p*p/4 - p*(2n+1)/6

For p*(p/4-(2*n+1)/6) and so n*(n+1)*(n*(n+1)/4 - (2n+1)/6), it works half the time only, and I suspect integer division to be the cause ( f(3) giving 24 instead of 22, f(24) giving 85200 instead of 85100, so we can't factorize the macro's formula that way, even if mathematically it is the same.

Both the macro and function version are here because of macro substitution :

F(3) gives 3*3*(3+1)*(3+1)/4-3*(3+1)*(2*3+1)/6 = 22
F(5-2) gives 5-2*5-2*(5-2+1)*(5-2+1)/4-5-2*(5-2+1)*(2*5-2+1)/6 = -30

and mess up with the operator precedence. the function version does not have this problem

JavaScript (ES6), 22 bytes

n=>n*~-n*-~n*(n/4+1/6)

Try it online!

Pyth, 7 bytes

sm**hdh

Try it online here.

Uses the formula in Neil's answer.

sm**hdhddQ   Implicit: Q=eval(input())
             Trailing ddQ inferred
 m       Q   Map [0-Q) as d, using:
    hd         Increment d
   *  hd       Multiply the above with another copy
  *     d      Multiply the above by d
s            Sum, implicit print 

SNOBOL4 (CSNOBOL4), 70 69 bytes

 N =INPUT
I X =X + N ^ 3 - N ^ 2
 N =GT(N) N - 1 :S(I)
 OUTPUT =X
END

Try it online!

Pari/GP, 21 bytes

n->(3*n+2)*(n^3-n)/12

Try it online!

05AB1E, 6 bytes

LnDƶαO

Try it online!

Explanation

L         # push range [1 ... input]
 n        # square each
  D       # duplicate
   ƶ      # lift, multiply each by its 1-based index
    α     # element-wise absolute difference
     O    # sum

Some other versions at the same byte count:

L<ān*O
Ln.āPO
L¦nā*O

R, 28 bytes

x=1:scan();sum(x)^2-sum(x^2)

Try it online!

MathGolf, 6 bytes

{î²ï*+

Try it online!

Calculates $\sum_{k=1}^n (k^2(k-1))$

Explanation:

{       Loop (implicit) input times
 î²     1-index of loop squared
    *   Multiplied by
   ï    The 0-index of the loop
     +  And add to the running total

Clojure, 58 bytes

(fn[s](-(Math/pow(reduce + s)2)(reduce +(map #(* % %)s))))

Try it online!

Edit: I misunderstood the question

Clojure, 55, 35 bytes

#(* %(+ 1 %)(- % 1)(+(* 3 %)2)1/12)

Try it online!

cQuents, 17 15 bytes

b$)^2-c$
;$
;$$

Try it online!

Explanation

 b$)^2-c$     First line
:             Implicit (output nth term in sequence)
 b$)          Each term in the sequence equals the second line at the current index
    ^2        squared
      -c$     minus the third line at the current index

;$            Second line - sum of integers up to n
;$$           Third line - sum of squares up to n

APL(NARS), 13 chars, 26 bytes

{+/⍵×⍵×⍵-1}∘⍳

use the formula Sum'w=1..n'(ww(w-1)) possible i wrote the same some other wrote + or - as "1⊥⍳×⍳×⍳-1"; test:

  g←{+/⍵×⍵×⍵-1}∘⍳
  g 0
0
  g 1
0
  g 2
4
  g 3
22
  g 10
2640

Stax, 4 bytes

╡⌠(♠

Run and debug it

For all positive k integers up to the input, add k^2 * (k-1).

QBASIC, 45 44 bytes

Going pure-math saves 1 byte!

INPUT n
?n^2*(n+1)*(n+1)/4-n*(n+1)*(2*n+1)/6

Try THAT online!

Previous, loop-based answer

INPUT n
FOR q=1TO n
a=a+q^2
b=b+q
NEXT
?b^2-a

Try it online!

Note that the REPL is a bit more expanded because the interpreter fails otherwise.

JAEL, 13 10 bytes

#&àĝ&oȦ

Try it online!

Explanation (generated automatically):

./jael --explain '#&àĝ&oȦ'
ORIGINAL CODE:  #&àĝ&oȦ

EXPANDING EXPLANATION:
à => `a
ĝ => ^g
Ȧ => .a!

EXPANDED CODE:  #&`a^g&o.a!

COMPLETED CODE: #&`a^g&o.a!,

#          ,            repeat (p1) times:
 &                              push number of iterations of this loop
  `                             push 1
   a                            push p1 + p2
    ^                           push 2
     g                          push p2 ^ p1
      &                         push number of iterations of this loop
       o                        push p1 * p2
        .                       push the value under the tape head
         a                      push p1 + p2
          !                     write p1 to the tapehead
            ␄           print machine state

05AB1E, 6 bytes

LDOšnÆ

Try it online!

Explanation:

           # implicit input (example: 3)
L          # range ([1, 2, 3])
 DOš       # prepend the sum ([6, 1, 2, 3])
    n      # square each ([36, 1, 4, 9])
     Æ     # reduce by subtraction (22)
           # implicit output

Æ isn't useful often, but this is its time to shine. This beats the naïve LOnILnO- by two whole bytes.