Difference of sums

Question

I take no credit for this challenge at all. It's Project Euler problem 6:

The sum of the squares of the first ten natural numbers is,
1^(2) + 2^(2) + ... + 10^(2) = 385

The square of the sum of the first ten natural numbers is,
(1 + 2 + ... + 10)^(2) = 55^(2) = 3025

Hence the difference between the sum of the squares of the first ten natural
numbers and the square of the sum is 3025 − 385 = 2640.

Find the difference between the sum of the squares of the first one hundred 
natural numbers and the square of the sum.

I became interested in some code golfing here when I noticed my solution (in Python) was very, very short. I want to see how some other languages (perl, I'm looking at you!) can bring it in this simple problem.

So, what is the shortest possible way to solve this problem? Shortest means fewest characters in source code.

NOTE: bonus points for solving for the first n natural numbers.

Answer 1

40/49 43 characters; should work in most languages

n=100;(n*(n+1)/2)**2-n*(n+1)*(2*n+1)/6;

Should work in some languages;

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

This should work in most of the languages.

Note that 1^2 + 2^2 + ... + n^2 = n(n+1)(2n+1)/6 and 1 + 2 + ... + n = n(n+1)/2

EDIT: oh and for the bonus you just remove the first 6 chracters.

Answer 2

C#

Math.Pow(Enumerable.Range(1, 100).Sum(), 2)-
Enumerable.Range(1, 100).Select(i => i*i).Sum()

Answer 3

Mine was also short...

def euler6(limit):
    """
    calculate the difference between the sum of the squares of
    the first n natural numbers and the square of the sum of
    the same n natural numbers.

      >>> euler6(10)
      2640


    """
    sequence = range(limit+1)
    squares = sum(map(lambda x: x*x, sequence))
    sums = sum(sequence)
    sums *= sums
    return sums-squares

Answer 4

import numpy
v = numpy.arange(100)
print sum(v)**2 - sum(v*v)

Answer 5

Python 2.x, 48 characters

a=range(n+1)
print sum(a)**2-sum(x*x for x in a)

I originally wrote it in Python 3.x, which is 49 characters:

a=range(n+1)
print(sum(a)**2-sum(x*x for x in a))

Answer 6

Perl 15 chars:

 print 25164150;

Answer 7

Octave: 28 chars

v=1:100;sum(v)**2-sum(v.*v)

Answer 8

Since the "intelligent" solution (that comes from two simple math proofs) has been already posted by @Gabi Purcaru and short solutions for such problem are easy, instead I'll post a long solution based on template metaprogramming, I don't think it's so easy to make it longer without putting in useless garbage/whitespace/....

C++ - 648 659 chars

#include <iostream>

template<int Num>
struct Square
{
    static const int Value = Num*Num;
};

template<int Num>
struct NatSum
{
    static const int Value=Num+NatSum<Num-1>::Value;
};

template<>
struct NatSum<0>
{
    static const int Value = 0;
};

template<int Num>
struct SquaresSum
{
    static const int Value=Square<Num>::Value+SquaresSum<Num-1>::Value;
};

template<>
struct SquaresSum<0>
{
    static const int Value = 0;
};

template<int Num>
struct DifferenceOfSums
{
    static const int Value = Square<NatSum<Num>::Value>::Value - SquaresSum<Num>::Value;
};

int main()
{
    std::cout<<DifferenceOfSums<100>::Value<<std::endl;
    return 0;
}

Now enjoy your challenge result calculated at compile time and put directly in the executable. :)

Answer 9

Mathematica 17 chars: After applying FullSimplify

n(n^2-1)(3n+2)/12

Mathematica 27 chars: As it doesn't require those pesky multiplication symbols...

(n(n+1))^2/4-n(n+1)(2n+1)/6

Or in vector form, Mathematica 2825 chars: after reviewing the other Mathematica answer, I was able to shave off another 3 chars

Plus@@#^2-#.#&@Range[100]

Answer 10

Almost Any Language: 20 chars.

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

Answer 11

17 or 18 characters

(3n/2+1)(n^3-n)/6
(3n/2+1)(n**3-n)/6

depending on how your language does exponents

Edit: well, 20 characters (3*n/2+1)*(n**3-n)/6 if your language doesn't understand implicit multiplication... but Mathematica does.

Answer 12

J, 19 characters

(12%~]*<:@*:*2+3*])

This just calculates n(n^2-1)(3n+2)/12.

J, 21 characters

(([:*:+/)-[:+/*:)i.>:

This actually generates the list of natural numbers up to N (i.>:), then calculates the sum of squares [:*:+/ and square of sums [:+/*:, then subtracts them.

Answer 13

Haskell - 33 chars

g x=sum.map(\y->(y-1)*y*y)$[2..x]

edit:

To make a full program we need 79 chars

import System
main=getArgs>>=print.(\x->sum.map(\y->(y-1)*y*y)$[2..x]).read.head

Answer 14

Perl, 41 Chars

This is a 'proper' attempt.

Code: $c+=$_**2,$e+=$_ for 0..pop;print$e**2-$c

Usage:

$ perl -e '$c+=$_**2,$e+=$_ for 0..pop;print$e**2-$c' 100
25164150

Answer 15

Golfscript - 17 chars

~:).*(3)*2+*)*12/

Reads number from stdin\

23 chars to generate the first 100

100,{:).*(3)*2+*)*12/}%

Answer 16

Mathematica 8 chars

"My In is your Out"

  In> 25164150
  Out> 25164150

25164150 is a full valid Mathematica expression that can be evaluated on its own.

Answer 17

Mathematica "Guessing the Answer"

Mathematica is able to "guess" the function that generates some sequences.

So, If you calculate the first six terms for this problem, the result is:

 {0, 4, 22, 70, 170, 350}  

Now we can enter that sequence to the "sequences oracle", and get the function:

FindSequenceFunction[{0, 4, 22, 70, 170, 350}]

Mathematica answers:

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

which is the formula posted anywhere in the other answers.

So we can calculate the 100th term using the first six terms ... without knowing how to generate them!

In> FindSequenceFunction[{0, 4, 22, 70, 170, 350}][100]
Out> 25164150    

Answer 18

Oracle SQL - 82 chars

select sum(l)*sum(l)-sum(l*l) from (select level l from dual connect by level<=:n)