Implement a function that normalizes out of range sequence indexes (converts them to 'in range' indexes) by making them repeatedly 'loop' around the array. The function should then return the value at that index. Indexes that are not out of range should be handled normally and indexes to empty sequences should return undefined/None depending on the language.

For positive numbers that are out of range, they loop around starting at the beginning, so 

```python
norm_index_test(seq, len(seq))     # Returns first element
norm_index_test(seq, len(seq) + 1) # Returns second element
norm_index_test(seq, len(seq) + 2) # Returns third element
# And so on...
norm_index_test(seq, len(seq) * 2) # Returns first element
```

For negative numbers, they loop starting from the end, so

```python norm_index_test(seq, len(seq))
norm_index_test(seq, -1)        # Returns last element
norm_index_test(seq, -2)        # Returns second to last element
norm_index_test(seq, -3)        # Returns third to last element
# And so on...
norm_index_test(seq, -len(seq)) # Returns first element
```

Source: codewars | Difficulty: EASY
Tags: Data structures

Starter code: def norm_index_test(seq, ind):
	

Solutions:
def norm_index_test(a, n):
	if a:
		return a[n % len(a)]


def norm_index_test(seq, ind):
	if seq:
		return seq[ind % len(seq)]
	return None


def norm_index_test(seq, ind):
	try:
		return seq[ind % len(seq)]
	except:
		pass


def norm_index_test(seq, ind):
	if seq == []:
		return None
	elif ind >= len(seq) or ind < 0:
		return seq[ind % len(seq)]
	else:
		return seq[ind]


def norm_index_test(seq, ind):
	return None if len(seq) == 0 else seq[ind % len(seq)]


norm_index_test = lambda seq, ind: None if len(seq) == 0 else seq[ind % len(seq)]


def norm_index_test(arr, ind):
	return arr[ind % len(arr)] if arr else None


def norm_index_test(lst, ind):
	return lst[ind % len(lst)] if lst else None


def norm_index_test(seq, n):
	try:
		return seq[n % len(seq)]
	except ZeroDivisionError:
		return None