#Unflatten a list (Easy)

There are several katas like "Flatten a list".
These katas are done by so many warriors, that the count of available list to flattin goes down!

So you have to build a method, that creates new arrays, that can be flattened!

#Shorter: You have to unflatten a list/an array.

You get an array of integers and have to unflatten it by these rules:
```
- You start at the first number.
- If this number x is smaller than 3, take this number x direct 
  for the new array and continue with the next number.
- If this number x is greater than 2, take the next x numbers (inclusive this number) as a 
  sub-array in the new array. Continue with the next number AFTER this taken numbers.
- If there are too few numbers to take by number, take the last available numbers.
```

The given array will always contain numbers. There will only be numbers > 0.

Example:
```
 [1,4,5,2,1,2,4,5,2,6,2,3,3] -> [1,[4,5,2,1],2,[4,5,2,6],2,[3,3]]

Steps: 
1. The 1 is added directly to the new array.
2. The next number is 4. So the next 4 numbers (4,5,2,1) are added as sub-array in the new array.
3. The 2 is added directly to the new array.
4. The next number is 4. So the next 4 numbers (4,5,2,6) are added as sub-array in the new array.
5. The 2 is added directly to the new array.
6. The next number is 3. So the next 3 numbers would be taken. There are only 2, 
   so take these (3,3) as sub-array in the new array.
```

There is a harder version of this kata!
Unflatten a list (Harder than easy)

Have fun coding it and please don't forget to vote and rank this kata! :-) 

I have created other katas. Have a look if you like coding and challenges.

Difficulty: introductory

Starter code:

def unflatten(flat_array):
	

Solutions:
def unflatten(flat_array):
    arr = flat_array[:]
    for i, v in enumerate(arr):
        if v > 2:
            arr[i], arr[i+1:i+v] = arr[i:i+v], []
    return arr

def unflatten(flat):
    if not flat :  return []
    if flat[0]<3 : return [flat[0]] + unflatten(flat[1:])
    else:          return [ flat[0:flat[0]] ] + unflatten(flat[flat[0]:])

from itertools import islice

def unflatten(a):
    it = iter(a)
    return [x if x < 3 else [x] + list(islice(it, 0, x-1)) for x in it]

def unflatten(flat_array):
    result = []
    i = 0
    while i < len(flat_array):
        num = flat_array[i]
        if num <= 2:
            result.append(num)
            i += 1
        else:
            result.append(flat_array[i:i+num])
            i += num
    return result

def unflatten(flat_array):
    new_array = []
    i = 0
    while i < len(flat_array):
        if flat_array[i] < 3:
            new_array.append(flat_array[i])
            i+=1
        else:
            new_array.append(flat_array[i:i+flat_array[i]])
            i+=flat_array[i]
    return new_array

def unflatten(flat_array):
    #your code here
    result = []
    index = 0
    while index < len(flat_array):
        value = flat_array[index]
        if value < 3:
            result.append(value)
            index += 1
        else:
            result.append(flat_array[index:index + value])
            index += value
    return result

def unflatten(flat_array):
    dex = 0
    result = []
    while dex < len(flat_array):
        current = flat_array[dex]
        if current > 2:
            result.append(flat_array[dex:dex + current])
            dex += current
        else:
            result.append(current)
            dex += 1
    return result

def unflatten(flat):
    a = []
    while flat:
        a, flat = (a + [flat[0]], flat[1:]) if flat[0] < 3 else (a + [flat[:flat[0]]], flat[flat[0]:])
    return a

def unflatten(arr):
  
  j = 0
  res = []
  
  for x in arr:
    if j > 0:
      res[-1].append(x)
      j -= 1
    elif x < 3:
      res.append(x)
    else:
      res.append([x])
      j = x-1
  
  return res

def unflatten(flat_array):
    new_array = []
    start = 0
    
    while start < len(flat_array):
        if flat_array[start] < 3:
            new_array.append(flat_array[start])
            start += 1

        else:
            new_array.append(flat_array[start: start + flat_array[start]])
            start += flat_array[start]


    return new_array