sudoku-funpark/solver/processing.go

package solver

import (
	"fmt"
	"runtime"
	"strconv"
)

func (solver *Solver) find_blocks(row *string, rows *[]int) {
	// Declare selection
	var selection []int
	var curr_blocks []int
	func_row := *row

	// fmt.Println(row)
	for letter := range func_row {

		if len(selection) == 0 {
			curr_blocks = solver.blocks
		} else {
			curr_blocks = selection
			selection = nil
		}

		for block := range curr_blocks {

			curr_row := strconv.Itoa(curr_blocks[block])

			if func_row[letter] == curr_row[letter] {
				found_row, _ := strconv.Atoi(curr_row)
				selection = append(selection, found_row)
			}
			if func_row[letter] == '0' {
				found_row, _ := strconv.Atoi(curr_row)
				selection = append(selection, found_row)
			}

		} // End for-loop

	} // End for-loop

	*rows = selection
}

func (solver *Solver) check_combinations() {
	// for rows1_index := range solver.row1s {
	// 	solver.wg.Add(1)
	// 	go solver.routine_row1(rows1_index)
	// }
	// solver.wg.Wait()

	for rows1_index := range solver.row1s {
		for rows2_index := range solver.row2s {
			for rows3_index := range solver.row3s {
				for rows4_index := range solver.row4s {
					for rows5_index := range solver.row5s {
						for rows6_index := range solver.row6s {
							for rows7_index := range solver.row7s {
								for rows8_index := range solver.row8s {
									defer solver.wg.Done()
									solver.wg.Add(1)
									go solver.routine_row8(rows1_index, rows2_index, rows3_index, rows4_index, rows5_index, rows6_index, rows7_index, rows8_index)
									// for rows9_index := range solver.row9s {
									//   go solver.routine_validator(rows1_index, rows2_index, rows3_index, rows4_index, rows5_index, rows6_index, rows7_index, rows8_index, rows9_index)
									// // }
									// }
								}
							}
						}
					}
				}
			}
		}
	}
}

func (solver *Solver) routine_row1(index1 int) {
	defer solver.wg.Done()
	for index2 := range solver.row2s {
		solver.wg.Add(1)
		go solver.routine_row2(index1, index2)
	}
}

func (solver *Solver) routine_row2(index1 int, index2 int) {
	defer solver.wg.Done()
	for index3 := range solver.row3s {
		solver.wg.Add(1)
		go solver.routine_row3(index1, index2, index3)
	}
}

func (solver *Solver) routine_row3(index1 int, index2 int, index3 int) {
	defer solver.wg.Done()
	for index4 := range solver.row4s {
		solver.wg.Add(1)
		go solver.routine_row4(index1, index2, index3, index4)
	}
}

func (solver *Solver) routine_row4(index1 int, index2 int, index3 int, index4 int) {
	defer solver.wg.Done()
	for index5 := range solver.row5s {
		solver.wg.Add(1)
		go solver.routine_row5(index1, index2, index3, index4, index5)
	}
}

func (solver *Solver) routine_row5(index1 int, index2 int, index3 int, index4 int, index5 int) {
	defer solver.wg.Done()
	for index6 := range solver.row6s {
		solver.wg.Add(1)
		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) {
	defer solver.wg.Done()
	for index7 := range solver.row7s {
		solver.wg.Add(1)
		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) {
	defer solver.wg.Done()
	for index8 := range solver.row8s {
		solver.wg.Add(1)
		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) {
	defer solver.wg.Done()
	for index9 := range solver.row9s {
		solver.wg.Add(1)
		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) {
	defer solver.wg.Done()
	solver.wg.Add(1)
	go solver.routine_validator(index1, index2, index3, index4, index5, index6, index7, index8, index9)
}

func (solver *Solver) routine_validator(rows1_index int, rows2_index int, rows3_index int, rows4_index int, rows5_index int, rows6_index int, rows7_index int, rows8_index int, rows9_index int) {

	var percentage float32

	if solver.validate_combination(solver.row1s[rows1_index], solver.row2s[rows2_index], solver.row3s[rows3_index], solver.row4s[rows4_index], solver.row5s[rows5_index], solver.row6s[rows6_index], solver.row7s[rows7_index], solver.row8s[rows8_index], solver.row9s[rows9_index]) {
		solver.solutions = append(solver.solutions, solver.render_combination(solver.row1s[rows1_index], solver.row2s[rows2_index], solver.row3s[rows3_index], solver.row4s[rows4_index], solver.row5s[rows5_index], solver.row6s[rows6_index], solver.row7s[rows7_index], solver.row8s[rows8_index], solver.row9s[rows9_index]))
	}

	solver.counter = solver.counter + 1

	if solver.counter%1000000 == 0 {
		percentage = (float32(solver.counter) / (float32(solver.iter) / 100))
		fmt.Println("Processing:", percentage, "%; Procs:", runtime.NumGoroutine())
	}

	solver.wg.Done()

}

func (solver *Solver) validate_combination(row1 int, row2 int, row3 int, row4 int, row5 int, row6 int, row7 int, row8 int, row9 int) bool {
	var retval bool
	retval = true

	row1s := strconv.Itoa(row1)
	row2s := strconv.Itoa(row2)
	row3s := strconv.Itoa(row3)
	row4s := strconv.Itoa(row4)
	row5s := strconv.Itoa(row5)
	row6s := strconv.Itoa(row6)
	row7s := strconv.Itoa(row7)
	row8s := strconv.Itoa(row8)
	row9s := strconv.Itoa(row9)

	for index := range 9 {
		if row1s[index] == row2s[index] || row1s[index] == row3s[index] || row1s[index] == row4s[index] || row1s[index] == row5s[index] || row1s[index] == row6s[index] || row1s[index] == row7s[index] || row1s[index] == row8s[index] || row1s[index] == row9s[index] {
			retval = false
		}

		if row2s[index] == row1s[index] || row2s[index] == row3s[index] || row2s[index] == row4s[index] || row2s[index] == row5s[index] || row2s[index] == row6s[index] || row2s[index] == row7s[index] || row2s[index] == row8s[index] || row2s[index] == row9s[index] {
			retval = false
		}

		if row3s[index] == row1s[index] || row3s[index] == row2s[index] || row3s[index] == row4s[index] || row3s[index] == row5s[index] || row3s[index] == row6s[index] || row3s[index] == row7s[index] || row3s[index] == row8s[index] || row3s[index] == row9s[index] {
			retval = false
		}

		if row4s[index] == row1s[index] || row4s[index] == row2s[index] || row4s[index] == row3s[index] || row4s[index] == row5s[index] || row4s[index] == row6s[index] || row4s[index] == row7s[index] || row4s[index] == row8s[index] || row4s[index] == row9s[index] {
			retval = false
		}

		if row5s[index] == row1s[index] || row5s[index] == row2s[index] || row5s[index] == row3s[index] || row5s[index] == row4s[index] || row5s[index] == row6s[index] || row5s[index] == row7s[index] || row5s[index] == row8s[index] || row5s[index] == row9s[index] {
			retval = false
		}

		if row6s[index] == row1s[index] || row6s[index] == row2s[index] || row6s[index] == row3s[index] || row6s[index] == row4s[index] || row6s[index] == row5s[index] || row6s[index] == row7s[index] || row6s[index] == row8s[index] || row6s[index] == row9s[index] {
			retval = false
		}

		if row7s[index] == row1s[index] || row7s[index] == row2s[index] || row7s[index] == row3s[index] || row7s[index] == row4s[index] || row5s[index] == row6s[index] || row7s[index] == row6s[index] || row7s[index] == row8s[index] || row7s[index] == row9s[index] {
			retval = false
		}

		if row8s[index] == row1s[index] || row8s[index] == row2s[index] || row8s[index] == row3s[index] || row8s[index] == row4s[index] || row8s[index] == row5s[index] || row8s[index] == row6s[index] || row8s[index] == row7s[index] || row8s[index] == row9s[index] {
			retval = false
		}

		if row9s[index] == row1s[index] || row9s[index] == row2s[index] || row9s[index] == row3s[index] || row9s[index] == row4s[index] || row9s[index] == row5s[index] || row9s[index] == row6s[index] || row9s[index] == row7s[index] || row9s[index] == row8s[index] {
			retval = false
		}

	}

	return retval
}