This is the first step to understanding FizzBuzz.  

Your inputs:
a positive integer, n, greater than or equal to one.
n is provided, you have NO CONTROL over its value.

Your expected output is an array of positive integers from 1 to n (inclusive).

Your job is to write an algorithm that gets you from the input to the output.

Difficulty: EASY

Starter code:
def pre_fizz(n):
	

Solutions:
def pre_fizz(n):
	return list(range(1, n + 1))


def pre_fizz(n):
	return [i + 1 for i in range(0, n)]


def pre_fizz(n):
	return [x for x in range(1, n + 1)]


pre_fizz = lambda n: list(range(1, n + 1))


def pre_fizz(n):
	mas = []
	for i in range(1, n + 1):
		mas.append(i)
	return mas


def pre_fizz(n):
	ar = []
	for i in range(1, n + 1):
		ar.append(i)
	return ar


from itertools import islice, count
pre_fizz = lambda n: list(islice(count(1), n))


from typing import List

def pre_fizz(n: int) -> List[int]:
	return list(range(1, n + 1))


pre_fizz = lambda x: [n + 1 for n in range(x)]


def pre_fizz(n):
	count = 1
	nums = []
	while count <= n:
		nums.append(count)
		count += 1
	return nums


def pre_fizz(n):
	i = 1
	list_n = []
	while i != n + 1:
		list_n.append(i)
		i += 1
	return list_n


def pre_fizz(n):
	arr = []
	s = 1
	while s <= n:
		arr.append(s)
		s += 1
	return arr


def pre_fizz(n):
	out = []
	for i in range(n):
		out.append(i + 1)
	return out


def pre_fizz(n):
	new_list = []
	for i in range(n):
		new_list.append(i + 1)
	return new_list


def pre_fizz(n):
	counter = 0
	result = []
	while counter < n:
		counter += 1
		result.append(counter)
	return result


def pre_fizz(n):
	return [el for el in range(1, n + 1)]


def pre_fizz(n):
	pre_fizz = []
	while n != 0:
		pre_fizz.append(n)
		n -= 1
	pre_fizz.sort()
	return pre_fizz


def pre_fizz(n):
	arr = []
	for i in range(1, n + 1):
		if n >= 1:
			arr.append(i)
	return arr


def pre_fizz(n):
	return [y for y in range(1, n + 1)]


def pre_fizz(n):
	outList = []
	for i in range(n):
		outList.append(i + 1)
	return outList


def pre_fizz(n):
	if n >= 1:
		fizzbuzz = []
		for o in range(1, n + 1):
			fizzbuzz.append(o)
		return fizzbuzz


def pre_fizz(n):
	ar = []
	number = 0
	for x in range(n):
		number += 1
		ar.append(number)
	return ar


from typing import List

def pre_fizz(n: int) -> List[int]:
	return [it for it in range(1, n + 1)]


def pre_fizz(n):
	n = list(range(n))
	x = n[-1] + 1
	n.append(x)
	del n[0]
	return n


def pre_fizz(n):
	nums = []
	for num in range(n + 1):
		if num == 0:
			continue
		else:
			nums.append(num)
	return nums


def pre_fizz(n):
	mylist = []
	for num in range(n):
		num += 1
		mylist.append(num)
	return mylist


def pre_fizz(n):
	new_arr = list()
	for i in range(1, n + 1):
		new_arr.append(i)
	return new_arr


def pre_fizz(n):
	x = []
	for i in range(n):
		x.append(i + 1)
	return x


def pre_fizz(n):
	k = [i for i in range(n + 1)]
	k.pop(0)
	return k


def pre_fizz(n):
	num = []
	i = 1
	while i <= n:
		num.append(i)
		i += 1
	return num


def pre_fizz(n):
	resultlist = []
	for i in range(n):
		resultlist.append(i + 1)
	return resultlist


def pre_fizz(n):
	array = []
	x = 1
	while x <= n:
		array.append(x)
		x += 1
	return array


def pre_fizz(n):
	z = []
	for x in range(n):
		x += n - n + 1
		z.append(x)
	return z


def pre_fizz(n):
	x = []
	number: int
	for number in range(1, n + 1):
		x.append(number)
	return x


def pre_fizz(n):
	a = []
	i = 1
	for i in range(1, n + 1):
		a.append(i)
		i = i + 1
	return a


def pre_fizz(n):
	numbers = []
	for i in range(1, n + 1):
		numbers.append(i)
	return numbers


def pre_fizz(n):
	array = [1]
	for i in range(2, n + 1):
		array.append(i)
	return array


def pre_fizz(n):
	result = []
	i = 1
	while i <= n:
		result.append(i)
		i = i + 1
	return result


def pre_fizz(n):
	list = []
	i = 1
	while i <= n:
		list.append(i)
		i = i + 1
	return list


def pre_fizz(n):
	z = range(1, n + 1)
	y = []
	for i in z:
		y.append(i)
	return y


def pre_fizz(n):
	arr = []
	counter = 1
	for i in range(n):
		arr.append(counter)
		counter += 1
	return arr


def pre_fizz(n):
	x = 0
	return_list = []
	while x < n:
		x += 1
		return_list.append(x)
	return return_list


def pre_fizz(n):
	l = [i for i in range(1, n + 1)]
	return l


def pre_fizz(n):
	return [1] if n == 1 else list(range(1, n + 1))


def pre_fizz(n):
	count = 0
	x = []
	while n > count:
		count += 1
		x.append(count)
	return x


def pre_fizz(n):
	i = 1
	a = []
	while i < n + 1:
		a.append(i)
		i += 1
	return a


def pre_fizz(n):
	res = []
	for number in range(1, n + 1):
		res.append(number)
	return res


def pre_fizz(n):
	emptylist = []
	if n >= 1:
		for eachnumber in range(1, n + 1):
			emptylist.append(eachnumber)
		return emptylist


def pre_fizz(n):
	i = 1
	output = []
	while i <= n:
		output.append(i)
		i = i + 1
	return output


def pre_fizz(n):
	li = []
	for k in range(1, n + 1):
		li.append(k)
	return li


def pre_fizz(n):
	return list(map(lambda x: x, list(range(1, n + 1))))


def pre_fizz(n):
	new_list = list()
	if n == 1:
		new_list1 = [n]
		return new_list1
	for numbers in range(1, n + 1):
		new_list.append(numbers)
	return new_list


def pre_fizz(n):
	tab = []
	if n == 1:
		tab.append(1)
		return tab
	else:
		for i in range(1, n + 1):
			tab.append(i)
	return tab


def pre_fizz(n):
	myList = []
	num = 1
	while len(myList) < n:
		myList.append(num)
		num += 1
	return myList


def pre_fizz(n):
	arr = [i for i in range(1, n + 1)]
	return arr


def pre_fizz(n):
	new = []
	for num in range(1, n + 1):
		new.append(num)
	return new


def pre_fizz(n):
	res = list()
	for i in range(1, n + 1):
		res.append(i)
	return res


def pre_fizz(n):
	list = []
	for i in range(n + 1):
		list.append(i)
	list.pop(0)
	return list


def pre_fizz(n):
	list = []
	while True:
		if n != 0:
			list.insert(0, n)
			n -= 1
		elif n == 0:
			break
	return list


def pre_fizz(n):
	matriz = []
	for x in range(1, n + 1):
		matriz.append(x)
	return matriz


def pre_fizz(n: int) -> list:
	answer: list = []
	for i in range(1, n + 1):
		answer.append(i)
	return answer


def pre_fizz(n):
	list = []
	account = 1
	while account <= n:
		list += [account]
		account += 1
	return list


def pre_fizz(n):
	list = []
	num = 0
	while num < n:
		num += 1
		list.append(num)
	return list


def pre_fizz(n):
	numlist = []
	for shit in range(0, n):
		numlist.append(shit + 1)
	return numlist


def pre_fizz(n):
	if type(n) == int:
		a = list(range(1, n + 1))
		return a


def pre_fizz(n):
	fiz = []
	for i in range(1, n + 1):
		fiz.append(i)
	return fiz


def pre_fizz(n):
	vso = []
	for i in range(1, n + 1):
		vso.append(i)
	return vso


def pre_fizz(length):
	return [n for n in range(1, length + 1)]


pre_fizz = lambda n: [i for i in range(1, n + 1)]


def pre_fizz(n):
	output = []
	for i in range(0, n):
		output.append(i + 1)
	return output


def pre_fizz(n):
	fizzbuzz = []
	for i in range(1, n + 1):
		fizzbuzz.append(i)
	return fizzbuzz


def pre_fizz(n):
	rez = list()
	for it in range(1, n + 1):
		rez.append(it)
	return rez


def pre_fizz(n):
	fizz = []
	while n >= 1:
		if n != 0:
			fizz.append(n)
			n = n - 1
			sort_fizz = sorted(fizz)
	return sort_fizz