CodeCup is offering a challenging programming contest. Anybody can participate; there are no age restrictions or other special requirements. The CodeCup never charges entry fees.
The CodeCup 2024 game is based on the puzzle sudoku, where two players take turns placing digits on a 9x9 grid with the aim to claim a unique solution before the other. The unique twist in this version is that each move must decrease the number of possible solutions, adding a strategic layer. If a move results in a puzzle that either becomes unsolvable or does not decrease the solutions as required, the player loses. Players must also be careful when claiming that a sudoku has a unique solution; an incorrect claim results in a loss. The game ends when one player successfully claims a unique solution or an invalid move leads to disqualification.
Alex: "I attempted to participate in the 2024 CodeCup competition using a Python script, which was developed by ChatGPT. The very difficult challenge involves strategically placing numbers in a sudoku grid, where each move needed to decrease the number of possible solutions. The competition's unique rule set required meticulous programming to handle game logic, move validation, and strategy to preemptively claim a unique solution before the opponent."
Concept Python Code Entry
import tkinter as tk
import numpy as np
import sys
class SudokuGUI:
def __init__(self, master):
self.master = master
master.title("Sudoku Solver")
# Setup frames for the input and solution grids
frame_input = tk.Frame(master)
frame_input.grid(row=0, column=0, padx=(20, 10), pady=20)
frame_solution = tk.Frame(master)
frame_solution.grid(row=0, column=1, padx=(10, 20), pady=20)
# Initialize grids and GUI components
self.grid = np.zeros((9, 9), dtype=int)
self.entries = [[tk.Entry(frame_input, width=3, font=('Arial', 18), justify='center') for _ in range(9)] for _ in range(9)]
self.solution_entries = [[tk.Entry(frame_solution, width=3, font=('Arial', 18), justify='center', fg='blue') for _ in range(9)] for _ in range(9)]
# Place entry widgets in the grid
for i in range(9):
for j in range(9):
self.entries[i][j].grid(row=i, column=j, stick="nsew", padx=1, pady=1)
self.solution_entries[i][j].grid(row=i, column=j, stick="nsew", padx=1, pady=1)
# Add solve and clear buttons
solve_button = tk.Button(master, text='Solve', command=self.solve)
solve_button.grid(row=1, column=0, sticky="ew", padx=20, pady=10)
clear_button = tk.Button(master, text='Clear', command=self.clear)
clear_button.grid(row=1, column=1, sticky="ew", padx=20, pady=10)
def solve(self):
for i in range(9):
for j in range(9):
try:
self.grid[i][j] = int(self.entries[i][j].get())
except ValueError:
self.grid[i][j] = 0
if self.backtrack_solve(np.copy(self.grid), count_solutions=True):
self.display_solution(self.grid)
else:
print("No solution exists", file=sys.stderr)
def backtrack_solve(self, grid, count_solutions=False):
if count_solutions:
return self.count_solutions(grid) == 1
find = self.find_empty_location(grid)
if not find:
return True
row, col = find
for num in range(1, 10):
if self.is_safe(grid, row, col, num):
grid[row][col] = num
if self.backtrack_solve(grid):
return True
grid[row][col] = 0
return False
def count_solutions(self, grid, limit=2):
"""Count solutions up to a specified limit."""
find = self.find_empty_location(grid)
if not find:
return 1
row, col = find
solution_count = 0
for num in range(1, 10):
if self.is_safe(grid, row, col, num):
grid[row][col] = num
solution_count += self.count_solutions(grid, limit)
grid[row][col] = 0
if solution_count >= limit:
break # Early exit if we reach the limit
return solution_count
def find_empty_location(self, grid):
return next(((i, j) for i in range(9) for j in range(9) if grid[i][j] == 0), None)
def is_safe(self, grid, row, col, num):
box_x, box_y = (row // 3) * 3, (col // 3) * 3
return all([
num not in grid[row], # Check row
num not in grid[:, col], # Check column
num not in grid[box_x:box_x + 3, box_y:box_y + 3] # Check box
])
def display_solution(self, solved_grid):
for i in range(9):
for j in range(9):
self.solution_entries[i][j].delete(0, tk.END)
self.solution_entries[i][j].insert(0, str(solved_grid[i][j]))
def clear(self):
for i in range(9):
for j in range(9):
self.entries[i][j].delete(0, tk.END)
self.solution_entries[i][j].delete(0, tk.END)
def main():
root = tk.Tk()
app = SudokuGUI(root)
root.mainloop()
if __name__ == "__main__":
main()
๐ This information is free and open-source; anyone can redistribute it and/or modify.