Return a new array consisting of elements which are multiple of their own index in input array (length > 1).

Some cases: 

```
[22, -6, 32, 82, 9, 25] =>  [-6, 32, 25]

[68, -1, 1, -7, 10, 10] => [-1, 10]

[-56,-85,72,-26,-14,76,-27,72,35,-21,-67,87,0,21,59,27,-92,68] => [-85, 72, 0, 68]
```

Difficulty: EASY
Tags: Fundamentals

Data structures
Skill types: Data structures

Starter code:
def multiple_of_index(arr):
	

Solutions:
def multiple_of_index(l):
	return [l[i] for i in range(1, len(l)) if l[i] % i == 0]


def multiple_of_index(arr):
	return [val for (index, val) in enumerate(arr) if index and val % index == 0]


def multiple_of_index(arr):
	return [arr[i] for i in range(1, len(arr)) if arr[i] % i == 0]


def multiple_of_index(arr):
	i = 1
	rst = []
	while i < len(arr):
		if arr[i] % i == 0:
			print(i)
			rst.append(arr[i])
		i += 1
	return rst


def multiple_of_index(arr):
	return [n for (i, n) in enumerate(arr[1:], 1) if n % i == 0]


def multiple_of_index(arr):
	results = []
	i = 0
	for elem in arr:
		if i > 0 and elem % i == 0:
			results.append(elem)
		i += 1
	return results


def multiple_of_index(arr):
	return [e for (i, e) in enumerate(arr) if i and (not e % i)]


def multiple_of_index(arr):
	return [x for (y, x) in enumerate(arr[1:], 1) if not abs(x) % y]


def multiple_of_index(arr):
	return [arr[x] for x in range(1, len(arr)) if x == 0 or arr[x] % x == 0]


def multiple_of_index(arr):
	return [x[1] for x in enumerate(arr) if x[0] != 0 and (not x[1] % x[0])]


def multiple_of_index(arr):
	return [x for (i, x) in enumerate(arr[1:], 1) if not x % i]


def multiple_of_index(arr):
	return [x for (i, x) in enumerate(arr) if i and x % i == 0]


def multiple_of_index(arr):
	return [a for (i, a) in enumerate(arr) if i > 0 and a % i == 0]


def multiple_of_index(arr):
	return [v for (i, v) in enumerate(arr[1:]) if v % (i + 1) == 0]


def multiple_of_index(arr):
	return [elt for (i, elt) in enumerate(arr[1:]) if not elt % (i + 1)]


def multiple_of_index(arr):
	vList = []
	for (key, value) in enumerate(arr):
		if key == 0:
			continue
		if value % key == 0:
			vList.append(value)
	return vList


from typing import List

def multiple_of_index(arr: List[int]) -> List[int]:
	return list(dict(filter(lambda _it: _it[0] > 0 and (_it[1] / _it[0]).is_integer(), enumerate(arr))).values())


def multiple_of_index(arr):
	return [v for (i, v) in enumerate(arr) if i > 0 and v % i == 0]


def multiple_of_index(arr):
	ar = []
	for num in range(1, len(arr)):
		if arr[num] % num == 0:
			ar.append(arr[num])
	return ar


def multiple_of_index(arr):
	return [i for (idx, i) in enumerate(arr) if idx and (not i % idx)]


def multiple_of_index(a):
	return [v for (i, v) in enumerate(a) if i and v % i == 0]


multiple_of_index = lambda a: [n for (i, n) in enumerate(a) if i >= 1 > n % i]


def multiple_of_index(arr):
	result = list()
	for i in range(1, len(arr)):
		if arr[i] % i == 0:
			result.append(arr[i])
	return result


def multiple_of_index(arr):
	result = []
	n = 0
	while n < len(arr):
		if n != 0 and arr[n] % n == 0:
			result.append(arr[n])
		n += 1
	return result


def multiple_of_index(arr):
	res = []
	for (c, a) in enumerate(arr):
		if c != 0 and a % c == 0:
			res.append(a)
	return res


def multiple_of_index(arr):
	arr.pop(0)
	return list((b for (a, b) in list(enumerate(arr, start=1)) if b % a == 0))


def multiple_of_index(arr):
	new = []
	i = 1
	while i < len(arr):
		if arr[i] % i == 0:
			new.append(arr[i])
		i += 1
	return new


def multiple_of_index(arr):
	output = []
	count = 0
	for num in arr:
		if count != 0:
			if not num % count:
				output.append(num)
		count += 1
	return output


def multiple_of_index(arr):
	res = []
	for x in range(len(arr)):
		if x != 0 and arr[x] % x == 0:
			res.append(arr[x])
	return res


def multiple_of_index(arr):
	output = []
	for (index_, value) in enumerate(arr):
		try:
			if value % index_ == 0:
				output.append(value)
		except ZeroDivisionError:
			continue
	return output


def multiple_of_index(arr):
	new_arr = []
	i = 1
	for x in arr[1:]:
		if x % i == 0:
			new_arr.append(x)
		i += 1
	return new_arr


def multiple_of_index(arr):
	return [v for (k, v) in enumerate(arr) if k > 0 and (not v % k)]


def multiple_of_index(arr):
	lst = []
	for i in range(len(arr)):
		if i == 0:
			if arr[i] == 0:
				lst.append(arr[i])
		elif arr[i] % i == 0:
			lst.append(arr[i])
	return lst


multiple_of_index = lambda a: [n for (i, n) in enumerate(a) if i and (not n % i)]


def multiple_of_index(arr):
	return [i for (num, i) in enumerate(arr[1:], 1) if i % num == 0]


def multiple_of_index(arr):
	return [arr[el] for el in range(1, len(arr)) if arr[el] % el == 0]


def multiple_of_index(arr):
	l = []
	for i in range(len(arr)):
		if i == 0:
			continue
		elif arr[i] % i == 0:
			l.append(arr[i])
	return l


def multiple_of_index(arr):
	lst = []
	for (i, elem) in enumerate(arr):
		try:
			if elem % int(i) == 0:
				lst.append(elem)
		except ZeroDivisionError:
			pass
	return lst


def multiple_of_index(arr):
	temp = []
	for n in range(1, len(arr)):
		if arr[n] % n == 0:
			temp.append(arr[n])
	return temp


def multiple_of_index(arr):
	return [y for (x, y) in enumerate(arr[1:], start=1) if y % x == 0]


def multiple_of_index(arr):
	res = []
	if arr[0] == 0:
		res.append(0)
	for i in range(1, len(arr)):
		try:
			if arr[i] % i == 0:
				res.append(arr[i])
		except:
			res.append(0)
	return res


def multiple_of_index(arr):
	bigboy = []
	index = 1
	for x in arr[1:]:
		if x % index == 0:
			bigboy.append(x)
		index += 1
	return bigboy


def multiple_of_index(arr):
	result = []
	for i in range(1, len(arr)):
		if arr[i] % i == 0:
			result.append(arr[i])
		else:
			pass
	return result


def multiple_of_index(arr):
	result = []
	for i in range(1, len(arr)):
		if not arr[i] % i:
			result.append(arr[i])
	return result


def multiple_of_index(arr):
	return [k for (i, k) in enumerate(arr[1:]) if not k % (i + 1)]


def multiple_of_index(arr):
	return [b for (a, b) in enumerate(arr[1:], 1) if b % a == 0]


def multiple_of_index(arr):
	matches = []
	index = 1
	for value in arr[1:]:
		if value % index == 0:
			matches.append(value)
		index += 1
	return matches


def multiple_of_index(arr):
	return [x for x in [arr[i] if arr[i] % i == 0 else None for i in range(1, len(arr))] if x is not None]


def multiple_of_index(arr):
	return [i for (loop, i) in enumerate(arr[1:]) if i % (loop + 1) == 0]


def multiple_of_index(arr: list) -> list:
	return [val for (idx, val) in enumerate(arr) if len(arr) > 1 and idx != 0 if val % idx == 0]


def multiple_of_index(arr):
	return [i for (j, i) in enumerate(arr) if j != 0 and i % j == 0]


def multiple_of_index(a):
	l = []
	for (i, v) in enumerate(a):
		if i >= 1 and v % i == 0:
			l.append(v)
	return l


def multiple_of_index(arr):
	x = []
	for (idx, n) in enumerate(arr):
		if idx >= 1 and n % idx == 0:
			x.append(n)
	return x


def multiple_of_index(xs):
	return [i for (idx, i) in enumerate(xs[1:]) if i % (idx + 1) == 0]


def multiple_of_index(arr):
	return [x for (index, x) in enumerate(arr) if index != 0 and x % index == 0]


def multiple_of_index(arr):
	return [element for (index, element) in enumerate(arr[1:], 1) if not element % index]


def multiple_of_index(arr):
	return [i[1] for i in zip(list(range(1, len(arr))), arr[1:]) if i is 0 or i[1] % i[0] == 0]


def multiple_of_index(arr):
	return [case for (i, case) in enumerate(arr) if i > 0 and case % i == 0]


def multiple_of_index(arr):
	index = 1
	res = []
	while index < len(arr):
		if arr[index] % index == 0:
			res.append(arr[index])
		index += 1
	return res


def multiple_of_index(arr):
	print(arr)
	return [arr[i] for i in range(1, len(arr)) if not arr[i] % i]


def multiple_of_index(arr):
	arr2 = []
	for i in range(len(arr)):
		if i > 0 and arr[i] % i == 0:
			arr2.append(arr[i])
	return arr2
	pass


def multiple_of_index(arr):
	num = 1
	ret = []
	for i in arr[1:]:
		if i % num == 0:
			ret.append(i)
		num = num + 1
	return ret


def multiple_of_index(arr):
	ret = []
	for val in range(1, len(arr)):
		if arr[val] % val == 0:
			ret.append(arr[val])
	return ret


def multiple_of_index(arr):
	return [arr for (ind, arr) in enumerate(arr) if ind > 0 and arr % ind == 0]


def multiple_of_index(arr):
	result = []
	for (i, j) in enumerate(arr):
		try:
			if j % i == 0:
				result.append(j)
		except:
			continue
	return result


def multiple_of_index(arr):
	n_arr = []
	a1 = tuple(arr)
	n = 0
	m = 0
	for i in range(len(a1)):
		n = i
		m = a1[i]
		if n == 0:
			continue
		elif m % n == 0:
			n_arr.append(m)
	return n_arr


def multiple_of_index(arr):
	new_array = []
	counter = 0
	for i in arr:
		if counter != 0:
			if i % counter == 0:
				new_array.append(i)
		counter += 1
	return new_array


def multiple_of_index(arr):
	listofmultiples = []
	index = 0
	for eachnumber in arr:
		if index == 0:
			index = index + 1
		elif eachnumber % index == 0:
			listofmultiples.append(eachnumber)
			index = index + 1
		else:
			index = index + 1
	return listofmultiples


def multiple_of_index(arr):
	array = []
	for x in range(1, len(arr), 1):
		if arr[x] % x == 0:
			array.append(arr[x])
	return array


def multiple_of_index(arr):
	lst = []
	for (keys, values) in enumerate(arr):
		if keys >= 1 and values % keys == 0:
			lst.append(values)
	return lst


def multiple_of_index(arr):
	my_list = []
	array = arr[1:]
	for (i, x) in enumerate(array, 1):
		if x % i == 0:
			my_list.append(x)
	return my_list


def multiple_of_index(arr):
	res = []
	for (idx, elem) in enumerate(arr):
		if idx != 0:
			if elem % idx == 0:
				res.append(elem)
	return res


def multiple_of_index(arr):
	ls = []
	for i in range(len(arr)):
		if i == 0:
			continue
		if arr[i] % i == 0:
			ls.append(arr[i])
	return ls


def multiple_of_index(arr):
	l = list()
	for i in range(len(arr)):
		print(arr[i], i)
		if i == 0 and arr[i] == 0:
			l.append(i)
		elif i == 0:
			continue
		if arr[i] % i == 0:
			l.append(arr[i])
	print(l)
	return l