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: introductory

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):
    new_arr = []
    
    for i in range(1, len(arr)):
        if (arr[i] % i == 0):
            new_arr.append(arr[i])    
            
    return new_arr            

    
    
    
    
    
"""    new_arr = []
    for i in range(1,len(arr)):
        if (arr[i] % i == 0):
            new_arr = 
        i = i + 1
    return new_arr
"""    
    


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]:
    """ Get a new array consisting of elements which are multiple of their own index in input array. """
    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):
    res = [arr[i] for i in range(1, len(arr)) if arr[i] % i == 0]
    return res

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

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):
        # test if value is a multiple of the index
        if c != 0 and a % c == 0:
            res.append(a)
    return res

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

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):
    nArr=[]
    for i in range(1,len(arr)):
        if arr[i]%i==0: nArr.append(arr[i])
    return nArr

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):
    res = []
    for i in range(1, len(arr), 1):
        if arr[i] % i == 0:
            res.append(arr[i])
    return res

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):
    print(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):
    mult = []
    for i in range(1, len(arr)):
        if arr[i]%i == 0:
            mult.append(arr[i])
    return mult

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

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):
    return list(arr[i] for i in range(1, len(arr)) if arr[i] % i == 0)

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


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):
    result_arr = []
    for i in range(1, len(arr)):
        if arr[i] % i == 0:
            result_arr.append(arr[i])
    return result_arr

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):
    new = []
    x = 1
    for i in arr[1:]:
        if i % x == 0:
            new.append(i)
        x += 1
            
    return new

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):
    result = []
    for i in range(len(arr)):
        if i!=0:
            if arr[i]%i==0:
                result.append(arr[i])
    return result

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

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

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

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

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(arr):
    ll = list()
    for i in range(1, len(arr)):
        if arr[i] % i == 0:
            ll.append(arr[i])
    return ll

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(arr):
    returnArr = []
    for i in range(1,len(arr)): 
        if arr[i] % i == 0: 
            returnArr.append(arr[i])
    return returnArr

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

# 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]

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


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):
    newA = []
    for i in range(1,len(arr)):
         if arr[i]%i==0:
                newA.append(arr[i]) 
    return newA

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

def multiple_of_index(arr):
    """
        Returns a list of elements which are multiple of their own index in '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):
    ret = []
    for val in range(len(arr)-1):
        if arr[val+1] % (val+1) == 0:
            ret.append(arr[val+1])
    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_list = []
    for i in range(1,len(arr)):
        if(not arr[i]%i): new_list.append(arr[i])
    return new_list


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):
    a=[]
    for i,elem in enumerate(arr):
        if i!=0 and elem%i==0:
            a.append(elem)
    return a

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):
    ar = []
    for i in range(1,len(arr)):
        if arr[i] % i == 0:
            ar.append(arr[i])
    return ar        

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