Let's learn some new Python concepts! You have to generate a list of the first $N$ fibonacci numbers, $\mbox{o}$ being the first number. Then, apply the map function and a lambda expression to cube each fibonacci number and print the list.

Concept

The map() function applies a function to every member of an iterable and returns the result. It takes two parameters: first, the function that is to be applied and secondly, the iterables. 

Let's say you are given a list of names, and you have to print a list that contains the length of each name.  

>> print (list(map(len, ['Tina', 'Raj', 'Tom'])))  
[4, 3, 3]  

Lambda is a single expression anonymous function often used as an inline function. In simple words, it is a function that has only one line in its body. It proves very handy in functional and GUI programming.  

>> sum = lambda a, b, c: a + b + c
>> sum(1, 2, 3)
6

Note: 

Lambda functions cannot use the return statement and can only have a single expression. Unlike def, which creates a function and assigns it a name, lambda creates a function and returns the function itself. Lambda can be used inside lists and dictionaries. 

Input Format

One line of input: an integer $N$.

Constraints 

$0\leq N\leq15$ 

Output Format

A list on a single line containing the cubes of the first $N$ fibonacci numbers.

Sample Input
5

Sample Output
[0, 1, 1, 8, 27]

Explanation

The first $5$ fibonacci numbers are $[0,1,1,2,3]$, and their cubes are $[0,1,1,8,27]$.

Difficulty: EASY

Solutions:
def fib(n):
	return n if n < 2 else fib(n - 2) + fib(n - 1)
arr = map(fib, range(int(input())))
arr = map(lambda x: x ** 3, arr)
print(list(arr))


import fileinput
N = int(input())
fibs = [] if N < 1 else [0] if N < 2 else [0, 1]
for i in range(1, N - 1):
	fibs.append(fibs[i] + fibs[i - 1])
print(list(map(lambda x: x * x * x, fibs)))


fib = [0, 1]
N = int(input())
if N <= 1:
	print(fib[:N])
else:
	for i in range(N - 2):
		fib += [fib[-2] + fib[-1]]
	print(list(map(lambda a: a ** 3, fib)))


n = int(input())
f = [0, 1]
for i in range(15):
	f.append(f[-1] + f[-2])
while len(f) != n:
	f.pop()
print(list(map(lambda x: x ** 3, f)))


N = int(input())

def fib_list(N):
	(a, b) = (0, 1)
	fib_l = []
	for i in range(N):
		fib_l.append(a)
		(a, b) = (b, a + b)
	return fib_l
print(list(map(lambda x: x ** 3, fib_list(N))))


t = int(input())
if t > 15 and t < 0:
	exit(-1)
l = []
for i in range(t):
	if i == 0:
		l.append(0)
	elif i == 1:
		l.append(1)
	else:
		l.append(l[i - 1] + l[i - 2])
for i in range(t):
	l[i] = l[i] ** 3
print(l)


from math import sqrt

def F(n):
	return ((1 + sqrt(5)) ** n - (1 - sqrt(5)) ** n) / (2 ** n * sqrt(5))
n = int(input())
a = []
for i in range(0, n):
	a.append(int(F(i)))
F = lambda x: x ** 3
k = map(F, a)
print(list(k))


cube = lambda x: x ** 3
arr = []
for i in range(0, int(input())):
	if i == 0:
		arr.append(0)
	elif i == 1:
		arr.append(1)
	else:
		arr.append(arr[i - 2] + arr[i - 1])
print(list(map(cube, arr)))


max = int(input())
if max == 0:
	fiblist = []
	print(fiblist)
elif max == 1:
	fiblist = [0]
	print(fiblist)
elif max == 2:
	fiblist = [0, 1]
	print(fiblist)
else:
	fiblist = [0, 1]
	for i in range(2, max):
		fiblist.append(fiblist[i - 2] + fiblist[i - 1])
	print(list((x ** 3 for x in fiblist)))


n = int(input().strip())

def fib(N):
	a = 0
	b = 1
	if N == 1:
		return [a]
	if N == 2:
		return [a, b]
	ret = []
	for i in range(N):
		ret.append(a)
		c = a + b
		(a, b) = (b, c)
	return ret
print(list(map(lambda x: x * x * x, fib(n))))


N = int(input())
if N == 0:
	Fib = []
elif N == 1:
	Fib = [0]
else:
	Fib = [0, 1]
	for i in range(2, N):
		Fib.append(Fib[i - 1] + Fib[i - 2])
print(list(map(lambda a: a ** 3, Fib)))


fibo = []
for i in range(int(input())):
	if i == 0:
		fibo.append(0)
	elif i == 1:
		fibo.append(1)
	else:
		fibo.append(fibo[-1] + fibo[-2])
print(list(map(lambda x: x ** 3, fibo)))


def feb(n):
	(a, b) = (0, 1)
	L = []
	i = 0
	while i < n:
		L.append(a)
		(a, b) = (b, a + b)
		i += 1
	return L
cube = lambda a: a ** 3
print(list(map(cube, feb(int(input())))))


n = int(input())
fibs = []
for _ in range(n):
	if len(fibs) == 0:
		fibs.append(0)
	elif len(fibs) == 1:
		fibs.append(1)
	else:
		fibs.append(fibs[len(fibs) - 1] + fibs[len(fibs) - 2])
print(list(map(lambda x: x ** 3, fibs)))


def fibonacci(iterations):
	(a, b) = (0, 1)
	fiblist = []
	for i in range(iterations):
		fiblist.append(a)
		(a, b) = (b, a + b)
	return fiblist

def main():
	iterations = int(input())
	fiblist = fibonacci(iterations)
	fiblist_cubed = list(map(lambda num: num ** 3, fiblist))
	print(fiblist_cubed)
main()


n = int(input())

def fib(n):
	if n == 1 or n == 0:
		return 0
	if n == 2:
		return 1
	return fib(n - 1) + fib(n - 2)
lis = [fib(x) ** 3 for x in range(1, n + 1)]
print(lis)


def fib(n):
	(i, x, y) = (0, 0, 1)
	while i < n:
		yield x
		(x, y) = (y, x + y)
		i += 1
n = int(input())
print(list(map(lambda x: x ** 3, fib(n))))


n = int(input())

def fib(n):
	if n <= 0:
		return 0
	elif n == 1:
		return 1
	else:
		return fib(n - 1) + fib(n - 2)
cubes = lambda x: x * x * x
print(list(map(cubes, [fib(x) for x in range(0, n)])))


n = int(input())
fib = []
if n >= 1:
	fib.append(0)
if n >= 2:
	fib.append(1)
for i in range(n - 2):
	fib.append(fib[i + 1] + fib[i])
print([x * x * x for x in fib])


def cube(x):
	return x * x * x
N = int(input())
fib = [0, 1]
if N == 0:
	print([])
elif N == 1:
	print([0])
elif N == 2:
	print(fib)
else:
	for i in range(N - 2):
		fib.append(fib[i + 1] + fib[i])
	print(list(map(cube, fib)))


def getFibbo(n):
	l = []
	previous = 0
	current = 1
	for i in range(n):
		l.append(previous)
		(current, previous) = (previous + current, current)
	return l
print([x ** 3 for x in getFibbo(int(input()))])


fib = [0, 1]
N = int(input())
for i in range(2, N):
	fib.append(fib[-1] + fib[-2])
print(list(map(lambda x: x ** 3, fib[:N])))


import sys
N = int(sys.stdin.readline())

def fibonacci(n):
	if n <= 1:
		return 0
	if n == 2:
		return 1
	if n > 2:
		return fibonacci(n - 1) + fibonacci(n - 2)
fibonacci_list = []
for i in range(1, N + 1):
	if i < 1:
		next
	elif i == 1:
		fibonacci_list.append(0)
	elif i == 2:
		fibonacci_list.append(1)
	elif i > 2:
		fibonacci_list.append(fibonacci_list[i - 2] + fibonacci_list[i - 3])
print(list(map(lambda x: x ** 3, fibonacci_list)))


f = [0, 1]
for n in range(13):
	f.append(f[-1] + f[-2])
N = int(input())
print(list(map(lambda x: x * x * x, f[:N])))


N = int(input())
fiblist = []
if N >= 1:
	fiblist.append(0)
if N >= 2:
	fiblist.append(1)
for n in range(N - 2):
	fiblist.append(fiblist[-1] + fiblist[-2])
print(list(map(lambda x: x ** 3, fiblist)))


N = int(input())
lsum = lambda a, b: a + b
lcube = lambda a: a ** 3
fib_ser = []
if N == 1:
	fib_ser = [0]
elif N == 2:
	fib_ser = [0, 1]
elif N >= 2:
	fib_ser = [0, 1]
	for i in range(2, N):
		fib_ser.append(lsum(fib_ser[i - 2], fib_ser[i - 1]))
print(list(map(lcube, fib_ser)))


import sys
if sys.version_info[0] >= 3:
	raw_input = input

def fib():
	a = 0
	b = 1
	yield a
	while True:
		yield b
		(a, b) = (b, a + b)
print([e[0] ** 3 for e in zip(fib(), range(int(raw_input())))])


def fib(n):
	if n == 0:
		return []
	if n == 1:
		return [0]
	res = [0, 1]
	while len(res) < n:
		res.append(res[-1] + res[-2])
	return res
print(list(map(lambda x: x * x * x, fib(int(input())))))


n = int(input())

def fib():
	(a, b) = (0, 1)
	for _ in range(n):
		yield a
		(a, b) = (b, a + b)
print(list(map(lambda x: x * x * x, fib())))


def fun(id):
	if id == 0:
		return 0
	(f1, f2) = (0, 1)
	for iter in range(id - 1):
		(f1, f2) = (f2, f1 + f2)
	return f2
n = int(input().split()[0])
_list = list(map(fun, range(0, n)))
print(list(map(lambda x: x ** 3, _list)))


def next_fib(fib):
	n = len(fib)
	if n == 0:
		return [0]
	if n == 1:
		return [1]
	return [fib[n - 1] + fib[n - 2]]
n = int(input())
fib = []
while len(fib) < n:
	fib += next_fib(fib)
print([i ** 3 for i in fib])


n = int(input())

def fib():
	(a, b) = (0, 1)
	while 1:
		yield a
		(a, b) = (b, a + b)
l = []
g = fib()
for i in range(n):
	l.append(next(g))
print(list(map(lambda x: x ** 3, l)))


fib = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
n = int(input())
cube = lambda a: a ** 3
lst = list(map(cube, fib[0:n]))
print(lst)


cube = lambda x: x * x * x
fib = []
num = int(input())
for i in range(0, num):
	if i < 2:
		fib.append(i)
	else:
		fib.append(fib[i - 1] + fib[i - 2])
print(list(map(cube, fib)))


n = int(input())

def Fib(n):
	if n == 1:
		return [0]
	if n == 0:
		return []
	t1 = 0
	t2 = 1
	L = [t1, t2]
	for i in range(n - 2):
		foo = t2
		t2 = t1 + t2
		t1 = foo
		L.append(t2)
	return L
cube = lambda x: x ** 3
print(list(map(cube, Fib(n))))


import sys

def fib(n):
	if not n in fib.data:
		fib.data[n] = fib(n - 1) + fib(n - 2)
	return fib.data[n]
fib.data = {0: 0, 1: 1}
print(list(map(lambda x: x * x * x, map(fib, range(int(sys.stdin.readline()))))))


from sys import exit
N = int(input())
if N == 0:
	print('[]')
	exit()
if N == 1:
	print('[0]')
	exit()
if N == 2:
	print('[0, 1]')
	exit()
a = 0
b = 1
fib = [0, 1]
for i in range(3, N + 1):
	total = a + b
	a = b
	b = total
	fib.append(total)
cube = lambda x: x ** 3
print(list(map(cube, fib)))


number = input()
cube = lambda n: n ** 3
my_list = []

def fibonacci(num):
	if num == 0:
		result = 0
		return result
	elif num == 1:
		result = 1
		return result
	else:
		result = fibonacci(num - 1) + fibonacci(num - 2)
		return result
for i in range(int(number)):
	my_list.append(fibonacci(i))
print(list(map(cube, my_list)))


fib = lambda x: x if x < 2 else fib(x - 1) + fib(x - 2)
cb = lambda x: x ** 3
print(list(map(cb, map(fib, range(0, int(input()))))))


n = int(input())
fp = 0
fn = 1
fib = [fp, fn]
for i in range(n):
	tmp = fn
	fn = fn + fp
	fp = tmp
	fib.append(fn)
fib = fib[0:len(fib) - 2]
cube = lambda x: x * x * x
print(list(map(cube, fib)))


t = int(input())
lst = []
if t > 0:
	lst.append(0)
if t > 1:
	lst.append(1)
(x1, x2) = (0, 1)
for j in range(2, t):
	(x1, x2) = (x2, x1 + x2)
	lst.append(x2)
lst = list(map(lambda x: x * x * x, lst))
print(lst)


import sys
n = int(sys.stdin.readline())
fib0 = 0
fib1 = 1
res = []
for i in range(n):
	res.append(fib0)
	tmp = fib0 + fib1
	fib0 = fib1
	fib1 = tmp
	i += 1
cube = lambda a: a * a * a
print(list(map(cube, res)))


def fib(n):
	if n == 0:
		return 0
	(a, b) = (1, 1)
	for i in range(n - 1):
		(a, b) = (b, a + b)
	return a
num = int(input())
print(list(map(lambda x: fib(x) ** 3, range(0, num))))


N = int(input())
if N < 1:
	cubes = []
elif N < 2:
	cubes = [0]
else:
	cubes = [0, 1]
for n in range(1, N - 1):
	cubes.append(cubes[n] + cubes[n - 1])
print(list(map(lambda x: x ** 3, cubes)))


def fib(n):
	numbers = [0, 1, 1]
	if n < 4:
		return numbers[0:n]
	while len(numbers) < n:
		numbers.append(numbers[-1] + numbers[-2])
	return numbers
print(list(map(lambda x: x ** 3, fib(int(input())))))


N = int(input())
lis = [0, 1, 1]
for i in range(3, N):
	lis.append(lis[i - 1] + lis[i - 2])
lis = list(map(lambda a: a * a * a, lis))
print(lis[:N])


n = int(input())
a = 0
b = 1
c = 0
l = []
while len(l) < n:
	l.append(c)
	a = b
	b = c
	c = a + b
print(list(map(lambda a: a * a * a, l)))


from sys import stdin

def fib(n):
	fibs = [0, 1]
	while len(fibs) < n:
		fibs.append(fibs[-1] + fibs[-2])
	return fibs[:n]

def main():
	num_fib = int(stdin.readline())
	print(list(map(lambda x: x ** 3, fib(num_fib))))
main()


__author__ = 'anshuk'

def cube(x):
	return x * x * x
num = int(input())
if num == 0:
	print('[]')
elif num == 1:
	print('[0]')
else:
	first = 0
	second = 1
	fib = list()
	fib.append(0)
	fib.append(1)
	for i in range(num - 2):
		result = first + second
		fib.append(result)
		first = second
		second = result
	print(list(map(cube, [i for i in fib])))


fib = lambda n: fib(n - 1) + fib(n - 2) if n > 2 else 1
l = list((fib(i) for i in range(int(input()))))
cub = lambda n: n ** 3
if len(l) > 0:
	l[0] = 0
print(list(map(cub, l)))


num_fibs = int(input())
fibs = [0, 1]
if num_fibs >= 2:
	for i in range(2, num_fibs):
		fibs.append(fibs[-2] + fibs[-1])
fibs = fibs[0:num_fibs]
print(list(map(lambda x: x ** 3, fibs)))


N = int(input())
if N < 1:
	fibs = []
elif N == 1:
	fibs = [0]
else:
	fibs = [0, 1]
for _ in range(N - 2):
	fibs.append(fibs[len(fibs) - 2] + fibs[len(fibs) - 1])
fibs = list(map(lambda x: x ** 3, fibs))
print(fibs)


n = int(input())
fib = []
for i in range(n):
	if i == 0:
		fib.append(0)
	elif i == 1:
		fib.append(1)
	else:
		fib.append(fib[i - 1] + fib[i - 2])
print(list(map(lambda a: a ** 3, fib)))


n = int(input())
lst = [0 for i in range(n)]
f1 = 0
f2 = 1
for i in range(n):
	lst[i] = f1 ** 3
	f3 = f1 + f2
	f1 = f2
	f2 = f3
print(lst)


n = int(input())
(a, b) = (1, 0)
l = []
for i in range(n):
	(a, b) = (b, a + b)
	l.append(a)
print(list(map(lambda x: x ** 3, l)))


fib = lambda x: x if x <= 1 else fib(x - 1) + fib(x - 2)
cube = lambda x: x * x * x
print(list(map(cube, map(fib, range(int(input()))))))


def fibo(n):
	lst = [x for x in range(0, n)]
	for i in range(2, n):
		lst[i] = lst[i - 1] + lst[i - 2]
	return lst

def cube(n):
	return n * n * n
n = int(input())
print(list(map(cube, fibo(n))))


from itertools import islice

def fib():
	a = 0
	b = 1
	while True:
		yield a
		(a, b) = (b, a + b)
print(list(map(lambda c: c ** 3, islice(fib(), int(input())))))


n = int(input())
l = [0, 1]
for i in range(1, n):
	l.append(l[-1] + l[-2])
print(list(map(lambda i: i * i * i, l[:n])))


def fib(n):
	(curr, prev) = (0, 1)
	for i in range(n):
		(curr, prev) = (curr + prev, curr)
	return curr
n = int(input())
print([fib(i) ** 3 for i in range(n)])


n = int(input())
l = [0] * n
if n > 1:
	l[1] = 1
for i in range(2, n):
	l[i] = l[i - 1] + l[i - 2]
cube = lambda x: x ** 3
print(list(map(cube, l)))


l = []

def fib(i):
	if i <= 0:
		return 0
	elif i == 1:
		return 1
	else:
		return fib(i - 1) + fib(i - 2)
i = int(input())
if i >= 0 and i <= 15:
	for j in range(i):
		l.append(fib(j))
	print(list(map(lambda a: a ** 3, l)))


n = int(input())
temp = []
if n == 0:
	print(temp)
elif n == 1:
	temp.append(0)
	print(temp)
elif n == 2:
	temp.append(0)
	temp.append(1)
	print(temp)
else:
	fibo = [0, 1]
	for i in range(2, n):
		fibo.append(fibo[i - 1] + fibo[i - 2])
	cube = lambda a: a * a * a
	print(list(map(cube, fibo)))


n = input()
first = 1
new = 0
a = []
for i in range(int(n)):
	total = new + first
	a.append(total)
	first = new
	new = total
a.insert(0, 0)
a.pop()
cube = lambda x: x * x * x
a1 = list(map(cube, a))
print(a1)


cube = lambda n: n ** 3
n = int(input())
f = []
(a, b) = (0, 1)
for i in range(n):
	f.append(a)
	(a, b) = (b, a + b)
print(list(map(cube, f)))


def fib(x):
	if x == 0:
		return 0
	elif x == 1:
		return 1
	else:
		return fib(x - 1) + fib(x - 2)
print(list(map(lambda x: fib(x) ** 3, range(int(input())))))


t = int(input())
a = []
x = 0
y = 1
for i in range(0, t):
	a += [x]
	(x, y) = (y, x + y)
s = lambda a: a ** 3
print(list(map(s, a)))


(N, f) = (int(input()), [0, 1])
for i in range(2, N):
	f.append(f[i - 1] + f[i - 2])
print(list(map(lambda x: x ** 3, f))[:N])


n = int(input())
a = []

def fibo(n):
	if n == 0:
		return 0
	elif n == 1:
		return 1
	else:
		return fibo(n - 1) + fibo(n - 2)
for i in range(0, n):
	a.append(fibo(i))
print(list(map(lambda x: x * x * x, a)))


numoffib = int(input())

def fib(n):
	out = []
	for i in range(n):
		if i == 0:
			out.append(0)
		elif i == 1:
			out.append(1)
		else:
			out.append(out[i - 1] + out[i - 2])
	return out
qube = lambda i: i * i * i
print(list(map(qube, fib(numoffib))))


def fibonacciTo(n):
	if n == 0:
		return []
	if n == 1:
		return [0]
	out = [0, 1]
	for i in range(n, 2, -1):
		out.append(out[-1] + out[-2])
	return out

def fibCubesTo(n):
	return list(map(lambda x: x ** 3, fibonacciTo(n)))
print(fibCubesTo(int(input())))


import sys
sys.path
T = int(input())
L = []
for x in range(0, T):
	if x > 1:
		L.append(L[x - 1] + L[x - 2])
	elif x == 0:
		L.append(0)
	else:
		L.append(1)
print(list(map(lambda x: x * x * x, L)))


def get_fibos(n):
	(a, b) = (0, 1)
	res = []
	for i in range(n):
		res.append(a)
		(a, b) = (b, a + b)
	return res
print(list(map(lambda a: a ** 3, get_fibos(int(input())))))


cubes = []
fib_list = []
n = int(input())
x = 0
for i in range(n):
	if i == 0:
		fib_list.append(i)
	elif i == 1:
		fib_list.append(i)
	else:
		x = fib_list[i - 2]
		y = fib_list[i - 1]
		fib_list.append(x + y)
cubes = list(map(lambda x: x ** 3, fib_list))
print('[', end='')
for i in range(len(cubes)):
	print('%d' % cubes[i], end='')
	if i != len(cubes) - 1:
		print(', ', end='')
print(']', end='')


n = int(input())
if n == 0:
	print([])
elif n == 1:
	print([0])
else:
	lis = [0, 1]
	for x in range(n - 2):
		lis.append(lis[len(lis) - 1] + lis[len(lis) - 2])
	cube = lambda val: val ** 3
	print(list(map(cube, lis)))


a = int(input())
i = 0
j = 1
k = i + j
count = 3
lst = [0, 1, 1]
while count < a:
	i = j
	j = k
	k = i + j
	lst.append(k)
	count += 1
if a <= 0:
	lst = []
elif a == 1:
	lst = [0]
elif a == 2:
	lst = [0, 1]
elif a == 3:
	lst = [0, 1, 1]
print([lst[x] ** 3 for x in range(len(lst))])


n = int(input())

def fibGenerator():
	(a, b) = (0, 1)
	yield 0
	while True:
		(a, b) = (b, a + b)
		yield a
fibonaccinumbers = []
fib = fibGenerator()
for n in range(n):
	fibonaccinumbers.append(next(fib) ** 3)
print(fibonaccinumbers)


n = int(input())
a = 0
b = 1
fib = []
for i in range(n):
	fib.append(a)
	(a, b) = (b, a + b)
print(list(map(lambda x: x * x * x, fib)))


n = int(input())
fibs = [0, 1]
for i in range(n - 1):
	fibs.append(fibs[i] + fibs[i + 1])
print(list(map(lambda x: x ** 3, fibs))[:n])


n = int(input())
(a, b, f) = (0, 1, [])
for i in range(n):
	f.append(a)
	(a, b) = (b, a + b)
print(list(map(lambda x: x ** 3, f)))


from sys import stdin

def fib(N):
	if N == 0:
		return []
	elif N == 1:
		return [0]
	elif N == 2:
		return [0, 1]
	else:
		l = [0, 1]
		for i in range(N - 2):
			l.append(l[-1] + l[-2])
		return l

def main():
	N = int(stdin.readline())
	l = list(map(lambda x: x ** 3, fib(N)))
	print(l)
main()


def sqr(a):
	return a * a * a
n = int(input())
if n == 0:
	print('[]')
elif n == 1:
	print('[0]')
else:
	ar = [0] * n
	ar[0] = 0
	ar[1] = 1
	for i in range(2, n):
		ar[i] = ar[i - 1] + ar[i - 2]
	ar = list(map(sqr, ar))
	print(ar)


N = int(input())
if N == 0:
	print('[]')
elif N == 1:
	print('[0]')
else:
	lst = [0, 1]
	x = 0
	y = 1
	for i in range(2, N):
		a = y
		y = x + y
		x = a
		lst.append(y)
	print(list(map(lambda x: x * x * x, lst)))


n = int(input())
xs = [0, 1][:n]
for i in range(2, n):
	xs.append(xs[i - 2] + xs[i - 1])
print(list(map(lambda x: x ** 3, xs)))


n = int(input())
fibo = [0, 1]
while len(fibo) < n:
	fibo.append(fibo[-1] + fibo[-2])
fibo = [x * x * x for x in fibo]
print(fibo[:n])


def fibo(max):
	if max == 0:
		return []
	if max == 1:
		return [0]
	(n1, n2) = (0, 1)
	res = [n1, n2]
	for _ in range(2, max):
		(n1, n2) = (n2, n1 + n2)
		res.append(n2)
	return res
print(list(map(lambda x: x ** 3, fibo(int(input())))))


N = int(input())

def fibs():
	(a, b) = (0, 1)
	while True:
		yield a
		(a, b) = (b, a + b)
f = fibs()
print(list(map(lambda x: x ** 3, [next(f) for i in range(N)])))


n = int(input())
f1 = 0
f2 = 1
lst = []
for i in range(n):
	lst.append(f1)
	res = f1 + f2
	f1 = f2
	f2 = res
cube = lambda x: x ** 3
newlst = list(map(cube, lst))
print(newlst)


n = int(input())
if n > 15:
	n = 15
if n < 2:
	if n != 0:
		print([0])
	else:
		print([])
else:
	fib = [0, 1]
	for i in range(n - 2):
		fib.append(sum(fib[len(fib) - 2:]))
	print(list(map(lambda x: x ** 3, fib)))


def fib(N):
	if N > 0:
		yield 0
	if N > 1:
		yield 1
	if N > 2:
		(a, b, N) = (0, 1, N - 2)
		while N > 0:
			(a, b, N) = (b, a + b, N - 1)
			yield b
N = int(input())
print(list(map(lambda x: x ** 3, fib(N))))


def fibo(n):
	a = 0
	b = 1
	for i in range(n):
		yield a
		c = b
		b += a
		a = c
a = lambda l: [i ** 3 for i in l]
n = int(input())
b = fibo(n)
print(a([i for i in b]))


n = int(input())
if n == 0:
	print('[]')
elif n == 1:
	print('[0]')
elif n == 2:
	print('[0, 1]')
else:
	a = 0
	b = 1
	mylist = [0, 1]
	while n - 2 > 0:
		n -= 1
		c = a + b
		(a, b) = (b, c)
		mylist.append(c)
	cube = lambda x: x ** 3
	mylist = list(map(cube, mylist))
	print(mylist)


n = int(input())
if n > 1:
	x = [0, 1]
elif n == 1:
	x = [0]
	print(x)
	exit()
else:
	print([])
	exit()
for i in range(n - 2):
	c = int(x[i] + x[i + 1])
	x.append(c)
print(list(map(lambda z: int(z * z * z), x)))


n = int(input())
(a, b) = (0, 1)
f = []
for i in range(n):
	f.append(a)
	c = b
	b = a + b
	a = c
for i in range(n):
	f[i] = f[i] ** 3
print(f)


def fib(x):
	if x == 0:
		return 0
	if x == 1:
		return 1
	return fib(x - 1) + fib(x - 2)
sq = lambda a: a ** 3
l = [fib(x) for x in range(int(input()))]
s = list(map(sq, l))
print(s)


def fibo(x):
	if x < 2:
		return x
	return fibo(x - 1) + fibo(x - 2)
print(list(map(lambda x: x * x * x, [fibo(i) for i in range(int(input()))])))


fib = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
n = int(input())
print(list(map(lambda a: a * a * a, fib[:n])))