# Task
 We have a N×N `matrix` (N<10) and a robot. 
 
 We wrote in each point of matrix x and y coordinates of a point of matrix. 
 
 When robot goes to a point of matrix, reads x and y and transfer to point with x and y coordinates.
 
 For each point in the matrix we want to know if robot returns back to it after `EXACTLY k` moves. So your task is to count points to which Robot returns in `EXACTLY k` moves. 
 
 You should stop counting moves as soon as the robot returns to the starting point. That is, if the robot returns to the starting point in fewer than k moves, that point should not count as a valid point.
 
# example

 For:
 ```
 matrix=[
 ["0,1","0,0","1,2"], 
 ["1,1","1,0","0,2"], 
 ["2,1","2,0","0,0"]]
 k= 2
 ```
 The result should be `8`
```
Robot start at (0,0) --> (0,1) --> (0,0), total 2 moves
Robot start at (0,1) --> (0,0) --> (0,1), total 2 moves
Robot start at (0,2) --> (1,2) --> (0,2), total 2 moves
Robot start at (1,2) --> (0,2) --> (1,2), total 2 moves
Robot start at (1,0) --> (1,1) --> (1,0), total 2 moves
Robot start at (1,1) --> (1,0) --> (1,1), total 2 moves
Robot start at (2,0) --> (2,1) --> (2,0), total 2 moves
Robot start at (2,1) --> (2,0) --> (2,1), total 2 moves
Robot start at (2,2) --> (0,0) --> (0,1) --> (0,0) --> (0,1) ....
(Robot can not transfer back to 2,2)
```
So the result is 8.

# Input/Output


 - `[input]` 2D integer array matrix
 
 n x n matrix. 3 <= n <=9
 
 
 - `[input]` integer `k`
 
 `2 <= k <= 5`
 
 
 - `[output]` an integer

Difficulty: introductory

Starter code:

def robot_transfer(matrix, k):
	

Solutions:
def robot_transfer(matrix, k):
    c = 0
    for l, i in enumerate(matrix):
        for o, j in enumerate(i):
            x, y = j.split(",")
            current,count,new = [l, o],0,[]
            while count < k and current != new:
                new = [int(x), int(y)] ; x, y = matrix[int(x)][int(y)].split(",") ; count += 1
            if current == new and count == k : c += 1
    return c 

def robot_transfer(matrix, k):
    res, seen = 0, set()
    for i in range(len(matrix)):
        for j in range(len(matrix)):
            if (i, j) in seen: continue
            x, y, S = i, j, {(i, j)}
            for _ in range(k):
                x, y = map(int, matrix[x][y].split(','))
                S.add((x, y))
            if (x, y) == (i, j) and len(S) == k:
                res += k
                seen |= S
    return res

def f(matrix, k, i, j):
    i0, j0 = i, j
    for n in range(1, k+1):
        i, j = matrix[i][j]
        if i == i0 and j == j0:
            return n == k
    return False

def robot_transfer(matrix, k):
    matrix = [
        [tuple(map(int, x.split(','))) for x in row]
        for row in matrix
    ]
    return sum(
        f(matrix, k, i, j)
        for i, row in enumerate(matrix)
        for j, x in enumerate(row)
    )

def robot_transfer(matrix, k):
    result = 0
    for i in range(len(matrix[0])):
        for j in range(len(matrix)):
            x, y, back = i, j, 0
            for _ in range(k):
                x, y = (int(n) for n in matrix[x][y].split(","))
                back += ((i, j) == (x, y))
            result += ((i, j) == (x, y) and back == 1)
    return result



def robot_transfer(matrix, k):
    cycles = 0
    for x, l in enumerate(matrix):
        for y, _ in enumerate(l):
            u, v = x, y
            for n in range(k):
                u, v = map(int, matrix[u][v].split(','))
                if (x, y) == (u, v):
                    cycles += n == k-1
                    break
    return cycles

def robot_transfer(matrix, k):
    count = 0
    for start_y, row in enumerate(matrix):
        for start_x, point in enumerate(row):
            y, x = int(point[0]), int(point[2])
            for t in range(k-1):
                y, x = int(matrix[y][x][0]), int(matrix[y][x][2])
                if (y, x) == (start_y, start_x):
                    count += (t+2 == k)
                    break        
    return count


def robot_transfer(matrix, k):
    r=0
    n=len(matrix)
    for i in range(n):
        for j in range(n):
            x,y=i,j
            for step in range(k):
                x,y=map(int,matrix[x][y].split(','))
                if x==i and y==j:
                    break
            if x==i and y==j and step==k-1:
                r+=1
    return r

def robot_transfer(matrix, k):
  res = []
  for r, rows in enumerate(matrix):
      for c,point in enumerate(rows):
          kk = 1
          while kk <= k:
              t = list(map(int, point.split(',')))
              print(t)
              point = matrix[t[0]][t[1]]
              kk += 1
              if list(map(int, point.split(','))) == [r, c]: break
          if kk == k and list(map(int, point.split(','))) == [r, c]:
              res.append(1)
  return sum(res)

def floyd(matrix, row, col):
    def f(row, col):
        return list(map(int, matrix[row][col].split(',')))
    x0 = [row,col]
    tortoise = f(*x0)
    hare = f(*f(*x0))
    while tortoise != hare:
        tortoise = f(*tortoise)
        hare = f(*f(*hare))
  
    mu = 0
    tortoise = x0
    while tortoise != hare:
        tortoise = f(*tortoise)
        hare = f(*hare)
        mu += 1
        
    lam = 1
    hare = f(*tortoise)
    while tortoise != hare:
        hare = f(*hare)
        lam += 1
    
    return lam if mu==0 else -1

def robot_transfer(matrix, k):
    SIZE = len(matrix)
    return sum(1 for row in range(SIZE) for col in range(SIZE) if floyd(matrix, row, col)==k)
                
                


def robot_transfer(matrix, k):
  N=len(matrix)
  mat=[[0]*N for i in range(N)]
  for i in range(N):
      for j in range(N):
          mat[i][j]=(int(matrix[i][j][0]),int(matrix[i][j][2]))
  tot=0
  for i in range(N):
      for j in range(N):
          y=(i,j)
          for kk in range(k):
              y=mat[y[0]][y[1]]
              if y==(i,j) and kk<k-1: 
                  break
          if y==(i,j) and kk==k-1: tot+=1
  return tot