Link's awakening, Color Dungeon, Room 18 puzzle solver (brute force)

Links awakening color dungeon room 18 puzzle solver.swift

import Foundation

enum SwitchState: Int, Equatable {
	case on = 1, off = 0
	
	mutating func toggle() {
		switch self {
		case .on: self = .off
		case .off: self = .on
		}
	}
}

extension Array {
	subscript(safe index: Int) -> Element? {
		get {
			guard self.indices.contains(index) else { return nil }
			return self[index]
		} set {
			guard self.indices.contains(index), let newValue = newValue else { return }
			self[index] = newValue
		}
	}
}

struct Solver {
	
	static var bestIterations = Int.max
	
	var matrix: [[SwitchState]] = [
		[.on, .off, .on],
		[.off, .on, .off],
		[.on, .off, .on]
	]
	
	var history: [(row: Int, column: Int)] = []
	
	mutating func permute(row: Int, column: Int) {
		guard matrix[safe: row]?[safe: column] != nil else { return }
		
		// toggle self
		matrix[safe: row]?[safe: column]?.toggle()
		
		// toggle adjacents
		matrix[safe: row - 1]?[safe: column]?.toggle()
		matrix[safe: row + 1]?[safe: column]?.toggle()
		matrix[safe: row]?[safe: column - 1]?.toggle()
		matrix[safe: row]?[safe: column + 1]?.toggle()
		
		// toggle non-adjacents
		matrix[safe: row - 1]?[safe: column - 1]?.toggle()
		matrix[safe: row - 1]?[safe: column + 1]?.toggle()
		matrix[safe: row + 1]?[safe: column - 1]?.toggle()
		matrix[safe: row + 1]?[safe: column + 1]?.toggle()
	}
	
	var isSolved: Bool {
		return matrix.flatMap{$0}.firstIndex { $0 == .off } == nil
	}
	
	func printMatrix() {
		for row in matrix {
			for column in row {
				print(column.rawValue, " ", terminator: "")
			}
			print()
		}
		print()
	}
	
	mutating func bruteForceSolve() {
		var iterations = 0
		
		while !isSolved {
			let randomRow = Int.random(in: 0...2)
			let randomColumn = Int.random(in: 0...2)
			history.append((randomRow, randomColumn))
			permute(row: randomRow, column: randomColumn)

			iterations += 1
		}
		
		Solver.bestIterations = iterations
	}
}

//

var solver = Solver()

while Solver.bestIterations > 4 {
	solver = Solver()
	solver.bruteForceSolve()
}

print()
print(Solver.bestIterations)

solver.printMatrix()
print(solver.history) // solution