# Task
 Mr.Nam has `n` candies, he wants to put one candy in each cell of a table-box. The table-box has `r` rows and `c` columns.

 Each candy was labeled by its cell number. The cell numbers are in range from 1 to N and the direction begins from right to left and from bottom to top.

 Nam wants to know the position of a specific `candy` and which box is holding it.

 The result should be an array and contain exactly 3 elements. The first element is the `label` of the table; The second element is the `row` of the candy; The third element is the `column` of the candy.
 
 If there is no candy with the given number, return `[-1, -1, -1]`.

 Note: 
 
 When the current box is filled up, Nam buys another one. 
 
 The boxes are labeled from `1`.

 Rows and columns are `0`-based numbered from left to right and from top to bottom.
 
# Example

 For `n=6,r=2,c=2,candy=3`, the result should be `[1,0,1]`
 
 the candies will be allocated like this:
```
Box 1
+-----+-----+
|  4  | (3) | --> box 1,row 0, col 1
+-----+-----+
|  2  |  1  |
+-----+-----+
Box 2
+-----+-----+
|  x  |  x  |
+-----+-----+
|  6  | (5) | --> box 2,row 1, col 1
+-----+-----+```
 For `candy = 5(n,r,c same as above)`, the output should be `[2,1,1]`.
 
 For `candy = 7(n,r,c same as above)`, the output should be `[-1,-1,-1]`.
 
 For `n=8,r=4,c=2,candy=3`, the result should be `[1,2,1]` 
```
Box 1
+-----+-----+
|  8  |  7  |
+-----+-----+
|  6  |  5  |
+-----+-----+
|  4  | (3) |--> box 1,row 2, col 1
+-----+-----+
|  2  |  1  |
+-----+-----+
```

# Input/Output


 - `[input]` integer `n`

  The number of candies. 
  
  `0 < n <= 100`


 - `[input]` integer `r`

  The number of rows. 
  
  `0 < r <= 100`


 - `[input]` integer `c`

 The number of columns.

 `0 < c <= 100`


 - `[input]` integer `candy`

 The label of the candy Nam wants to get position of.
 
 `0 < c <= 120`

 - `[output]` an integer array

  Array of 3 elements: a label, a row and a column.

Source: codewars | Difficulty: EASY
Tags: Ad-hoc

Starter code: def get_candy_position(n, r, c, candy):
	

Solutions:
def get_candy_position(n, r, c, candy):
	if candy > n:
		return [-1, -1, -1]
	linIdx = r * c - ((candy - 1) % (r * c) + 1)
	return [(candy - 1) // (r * c) + 1, linIdx // c, linIdx % c]


def get_candy_position(n, r, c, candy):
	if candy > n:
		return [-1, -1, -1]
	label = (candy + r * c - 1) // (r * c)
	candy = (candy - 1) % (r * c)
	row = r - 1 - candy // c
	col = c - 1 - candy % c
	return [label, row, col]


def get_candy_position(n, r, c, candy):
	(q1, r1) = divmod(candy - 1, r * c)
	(q2, r2) = divmod(r1, c)
	return [-1, -1, -1] if n < candy else [q1 + 1, r - q2 - 1, c - r2 - 1]


import numpy as np
import math

def get_candy_position(n, r, c, candy):
	if n < candy:
		return [-1, -1, -1]
	box = np.array([['*'] * c] * r)
	n1 = math.ceil(n / (c * r))
	count = 1
	for i in range(1, n1 + 1):
		b = box.copy()
		for j in range(r - 1, -1, -1):
			for k in range(c - 1, -1, -1):
				if count == candy:
					return [i, j, k]
				b[j][k] = count
				count += 1


def get_candy_position(n, r, c, candy):
	if candy > n:
		return [-1, -1, -1]
	(box, res) = divmod(candy, r * c)
	if res == 0:
		return [box, 0, 0]
	(row, res) = divmod(res, c)
	return [box + 1, r - row, 0] if res == 0 else [box + 1, r - row - 1, c - res]


from math import ceil

def get_candy_position(n, r, c, candy):
	if candy > n:
		return [-1, -1, -1]
	box = ceil(candy / (r * c))
	candy -= (box - 1) * r * c
	row = r - ceil(candy / c)
	column = c - candy % c if candy % c > 0 else 0
	return [box, row, column]


def get_candy_position(a, row, col, candy):
	from math import ceil
	bx_sz = row * col
	if row * col < a:
		n = ceil(a / (row * col)) * (col * row)
	else:
		n = row * col
	l = [i if i <= a else 'X' for i in list(range(1, n - n % row + 1))]
	split_l = [list(l[i:i + bx_sz])[::-1] for i in range(0, len(l), bx_sz)]
	b = [i[j:j + col] for i in split_l for j in range(0, len(i), col)]
	c = [b[i:i + row] for i in range(0, len(b), row)]
	for i in range(len(c)):
		for j in range(len(c[i])):
			for k in range(len(c[i][j])):
				if c[i][j][k] == candy:
					return [i + 1, j, k]
	return [-1, -1, -1]


def get_candy_position(n, r, c, candy):
	if min(n, r, c, candy) <= 0 or candy > n:
		return [-1] * 3
	(box, candy) = divmod(candy - 1, r * c)
	(row, col) = divmod(candy, c)
	return [box + 1, r - row - 1, c - col - 1]


from math import ceil

def get_candy_position(n, r, c, candy):
	d = r * c
	(boxes_cnt, boxes) = (ceil(n / d), [])
	lst = [[i * c + j + 1 for j in range(c - 1, -1, -1)] for i in range(r - 1, -1, -1)]
	for i in range(boxes_cnt):
		boxes.append([i + 1, [[v + i * d if v + i * d <= n else 'x' for v in row] for row in lst]])
	bx = next((box for box in boxes if any((candy in b for b in box[1]))), None)
	if not bx:
		return [-1, -1, -1]
	i = next((k for (k, b) in enumerate(bx[1]) if candy in b))
	j = bx[1][i].index(candy)
	return [bx[0], i, j]


def get_candy_position(n, row, column, element):
	(arr, arr_p, row_p, col_p) = ([[[0] * column for i in range(row)]], 0, row - 1, column - 1)
	i = 1
	while i < n + 1:
		arr[arr_p][row_p][col_p] = i
		col_p -= 1
		if col_p < 0:
			col_p = column - 1
			row_p -= 1
		if all([k != 0 for j in arr for k in sum(j, [])]):
			arr.append([[0] * column for i in range(row)])
			row_p = row - 1
			arr_p += 1
		i += 1
	final = [[i + 1, j, y.index(element)] for (i, x) in enumerate(arr) for (j, y) in enumerate(x) if element in y]
	return final[0] if final else [-1, -1, -1]