Exercises 5.2 finished

Author: antoniolopez7217

part5/2. References/items_multiplied_by_two.py

@@ -0,0 +1,22 @@
+# Please write a function named double_items(numbers: list), which takes a list of integers as its argument.
+
+# The function should return a new list, which contains all values from the original list doubled. 
+# The function should not change the original list.
+
+# An example of the function at work:
+
+# if __name__ == "__main__":
+#     numbers = [2, 4, 5, 3, 11, -4]
+#     numbers_doubled = double_items(numbers)
+#     print("original:", numbers)
+#     print("doubled:", numbers_doubled)
+
+# original: [2, 4, 5, 3, 11, -4]
+# doubled: [4, 8, 10, 6, 22, -8]
+
+def double_items(numbers: list):
+    new_list = []
+    for i in range(len(numbers)):
+        new_list.append(numbers[i] * 2)
+    return new_list
+

part5/2. References/remove_smallest.py

@@ -0,0 +1,22 @@
+# Please write a function named remove_smallest(numbers: list), which takes a list of integers as its argument.
+
+# The functions should find and remove the smallest item in the list. 
+# You may assume there is a single smallest item in the list.
+
+# The function should not have a return value - it should directly modify the list it receives as a parameter.
+
+# An example of how the function works:
+
+# if __name__ == "__main__":
+#     numbers = [2, 4, 6, 1, 3, 5]
+#     remove_smallest(numbers)
+#     print(numbers)
+
+# [2, 4, 6, 3, 5]
+
+def remove_smallest(numbers: list):
+    small = numbers[0]
+    for item in numbers:
+        if item < small:
+            small = item
+    numbers.remove(small)

part5/2. References/sudoku_add_to_copy.py

@@ -0,0 +1,67 @@
+# This is the very last sudoku task. 
+# This time we will create a slightly different version of the function for adding new numbers to the grid.
+
+# The function copy_and_add(sudoku: list, row_no: int, column_no: int, number: int) takes a two-dimensional 
+# array representing a sudoku grid, two integers referring to the row and column indexes of a single square, and a single digit between 1 and 9, as its arguments. 
+# The function should return a copy of the original grid with the new digit added in the correct location. 
+# The function should not change the original grid received as a parameter.
+
+# The print_sudoku function from the previous exercise could be useful for testing, and it is used in the example below:
+
+# sudoku  = [
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0]
+# ]
+
+# grid_copy = copy_and_add(sudoku, 0, 0, 2)
+# print("Original:")
+# print_sudoku(sudoku)
+# print()
+# print("Copy:")
+# print_sudoku(grid_copy)
+
+# Original:
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+
+# Copy:
+# 2 _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+
+# Hint When dealing with nested lists you should be extra careful when copying. 
+# What all needs to be explicitly copied, and where do changes actually have an effect? 
+# The visualisation tool is a great help here, too, although the size of the sudoku grid will make the view less orderly than usual.
+
+def copy_and_add(sudoku: list, row_no: int, column_no: int, number: int):
+	new_sudoku = []
+	for i in range(len(sudoku)):
+		row = sudoku[i][:]
+		new_sudoku.append(row)
+	new_sudoku[row_no][column_no] = number
+	return new_sudoku
+

part5/2. References/sudoku_print_and_add.py

@@ -0,0 +1,89 @@
+# In this exercise we will complete two more functions for the sudoku project from the previous section: print_sudoku and add_number.
+
+# The function print_sudoku(sudoku: list) takes a two-dimensional array representing a sudoku grid as its argument. 
+# The function should print out the grid in the format specified in the examples below.
+
+# The function add_number(sudoku: list, row_no: int, column_no: int, number:int) takes a two-dimensional array representing a sudoku grid, 
+# two integers referring to the row and column indexes of a single square, and a single digit between 1 and 9, as its arguments. 
+# The function should add the digit to the specified location in the grid.
+
+# sudoku  = [
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
+#     [0, 0, 0, 0, 0, 0, 0, 0, 0]
+# ]
+
+# print_sudoku(sudoku)
+# add_number(sudoku, 0, 0, 2)
+# add_number(sudoku, 1, 2, 7)
+# add_number(sudoku, 5, 7, 3)
+# print()
+# print("Three numbers added:")
+# print()
+# print_sudoku(sudoku)
+
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+
+# Three numbers added:
+
+# 2 _ _  _ _ _  _ _ _
+# _ _ 7  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ 3 _
+
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+# _ _ _  _ _ _  _ _ _
+
+# Hint
+
+# Remember it is possible to call the print function without causing a line change:
+
+# print("characters ", end="")
+# print("without carriage returns", end="")
+
+# characters without carriage returns
+
+# Sometimes you need just a new line, which a print statement without any argument will achieve:
+
+# print()
+
+def print_sudoku(sudoku: list):
+	row_count = 1
+	for row in sudoku:
+		col_count = 1
+		for item in row:
+			if item == 0:
+				print("_ ", end="")
+			else:
+				print(f"{item} ", end="")
+			if col_count == 3 or col_count == 6:
+				print(" ", end="")
+			col_count += 1
+		if row_count == 3 or row_count == 6:
+			print()
+		row_count += 1
+		print()
+
+def add_number(sudoku: list, row_no: int, column_no: int, number:int):
+	sudoku[row_no][column_no] = number
+

part5/2. References/tic_tac_toe.py

@@ -0,0 +1,35 @@
+# Tic-Tac-Toe is played on a 3 by 3 grid, by two players who take turns inputting noughts and crosses. 
+# If either player succeeds in placing three of their own symbols on any row, column or diagonal, they win. 
+# If neither player manages this, it is a draw.
+
+# Please write a function named play_turn(game_board: list, x: int, y: int, piece: str), which places the given symbol at the given coordinates on the board. 
+# The values of the coordinates on the board are between 0 and 2.
+
+# NB: when compared to the sudoku exercises, the arguments the function takes are the other way around here. 
+# The column x comes first, and the row y second.
+
+# The board consists of the following strings:
+
+# "": empty square
+# "X": player 1 symbol
+# "O": player 2 symbol
+# The function should return True if the square was empty and the symbol was successfully placed on the game board. 
+# The function should return False if the square was occupied, or if the coordinates weren't valid.
+
+# An example execution of the function:
+
+# game_board = [["", "", ""], ["", "", ""], ["", "", ""]]
+# print(play_turn(game_board, 2, 0, "X"))
+# print(game_board)
+
+# True
+# [['', '', 'X'], ['', '', ''], ['', '', '']]
+
+def play_turn(game_board: list, x: int, y: int, piece: str):
+	for row in range(len(game_board)):
+		for col in range(3):
+			if x == col and y == row and game_board[y][x] == "":
+				game_board[y][x] = piece
+				return True
+	return False
+

part5/2. References/transpose_matrix.py

@@ -0,0 +1,28 @@
+# Please write a function named transpose(matrix: list), which takes a two-dimensional integer array, i.e., a matrix, as its argument. 
+# The function should transpose the matrix. Transposing means essentially flipping the matrix over its diagonal: columns become rows, and rows become columns.
+
+# You may assume the matrix is a square matrix, so it will have an equal number of rows and columns.
+
+# The following matrix
+
+# 1 2 3
+# 4 5 6
+# 7 8 9
+
+# transposed looks like this:
+
+# 1 4 7
+# 2 5 8
+# 3 6 9
+
+# The function should not have a return value. 
+# The matrix should be modified directly through the reference.
+
+def transpose(matrix: list):
+	copy_matrix = []
+	for row in matrix:
+		copy_matrix.append(row[:])
+	print(copy_matrix)
+	for row in range(len(copy_matrix)):
+		for col in range(len(copy_matrix[0])):
+			matrix[col][row] = copy_matrix[row][col]