From 51f5d6d77d0dc4ce7db796bf2f83e0e469d3d25e Mon Sep 17 00:00:00 2001
From: Sacha Ligthert <sacha@ligthert.net>
Date: Mon, 27 Jan 2025 20:46:38 +0100
Subject: [PATCH 1/8] Quick cleanup

---
 README.md  | 41 +++++++++++++++++++++++-
 unused.txt | 94 ------------------------------------------------------
 2 files changed, 40 insertions(+), 95 deletions(-)
 delete mode 100644 unused.txt

diff --git a/README.md b/README.md
index d3964f8..4f02ae4 100644
--- a/README.md
+++ b/README.md
@@ -94,5 +94,44 @@ Solution #1:
 283597416
 ```
 
-# Caveats
+## Caveats
 While this may very well solve all possible Sudoku puzzles (including the one [designed against brute force algorithms](https://en.wikipedia.org/wiki/Sudoku_solving_algorithms)), the blanks in the puzzle, the harder it is, the more possible solutions there are, the more solutions it needs to parse, the longer it takes. As this is a computational heavy program, the more CPU you throw against it the faster it will solve issues.
+
+## Generating your own blocks
+To generate your own blocks, you could use the following code:
+```go
+func (solver *Solver) generate_blocks() []int {
+
+	var blocks []int
+	decvals := [9]int{49, 50, 51, 52, 53, 54, 55, 56, 57}
+
+	for counter := 123456789; counter <= 987654321; counter++ {
+
+		// Convert number to string ([]byte)
+		digits := strconv.Itoa(counter)
+
+		// Check if every number is only represented only once
+		var valid bool
+		valid = true
+		for decval := range decvals {
+			var count int
+			for digit := range digits {
+				if digits[digit] == byte(decvals[decval]) {
+					count = count + 1
+				}
+			}
+
+			if count != 1 {
+				valid = false
+			}
+		}
+
+		if valid {
+			blocks = append(blocks, counter)
+		}
+	}
+
+	return blocks
+
+}
+```
\ No newline at end of file
diff --git a/unused.txt b/unused.txt
deleted file mode 100644
index 882d598..0000000
--- a/unused.txt
+++ /dev/null
@@ -1,94 +0,0 @@
-// Processing
-func (solver *Solver) routine_row1(index1 int) {
-	for index2 := range solver.row2s {
-		go solver.routine_row2(index1, index2)
-	}
-}
-
-func (solver *Solver) routine_row2(index1 int, index2 int) {
-	for index3 := range solver.row3s {
-		go solver.routine_row3(index1, index2, index3)
-	}
-}
-
-func (solver *Solver) routine_row3(index1 int, index2 int, index3 int) {
-	for index4 := range solver.row4s {
-		go solver.routine_row4(index1, index2, index3, index4)
-	}
-}
-
-func (solver *Solver) routine_row4(index1 int, index2 int, index3 int, index4 int) {
-	for index5 := range solver.row5s {
-		go solver.routine_row5(index1, index2, index3, index4, index5)
-	}
-}
-
-func (solver *Solver) routine_row5(index1 int, index2 int, index3 int, index4 int, index5 int) {
-	for index6 := range solver.row6s {
-		go solver.routine_row6(index1, index2, index3, index4, index5, index6)
-	}
-}
-
-func (solver *Solver) routine_row6(index1 int, index2 int, index3 int, index4 int, index5 int, index6 int) {
-	for index7 := range solver.row7s {
-		go solver.routine_row7(index1, index2, index3, index4, index5, index6, index7)
-	}
-}
-
-func (solver *Solver) routine_row7(index1 int, index2 int, index3 int, index4 int, index5 int, index6 int, index7 int) {
-	for index8 := range solver.row8s {
-		go solver.routine_row8(index1, index2, index3, index4, index5, index6, index7, index8)
-	}
-}
-
-func (solver *Solver) routine_row8(index1 int, index2 int, index3 int, index4 int, index5 int, index6 int, index7 int, index8 int) {
-	for index9 := range solver.row9s {
-		go solver.routine_row9(index1, index2, index3, index4, index5, index6, index7, index8, index9)
-	}
-}
-
-func (solver *Solver) routine_row9(index1 int, index2 int, index3 int, index4 int, index5 int, index6 int, index7 int, index8 int, index9 int) {
-	go solver.routineValidator(index1, index2, index3, index4, index5, index6, index7, index8, index9)
-}
-
-// blocks.go
-func (solver *Solver) generate_blocks() []int {
-
-	var blocks []int
-	decvals := [9]int{49, 50, 51, 52, 53, 54, 55, 56, 57}
-
-	for counter := 123456789; counter <= 987654321; counter++ {
-
-		// Convert number to string ([]byte)
-		digits := strconv.Itoa(counter)
-
-		// Check if every number is only represented only once
-		var valid bool
-		valid = true
-		for decval := range decvals {
-			var count int
-			for digit := range digits {
-				if digits[digit] == byte(decvals[decval]) {
-					count = count + 1
-				}
-			}
-
-			if count != 1 {
-				valid = false
-			}
-		}
-
-		if valid {
-			blocks = append(blocks, counter)
-		}
-	}
-
-	return blocks
-
-}
-
-// stash.go
-func (solver *Solver) print_block(block int) {
-	digits := strconv.Itoa(block)
-	fmt.Printf("%c %c %c\n%c %c %c\n%c %c %c\n\n", digits[0], digits[1], digits[2], digits[3], digits[4], digits[5], digits[6], digits[7], digits[8])
-}
-- 
2.49.0


From 38207ceda37babffbe40b777acbce3a40e9b4223 Mon Sep 17 00:00:00 2001
From: Sacha Ligthert <sacha@ligthert.net>
Date: Mon, 27 Jan 2025 21:47:35 +0100
Subject: [PATCH 2/8] Move solver.Run() into main(). Split flags into its own
 separate interface.

---
 flags/parse.go       | 136 ++++++++++++++++++++++++++++++++++++
 flags/transfer.go    |  19 +++++
 flags/types.go       |  16 +++++
 main.go              |  41 ++++++++++-
 solver/blocks.go     |   2 +-
 solver/flags.go      | 163 -------------------------------------------
 solver/printers.go   |   2 +-
 solver/processing.go |  43 ++++++------
 solver/solver.go     |  44 ------------
 solver/split.go      |  16 ++---
 solver/types.go      |  26 +++----
 11 files changed, 256 insertions(+), 252 deletions(-)
 create mode 100644 flags/parse.go
 create mode 100644 flags/transfer.go
 create mode 100644 flags/types.go
 delete mode 100644 solver/flags.go
 delete mode 100644 solver/solver.go

diff --git a/flags/parse.go b/flags/parse.go
new file mode 100644
index 0000000..991da21
--- /dev/null
+++ b/flags/parse.go
@@ -0,0 +1,136 @@
+package flags
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"runtime"
+)
+
+func (flags *Flags) ParseFlags() {
+
+	// Define parameters
+	flag.StringVar(&flags.Row1, "row1", "000000000", "1st row of the sudoku puzzle.")
+	flag.StringVar(&flags.Row2, "row2", "000000000", "2nd row of the sudoku puzzle.")
+	flag.StringVar(&flags.Row3, "row3", "000000000", "4rd row of the sudoku puzzle.")
+	flag.StringVar(&flags.Row4, "row4", "000000000", "4th row of the sudoku puzzle.")
+	flag.StringVar(&flags.Row5, "row5", "000000000", "5th row of the sudoku puzzle.")
+	flag.StringVar(&flags.Row6, "row6", "000000000", "6th row of the sudoku puzzle.")
+	flag.StringVar(&flags.Row7, "row7", "000000000", "7th row of the sudoku puzzle.")
+	flag.StringVar(&flags.Row8, "row8", "000000000", "8th row of the sudoku puzzle.")
+	flag.StringVar(&flags.Row9, "row9", "000000000", "9th row of the sudoku puzzle.")
+	flag.IntVar(&flags.NumCPUs, "numcpu", runtime.NumCPU(), "Number of CPU cores to assign to this task.")
+	flag.IntVar(&flags.Split, "split", 1, "Split the tasks in n parts. This depends on the availability of the first row.")
+	flag.IntVar(&flags.Part, "part", 1, "Process part x in n parts. Cannot be lower than 1, or higher than specified in split.")
+
+	// Parse the flags
+	flag.Parse()
+
+	// Process any changes to the CPU usage.
+	if flags.NumCPUs <= 0 {
+		log.Printf("ERROR: Number of CPU cores must be 1 or higher.\n\n")
+		flags.printUsage()
+		os.Exit(1)
+	}
+
+	if flags.NumCPUs != runtime.NumCPU() {
+		runtime.GOMAXPROCS(flags.NumCPUs)
+	}
+
+	// Process rows
+	if flags.Row1 == "000000000" || flags.Row2 == "000000000" || flags.Row3 == "000000000" || flags.Row4 == "000000000" || flags.Row5 == "000000000" || flags.Row6 == "000000000" || flags.Row7 == "000000000" || flags.Row8 == "000000000" || flags.Row9 == "000000000" {
+		log.Printf("ERROR: All parameters must be entered.\n\n")
+		flags.printUsage()
+		os.Exit(1)
+	}
+
+	// Validate the row (never trust user input)
+	flags.validateRow("row1", flags.Row1)
+	flags.validateRow("row2", flags.Row2)
+	flags.validateRow("row3", flags.Row3)
+	flags.validateRow("row4", flags.Row4)
+	flags.validateRow("row5", flags.Row5)
+	flags.validateRow("row6", flags.Row6)
+	flags.validateRow("row7", flags.Row7)
+	flags.validateRow("row8", flags.Row8)
+	flags.validateRow("row9", flags.Row9)
+
+	// Process workload splitting
+	// Ensure split and part are 1 or higher
+	if flags.Split <= 0 || flags.Part <= 0 {
+		log.Printf("ERROR: '-split' and '-part' need to be 1 or higher.\n")
+		flags.printUsage()
+		os.Exit(1)
+	}
+
+	// Ensure part is between 1 and split
+	if flags.Part > flags.Split {
+		log.Printf("ERROR: '-part' cannot be bigger than `-split`.\n")
+		flags.printUsage()
+		os.Exit(1)
+	}
+
+}
+
+func (flags *Flags) validateRow(name string, row string) {
+
+	var found bool
+	var double bool
+	count := make(map[rune]int)
+
+	// 1. Make sure the row is 9 in length
+	if len(row) != 9 {
+		log.Printf("ERROR: Invalid length of %s (%s), must be 9 numbers\n\n", name, row)
+		flags.printUsage()
+		os.Exit(1)
+	}
+
+	// 2. Ensure all digits are numbers
+	for _, value := range row {
+		found = flags.validChar(value)
+	}
+
+	if !found {
+		log.Printf("ERROR: Invalid character of %s (%s), must be 9 numbers\n\n", name, row)
+		flags.printUsage()
+		os.Exit(1)
+	}
+
+	// 3. Ensure all digits (except zero) are there only once
+	for _, digits := range row {
+		count[digits] = count[digits] + 1
+	}
+
+	for key, value := range count {
+		if value > 1 && key != 48 {
+			double = true
+		}
+	}
+
+	if double {
+		log.Printf("ERROR: Double character of %s (%s), numbers between 1 and 9 may only be entered once\n\n", name, row)
+		flags.printUsage()
+		os.Exit(1)
+	}
+
+}
+
+func (flags *Flags) validChar(char rune) (valid bool) {
+	decvals := [10]int{48, 49, 50, 51, 52, 53, 54, 55, 56, 57}
+
+	for _, value := range decvals {
+		if char == rune(value) {
+			valid = true
+		}
+	}
+
+	return
+}
+
+func (flags *Flags) printUsage() {
+	fmt.Fprintf(flag.CommandLine.Output(), "Usage of %s:\n", os.Args[0])
+	fmt.Fprintf(flag.CommandLine.Output(), "\nPut every row of a Sudoku puzzle as paramters.\nUse '0' for what is currently blank in the puzzle you wish to solve.\n\n")
+	fmt.Fprintf(flag.CommandLine.Output(), "Example: %s -row1 ... -row2 ... -row3 ... (etc)\n\n", os.Args[0])
+	flag.PrintDefaults()
+}
diff --git a/flags/transfer.go b/flags/transfer.go
new file mode 100644
index 0000000..d77f8a9
--- /dev/null
+++ b/flags/transfer.go
@@ -0,0 +1,19 @@
+package flags
+
+import "gitea.ligthert.net/golang/sudoku-funpark/solver"
+
+func (flags *Flags) TransferConfig(solver *solver.Solver) {
+	// Parse variables parsed from the flags to solver
+	solver.NumCPUs = flags.NumCPUs
+	solver.Split = flags.Split
+	solver.Part = flags.Part
+	solver.Row1 = flags.Row1
+	solver.Row2 = flags.Row2
+	solver.Row3 = flags.Row3
+	solver.Row4 = flags.Row4
+	solver.Row5 = flags.Row5
+	solver.Row6 = flags.Row6
+	solver.Row7 = flags.Row7
+	solver.Row8 = flags.Row8
+	solver.Row9 = flags.Row9
+}
diff --git a/flags/types.go b/flags/types.go
new file mode 100644
index 0000000..8d03d81
--- /dev/null
+++ b/flags/types.go
@@ -0,0 +1,16 @@
+package flags
+
+type Flags struct {
+	Row1    string
+	Row2    string
+	Row3    string
+	Row4    string
+	Row5    string
+	Row6    string
+	Row7    string
+	Row8    string
+	Row9    string
+	NumCPUs int
+	Split   int
+	Part    int
+}
diff --git a/main.go b/main.go
index 21a09e0..311ecd4 100644
--- a/main.go
+++ b/main.go
@@ -1,10 +1,47 @@
 package main
 
 import (
+	"log"
+	"runtime"
+	"strconv"
+
+	"gitea.ligthert.net/golang/sudoku-funpark/flags"
 	"gitea.ligthert.net/golang/sudoku-funpark/solver"
 )
 
 func main() {
-	// Run the meat of the program
-	solver.Run()
+	// Instantiate the interfaces
+	solver := solver.Solver{}
+	flags := flags.Flags{}
+
+	// Parse and handle flags
+	flags.ParseFlags()
+	flags.TransferConfig(&solver)
+
+	// Report number of CPUs being used, if set.
+	if runtime.NumCPU() != solver.NumCPUs {
+		log.Println("Using " + strconv.Itoa(solver.NumCPUs) + " CPUs, (was " + strconv.Itoa(runtime.NumCPU()) + ")")
+	}
+
+	// Load blocks from CSV file
+	solver.LoadBlocks()
+
+	// Find rows that fit with the entered rows
+	solver.PopulateBlocks()
+
+	// If needed, split the workload
+	// May exit and throw an error if the work load isn't viable
+	if solver.Split != 1 {
+		solver.SelectWorkload()
+	}
+
+	// Print the total number of solutions to validate
+	log.Println("Number of (potential) solutions:", solver.Iter)
+
+	// Check the number of solutions
+	go solver.CheckCombinations()
+	solver.Tracker()
+
+	// Print the valid solutions
+	solver.PrintSolutions()
 }
diff --git a/solver/blocks.go b/solver/blocks.go
index ff06afd..0ac1c83 100644
--- a/solver/blocks.go
+++ b/solver/blocks.go
@@ -13,7 +13,7 @@ import (
 //go:embed blocks.csv
 var f embed.FS
 
-func (solver *Solver) loadBlocks() {
+func (solver *Solver) LoadBlocks() {
 
 	defer solver.timeTrack(time.Now(), "Loaded blocks")
 	log.Println("Loading blocks")
diff --git a/solver/flags.go b/solver/flags.go
deleted file mode 100644
index b929233..0000000
--- a/solver/flags.go
+++ /dev/null
@@ -1,163 +0,0 @@
-package solver
-
-import (
-	"flag"
-	"fmt"
-	"log"
-	"os"
-	"runtime"
-)
-
-func (solver *Solver) parseFlags() {
-
-	// Define variables
-	var row1 string
-	var row2 string
-	var row3 string
-	var row4 string
-	var row5 string
-	var row6 string
-	var row7 string
-	var row8 string
-	var row9 string
-	var split int
-	var part int
-
-	// Define parameters
-	flag.StringVar(&row1, "row1", "000000000", "1st row of the sudoku puzzle.")
-	flag.StringVar(&row2, "row2", "000000000", "2nd row of the sudoku puzzle.")
-	flag.StringVar(&row3, "row3", "000000000", "4rd row of the sudoku puzzle.")
-	flag.StringVar(&row4, "row4", "000000000", "4th row of the sudoku puzzle.")
-	flag.StringVar(&row5, "row5", "000000000", "5th row of the sudoku puzzle.")
-	flag.StringVar(&row6, "row6", "000000000", "6th row of the sudoku puzzle.")
-	flag.StringVar(&row7, "row7", "000000000", "7th row of the sudoku puzzle.")
-	flag.StringVar(&row8, "row8", "000000000", "8th row of the sudoku puzzle.")
-	flag.StringVar(&row9, "row9", "000000000", "9th row of the sudoku puzzle.")
-	flag.IntVar(&solver.numCPUs, "numcpu", runtime.NumCPU(), "Number of CPU cores to assign to this task.")
-	flag.IntVar(&split, "split", 1, "Split the tasks in n parts. This depends on the availability of the first row.")
-	flag.IntVar(&part, "part", 1, "Process part x in n parts. Cannot be lower than 1, or higher than specified in split.")
-
-	// Parse the flags
-	flag.Parse()
-
-	// Process any changes to the CPU usage.
-	if solver.numCPUs <= 0 {
-		log.Printf("ERROR: Number of CPU cores must be 1 or higher.\n\n")
-		solver.printUsage()
-		os.Exit(1)
-	}
-
-	if solver.numCPUs != runtime.NumCPU() {
-		runtime.GOMAXPROCS(solver.numCPUs)
-	}
-
-	// Process rows
-	if row1 == "000000000" || row2 == "000000000" || row3 == "000000000" || row4 == "000000000" || row5 == "000000000" || row6 == "000000000" || row7 == "000000000" || row8 == "000000000" || row9 == "000000000" {
-		log.Printf("ERROR: All parameters must be entered.\n\n")
-		solver.printUsage()
-		os.Exit(1)
-	}
-
-	// Validate the row (never trust user input)
-	solver.validateRow("row1", row1)
-	solver.validateRow("row2", row2)
-	solver.validateRow("row3", row3)
-	solver.validateRow("row4", row4)
-	solver.validateRow("row5", row5)
-	solver.validateRow("row6", row6)
-	solver.validateRow("row7", row7)
-	solver.validateRow("row8", row8)
-	solver.validateRow("row9", row9)
-
-	// Put entries in into the struct
-	solver.row1 = row1
-	solver.row2 = row2
-	solver.row3 = row3
-	solver.row4 = row4
-	solver.row5 = row5
-	solver.row6 = row6
-	solver.row7 = row7
-	solver.row8 = row8
-	solver.row9 = row9
-
-	// Process workload splitting
-	// Ensure split and part are 1 or higher
-	if split <= 0 || part <= 0 {
-		log.Printf("ERROR: '-split' and '-part' need to be 1 or higher.\n")
-		solver.printUsage()
-		os.Exit(1)
-	}
-
-	// Ensure part is between 1 and split
-	if part > split {
-		log.Printf("ERROR: '-part' cannot be bigger than `-split`.\n")
-		solver.printUsage()
-		os.Exit(1)
-	}
-
-	solver.split = split
-	solver.part = part
-
-}
-
-func (solver *Solver) validateRow(name string, row string) {
-
-	var found bool
-	var double bool
-	count := make(map[rune]int)
-
-	// 1. Make sure the row is 9 in length
-	if len(row) != 9 {
-		log.Printf("ERROR: Invalid length of %s (%s), must be 9 numbers\n\n", name, row)
-		solver.printUsage()
-		os.Exit(1)
-	}
-
-	// 2. Ensure all digits are numbers
-	for _, value := range row {
-		found = solver.validChar(value)
-	}
-
-	if !found {
-		log.Printf("ERROR: Invalid character of %s (%s), must be 9 numbers\n\n", name, row)
-		solver.printUsage()
-		os.Exit(1)
-	}
-
-	// 3. Ensure all digits (except zero) are there only once
-	for _, digits := range row {
-		count[digits] = count[digits] + 1
-	}
-
-	for key, value := range count {
-		if value > 1 && key != 48 {
-			double = true
-		}
-	}
-
-	if double {
-		log.Printf("ERROR: Double character of %s (%s), numbers between 1 and 9 may only be entered once\n\n", name, row)
-		solver.printUsage()
-		os.Exit(1)
-	}
-
-}
-
-func (solver *Solver) validChar(char rune) (valid bool) {
-	decvals := [10]int{48, 49, 50, 51, 52, 53, 54, 55, 56, 57}
-
-	for _, value := range decvals {
-		if char == rune(value) {
-			valid = true
-		}
-	}
-
-	return valid
-}
-
-func (solver *Solver) printUsage() {
-	fmt.Fprintf(flag.CommandLine.Output(), "Usage of %s:\n", os.Args[0])
-	fmt.Fprintf(flag.CommandLine.Output(), "\nPut every row of a Sudoku puzzle as paramters.\nUse '0' for what is currently blank in the puzzle you wish to solve.\n\n")
-	fmt.Fprintf(flag.CommandLine.Output(), "Example: %s -row1 ... -row2 ... -row3 ... (etc)\n\n", os.Args[0])
-	flag.PrintDefaults()
-}
diff --git a/solver/printers.go b/solver/printers.go
index 792d266..3764a11 100644
--- a/solver/printers.go
+++ b/solver/printers.go
@@ -5,7 +5,7 @@ import (
 	"log"
 )
 
-func (solver *Solver) printSolutions() {
+func (solver *Solver) PrintSolutions() {
 	for solutionIndex, solution := range solver.solutions {
 		log.Printf("\nSolution #%d:", solutionIndex+1)
 		//fmt.Println(solution)
diff --git a/solver/processing.go b/solver/processing.go
index c61a04d..8c4d162 100644
--- a/solver/processing.go
+++ b/solver/processing.go
@@ -6,23 +6,23 @@ import (
 	"time"
 )
 
-func (solver *Solver) populateBlocks() {
+func (solver *Solver) PopulateBlocks() {
 
 	defer solver.timeTrack(time.Now(), "Populated blocks")
 	log.Println("Populating blocks")
 
-	solver.findBlocks(&solver.row1, &solver.row1s)
-	solver.findBlocks(&solver.row2, &solver.row2s)
-	solver.findBlocks(&solver.row3, &solver.row3s)
-	solver.findBlocks(&solver.row4, &solver.row4s)
-	solver.findBlocks(&solver.row5, &solver.row5s)
-	solver.findBlocks(&solver.row6, &solver.row6s)
-	solver.findBlocks(&solver.row7, &solver.row7s)
-	solver.findBlocks(&solver.row8, &solver.row8s)
-	solver.findBlocks(&solver.row9, &solver.row9s)
+	solver.findBlocks(&solver.Row1, &solver.row1s)
+	solver.findBlocks(&solver.Row2, &solver.row2s)
+	solver.findBlocks(&solver.Row3, &solver.row3s)
+	solver.findBlocks(&solver.Row4, &solver.row4s)
+	solver.findBlocks(&solver.Row5, &solver.row5s)
+	solver.findBlocks(&solver.Row6, &solver.row6s)
+	solver.findBlocks(&solver.Row7, &solver.row7s)
+	solver.findBlocks(&solver.Row8, &solver.row8s)
+	solver.findBlocks(&solver.Row9, &solver.row9s)
 
 	// This calculates and stores the total number of solutions to validate.
-	solver.iter = int64(len(solver.row1s)) * int64(len(solver.row2s)) * int64(len(solver.row3s)) * int64(len(solver.row4s)) * int64(len(solver.row5s)) * int64(len(solver.row6s)) * int64(len(solver.row7s)) * int64(len(solver.row8s)) * int64(len(solver.row9s))
+	solver.Iter = int64(len(solver.row1s)) * int64(len(solver.row2s)) * int64(len(solver.row3s)) * int64(len(solver.row4s)) * int64(len(solver.row5s)) * int64(len(solver.row6s)) * int64(len(solver.row7s)) * int64(len(solver.row8s)) * int64(len(solver.row9s))
 
 }
 
@@ -61,7 +61,7 @@ func (solver *Solver) findBlocks(row *string, rows *[]int) {
 	*rows = selection
 }
 
-func (solver *Solver) checkCombinations() {
+func (solver *Solver) CheckCombinations() {
 	for rows1Index := range solver.row1s {
 		for rows2Index := range solver.row2s {
 			for rows3Index := range solver.row3s {
@@ -94,7 +94,7 @@ func (solver *Solver) routineValidator(rows1Index int, rows2Index int, rows3Inde
 
 }
 
-func (solver *Solver) tracker() {
+func (solver *Solver) Tracker() {
 
 	defer solver.timeTrack(time.Now(), "Validated solutions")
 	log.Println("Validating solutions")
@@ -118,11 +118,14 @@ func (solver *Solver) tracker() {
 	// Estimation how long it will take
 	var est_fin string
 
-	// for solver.iter != solver.counter { // Start for-loop
+	// While not needed for rateDiff anymore, it makes estimation calculations more accurate. ☹️
+	time.Sleep(time.Second)
+
+	// for solver.Iter != solver.counter { // Start for-loop
 	for !done {
 
 		// Determine how far we are.
-		percentage = (float32(solver.counter.Load()) / (float32(solver.iter) / 100))
+		percentage = (float32(solver.counter.Load()) / (float32(solver.Iter) / 100))
 
 		// Reset the loop
 		rateDiff = solver.counter.Load() - rateStart
@@ -130,9 +133,9 @@ func (solver *Solver) tracker() {
 		if track <= int(percentage) || rateDiff == 0 { // Start if-statement
 
 			// Make sure something happened, making rateStart the only reliable variable
-			if solver.iter == solver.counter.Load() {
+			if solver.Iter == solver.counter.Load() {
 				percentage = 100
-				solver.counter.Store(solver.iter)
+				solver.counter.Store(solver.Iter)
 				done = true
 			}
 
@@ -144,7 +147,7 @@ func (solver *Solver) tracker() {
 			if rateDiff == 0 {
 				est_fin = "N/A"
 			} else {
-				duration_int := (solver.iter - solver.counter.Load()) / rate_avg
+				duration_int := (solver.Iter - solver.counter.Load()) / rate_avg
 				duration_string := strconv.Itoa(int(duration_int)) + "s"
 				est, err := time.ParseDuration(duration_string)
 				if err != nil {
@@ -154,7 +157,7 @@ func (solver *Solver) tracker() {
 			}
 
 			// Printing the progress
-			log.Println("Processing: " + strconv.Itoa(int(percentage)) + "% (" + strconv.FormatInt(solver.counter.Load(), 10) + "/" + strconv.Itoa(int(solver.iter)) + "); Rate: " + strconv.FormatInt(rateDiff, 10) + "/sec for " + timer_elapsed.String() + "; Time left (est.): " + est_fin)
+			log.Println("Processing: " + strconv.Itoa(int(percentage)) + "% (" + strconv.FormatInt(solver.counter.Load(), 10) + "/" + strconv.Itoa(int(solver.Iter)) + "); Rate: " + strconv.FormatInt(rateDiff, 10) + "/sec for " + timer_elapsed.String() + "; Time left (est.): " + est_fin)
 
 			// After we are done printing, exit this for-loop
 			if percentage == 100 {
@@ -176,7 +179,7 @@ func (solver *Solver) tracker() {
 		rateStart = solver.counter.Load()
 
 		// Sleep for a second
-		if solver.iter != solver.counter.Load() {
+		if solver.Iter != solver.counter.Load() {
 			time.Sleep(1 * time.Second)
 		}
 	} // End for-loop
diff --git a/solver/solver.go b/solver/solver.go
deleted file mode 100644
index 0751ace..0000000
--- a/solver/solver.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package solver
-
-import (
-	"log"
-	"runtime"
-	"strconv"
-)
-
-// The main loop that orchastrates all the logic.
-func Run() {
-	// Instantiate the Solver interface
-	solver := Solver{}
-
-	// Parse and handle flags
-	solver.parseFlags()
-
-	// Report number of CPUs being used, if set.
-	if runtime.NumCPU() != solver.numCPUs {
-		log.Println("Using " + strconv.Itoa(solver.numCPUs) + " CPUs, (was " + strconv.Itoa(runtime.NumCPU()) + ")")
-	}
-
-	// Load blocks from CSV file
-	solver.loadBlocks()
-
-	// Find rows that fit with the entered rows
-	solver.populateBlocks()
-
-	// If needed, split the workload
-	// May exit and throw an error if the work load isn't viable
-	if solver.split != 1 {
-		solver.selectWorkload()
-	}
-
-	// Print the total number of solutions to validate
-	log.Println("Number of (potential) solutions:", solver.iter)
-
-	// Check the number of solutions
-	go solver.checkCombinations()
-	solver.tracker()
-
-	// Print the valid solutions
-	solver.printSolutions()
-
-}
diff --git a/solver/split.go b/solver/split.go
index ed64993..6189118 100644
--- a/solver/split.go
+++ b/solver/split.go
@@ -10,21 +10,21 @@ import (
 // Perform some checks
 // and
 // Modify solver.row1s so it limits the workload to what is only desired.
-func (solver *Solver) selectWorkload() {
-	if solver.split > len(solver.row1s) {
-		log.Println("ERROR: Unable to divide the workload in " + strconv.Itoa(solver.split) + " parts, when only " + strconv.Itoa(len(solver.row1s)) + " are available.\n\n")
+func (solver *Solver) SelectWorkload() {
+	if solver.Split > len(solver.row1s) {
+		log.Println("ERROR: Unable to divide the workload in " + strconv.Itoa(solver.Split) + " parts, when only " + strconv.Itoa(len(solver.row1s)) + " are available.\n\n")
 		os.Exit(1)
 	}
 	defer solver.timeTrack(time.Now(), "Workload set")
 	log.Println("Setting workload")
-	log.Println("We are agent " + strconv.Itoa(solver.part) + " of " + strconv.Itoa(solver.split))
+	log.Println("We are agent " + strconv.Itoa(solver.Part) + " of " + strconv.Itoa(solver.Split))
 	workloads := solver.splitWorkload()
 	solver.setWorkload(workloads)
 }
 
 // Determine how workload should be split among the agents
 func (solver *Solver) splitWorkload() []int {
-	agents := make([]int, solver.split)
+	agents := make([]int, solver.Split)
 	var tracker int
 	var tasks int = len(solver.row1s)
 
@@ -32,7 +32,7 @@ func (solver *Solver) splitWorkload() []int {
 		agents[tracker] += 1
 		tasks -= 1
 		tracker += 1
-		if tracker == solver.split {
+		if tracker == solver.Split {
 			tracker = 0
 		}
 	}
@@ -45,7 +45,7 @@ func (solver *Solver) setWorkload(agents []int) {
 	var start int = 0
 	var finish int = 0
 	for key, value := range agents {
-		if key == solver.part-1 {
+		if key == solver.Part-1 {
 			finish = start + value
 			break
 		} else {
@@ -57,5 +57,5 @@ func (solver *Solver) setWorkload(agents []int) {
 	solver.row1s = solver.row1s[start:finish]
 
 	// Recalculate how much we need to grind through
-	solver.iter = int64(len(solver.row1s)) * int64(len(solver.row2s)) * int64(len(solver.row3s)) * int64(len(solver.row4s)) * int64(len(solver.row5s)) * int64(len(solver.row6s)) * int64(len(solver.row7s)) * int64(len(solver.row8s)) * int64(len(solver.row9s))
+	solver.Iter = int64(len(solver.row1s)) * int64(len(solver.row2s)) * int64(len(solver.row3s)) * int64(len(solver.row4s)) * int64(len(solver.row5s)) * int64(len(solver.row6s)) * int64(len(solver.row7s)) * int64(len(solver.row8s)) * int64(len(solver.row9s))
 }
diff --git a/solver/types.go b/solver/types.go
index 3b94676..11af96b 100644
--- a/solver/types.go
+++ b/solver/types.go
@@ -7,15 +7,15 @@ import (
 // Struct/Interface containing all the important variabes it functions need access to.
 type Solver struct {
 	blocks    []int
-	row1      string
-	row2      string
-	row3      string
-	row4      string
-	row5      string
-	row6      string
-	row7      string
-	row8      string
-	row9      string
+	Row1      string
+	Row2      string
+	Row3      string
+	Row4      string
+	Row5      string
+	Row6      string
+	Row7      string
+	Row8      string
+	Row9      string
 	row1s     []int
 	row2s     []int
 	row3s     []int
@@ -25,11 +25,11 @@ type Solver struct {
 	row7s     []int
 	row8s     []int
 	row9s     []int
-	iter      int64
+	Iter      int64
 	counter   atomic.Int64
 	solutions []string
 	rates     []int64
-	numCPUs   int
-	split     int
-	part      int
+	NumCPUs   int
+	Split     int
+	Part      int
 }
-- 
2.49.0


From e3be1094ea3962c7608cbbd32a327b8527a08482 Mon Sep 17 00:00:00 2001
From: Sacha Ligthert <sacha@ligthert.net>
Date: Mon, 27 Jan 2025 22:40:13 +0100
Subject: [PATCH 3/8] Little cleanup

---
 solver/processing.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/solver/processing.go b/solver/processing.go
index 8c4d162..d63c4a4 100644
--- a/solver/processing.go
+++ b/solver/processing.go
@@ -71,7 +71,7 @@ func (solver *Solver) CheckCombinations() {
 							for rows7Index := range solver.row7s {
 								for rows8Index := range solver.row8s {
 									for rows9Index := range solver.row9s {
-										go solver.routineValidator(rows1Index, rows2Index, rows3Index, rows4Index, rows5Index, rows6Index, rows7Index, rows8Index, rows9Index)
+										go solver.validator(rows1Index, rows2Index, rows3Index, rows4Index, rows5Index, rows6Index, rows7Index, rows8Index, rows9Index)
 									}
 								}
 							}
@@ -83,9 +83,8 @@ func (solver *Solver) CheckCombinations() {
 	}
 }
 
-func (solver *Solver) routineValidator(rows1Index int, rows2Index int, rows3Index int, rows4Index int, rows5Index int, rows6Index int, rows7Index int, rows8Index int, rows9Index int) {
+func (solver *Solver) validator(rows1Index int, rows2Index int, rows3Index int, rows4Index int, rows5Index int, rows6Index int, rows7Index int, rows8Index int, rows9Index int) {
 
-	// solver.counter = solver.counter + 1
 	solver.counter.Add(1)
 
 	if solver.validateCombination(solver.row1s[rows1Index], solver.row2s[rows2Index], solver.row3s[rows3Index], solver.row4s[rows4Index], solver.row5s[rows5Index], solver.row6s[rows6Index], solver.row7s[rows7Index], solver.row8s[rows8Index], solver.row9s[rows9Index]) {
@@ -96,6 +95,7 @@ func (solver *Solver) routineValidator(rows1Index int, rows2Index int, rows3Inde
 
 func (solver *Solver) Tracker() {
 
+	// Add time tracking
 	defer solver.timeTrack(time.Now(), "Validated solutions")
 	log.Println("Validating solutions")
 
-- 
2.49.0


From 3bcb5b95e71d173b196d66b27997b92dbd0bd840 Mon Sep 17 00:00:00 2001
From: Sacha Ligthert <sacha@ligthert.net>
Date: Mon, 27 Jan 2025 23:14:49 +0100
Subject: [PATCH 4/8] Make the linter happy.

---
 solver/processing.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/solver/processing.go b/solver/processing.go
index d63c4a4..23b771d 100644
--- a/solver/processing.go
+++ b/solver/processing.go
@@ -152,8 +152,9 @@ func (solver *Solver) Tracker() {
 				est, err := time.ParseDuration(duration_string)
 				if err != nil {
 					est_fin = "parse error"
+				} else {
+					est_fin = est.String()
 				}
-				est_fin = est.String()
 			}
 
 			// Printing the progress
-- 
2.49.0


From d8636d07f4f1bea966710be0b77edfb4befbba2c Mon Sep 17 00:00:00 2001
From: Sacha Ligthert <sacha@ligthert.net>
Date: Mon, 27 Jan 2025 23:46:26 +0100
Subject: [PATCH 5/8] Move all variables to the controller interface.

---
 .gitea/workflows/demo.txt |  1 -
 README.md                 |  2 +-
 controller/types.go       | 34 +++++++++++++++++++
 flags/parse.go            | 54 +++++++++++++++---------------
 flags/transfer.go         | 19 -----------
 flags/types.go            | 15 ++-------
 main.go                   | 15 +++++----
 solver/blocks.go          |  2 +-
 solver/printers.go        |  2 +-
 solver/processing.go      | 70 +++++++++++++++++++--------------------
 solver/split.go           | 18 +++++-----
 solver/types.go           | 58 +++++++++++++++++---------------
 12 files changed, 150 insertions(+), 140 deletions(-)
 create mode 100644 controller/types.go
 delete mode 100644 flags/transfer.go

diff --git a/.gitea/workflows/demo.txt b/.gitea/workflows/demo.txt
index 49db389..c537cc6 100644
--- a/.gitea/workflows/demo.txt
+++ b/.gitea/workflows/demo.txt
@@ -17,4 +17,3 @@ jobs:
         run: |
           ls ${{ gitea.workspace }}
       - run: echo "🍏 This job's status is ${{ job.status }}."
-
diff --git a/README.md b/README.md
index 4f02ae4..d0f47c1 100644
--- a/README.md
+++ b/README.md
@@ -134,4 +134,4 @@ func (solver *Solver) generate_blocks() []int {
 	return blocks
 
 }
-```
\ No newline at end of file
+```
diff --git a/controller/types.go b/controller/types.go
new file mode 100644
index 0000000..340c32c
--- /dev/null
+++ b/controller/types.go
@@ -0,0 +1,34 @@
+package controller
+
+import (
+	"sync/atomic"
+)
+
+type Controller struct {
+	Blocks    []int
+	Row1      string
+	Row2      string
+	Row3      string
+	Row4      string
+	Row5      string
+	Row6      string
+	Row7      string
+	Row8      string
+	Row9      string
+	Row1s     []int
+	Row2s     []int
+	Row3s     []int
+	Row4s     []int
+	Row5s     []int
+	Row6s     []int
+	Row7s     []int
+	Row8s     []int
+	Row9s     []int
+	Iter      int64
+	Counter   atomic.Int64
+	Solutions []string
+	Rates     []int64
+	NumCPUs   int
+	Split     int
+	Part      int
+}
diff --git a/flags/parse.go b/flags/parse.go
index 991da21..d029d90 100644
--- a/flags/parse.go
+++ b/flags/parse.go
@@ -11,61 +11,61 @@ import (
 func (flags *Flags) ParseFlags() {
 
 	// Define parameters
-	flag.StringVar(&flags.Row1, "row1", "000000000", "1st row of the sudoku puzzle.")
-	flag.StringVar(&flags.Row2, "row2", "000000000", "2nd row of the sudoku puzzle.")
-	flag.StringVar(&flags.Row3, "row3", "000000000", "4rd row of the sudoku puzzle.")
-	flag.StringVar(&flags.Row4, "row4", "000000000", "4th row of the sudoku puzzle.")
-	flag.StringVar(&flags.Row5, "row5", "000000000", "5th row of the sudoku puzzle.")
-	flag.StringVar(&flags.Row6, "row6", "000000000", "6th row of the sudoku puzzle.")
-	flag.StringVar(&flags.Row7, "row7", "000000000", "7th row of the sudoku puzzle.")
-	flag.StringVar(&flags.Row8, "row8", "000000000", "8th row of the sudoku puzzle.")
-	flag.StringVar(&flags.Row9, "row9", "000000000", "9th row of the sudoku puzzle.")
-	flag.IntVar(&flags.NumCPUs, "numcpu", runtime.NumCPU(), "Number of CPU cores to assign to this task.")
-	flag.IntVar(&flags.Split, "split", 1, "Split the tasks in n parts. This depends on the availability of the first row.")
-	flag.IntVar(&flags.Part, "part", 1, "Process part x in n parts. Cannot be lower than 1, or higher than specified in split.")
+	flag.StringVar(&flags.Controller.Row1, "row1", "000000000", "1st row of the sudoku puzzle.")
+	flag.StringVar(&flags.Controller.Row2, "row2", "000000000", "2nd row of the sudoku puzzle.")
+	flag.StringVar(&flags.Controller.Row3, "row3", "000000000", "4rd row of the sudoku puzzle.")
+	flag.StringVar(&flags.Controller.Row4, "row4", "000000000", "4th row of the sudoku puzzle.")
+	flag.StringVar(&flags.Controller.Row5, "row5", "000000000", "5th row of the sudoku puzzle.")
+	flag.StringVar(&flags.Controller.Row6, "row6", "000000000", "6th row of the sudoku puzzle.")
+	flag.StringVar(&flags.Controller.Row7, "row7", "000000000", "7th row of the sudoku puzzle.")
+	flag.StringVar(&flags.Controller.Row8, "row8", "000000000", "8th row of the sudoku puzzle.")
+	flag.StringVar(&flags.Controller.Row9, "row9", "000000000", "9th row of the sudoku puzzle.")
+	flag.IntVar(&flags.Controller.NumCPUs, "numcpu", runtime.NumCPU(), "Number of CPU cores to assign to this task.")
+	flag.IntVar(&flags.Controller.Split, "split", 1, "Split the tasks in n parts. This depends on the availability of the first row.")
+	flag.IntVar(&flags.Controller.Part, "part", 1, "Process part x in n parts. Cannot be lower than 1, or higher than specified in split.")
 
 	// Parse the flags
 	flag.Parse()
 
 	// Process any changes to the CPU usage.
-	if flags.NumCPUs <= 0 {
+	if flags.Controller.NumCPUs <= 0 {
 		log.Printf("ERROR: Number of CPU cores must be 1 or higher.\n\n")
 		flags.printUsage()
 		os.Exit(1)
 	}
 
-	if flags.NumCPUs != runtime.NumCPU() {
-		runtime.GOMAXPROCS(flags.NumCPUs)
+	if flags.Controller.NumCPUs != runtime.NumCPU() {
+		runtime.GOMAXPROCS(flags.Controller.NumCPUs)
 	}
 
 	// Process rows
-	if flags.Row1 == "000000000" || flags.Row2 == "000000000" || flags.Row3 == "000000000" || flags.Row4 == "000000000" || flags.Row5 == "000000000" || flags.Row6 == "000000000" || flags.Row7 == "000000000" || flags.Row8 == "000000000" || flags.Row9 == "000000000" {
+	if flags.Controller.Row1 == "000000000" || flags.Controller.Row2 == "000000000" || flags.Controller.Row3 == "000000000" || flags.Controller.Row4 == "000000000" || flags.Controller.Row5 == "000000000" || flags.Controller.Row6 == "000000000" || flags.Controller.Row7 == "000000000" || flags.Controller.Row8 == "000000000" || flags.Controller.Row9 == "000000000" {
 		log.Printf("ERROR: All parameters must be entered.\n\n")
 		flags.printUsage()
 		os.Exit(1)
 	}
 
 	// Validate the row (never trust user input)
-	flags.validateRow("row1", flags.Row1)
-	flags.validateRow("row2", flags.Row2)
-	flags.validateRow("row3", flags.Row3)
-	flags.validateRow("row4", flags.Row4)
-	flags.validateRow("row5", flags.Row5)
-	flags.validateRow("row6", flags.Row6)
-	flags.validateRow("row7", flags.Row7)
-	flags.validateRow("row8", flags.Row8)
-	flags.validateRow("row9", flags.Row9)
+	flags.validateRow("row1", flags.Controller.Row1)
+	flags.validateRow("row2", flags.Controller.Row2)
+	flags.validateRow("row3", flags.Controller.Row3)
+	flags.validateRow("row4", flags.Controller.Row4)
+	flags.validateRow("row5", flags.Controller.Row5)
+	flags.validateRow("row6", flags.Controller.Row6)
+	flags.validateRow("row7", flags.Controller.Row7)
+	flags.validateRow("row8", flags.Controller.Row8)
+	flags.validateRow("row9", flags.Controller.Row9)
 
 	// Process workload splitting
 	// Ensure split and part are 1 or higher
-	if flags.Split <= 0 || flags.Part <= 0 {
+	if flags.Controller.Split <= 0 || flags.Controller.Part <= 0 {
 		log.Printf("ERROR: '-split' and '-part' need to be 1 or higher.\n")
 		flags.printUsage()
 		os.Exit(1)
 	}
 
 	// Ensure part is between 1 and split
-	if flags.Part > flags.Split {
+	if flags.Controller.Part > flags.Controller.Split {
 		log.Printf("ERROR: '-part' cannot be bigger than `-split`.\n")
 		flags.printUsage()
 		os.Exit(1)
diff --git a/flags/transfer.go b/flags/transfer.go
deleted file mode 100644
index d77f8a9..0000000
--- a/flags/transfer.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package flags
-
-import "gitea.ligthert.net/golang/sudoku-funpark/solver"
-
-func (flags *Flags) TransferConfig(solver *solver.Solver) {
-	// Parse variables parsed from the flags to solver
-	solver.NumCPUs = flags.NumCPUs
-	solver.Split = flags.Split
-	solver.Part = flags.Part
-	solver.Row1 = flags.Row1
-	solver.Row2 = flags.Row2
-	solver.Row3 = flags.Row3
-	solver.Row4 = flags.Row4
-	solver.Row5 = flags.Row5
-	solver.Row6 = flags.Row6
-	solver.Row7 = flags.Row7
-	solver.Row8 = flags.Row8
-	solver.Row9 = flags.Row9
-}
diff --git a/flags/types.go b/flags/types.go
index 8d03d81..439a4dc 100644
--- a/flags/types.go
+++ b/flags/types.go
@@ -1,16 +1,7 @@
 package flags
 
+import "gitea.ligthert.net/golang/sudoku-funpark/controller"
+
 type Flags struct {
-	Row1    string
-	Row2    string
-	Row3    string
-	Row4    string
-	Row5    string
-	Row6    string
-	Row7    string
-	Row8    string
-	Row9    string
-	NumCPUs int
-	Split   int
-	Part    int
+	Controller *controller.Controller
 }
diff --git a/main.go b/main.go
index 311ecd4..8c11848 100644
--- a/main.go
+++ b/main.go
@@ -5,22 +5,23 @@ import (
 	"runtime"
 	"strconv"
 
+	"gitea.ligthert.net/golang/sudoku-funpark/controller"
 	"gitea.ligthert.net/golang/sudoku-funpark/flags"
 	"gitea.ligthert.net/golang/sudoku-funpark/solver"
 )
 
 func main() {
 	// Instantiate the interfaces
-	solver := solver.Solver{}
-	flags := flags.Flags{}
+	controller := controller.Controller{}
+	solver := solver.Solver{Controller: &controller}
+	flags := flags.Flags{Controller: &controller}
 
 	// Parse and handle flags
 	flags.ParseFlags()
-	flags.TransferConfig(&solver)
 
 	// Report number of CPUs being used, if set.
-	if runtime.NumCPU() != solver.NumCPUs {
-		log.Println("Using " + strconv.Itoa(solver.NumCPUs) + " CPUs, (was " + strconv.Itoa(runtime.NumCPU()) + ")")
+	if runtime.NumCPU() != controller.NumCPUs {
+		log.Println("Using " + strconv.Itoa(controller.NumCPUs) + " CPUs, (was " + strconv.Itoa(runtime.NumCPU()) + ")")
 	}
 
 	// Load blocks from CSV file
@@ -31,12 +32,12 @@ func main() {
 
 	// If needed, split the workload
 	// May exit and throw an error if the work load isn't viable
-	if solver.Split != 1 {
+	if controller.Split != 1 {
 		solver.SelectWorkload()
 	}
 
 	// Print the total number of solutions to validate
-	log.Println("Number of (potential) solutions:", solver.Iter)
+	log.Println("Number of (potential) solutions:", controller.Iter)
 
 	// Check the number of solutions
 	go solver.CheckCombinations()
diff --git a/solver/blocks.go b/solver/blocks.go
index 0ac1c83..2bfd2ae 100644
--- a/solver/blocks.go
+++ b/solver/blocks.go
@@ -35,6 +35,6 @@ func (solver *Solver) LoadBlocks() {
 		blocks = append(blocks, block)
 	}
 
-	solver.blocks = blocks
+	solver.Controller.Blocks = blocks
 
 }
diff --git a/solver/printers.go b/solver/printers.go
index 3764a11..b9b4f00 100644
--- a/solver/printers.go
+++ b/solver/printers.go
@@ -6,7 +6,7 @@ import (
 )
 
 func (solver *Solver) PrintSolutions() {
-	for solutionIndex, solution := range solver.solutions {
+	for solutionIndex, solution := range solver.Controller.Solutions {
 		log.Printf("\nSolution #%d:", solutionIndex+1)
 		//fmt.Println(solution)
 		fmt.Println("╔═══════════╗")
diff --git a/solver/processing.go b/solver/processing.go
index 23b771d..b55094e 100644
--- a/solver/processing.go
+++ b/solver/processing.go
@@ -11,18 +11,18 @@ func (solver *Solver) PopulateBlocks() {
 	defer solver.timeTrack(time.Now(), "Populated blocks")
 	log.Println("Populating blocks")
 
-	solver.findBlocks(&solver.Row1, &solver.row1s)
-	solver.findBlocks(&solver.Row2, &solver.row2s)
-	solver.findBlocks(&solver.Row3, &solver.row3s)
-	solver.findBlocks(&solver.Row4, &solver.row4s)
-	solver.findBlocks(&solver.Row5, &solver.row5s)
-	solver.findBlocks(&solver.Row6, &solver.row6s)
-	solver.findBlocks(&solver.Row7, &solver.row7s)
-	solver.findBlocks(&solver.Row8, &solver.row8s)
-	solver.findBlocks(&solver.Row9, &solver.row9s)
+	solver.findBlocks(&solver.Controller.Row1, &solver.Controller.Row1s)
+	solver.findBlocks(&solver.Controller.Row2, &solver.Controller.Row2s)
+	solver.findBlocks(&solver.Controller.Row3, &solver.Controller.Row3s)
+	solver.findBlocks(&solver.Controller.Row4, &solver.Controller.Row4s)
+	solver.findBlocks(&solver.Controller.Row5, &solver.Controller.Row5s)
+	solver.findBlocks(&solver.Controller.Row6, &solver.Controller.Row6s)
+	solver.findBlocks(&solver.Controller.Row7, &solver.Controller.Row7s)
+	solver.findBlocks(&solver.Controller.Row8, &solver.Controller.Row8s)
+	solver.findBlocks(&solver.Controller.Row9, &solver.Controller.Row9s)
 
 	// This calculates and stores the total number of solutions to validate.
-	solver.Iter = int64(len(solver.row1s)) * int64(len(solver.row2s)) * int64(len(solver.row3s)) * int64(len(solver.row4s)) * int64(len(solver.row5s)) * int64(len(solver.row6s)) * int64(len(solver.row7s)) * int64(len(solver.row8s)) * int64(len(solver.row9s))
+	solver.Controller.Iter = int64(len(solver.Controller.Row1s)) * int64(len(solver.Controller.Row2s)) * int64(len(solver.Controller.Row3s)) * int64(len(solver.Controller.Row4s)) * int64(len(solver.Controller.Row5s)) * int64(len(solver.Controller.Row6s)) * int64(len(solver.Controller.Row7s)) * int64(len(solver.Controller.Row8s)) * int64(len(solver.Controller.Row9s))
 
 }
 
@@ -35,7 +35,7 @@ func (solver *Solver) findBlocks(row *string, rows *[]int) {
 	for letter := range funcRow {
 
 		if len(selection) == 0 {
-			currBlocks = solver.blocks
+			currBlocks = solver.Controller.Blocks
 		} else {
 			currBlocks = selection
 			selection = nil
@@ -62,15 +62,15 @@ func (solver *Solver) findBlocks(row *string, rows *[]int) {
 }
 
 func (solver *Solver) CheckCombinations() {
-	for rows1Index := range solver.row1s {
-		for rows2Index := range solver.row2s {
-			for rows3Index := range solver.row3s {
-				for rows4Index := range solver.row4s {
-					for rows5Index := range solver.row5s {
-						for rows6Index := range solver.row6s {
-							for rows7Index := range solver.row7s {
-								for rows8Index := range solver.row8s {
-									for rows9Index := range solver.row9s {
+	for rows1Index := range solver.Controller.Row1s {
+		for rows2Index := range solver.Controller.Row2s {
+			for rows3Index := range solver.Controller.Row3s {
+				for rows4Index := range solver.Controller.Row4s {
+					for rows5Index := range solver.Controller.Row5s {
+						for rows6Index := range solver.Controller.Row6s {
+							for rows7Index := range solver.Controller.Row7s {
+								for rows8Index := range solver.Controller.Row8s {
+									for rows9Index := range solver.Controller.Row9s {
 										go solver.validator(rows1Index, rows2Index, rows3Index, rows4Index, rows5Index, rows6Index, rows7Index, rows8Index, rows9Index)
 									}
 								}
@@ -85,10 +85,10 @@ func (solver *Solver) CheckCombinations() {
 
 func (solver *Solver) validator(rows1Index int, rows2Index int, rows3Index int, rows4Index int, rows5Index int, rows6Index int, rows7Index int, rows8Index int, rows9Index int) {
 
-	solver.counter.Add(1)
+	solver.Controller.Counter.Add(1)
 
-	if solver.validateCombination(solver.row1s[rows1Index], solver.row2s[rows2Index], solver.row3s[rows3Index], solver.row4s[rows4Index], solver.row5s[rows5Index], solver.row6s[rows6Index], solver.row7s[rows7Index], solver.row8s[rows8Index], solver.row9s[rows9Index]) {
-		solver.solutions = append(solver.solutions, solver.renderCombination(solver.row1s[rows1Index], solver.row2s[rows2Index], solver.row3s[rows3Index], solver.row4s[rows4Index], solver.row5s[rows5Index], solver.row6s[rows6Index], solver.row7s[rows7Index], solver.row8s[rows8Index], solver.row9s[rows9Index]))
+	if solver.validateCombination(solver.Controller.Row1s[rows1Index], solver.Controller.Row2s[rows2Index], solver.Controller.Row3s[rows3Index], solver.Controller.Row4s[rows4Index], solver.Controller.Row5s[rows5Index], solver.Controller.Row6s[rows6Index], solver.Controller.Row7s[rows7Index], solver.Controller.Row8s[rows8Index], solver.Controller.Row9s[rows9Index]) {
+		solver.Controller.Solutions = append(solver.Controller.Solutions, solver.renderCombination(solver.Controller.Row1s[rows1Index], solver.Controller.Row2s[rows2Index], solver.Controller.Row3s[rows3Index], solver.Controller.Row4s[rows4Index], solver.Controller.Row5s[rows5Index], solver.Controller.Row6s[rows6Index], solver.Controller.Row7s[rows7Index], solver.Controller.Row8s[rows8Index], solver.Controller.Row9s[rows9Index]))
 	}
 
 }
@@ -121,33 +121,33 @@ func (solver *Solver) Tracker() {
 	// While not needed for rateDiff anymore, it makes estimation calculations more accurate. ☹️
 	time.Sleep(time.Second)
 
-	// for solver.Iter != solver.counter { // Start for-loop
+	// for solver.Controller.Iter != solver.Controller.Counter { // Start for-loop
 	for !done {
 
 		// Determine how far we are.
-		percentage = (float32(solver.counter.Load()) / (float32(solver.Iter) / 100))
+		percentage = (float32(solver.Controller.Counter.Load()) / (float32(solver.Controller.Iter) / 100))
 
 		// Reset the loop
-		rateDiff = solver.counter.Load() - rateStart
+		rateDiff = solver.Controller.Counter.Load() - rateStart
 
 		if track <= int(percentage) || rateDiff == 0 { // Start if-statement
 
 			// Make sure something happened, making rateStart the only reliable variable
-			if solver.Iter == solver.counter.Load() {
+			if solver.Controller.Iter == solver.Controller.Counter.Load() {
 				percentage = 100
-				solver.counter.Store(solver.Iter)
+				solver.Controller.Counter.Store(solver.Controller.Iter)
 				done = true
 			}
 
 			timer_elapsed := time.Since(timerStart)
-			solver.rates = append(solver.rates, rateDiff)
+			solver.Controller.Rates = append(solver.Controller.Rates, rateDiff)
 			rate_avg := solver.calcAVG()
 
 			// Estimate when this is finished
 			if rateDiff == 0 {
 				est_fin = "N/A"
 			} else {
-				duration_int := (solver.Iter - solver.counter.Load()) / rate_avg
+				duration_int := (solver.Controller.Iter - solver.Controller.Counter.Load()) / rate_avg
 				duration_string := strconv.Itoa(int(duration_int)) + "s"
 				est, err := time.ParseDuration(duration_string)
 				if err != nil {
@@ -158,7 +158,7 @@ func (solver *Solver) Tracker() {
 			}
 
 			// Printing the progress
-			log.Println("Processing: " + strconv.Itoa(int(percentage)) + "% (" + strconv.FormatInt(solver.counter.Load(), 10) + "/" + strconv.Itoa(int(solver.Iter)) + "); Rate: " + strconv.FormatInt(rateDiff, 10) + "/sec for " + timer_elapsed.String() + "; Time left (est.): " + est_fin)
+			log.Println("Processing: " + strconv.Itoa(int(percentage)) + "% (" + strconv.FormatInt(solver.Controller.Counter.Load(), 10) + "/" + strconv.Itoa(int(solver.Controller.Iter)) + "); Rate: " + strconv.FormatInt(rateDiff, 10) + "/sec for " + timer_elapsed.String() + "; Time left (est.): " + est_fin)
 
 			// After we are done printing, exit this for-loop
 			if percentage == 100 {
@@ -177,10 +177,10 @@ func (solver *Solver) Tracker() {
 		}
 
 		// Resert the rate counter
-		rateStart = solver.counter.Load()
+		rateStart = solver.Controller.Counter.Load()
 
 		// Sleep for a second
-		if solver.Iter != solver.counter.Load() {
+		if solver.Controller.Iter != solver.Controller.Counter.Load() {
 			time.Sleep(1 * time.Second)
 		}
 	} // End for-loop
@@ -245,11 +245,11 @@ func (solver *Solver) validateCombination(row1 int, row2 int, row3 int, row4 int
 func (solver *Solver) calcAVG() (avg int64) {
 	var avgSum int64
 
-	for _, value := range solver.rates {
+	for _, value := range solver.Controller.Rates {
 		avgSum += value
 	}
 
-	avg = avgSum / int64(len(solver.rates))
+	avg = avgSum / int64(len(solver.Controller.Rates))
 
 	return
 }
diff --git a/solver/split.go b/solver/split.go
index 6189118..373f0ac 100644
--- a/solver/split.go
+++ b/solver/split.go
@@ -11,28 +11,28 @@ import (
 // and
 // Modify solver.row1s so it limits the workload to what is only desired.
 func (solver *Solver) SelectWorkload() {
-	if solver.Split > len(solver.row1s) {
-		log.Println("ERROR: Unable to divide the workload in " + strconv.Itoa(solver.Split) + " parts, when only " + strconv.Itoa(len(solver.row1s)) + " are available.\n\n")
+	if solver.Controller.Split > len(solver.Controller.Row1s) {
+		log.Println("ERROR: Unable to divide the workload in " + strconv.Itoa(solver.Controller.Split) + " parts, when only " + strconv.Itoa(len(solver.Controller.Row1s)) + " are available.\n\n")
 		os.Exit(1)
 	}
 	defer solver.timeTrack(time.Now(), "Workload set")
 	log.Println("Setting workload")
-	log.Println("We are agent " + strconv.Itoa(solver.Part) + " of " + strconv.Itoa(solver.Split))
+	log.Println("We are agent " + strconv.Itoa(solver.Controller.Part) + " of " + strconv.Itoa(solver.Controller.Split))
 	workloads := solver.splitWorkload()
 	solver.setWorkload(workloads)
 }
 
 // Determine how workload should be split among the agents
 func (solver *Solver) splitWorkload() []int {
-	agents := make([]int, solver.Split)
+	agents := make([]int, solver.Controller.Split)
 	var tracker int
-	var tasks int = len(solver.row1s)
+	var tasks int = len(solver.Controller.Row1s)
 
 	for tasks != 0 {
 		agents[tracker] += 1
 		tasks -= 1
 		tracker += 1
-		if tracker == solver.Split {
+		if tracker == solver.Controller.Split {
 			tracker = 0
 		}
 	}
@@ -45,7 +45,7 @@ func (solver *Solver) setWorkload(agents []int) {
 	var start int = 0
 	var finish int = 0
 	for key, value := range agents {
-		if key == solver.Part-1 {
+		if key == solver.Controller.Part-1 {
 			finish = start + value
 			break
 		} else {
@@ -54,8 +54,8 @@ func (solver *Solver) setWorkload(agents []int) {
 	}
 
 	// Set the shortened set of instructions
-	solver.row1s = solver.row1s[start:finish]
+	solver.Controller.Row1s = solver.Controller.Row1s[start:finish]
 
 	// Recalculate how much we need to grind through
-	solver.Iter = int64(len(solver.row1s)) * int64(len(solver.row2s)) * int64(len(solver.row3s)) * int64(len(solver.row4s)) * int64(len(solver.row5s)) * int64(len(solver.row6s)) * int64(len(solver.row7s)) * int64(len(solver.row8s)) * int64(len(solver.row9s))
+	solver.Controller.Iter = int64(len(solver.Controller.Row1s)) * int64(len(solver.Controller.Row2s)) * int64(len(solver.Controller.Row3s)) * int64(len(solver.Controller.Row4s)) * int64(len(solver.Controller.Row5s)) * int64(len(solver.Controller.Row6s)) * int64(len(solver.Controller.Row7s)) * int64(len(solver.Controller.Row8s)) * int64(len(solver.Controller.Row9s))
 }
diff --git a/solver/types.go b/solver/types.go
index 11af96b..a793d36 100644
--- a/solver/types.go
+++ b/solver/types.go
@@ -1,35 +1,39 @@
 package solver
 
 import (
-	"sync/atomic"
+	"gitea.ligthert.net/golang/sudoku-funpark/controller"
 )
 
 // Struct/Interface containing all the important variabes it functions need access to.
 type Solver struct {
-	blocks    []int
-	Row1      string
-	Row2      string
-	Row3      string
-	Row4      string
-	Row5      string
-	Row6      string
-	Row7      string
-	Row8      string
-	Row9      string
-	row1s     []int
-	row2s     []int
-	row3s     []int
-	row4s     []int
-	row5s     []int
-	row6s     []int
-	row7s     []int
-	row8s     []int
-	row9s     []int
-	Iter      int64
-	counter   atomic.Int64
-	solutions []string
-	rates     []int64
-	NumCPUs   int
-	Split     int
-	Part      int
+	Controller *controller.Controller
 }
+
+// type Solver struct {
+// 	blocks    []int
+// 	Row1      string
+// 	Row2      string
+// 	Row3      string
+// 	Row4      string
+// 	Row5      string
+// 	Row6      string
+// 	Row7      string
+// 	Row8      string
+// 	Row9      string
+// 	row1s     []int
+// 	row2s     []int
+// 	row3s     []int
+// 	row4s     []int
+// 	row5s     []int
+// 	row6s     []int
+// 	row7s     []int
+// 	row8s     []int
+// 	row9s     []int
+// 	Iter      int64
+// 	counter   atomic.Int64
+// 	solutions []string
+// 	rates     []int64
+// 	NumCPUs   int
+// 	Split     int
+// 	Part      int
+// }
-- 
2.49.0


From d0d15682492769ac06cc2f81b41d88fd7d5bef14 Mon Sep 17 00:00:00 2001
From: Sacha Ligthert <sacha@ligthert.net>
Date: Mon, 27 Jan 2025 23:49:51 +0100
Subject: [PATCH 6/8] Added godoc support to Taskfile

---
 Taskfile.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Taskfile.yml b/Taskfile.yml
index 318fa62..6151ca9 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -38,3 +38,7 @@ tasks:
     cmds:
       - gource --auto-skip-seconds 1 --key -r 60
     silent: true
+  godoc:
+    cmds:
+      - godoc -http=:6060
+    silent: true
-- 
2.49.0


From c819343db0a46ebaf069b7feefa701053fed2614 Mon Sep 17 00:00:00 2001
From: Sacha Ligthert <sacha@ligthert.net>
Date: Mon, 27 Jan 2025 23:55:31 +0100
Subject: [PATCH 7/8] Moved variables used by Solver back to Solver package.

---
 controller/types.go  | 16 -----------
 main.go              |  2 +-
 solver/processing.go | 68 ++++++++++++++++++++++----------------------
 solver/split.go      | 10 +++----
 solver/types.go      | 43 +++++++++-------------------
 5 files changed, 54 insertions(+), 85 deletions(-)

diff --git a/controller/types.go b/controller/types.go
index 340c32c..bca66c2 100644
--- a/controller/types.go
+++ b/controller/types.go
@@ -1,9 +1,5 @@
 package controller
 
-import (
-	"sync/atomic"
-)
-
 type Controller struct {
 	Blocks    []int
 	Row1      string
@@ -15,19 +11,7 @@ type Controller struct {
 	Row7      string
 	Row8      string
 	Row9      string
-	Row1s     []int
-	Row2s     []int
-	Row3s     []int
-	Row4s     []int
-	Row5s     []int
-	Row6s     []int
-	Row7s     []int
-	Row8s     []int
-	Row9s     []int
-	Iter      int64
-	Counter   atomic.Int64
 	Solutions []string
-	Rates     []int64
 	NumCPUs   int
 	Split     int
 	Part      int
diff --git a/main.go b/main.go
index 8c11848..3702a4a 100644
--- a/main.go
+++ b/main.go
@@ -37,7 +37,7 @@ func main() {
 	}
 
 	// Print the total number of solutions to validate
-	log.Println("Number of (potential) solutions:", controller.Iter)
+	log.Println("Number of (potential) solutions:", solver.Iter)
 
 	// Check the number of solutions
 	go solver.CheckCombinations()
diff --git a/solver/processing.go b/solver/processing.go
index b55094e..9f1b0b5 100644
--- a/solver/processing.go
+++ b/solver/processing.go
@@ -11,18 +11,18 @@ func (solver *Solver) PopulateBlocks() {
 	defer solver.timeTrack(time.Now(), "Populated blocks")
 	log.Println("Populating blocks")
 
-	solver.findBlocks(&solver.Controller.Row1, &solver.Controller.Row1s)
-	solver.findBlocks(&solver.Controller.Row2, &solver.Controller.Row2s)
-	solver.findBlocks(&solver.Controller.Row3, &solver.Controller.Row3s)
-	solver.findBlocks(&solver.Controller.Row4, &solver.Controller.Row4s)
-	solver.findBlocks(&solver.Controller.Row5, &solver.Controller.Row5s)
-	solver.findBlocks(&solver.Controller.Row6, &solver.Controller.Row6s)
-	solver.findBlocks(&solver.Controller.Row7, &solver.Controller.Row7s)
-	solver.findBlocks(&solver.Controller.Row8, &solver.Controller.Row8s)
-	solver.findBlocks(&solver.Controller.Row9, &solver.Controller.Row9s)
+	solver.findBlocks(&solver.Controller.Row1, &solver.row1s)
+	solver.findBlocks(&solver.Controller.Row2, &solver.row2s)
+	solver.findBlocks(&solver.Controller.Row3, &solver.row3s)
+	solver.findBlocks(&solver.Controller.Row4, &solver.row4s)
+	solver.findBlocks(&solver.Controller.Row5, &solver.row5s)
+	solver.findBlocks(&solver.Controller.Row6, &solver.row6s)
+	solver.findBlocks(&solver.Controller.Row7, &solver.row7s)
+	solver.findBlocks(&solver.Controller.Row8, &solver.row8s)
+	solver.findBlocks(&solver.Controller.Row9, &solver.row9s)
 
 	// This calculates and stores the total number of solutions to validate.
-	solver.Controller.Iter = int64(len(solver.Controller.Row1s)) * int64(len(solver.Controller.Row2s)) * int64(len(solver.Controller.Row3s)) * int64(len(solver.Controller.Row4s)) * int64(len(solver.Controller.Row5s)) * int64(len(solver.Controller.Row6s)) * int64(len(solver.Controller.Row7s)) * int64(len(solver.Controller.Row8s)) * int64(len(solver.Controller.Row9s))
+	solver.Iter = int64(len(solver.row1s)) * int64(len(solver.row2s)) * int64(len(solver.row3s)) * int64(len(solver.row4s)) * int64(len(solver.row5s)) * int64(len(solver.row6s)) * int64(len(solver.row7s)) * int64(len(solver.row8s)) * int64(len(solver.row9s))
 
 }
 
@@ -62,15 +62,15 @@ func (solver *Solver) findBlocks(row *string, rows *[]int) {
 }
 
 func (solver *Solver) CheckCombinations() {
-	for rows1Index := range solver.Controller.Row1s {
-		for rows2Index := range solver.Controller.Row2s {
-			for rows3Index := range solver.Controller.Row3s {
-				for rows4Index := range solver.Controller.Row4s {
-					for rows5Index := range solver.Controller.Row5s {
-						for rows6Index := range solver.Controller.Row6s {
-							for rows7Index := range solver.Controller.Row7s {
-								for rows8Index := range solver.Controller.Row8s {
-									for rows9Index := range solver.Controller.Row9s {
+	for rows1Index := range solver.row1s {
+		for rows2Index := range solver.row2s {
+			for rows3Index := range solver.row3s {
+				for rows4Index := range solver.row4s {
+					for rows5Index := range solver.row5s {
+						for rows6Index := range solver.row6s {
+							for rows7Index := range solver.row7s {
+								for rows8Index := range solver.row8s {
+									for rows9Index := range solver.row9s {
 										go solver.validator(rows1Index, rows2Index, rows3Index, rows4Index, rows5Index, rows6Index, rows7Index, rows8Index, rows9Index)
 									}
 								}
@@ -85,10 +85,10 @@ func (solver *Solver) CheckCombinations() {
 
 func (solver *Solver) validator(rows1Index int, rows2Index int, rows3Index int, rows4Index int, rows5Index int, rows6Index int, rows7Index int, rows8Index int, rows9Index int) {
 
-	solver.Controller.Counter.Add(1)
+	solver.counter.Add(1)
 
-	if solver.validateCombination(solver.Controller.Row1s[rows1Index], solver.Controller.Row2s[rows2Index], solver.Controller.Row3s[rows3Index], solver.Controller.Row4s[rows4Index], solver.Controller.Row5s[rows5Index], solver.Controller.Row6s[rows6Index], solver.Controller.Row7s[rows7Index], solver.Controller.Row8s[rows8Index], solver.Controller.Row9s[rows9Index]) {
-		solver.Controller.Solutions = append(solver.Controller.Solutions, solver.renderCombination(solver.Controller.Row1s[rows1Index], solver.Controller.Row2s[rows2Index], solver.Controller.Row3s[rows3Index], solver.Controller.Row4s[rows4Index], solver.Controller.Row5s[rows5Index], solver.Controller.Row6s[rows6Index], solver.Controller.Row7s[rows7Index], solver.Controller.Row8s[rows8Index], solver.Controller.Row9s[rows9Index]))
+	if solver.validateCombination(solver.row1s[rows1Index], solver.row2s[rows2Index], solver.row3s[rows3Index], solver.row4s[rows4Index], solver.row5s[rows5Index], solver.row6s[rows6Index], solver.row7s[rows7Index], solver.row8s[rows8Index], solver.row9s[rows9Index]) {
+		solver.Controller.Solutions = append(solver.Controller.Solutions, solver.renderCombination(solver.row1s[rows1Index], solver.row2s[rows2Index], solver.row3s[rows3Index], solver.row4s[rows4Index], solver.row5s[rows5Index], solver.row6s[rows6Index], solver.row7s[rows7Index], solver.row8s[rows8Index], solver.row9s[rows9Index]))
 	}
 
 }
@@ -121,33 +121,33 @@ func (solver *Solver) Tracker() {
 	// While not needed for rateDiff anymore, it makes estimation calculations more accurate. ☹️
 	time.Sleep(time.Second)
 
-	// for solver.Controller.Iter != solver.Controller.Counter { // Start for-loop
+	// for solver.Iter != solver.counter { // Start for-loop
 	for !done {
 
 		// Determine how far we are.
-		percentage = (float32(solver.Controller.Counter.Load()) / (float32(solver.Controller.Iter) / 100))
+		percentage = (float32(solver.counter.Load()) / (float32(solver.Iter) / 100))
 
 		// Reset the loop
-		rateDiff = solver.Controller.Counter.Load() - rateStart
+		rateDiff = solver.counter.Load() - rateStart
 
 		if track <= int(percentage) || rateDiff == 0 { // Start if-statement
 
 			// Make sure something happened, making rateStart the only reliable variable
-			if solver.Controller.Iter == solver.Controller.Counter.Load() {
+			if solver.Iter == solver.counter.Load() {
 				percentage = 100
-				solver.Controller.Counter.Store(solver.Controller.Iter)
+				solver.counter.Store(solver.Iter)
 				done = true
 			}
 
 			timer_elapsed := time.Since(timerStart)
-			solver.Controller.Rates = append(solver.Controller.Rates, rateDiff)
+			solver.rates = append(solver.rates, rateDiff)
 			rate_avg := solver.calcAVG()
 
 			// Estimate when this is finished
 			if rateDiff == 0 {
 				est_fin = "N/A"
 			} else {
-				duration_int := (solver.Controller.Iter - solver.Controller.Counter.Load()) / rate_avg
+				duration_int := (solver.Iter - solver.counter.Load()) / rate_avg
 				duration_string := strconv.Itoa(int(duration_int)) + "s"
 				est, err := time.ParseDuration(duration_string)
 				if err != nil {
@@ -158,7 +158,7 @@ func (solver *Solver) Tracker() {
 			}
 
 			// Printing the progress
-			log.Println("Processing: " + strconv.Itoa(int(percentage)) + "% (" + strconv.FormatInt(solver.Controller.Counter.Load(), 10) + "/" + strconv.Itoa(int(solver.Controller.Iter)) + "); Rate: " + strconv.FormatInt(rateDiff, 10) + "/sec for " + timer_elapsed.String() + "; Time left (est.): " + est_fin)
+			log.Println("Processing: " + strconv.Itoa(int(percentage)) + "% (" + strconv.FormatInt(solver.counter.Load(), 10) + "/" + strconv.Itoa(int(solver.Iter)) + "); Rate: " + strconv.FormatInt(rateDiff, 10) + "/sec for " + timer_elapsed.String() + "; Time left (est.): " + est_fin)
 
 			// After we are done printing, exit this for-loop
 			if percentage == 100 {
@@ -177,10 +177,10 @@ func (solver *Solver) Tracker() {
 		}
 
 		// Resert the rate counter
-		rateStart = solver.Controller.Counter.Load()
+		rateStart = solver.counter.Load()
 
 		// Sleep for a second
-		if solver.Controller.Iter != solver.Controller.Counter.Load() {
+		if solver.Iter != solver.counter.Load() {
 			time.Sleep(1 * time.Second)
 		}
 	} // End for-loop
@@ -245,11 +245,11 @@ func (solver *Solver) validateCombination(row1 int, row2 int, row3 int, row4 int
 func (solver *Solver) calcAVG() (avg int64) {
 	var avgSum int64
 
-	for _, value := range solver.Controller.Rates {
+	for _, value := range solver.rates {
 		avgSum += value
 	}
 
-	avg = avgSum / int64(len(solver.Controller.Rates))
+	avg = avgSum / int64(len(solver.rates))
 
 	return
 }
diff --git a/solver/split.go b/solver/split.go
index 373f0ac..0f59bbb 100644
--- a/solver/split.go
+++ b/solver/split.go
@@ -11,8 +11,8 @@ import (
 // and
 // Modify solver.row1s so it limits the workload to what is only desired.
 func (solver *Solver) SelectWorkload() {
-	if solver.Controller.Split > len(solver.Controller.Row1s) {
-		log.Println("ERROR: Unable to divide the workload in " + strconv.Itoa(solver.Controller.Split) + " parts, when only " + strconv.Itoa(len(solver.Controller.Row1s)) + " are available.\n\n")
+	if solver.Controller.Split > len(solver.row1s) {
+		log.Println("ERROR: Unable to divide the workload in " + strconv.Itoa(solver.Controller.Split) + " parts, when only " + strconv.Itoa(len(solver.row1s)) + " are available.\n\n")
 		os.Exit(1)
 	}
 	defer solver.timeTrack(time.Now(), "Workload set")
@@ -26,7 +26,7 @@ func (solver *Solver) SelectWorkload() {
 func (solver *Solver) splitWorkload() []int {
 	agents := make([]int, solver.Controller.Split)
 	var tracker int
-	var tasks int = len(solver.Controller.Row1s)
+	var tasks int = len(solver.row1s)
 
 	for tasks != 0 {
 		agents[tracker] += 1
@@ -54,8 +54,8 @@ func (solver *Solver) setWorkload(agents []int) {
 	}
 
 	// Set the shortened set of instructions
-	solver.Controller.Row1s = solver.Controller.Row1s[start:finish]
+	solver.row1s = solver.row1s[start:finish]
 
 	// Recalculate how much we need to grind through
-	solver.Controller.Iter = int64(len(solver.Controller.Row1s)) * int64(len(solver.Controller.Row2s)) * int64(len(solver.Controller.Row3s)) * int64(len(solver.Controller.Row4s)) * int64(len(solver.Controller.Row5s)) * int64(len(solver.Controller.Row6s)) * int64(len(solver.Controller.Row7s)) * int64(len(solver.Controller.Row8s)) * int64(len(solver.Controller.Row9s))
+	solver.Iter = int64(len(solver.row1s)) * int64(len(solver.row2s)) * int64(len(solver.row3s)) * int64(len(solver.row4s)) * int64(len(solver.row5s)) * int64(len(solver.row6s)) * int64(len(solver.row7s)) * int64(len(solver.row8s)) * int64(len(solver.row9s))
 }
diff --git a/solver/types.go b/solver/types.go
index a793d36..46dacfa 100644
--- a/solver/types.go
+++ b/solver/types.go
@@ -1,39 +1,24 @@
 package solver
 
 import (
+	"sync/atomic"
+
 	"gitea.ligthert.net/golang/sudoku-funpark/controller"
 )
 
 // Struct/Interface containing all the important variabes it functions need access to.
 type Solver struct {
 	Controller *controller.Controller
+	row1s      []int
+	row2s      []int
+	row3s      []int
+	row4s      []int
+	row5s      []int
+	row6s      []int
+	row7s      []int
+	row8s      []int
+	row9s      []int
+	Iter       int64
+	counter    atomic.Int64
+	rates      []int64
 }
-
-// type Solver struct {
-// 	blocks    []int
-// 	Row1      string
-// 	Row2      string
-// 	Row3      string
-// 	Row4      string
-// 	Row5      string
-// 	Row6      string
-// 	Row7      string
-// 	Row8      string
-// 	Row9      string
-// 	row1s     []int
-// 	row2s     []int
-// 	row3s     []int
-// 	row4s     []int
-// 	row5s     []int
-// 	row6s     []int
-// 	row7s     []int
-// 	row8s     []int
-// 	row9s     []int
-// 	Iter      int64
-// 	counter   atomic.Int64
-// 	solutions []string
-// 	rates     []int64
-// 	NumCPUs   int
-// 	Split     int
-// 	Part      int
-// }
-- 
2.49.0


From 5683b66f1162ad7700aad9768ef24e191d7b4271 Mon Sep 17 00:00:00 2001
From: Sacha Ligthert <sacha@ligthert.net>
Date: Tue, 28 Jan 2025 00:04:11 +0100
Subject: [PATCH 8/8] Move printing of output into its own package.

---
 solver/printers.go => export/human-readable.go | 6 +++---
 export/types.go                                | 7 +++++++
 main.go                                        | 4 +++-
 3 files changed, 13 insertions(+), 4 deletions(-)
 rename solver/printers.go => export/human-readable.go (91%)
 create mode 100644 export/types.go

diff --git a/solver/printers.go b/export/human-readable.go
similarity index 91%
rename from solver/printers.go
rename to export/human-readable.go
index b9b4f00..01eb6e6 100644
--- a/solver/printers.go
+++ b/export/human-readable.go
@@ -1,12 +1,12 @@
-package solver
+package export
 
 import (
 	"fmt"
 	"log"
 )
 
-func (solver *Solver) PrintSolutions() {
-	for solutionIndex, solution := range solver.Controller.Solutions {
+func (export *Export) PrintSolutions() {
+	for solutionIndex, solution := range export.Controller.Solutions {
 		log.Printf("\nSolution #%d:", solutionIndex+1)
 		//fmt.Println(solution)
 		fmt.Println("╔═══════════╗")
diff --git a/export/types.go b/export/types.go
new file mode 100644
index 0000000..82d7e2d
--- /dev/null
+++ b/export/types.go
@@ -0,0 +1,7 @@
+package export
+
+import "gitea.ligthert.net/golang/sudoku-funpark/controller"
+
+type Export struct {
+	Controller *controller.Controller
+}
diff --git a/main.go b/main.go
index 3702a4a..9cfcfc5 100644
--- a/main.go
+++ b/main.go
@@ -6,6 +6,7 @@ import (
 	"strconv"
 
 	"gitea.ligthert.net/golang/sudoku-funpark/controller"
+	"gitea.ligthert.net/golang/sudoku-funpark/export"
 	"gitea.ligthert.net/golang/sudoku-funpark/flags"
 	"gitea.ligthert.net/golang/sudoku-funpark/solver"
 )
@@ -15,6 +16,7 @@ func main() {
 	controller := controller.Controller{}
 	solver := solver.Solver{Controller: &controller}
 	flags := flags.Flags{Controller: &controller}
+	export := export.Export{Controller: &controller}
 
 	// Parse and handle flags
 	flags.ParseFlags()
@@ -44,5 +46,5 @@ func main() {
 	solver.Tracker()
 
 	// Print the valid solutions
-	solver.PrintSolutions()
+	export.PrintSolutions()
 }
-- 
2.49.0