text: import itertools
  from utils import *
  
  
  row_units = [cross(r, cols) for r in rows]
  column_units = [cross(rows, c) for c in cols]
  square_units = [cross(rs, cs) for rs in ('ABC','DEF','GHI') for cs in ('123','456','789')]
  diag_el = [[x + y for x, y in zip(rows, cols)], [x + y for x, y in zip(rows, cols[::-1])]]
  
  # TODO: Update the unit list to add the new diagonal units
  unitlist = row_units + column_units + square_units + diag_el
  
  
  # Must be called after all units (including diagonals) are added to the unitlist
  units = extract_units(unitlist, boxes)
  peers = extract_peers(units, boxes)
  
  
  def naked_twins(values):
      """Eliminate values using the naked twins strategy.
  
      The naked twins strategy says that if you have two or more unallocated boxes
      in a unit and there are only two digits that can go in those two boxes, then
      those two digits can be eliminated from the possible assignments of all other
      boxes in the same unit.
  
      Parameters
      ----------
      values(dict)
          a dictionary of the form {'box_name': '123456789', ...}
  
      Returns
      -------
      dict
          The values dictionary with the naked twins eliminated from peers
  
      Notes
      -----
      Your solution can either process all pairs of naked twins from the input once,
      or it can continue processing pairs of naked twins until there are no such
      pairs remaining -- the project assistant test suite will accept either
      convention. However, it will not accept code that does not process all pairs
      of naked twins from the original input. (For example, if you start processing
      pairs of twins and eliminate another pair of twins before the second pair
      is processed then your code will fail the PA test suite.)
  
      The first convention is preferred for consistency with the other strategies,
      and because it is simpler (since the reduce_puzzle function already calls this
      strategy repeatedly).
  
      See Also
      --------
      Pseudocode for this algorithm on github:
      https://github.com/udacity/artificial-intelligence/blob/master/Projects/1_Sudoku/pseudocode.md
      """ 
      for unit in unitlist:
          pairs = [cell for cell in unit if len(values[cell])==2]
  #         for tw in itertools.combinations(pairs, 2):
  #             twins.append(tw)
          twins = [list(tw) for tw in itertools.combinations(pairs, 2)]
          
          for tw in twins:
              boxA = tw[0]
              boxB = tw[1]
              if values[boxA] == values[boxB]:
                  for cell in unit:
                      if cell!=boxA and cell!=boxB:
                          for num in values[boxA]:
                              values[cell] = values[cell].replace(num, '')
      return values
  
  
  def eliminate(values):
      """Apply the eliminate strategy to a Sudoku puzzle
  
      The eliminate strategy says that if a box has a value assigned, then none
      of the peers of that box can have the same value.
  
      Parameters
      ----------
      values(dict)
          a dictionary of the form {'box_name': '123456789', ...}
  
      Returns
      -------
      dict
          The values dictionary with the assigned values eliminated from peers
      """
      solved = [box for box in values.keys() if len(values[box]) == 1]
      for box in solved:
          digit = values[box]
          for peer in peers[box]:
              values[peer] = values[peer].replace(digit,'')
      return values
  
  
  def only_choice(values):
      """Apply the only choice strategy to a Sudoku puzzle
  
      The only choice strategy says that if only one box in a unit allows a certain
      digit, then that box must be assigned that digit.
  
      Parameters
      ----------
      values(dict)
          a dictionary of the form {'box_name': '123456789', ...}
  
      Returns
      -------
      dict
          The values dictionary with all single-valued boxes assigned
  
      Notes
      -----
      You should be able to complete this function by copying your code from the classroom
      """
      for unit in unitlist:
          for digit in '123456789':
              dplaces = [box for box in unit if digit in values[box]]
              if len(dplaces) == 1:
                  values[dplaces[0]] = digit
      return values
  
  
  def reduce_puzzle(values):
      """Reduce a Sudoku puzzle by repeatedly applying all constraint strategies
  
      Parameters
      ----------
      values(dict)
          a dictionary of the form {'box_name': '123456789', ...}
  
      Returns
      -------
      dict or False
          The values dictionary after continued application of the constraint strategies
          no longer produces any changes, or False if the puzzle is unsolvable 
      """
      stalled = False
      while not stalled:
          # Check how many boxes have a determined value
          solved_values_before = len([box for box in values.keys() if len(values[box]) == 1])
  
          # Your code here: Use the Eliminate Strategy
          values = eliminate(values)
          # Your code here: Use the Only Choice Strategy
          # values = 
          values = only_choice(values)
          # Check how many boxes have a determined value, to compare
          solved_values_after = len([box for box in values.keys() if len(values[box]) == 1])
          # If no new values were added, stop the loop.
          stalled = solved_values_before == solved_values_after
          # Sanity check, return False if there is a box with zero available values:
          if len([box for box in values.keys() if len(values[box]) == 0]):
              return False
      return values
  
  
  def search(values):
      """Apply depth first search to solve Sudoku puzzles in order to solve puzzles
      that cannot be solved by repeated reduction alone.
  
      Parameters
      ----------
      values(dict)
          a dictionary of the form {'box_name': '123456789', ...}
  
      Returns
      -------
      dict or False
          The values dictionary with all boxes assigned or False
  
      Notes
      -----
      You should be able to complete this function by copying your code from the classroom
      and extending it to call the naked twins strategy.
      """
      # TODO: Copy your code from the classroom to complete this function
      values = reduce_puzzle(values)
      if values is False: # dict empty
          return False 
      
      if all(len(values[s]) == 1 for s in boxes): # sudoku solved
          return values
      # Choose one of the unfilled squares with the fewest possibilities
      box, pos = min((len(values[pos]), pos) for pos in boxes if len(values[pos])>1)
  
      # Now use recursion to solve each one of the resulting sudokus, 
      # if one returns a value (not False), return that answer!
      for value in values[pos]:
          new_sudoku = values.copy()
          new_sudoku[pos] = value
          attempt = search(new_sudoku)
          if attempt:
              return attempt
  
  
  def solve(grid):
      """Find the solution to a Sudoku puzzle using search and constraint propagation
  
      Parameters
      ----------
      grid(string)
          a string representing a sudoku grid.
          
          Ex. '2.............62....1....7...6..8...3...9...7...6..4...4....8....52.............3'
  
      Returns
      -------
      dict or False
          The dictionary representation of the final sudoku grid or False if no solution exists.
      """
      values = grid2values(grid)
      values = search(values)
      return values
  
  
  if __name__ == "__main__":
      diag_sudoku_grid = '2.............62....1....7...6..8...3...9...7...6..4...4....8....52.............3'
      display(grid2values(diag_sudoku_grid))
      result = solve(diag_sudoku_grid)
      display(result)
  
      try:
          import PySudoku
          PySudoku.play(grid2values(diag_sudoku_grid), result, history)
  
      except SystemExit:
          pass
      except:
          print('We could not visualize your board due to a pygame issue. Not a problem! It is not a requirement.')
  