Given a board of `NxN`, distributed with tiles labeled `0` to `N² - 1`(inclusive):

A solved grid will have the tiles in order of label, left to right, top to bottom.

Return `true` if the board state is currently solved, and `false` if the board state is unsolved.

Input will always be a square 2d array.


For example, a 2x2 solved grid:
```
[ [0, 1],
  [2, 3] ]
```

A 2x2 unsolved grid:
```
[ [2, 1],
  [0, 3] ]
```

Difficulty: introductory

Starter code:

def is_solved(board):
	

Solutions:
def is_solved(board):
    curr = 0;
    for r in board:
        for c in r:
            if c != curr:
                return False;
            curr+=1;
    return True;

def is_solved(board):
    board = sum(board, [])
    return board == sorted(board)

def is_solved(board):
    return all( v==w for x,r in enumerate(board) for w,v in enumerate(r,x*len(board)) )

def is_solved(board):
    return sum(board, []) == list(range(0, len(board)**2))

def is_solved(board):
    flat = [y for x in board for y in x]
    return flat == sorted(flat)

def is_solved(board):
    return sum(board, []) == list(range(len(board)**2))

import numpy as np

def is_solved(board):
    n = len(board)
    a = np.arange(n*n, dtype=int).reshape(n,n)
    return a.tolist() == board

def is_solved(board):
    board2 = board[0] + board[1]
    board3 = board[0] + board[1]
    return sorted(board3) == board2

def is_solved(board):
    return all(a == b for a, b in enumerate(bx for by in board for bx in by))

def is_solved(board):
    flat_list = []
    for item in board:
        flat_list.extend(item)
    sorted_flat_list = sorted(flat_list)
    if sorted_flat_list == flat_list:
        return True
    else:
        return False