}

static int sumsquare(int n){

    int sum = 0 ;

    sum = (n*(n+1)(2*n+1))/6;

    return sum;

}

static int squaresum(int n){

   int sum  = 0;

   sum = (n(n+1))/2;

   return (sum *sum);

}

static int differencehelper(){

    return squaresum(n) - sumsquare(n);

}

function sumSquareDifference(n) {
  // Good luck!
  let a = 0,b=0,c=0;
  for(let i = 1;i<=n;i++){
    a+= (Math.pow(i,2));
    b+=i
  }
c=Math.pow(b,2)-a

console.log(a);
console.log(b);
  return c;
}

cout<<"the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum is \n ";
cout<< square_sum(sum)-sumQ ;  // without function : cout<<sum*sum-sumQ
return 0;

(1..100 |> Enum.map(&:math.pow(&1, 2)) |> Enum.sum()) -
  (1..100 |> Enum.sum() |> :math.pow(2))

// func SumSquareDifference receives the max range
// and returns the difference of the sumSquare and the squareSum.
func SumSquareDifference(x int) int {
    sum := 0
    sumSquare := 0

    for i := 1; i <= x; i++ {
        sum += i
        sumSquare += i * i
    }

    squareSum := sum * sum

    return squareSum - sumSquare
}

func sumSquareDifference(range: Int) -> Int {
    var sumOfSquares = 0
    var squareOfSum = 0
    for number in 1..<range+1 { //Is there a better way? Other than range+1?
        sumOfSquares += (number*number)
        squareOfSum += number
    }
    squareOfSum = squareOfSum*squareOfSum
    return (squareOfSum - sumOfSquares)
}

print(sumSquareDifference(range:100))

// with for loop
func sumSqDiffLoop(n int) int {
    var sOsq int
    var sOts int
    for i := 1; i <= 100; i++ {
        sOsq += i * i
        sOts += i
    }
    return (sOts * sOts) - sOsq
}
// no loop - thanks to @lmbarr for his solution
func sumSqDiffNoLoop(n int) int {
    return (((n * n) * ((n + 1) * (n + 1))) / 4) - (n * (n + 1) * (2*n + 1) / 6)
}

// Let's make some benchmarks!

import "testing"

func BenchmarkSumSquareDiff(b *testing.B) {
    benchs := []struct {
        name string
        fun  func(int) int
    }{
        {"Sum Square Diff Loop", sumSqDiffLoop},
        {"Sum Square Diff no Loop", sumSqDiffNoLoop},
    }
        // Let's test it with 1000 instead of 100 :D
    input := 1000

    for _, bench := range benchs {
        b.Run(bench.name, func(b *testing.B) {
            for i := 0; i < b.N; i++ {
                bench.fun(input)
            }
        })
    }
}

❯ go test -bench=.

goos: linux
goarch: amd64
/Sum_Square_Diff_Loop-4             20000000          62.7 ns/op
/Sum_Square_Diff_no_Loop-4          500000000         3.58 ns/op
PASS
ok      _/h/f/s/g/src/project-euler/06  3.474s

p (1..100).then { @1.sum ** 2 - @1.sum { @1 ** 2 } }

def challenge():
    sumOfSquares = 0
    squareOfSums = 0
    difference = 0
    for i in range(101):
        sumOfSquares += i ** 2
        squareOfSums += i
    squareOfSums = squareOfSums ** 2
    difference =  squareOfSums - sumOfSquares
    print("The difference between the sum of squares and the square of sums up to 100 is {}".format(difference))

The difference between the sum of squares and the square of sums up to 100 is 25164150

fn get_sum_square_difference(end: usize) -> usize {
    let mut sum: usize = 0;
    let square_sum = (1..=end).fold(0usize, |fin, num| { sum += num; fin + num.pow(2) });

    sum.pow(2) - square_sum
}