Complete the square sum function so that it squares each number passed into it and then sums the results together.

For example, for `[1, 2, 2]` it should return `9` because `1^2 + 2^2 + 2^2 = 9`.

```if:racket
In Racket, use a list instead of an array, so '(1 2 3) should return 9.
```

Source: codewars | Difficulty: EASY
Tags: Fundamentals

Data structures

Starter code: def square_sum(numbers):
	

Solutions:
def square_sum(numbers):
	return sum((x ** 2 for x in numbers))


def square_sum(numbers):
	return sum(map(lambda x: x ** 2, numbers))


def square_sum(numbers):
	res = 0
	for num in numbers:
		res = res + num * num
	return res


def square_sum(numbers):
	return sum([i * i for i in numbers])


def square_sum(numbers):
	res = 0
	for key in numbers:
		res += key ** 2
	return res


def square_sum(numbers):
	result = []
	for sqr in numbers:
		result.append(sqr ** 2)
	return sum(result)


import numpy

def square_sum(numbers):
	return sum(numpy.array(numbers) ** 2)


def square_sum(numbers):
	return sum((n ** 2 for n in numbers))


import functools

def square_sum(numbers):
	return functools.reduce(lambda x, y: x + y ** 2, numbers, 0)


def square_sum(numbers):
	li = []
	for number in numbers:
		li.append(number ** 2)
	return sum(li)


square_sum = lambda n: sum((e ** 2 for e in n))


from itertools import repeat

def square_sum(numbers):
	return sum(map(pow, numbers, repeat(2)))


import math

def square_sum(numbers):
	result = 0
	for c in numbers:
		result += math.pow(c, 2)
	return result


def square_sum(numbers):
	s = []
	for x in numbers:
		x = x ** 2
		s.append(x)
	return sum(s)


def square_sum(x):
	L = []
	for i in x:
		L.append(i ** 2)
	return sum(L)


def square_sum(numbers):
	i = 0
	sum = 0
	while i < len(numbers):
		sum = sum + numbers[i] ** 2
		i = i + 1
	return sum


def square_sum(numbers):
	new_lst = []
	for i in numbers:
		i = i * i
		new_lst.append(i)
	return sum(new_lst)


def square_sum(numbers):
	g = 0
	for i in range(len(numbers)):
		g += pow(int(numbers[i]), 2)
	return g


def square_sum(numbers):
	counter = 0
	for num in numbers:
		counter += pow(num, 2)
	return counter


def square_sum(numbers):
	s = 0
	for i in numbers:
		s += i * i
	return s


def square_sum(numbers):
	return sum(list(map(lambda x: x * x, numbers)))


def square_sum(n):
	return sum(map(lambda x: x * x, n))


def square_sum(numbers):
	return sum((pow(i, 2) for i in numbers))


def square_sum(numbers):
	return sum([l ** 2 for l in numbers])


square_sum = lambda n: sum((a ** 2 for a in n))


import numpy as np

def square_sum(numbers):
	array_sum = np.array(numbers)
	result = np.sum(array_sum ** 2)
	return result


def square_sum(numbers):
	lista = []
	for i in numbers:
		i = i ** 2
		lista.append(i)
	return sum(lista)


def square_sum(numbers):
	lol = 0
	hassu = len(numbers)
	while hassu > 0:
		lol = numbers[hassu - 1] ** 2 + lol
		hassu = hassu - 1
	return lol


def square_sum(numbers):
	r = [number * number for number in numbers]
	return sum(r)


def square_sum(numbers):
	return sum(list(map(lambda i: i ** 2, numbers)))


from functools import reduce

def square_sum(numbers):
	if len(numbers) == 0:
		return 0
	else:
		squared = [n ** 2 for n in numbers]
		return reduce(lambda x, y: x + y, squared)


def square_sum(numbers):
	total = 0
	for i in numbers:
		total += i ** 2
	return total


def square_sum(nums):
	return sum((i ** 2 for i in nums))


def square_sum(numbers):
	output = 0
	for x in numbers:
		output += x ** 2
	return output


def square_sum(numbers):
	li = []
	for x in numbers:
		x2 = x ** 2
		li.append(x2)
	add = sum(li[:])
	return add


def square_sum(numbers):
	return sum((int(a) ** 2 for a in numbers))


def square_sum(numbers):
	lista = []
	for valor in numbers:
		valor1 = valor * valor
		lista.append(valor1)
	lista = sum(lista)
	return lista


def square_sum(numbers):
	n = 0
	for m in numbers:
		n += m ** 2
	return n


def square_sum(num):
	sum1 = 0
	for i in num:
		sum1 = sum1 + i ** 2
	return sum1


def square_sum(numbers):
	sum = 0
	for nb in numbers:
		sum = sum + nb ** 2
	return sum


def square_sum(numbers):
	number = 0
	for x in numbers:
		number += x ** 2
	return number


def square_sum(numbers):
	b = 0
	for i in range(len(numbers)):
		b = b + numbers[i] ** 2
	return b


def square_sum(numbers):
	tmp = 0
	for i in numbers:
		tmp += i ** 2
	return tmp


square_sum = lambda numbers: sum(list(map(lambda arr: arr ** 2, numbers)))


def square_sum(numbers):
	sum = 0
	for number in numbers:
		sum = sum + abs(number ** 2)
	return sum


def square_sum(nums):
	return sum((n ** 2 for n in nums))


def square_sum(numbers):
	y = 0
	for each in numbers:
		x = each ** 2
		y = y + x
	return y


def square_sum(numbers):
	sq_nums = []
	for num in numbers:
		sq_nums.append(num ** 2)
	return sum(sq_nums)


def square_sum(num):
	return sum([el ** 2 for el in num])


def square_sum(numbers):
	numbers = [el * el for el in numbers]
	return sum(numbers)


def square_sum(num):
	return sum([num[i] * num[i] for i in range(0, len(num))])


def square_sum(numbers):
	sum1 = sum(list([pow(x, 2) for x in numbers]))
	return sum1


def square_sum(numbers):
	squared = [num ** 2 for num in numbers]
	return sum(squared)


def square_sum(numbers):
	sq = 0
	for i in numbers:
		sq = sq + i ** 2
	return sq


def square_sum(numbers):
	result = list()
	for i in numbers:
		result.append(i ** 2)
	return sum(result)


def square_sum(numbers):
	print(numbers)
	sqrtNum = [x * x for x in numbers]
	return sum(sqrtNum)


def square_sum(numbers):
	sum = 0
	x = len(numbers)
	for i in range(x):
		a = pow(numbers[i], 2)
		sum = a + sum
	return sum


def square_sum(numbers):
	sum = 0
	for number in numbers:
		sum = sum + number * number
	return sum


def square_sum(n):
	return pow(n.pop(0), 2) + square_sum(n) if len(n) > 0 else 0


def square_sum(numbers):
	return sum(map(lambda elem: elem ** 2, numbers))


def square_sum(numbers):
	sums = 0
	for num in range(len(numbers)):
		sums += pow(numbers[num], 2)
	return sums


def square_sum(n):
	a = 0
	for x in n:
		a += x ** 2
	return a


def square_sum(numbers):
	res = []
	for i in numbers:
		res.append(i * i)
	return sum(res)


def square_sum(numbers):
	sum = 0
	for i in numbers:
		n = i ** 2
		sum += n
	return sum
square_sum([1, 2, 2])


square_sum = lambda n: sum(map(2 .__rpow__, n))


def square_sum(numbers):
	list = [item ** 2 for item in numbers]
	return sum(list)


def square_sum(numbers):
	sum = 0

	def square(number):
		return pow(number, 2)
	for number in numbers:
		sum += square(number)
	return sum


def square_sum(n):
	n = list([x ** 2 for x in n])
	return sum(n)


def square_sum(numbers):
	res = 0
	for i in numbers:
		a = i * i
		res += a
	return res


def square_sum(numbers):
	sum = 0
	if numbers:
		for num in numbers:
			sum += num * num
	return sum


def square_sum(numbers):
	x = len(numbers)
	z = 0
	for k in range(0, x):
		z += numbers[k] ** 2
	return z


def square_sum(numbers):
	sq_sum = 0
	for square in numbers:
		sq_sum = sq_sum + square ** 2
	return sq_sum


def square_sum(numbers):
	arr = list()
	for i in numbers:
		arr.append(i * i)
	return sum(arr)


def square_sum(numbers, t=0):
	for i in numbers:
		t += i ** 2
	return t


def square_sum(n):
	a = [i * i for i in n]
	return sum(a)


def square_sum(numbers):
	suma = 0
	for i in numbers:
		i = i ** 2
		suma += i
	return suma


def square_sum(numbers):
	sum = 0
	for i in numbers:
		square = i * i
		sum = sum + square
	return sum


def square_sum(numbers):
	i = 0
	for x in numbers:
		i = i + x ** 2
	return i


def square_sum(numbers):
	squared = []
	for i in numbers:
		x = i ** 2
		squared.append(x)
	y = sum(squared)
	return y
square_sum([0, 3, 4, 5])


def square_sum(numbers):
	resultado = 0
	for x in numbers:
		resultado += x ** 2
	return resultado


def square_sum(numbers):
	sum = 0
	for i in numbers:
		squr = i ** 2
		sum += squr
	return sum


def square_sum(numbers):
	final_answer = 0
	for number in numbers:
		square = number ** 2
		final_answer += square
	return final_answer


def square_sum(numbers):
	resulting_sum = 0
	for i in numbers:
		resulting_sum += i ** 2
	return resulting_sum


def square_sum(numbers):
	total = 0
	for n in range(0, len(numbers)):
		total = total + numbers[n] ** 2
	return total


def square_sum(numbers):
	numbers_ = 0
	for i in range(0, len(numbers)):
		numbers_ += numbers[i] ** 2
	return numbers_


def square_sum(numbers):
	return sum([no ** 2 for no in numbers])