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

Source: codewars | Difficulty: EASY
Tags: Game theory

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)


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