From f378c48daf95bdc3a8306f2562f07effa772f3dd Mon Sep 17 00:00:00 2001 From: Abdulaziz Ghuloum Date: Wed, 6 Dec 2006 18:27:16 -0500 Subject: [PATCH] Added Rich Lewis's Sudoku solver and problems. --- lab/sudoku-2.ss | 619 +++++++++++++++++++++++ lab/sudoku-hard.txt | 1140 +++++++++++++++++++++++++++++++++++++++++++ lab/sudoku.txt | 500 +++++++++++++++++++ 3 files changed, 2259 insertions(+) create mode 100644 lab/sudoku-2.ss create mode 100644 lab/sudoku-hard.txt create mode 100644 lab/sudoku.txt diff --git a/lab/sudoku-2.ss b/lab/sudoku-2.ss new file mode 100644 index 0000000..4766c8f --- /dev/null +++ b/lab/sudoku-2.ss @@ -0,0 +1,619 @@ +;;; Rich Lewis +;;; Sudoku Puzzle Solver Version 2.0 + +;;; Hopefully someday, I'll work out a better user interface, but it +;;; serves its purpose for now. Feel free to pass it around to anyone +;;; who is interested in sudoku puzzles and wants a solver written in +;;; scheme. +;;; +;;; Rich Lewis + +;(print-vector-length #f) +(define make-table + (lambda (nr nc init) + (let ([tbl (make-vector nr)]) + (let insert-rows! ([i 0]) + (unless (= i nr) + (vector-set! tbl i (make-vector nc init)) + (insert-rows! (+ i 1)))) + tbl))) + +(define table-set! + (lambda (tbl ri ci x) + (vector-set! (vector-ref tbl ri) ci x))) + +(define table-ref + (lambda (tbl ri ci) + (vector-ref (vector-ref tbl ri) ci))) + +(define make-grid + (lambda () + (let ([grid (make-table 9 9 #f)]) + (let row-loop ([row 0]) + (if (= row 9) + grid + (let col-loop ([col 0]) + (if (= col 9) + (row-loop (+ row 1)) + (begin + (table-set! grid row col (make-vector 9 1)) + (col-loop (+ col 1)))))))))) + +(define grid (make-grid)) + +(define grid-ref + (lambda (x y) + (table-ref grid y x))) + +(define grid-set! + (lambda (x y val) + (table-set! grid y x val))) + +(define reset-row + (lambda (row) + (let loop ([i 0]) + (unless (= i 9) + (grid-set! row i (make-vector 9 1)) + (loop (+ i 1)))))) + +(define reset-grid + (lambda () + (let row-loop ([row 0]) + (unless (= row 9) + (let col-loop ([col 0]) + (if (= col 9) + (row-loop (+ row 1)) + (begin + (grid-set! row col (make-vector 9 1)) + (col-loop (+ col 1))))))))) + +(define input-grid + (lambda () + (printf " Sudoku Puzzle Solver~%~%") + (printf "Starting in the top left-hand corner, input either a 0 for a~%") + (printf "blank space or a number between 1 and 9. Then press enter and~%") + (printf "repeat across the first row. Return to the beginning of the~%") + (printf "next row and input each row until the end. If a number is~%") + (printf "mis-entered, inputing \"s\" will return to the beginning. \"r\" will~%") + (printf "restart the current row and \"q\" will quit the program altogether.~%~%") + (printf "When the last cell (9,9) is entered, the puzzle will automatically~%") + (printf "be solved and the result printed in a simple grid.~%~%") + (let row-loop ([i 0]) + (unless (= i 9) + (let col-loop ([j 0]) + (if (= j 9) + (begin + (newline) + (row-loop (+ i 1))) + (begin + (printf "cell ~a, ~a: " (+ i 1) (+ j 1)) + (let ([c (read)]) + (cond + [(and (number? c) (> c 0) (< c 10)) (begin + (grid-set! i j c) + (col-loop (+ j 1)))] + [(equal? c '0) (begin + (grid-set! i j (make-vector 9 1)) + (col-loop (+ j 1)))] + [(equal? c 'q) (row-loop 9)] + [(equal? c 'r) (begin + (reset-row i) + (col-loop 0))] + [(equal? c 's) (begin + (reset-grid) + (row-loop 0))] + [else (begin + (printf "invalid input ~a~%" c) + (col-loop j))]))))))))) + +(define input-block + (lambda (block) + (unless (= (length block) 10) + (error 'input-block "invalid block")) + (let f ([i 0] [ls (cdr block)]) + (unless (= i 9) + (let ([str (car ls)]) + (unless (and (string? str) (= (string-length str) 9)) + (error 'input-block "invalid string ~s" str)) + (for-each + (lambda (c j) + (grid-set! i j + (case c + [(#\0) (make-vector 9 1)] + [(#\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9) + (- (char->integer c) (char->integer #\0))] + [else (error 'input-block "invalid char ~s" c)]))) + (string->list str) + '(0 1 2 3 4 5 6 7 8))) + (f (add1 i) (cdr ls)))))) + +(define print-sudoku + (lambda () + (printf " column ~%") + (printf " 1 2 3 4 5 6 7 8 9~%") + (newline) + (let row-loop ([row 0]) + (unless (= row 9) + (printf "~a " (+ row 1)) + (let col-loop ([col 0]) + (if (= col 9) + (begin + (newline) + (row-loop (+ row 1))) + (begin + (if (vector? (grid-ref row col)) + (printf " ") + (printf "~a " (grid-ref row col))) + (col-loop (+ col 1))))))))) + +(define sub-grid-list + (lambda (sub) + (case sub + [(0) '(0 2 0 2)] + [(1) '(0 2 3 5)] + [(2) '(0 2 6 8)] + [(3) '(3 5 0 2)] + [(4) '(3 5 3 5)] + [(5) '(3 5 6 8)] + [(6) '(6 8 0 2)] + [(7) '(6 8 3 5)] + [(8) '(6 8 6 8)]))) + +(define sub-grid-list2 + (lambda (row col) + (case row + [(0 1 2) + (case col + [(0 1 2) 0] + [(3 4 5) 1] + [(6 7 8) 2])] + [(3 4 5) + (case col + [(0 1 2) 3] + [(3 4 5) 4] + [(6 7 8) 5])] + [(6 7 8) + (case col + [(0 1 2) 6] + [(3 4 5) 7] + [(6 7 8) 8])]))) + +(define row->vector + (lambda (row) + (let ([vec (make-vector 9 #f)]) + (let loop ([i 0]) + (if (= i 9) + vec + (begin + (vector-set! vec i (grid-ref row i)) + (loop (+ i 1)))))))) + +(define row-init + (lambda (row) + (vector->row (vector-init (row->vector row)) row))) + +(define row-init-all + (lambda () + (let loop ([i 0]) + (unless (= i 9) + (row-init i) + (loop (+ i 1)))))) + +(define col->vector + (lambda (col) + (let ([vec (make-vector 9 #f)]) + (let loop ([i 0]) + (if (= i 9) + vec + (begin + (vector-set! vec i (grid-ref i col)) + (loop (+ i 1)))))))) + +(define col-init + (lambda (col) + (vector->col (vector-init (col->vector col)) col))) + +(define col-init-all + (lambda () + (let loop ([i 0]) + (unless (= i 9) + (col-init i) + (loop (+ i 1)))))) + +(define sub-grid->vector + (lambda (sub-grid) + (let ([sub (sub-grid-list sub-grid)]) + (let ([vec (make-vector 9 #f)] [row1 (car sub)] [row2 (cadr sub)] + [col1 (caddr sub)] [col2 (cadddr sub)]) + (let loop1 ([i row1] [k 0]) + (if (= k 9) + vec + (let loop2 ([j col1] [k k]) + (if (= j (+ col2 1)) + (loop1 (+ i 1) k) + (begin + (vector-set! vec k (grid-ref i j)) + (loop2 (+ j 1) (+ k 1))))))))))) + +(define sub-grid-init + (lambda (sub) + (vector->sub-grid (vector-init (sub-grid->vector sub)) sub))) + +(define sub-grid-init-all + (lambda () + (let loop ([i 0]) + (unless (= i 9) + (sub-grid-init i) + (loop (+ i 1)))))) + +(define vector->row + (lambda (vec row) + (let loop ([i 0]) + (unless (= i 9) + (grid-set! row i (vector-ref vec i)) + (loop (+ i 1)))))) + +(define vector->col + (lambda (vec col) + (let loop ([i 0]) + (unless (= i 9) + (grid-set! i col (vector-ref vec i)) + (loop (+ i 1)))))) + +(define vector->sub-grid + (lambda (vec sub-grid) + (let ([sub (sub-grid-list sub-grid)]) + (let ([row1 (car sub)] [row2 (cadr sub)] + [col1 (caddr sub)] [col2 (cadddr sub)]) + (let loop1 ([i row1] [k 0]) + (unless (= k 9) + (let loop2 ([j col1] [k k]) + (if (= j (+ col2 1)) + (loop1 (+ i 1) k) + (begin + (grid-set! i j (vector-ref vec k)) + (loop2 (+ j 1) (+ k 1))))))))))) + +(define vector-init + (lambda (vec) + (let main-loop ([i 0]) + (if (= i 9) + vec + (let ([x (vector-ref vec i)]) + (if (vector? x) + (main-loop (+ i 1)) + (let sub-loop ([j 0]) + (if (= j 9) + (main-loop (+ i 1)) + (let ([y (vector-ref vec j)]) + (if (vector? y) + (begin + (vector-set! y (- x 1) 0) + (sub-loop (+ j 1))) + (sub-loop (+ j 1)))))))))))) + +(define grid-init + (lambda () + (row-init-all) + (col-init-all) + (sub-grid-init-all))) + +(define one-possible? + (lambda (vec) + (let loop ([i 0] [count 0]) + (if (= i 9) + (= count 1) + (if (= (vector-ref vec i) 1) + (loop (+ i 1) (+ count 1)) + (loop (+ i 1) count)))))) + +(define replace-one + (lambda (vec) + (let loop ([i 0]) + (if (= (vector-ref vec i) 1) + i + (loop (+ i 1)))))) + +(define level-one-row + (lambda (row) + (let loop ([i 0] [count 0] [vec (row->vector row)]) + (if (= i 9) + count + (let ([x (vector-ref vec i)]) + (if (vector? x) + (if (one-possible? x) + (begin + (grid-set! row i (+ (replace-one x) 1)) + (row-init row) + (col-init i) + (sub-grid-init (sub-grid-list2 row i)) + (loop (+ i 1) (+ count 1) (row->vector row))) + (loop (+ i 1) count vec)) + (loop (+ i 1) count vec))))))) + +(define level-one-pass + (lambda () + (let loop ([i 0] [count 0]) + (if (= i 9) + count + (loop (+ i 1) (+ count (level-one-row i))))))) + +(define level-one + (lambda () + (let loop () + (unless (= (level-one-pass) 0) + (loop))))) + +(define level-two-row + (lambda (row) + (let loop1 ([i 0] [count1 0] [vec (row->vector row)]) + (if (= i 9) + count1 + (let loop2 ([j 0] [count2 0] [col 0]) + (if (= j 9) + (if (= count2 1) + (begin + (grid-set! row col (+ i 1)) + (row-init row) + (col-init col) + (sub-grid-init (sub-grid-list2 row col)) + (loop1 (+ i 1) (+ count1 1) (row->vector row))) + (loop1 (+ i 1) count1 vec)) + (begin + (let ([x (vector-ref vec j)]) + (if (vector? x) + (if (= (vector-ref x i) 1) + (loop2 (+ j 1) (+ count2 1) j) + (loop2 (+ j 1) count2 col)) + (loop2 (+ j 1) count2 col)))))))))) + +(define level-two-row-pass + (lambda () + (let loop ([i 0] [count 0]) + (if (= i 9) + count + (loop (+ i 1) (+ count (level-two-row i))))))) + +(define level-two-col + (lambda (col) + (let loop1 ([i 0] [count1 0] [vec (col->vector col)]) + (if (= i 9) + count1 + (let loop2 ([j 0] [count2 0] [row 0]) + (if (= j 9) + (if (= count2 1) + (begin + (grid-set! row col (+ i 1)) + (row-init row) + (col-init col) + (sub-grid-init (sub-grid-list2 row col)) + (loop1 (+ i 1) (+ count1 1) (col->vector col))) + (loop1 (+ i 1) count1 vec)) + (begin + (let ([x (vector-ref vec j)]) + (if (vector? x) + (if (= (vector-ref x i) 1) + (loop2 (+ j 1) (+ count2 1) j) + (loop2 (+ j 1) count2 row)) + (loop2 (+ j 1) count2 row)))))))))) + +(define level-two-col-pass + (lambda () + (let loop ([i 0] [count 0]) + (if (= i 9) + count + (loop (+ i 1) (+ count (level-two-col i))))))) + +(define level-two-sub + (lambda (sub) + (let loop1 ([i 0] [count1 0] [vec (sub-grid->vector sub)]) + (if (= i 9) + count1 + (let loop2 ([j 0] [count2 0] [loc 0]) + (if (= j 9) + (if (= count2 1) + (begin + (let ([row (+ (car (sub-grid-list sub)) (quotient loc 3))] + [col (+ (caddr (sub-grid-list sub)) (modulo loc 3))]) + (grid-set! row col (+ i 1)) + (row-init row) + (col-init col) + (sub-grid-init sub)) + (loop1 (+ i 1) (+ count1 1) (sub-grid->vector sub))) + (loop1 (+ i 1) count1 vec)) + (begin + (let ([x (vector-ref vec j)]) + (if (vector? x) + (if (= (vector-ref x i) 1) + (loop2 (+ j 1) (+ count2 1) j) + (loop2 (+ j 1) count2 loc)) + (loop2 (+ j 1) count2 loc)))))))))) + +(define level-two-sub-pass + (lambda () + (let loop ([i 0] [count 0]) + (if (= i 9) + count + (loop (+ i 1) (+ count (level-two-sub i))))))) + +(define vector-count + (lambda (vec) + (let loop ([i 0] [count 0]) + (if (= i 9) + count + (if (= (vector-ref vec i) 1) + (loop (+ i 1) (+ count 1)) + (loop (+ i 1) count)))))) + +(define replace-2 + (lambda (vec loc1 loc2) + (let loop1 ([i 0] [count1 0]) + (if (= i 9) + (list count1 vec) + (let ([x (vector-ref vec i)]) + (if (and (vector? x) (not (= loc1 i)) (not (= loc2 i))) + (let loop2 ([j 0] [count2 count1]) + (if (= j 9) + (loop1 (+ i 1) count2) + (let ([y (vector-ref vec loc1)]) + (if (and (= (vector-ref y j) 1) (= (vector-ref x j) 1)) + (begin + (vector-set! (vector-ref vec i) j 0) + (loop2 (+ j 1) (+ count2 1))) + (loop2 (+ j 1) count2))))) + (loop1 (+ i 1) count1))))))) + +(define level-three-col + (lambda (col) + (let loop1 ([i 0] [count1 0] [vec (col->vector col)]) + (if (= i 9) + count1 + (let ([x1 (vector-ref vec i)]) + (if (vector? x1) + (let loop2 ([j 0]) + (if (= j 9) + (loop1 (+ i 1) count1 vec) + (let ([x2 (vector-ref vec j)]) + (if (and (vector? x2) (not (= i j)) (equal? x1 x2)) + (let ([y1 (vector-count x1)]) + (case y1 + [(2) (begin + (let ([z (replace-2 vec i j)]) + (if (= (car z) 0) + (loop2 (+ j 1)) + (begin + (vector->col (cadr z) col) + (loop1 (+ i 1) (+ count1 (car z)) (col->vector col))))))] + [(3) (loop2 (+ j 1))] + [(else) (loop2 (+ j 1))])) + (loop2 (+ j 1)))))) + (loop1 (+ i 1) count1 vec))))))) + + +(define done? + (lambda () + (let row-loop ([row 0] [count 0]) + (if (= row 9) + (= count 0) + (let col-loop ([col 0] [count count]) + (if (= col 9) + (row-loop (+ row 1) count) + (let ([x (grid-ref row col)]) + (if (vector? x) + (col-loop (+ col 1) (+ count 1)) + (col-loop (+ col 1) count))))))))) + +(define invalid? + (lambda () + (let row-loop ([row 0] [count 0]) + (if (= row 9) + (> count 0) + (let col-loop ([col 0] [count count]) + (if (= col 9) + (row-loop (+ row 1) count) + (let ([x (grid-ref row col)]) + (if (and (vector? x) (= (vector-count x) 0)) + (col-loop (+ col 1) (+ count 1)) + (col-loop (+ col 1) count))))))))) + +(define copy-grid + (lambda () + (let ([grid-orig (make-grid)]) + (let row-loop ([row 0]) + (if (= row 9) + grid-orig + (let col-loop ([col 0]) + (if (= col 9) + (row-loop (+ row 1)) + (let ([x1 (table-ref grid row col)] [y1 (table-ref grid-orig col row)]) + (if (not (vector? x1)) + (begin + (table-set! grid-orig col row x1) + (col-loop (+ col 1))) + (let vector-loop ([loc 0]) + (if (= loc 9) + (col-loop (+ col 1)) + (let ([x2 (vector-ref x1 loc)] [y2 (vector-ref y1 loc)]) + (vector-set! y1 loc x2) + (vector-loop (+ loc 1)))))))))))))) + +(define restore-grid + (lambda (grid-orig) + (reset-grid) + (let row-loop ([row 0]) + (unless (= row 9) + (let col-loop ([col 0]) + (if (= col 9) + (row-loop (+ row 1)) + (let ([x1 (table-ref grid row col)] [y1 (table-ref grid-orig row col)]) + (if (not (vector? y1)) + (begin + (grid-set! row col y1) + (col-loop (+ col 1))) + (let vector-loop ([loc 0]) + (if (= loc 9) + (col-loop (+ col 1)) + (let ([y2 (vector-ref y1 loc)]) + (vector-set! (grid-ref row col) loc y2) + (vector-loop (+ loc 1))))))))))))) + + +(define level-four + (lambda () + (let row-loop ([row 0]) + (unless (= row 9) + (let col-loop ([col 0]) + (if (= col 9) + (row-loop (+ row 1)) + (let ([x (grid-ref row col)]) + (if (and (vector? x) (= (vector-count x) 2)) + (let vector-loop ([loc 0]) + (if (= loc 9) + (col-loop (+ col 1)) + (let ([x2 (grid-ref row col)]) + (if (= (vector-ref x2 loc) 1) + (let ([grid-orig (copy-grid)]) + (vector-set! (grid-ref row col) loc 0) + (if (sudoku-help grid) + #t + (begin + (restore-grid grid-orig) + (vector-loop (+ loc 1))))) + (vector-loop (+ loc 1)))))) + (col-loop (+ col 1)))))))))) + +(define sudoku-help + (lambda (grid) + (grid-init) + (let loop () + (cond + [(and (number? (level-one-pass)) (> (level-one-pass) 0)) (loop)] + [(invalid?) #f] + [(and (number? (level-two-row-pass)) (> (level-two-row-pass) 0)) (loop)] + [(and (number? (level-two-col-pass)) (> (level-two-col-pass) 0)) (loop)] + [(and (number? (level-two-sub-pass)) (> (level-two-sub-pass) 0)) (loop)] + [(done?) #t] + [else (level-four)])))) + +(define sudoku + (lambda (block) + (define grid (make-grid)) + (input-block block) + (if (sudoku-help grid) + (print-sudoku) + (error 'sudoku "MIS-ENTERED INITIALIZATION")))) + +(define quotient fxquotient) +(define modulo fxmodulo) +(define do-file + (lambda () + (let f () + (let ([x (read)]) + (unless (eof-object? x) + (sudoku x) + (f)))))) +(with-input-from-file "sudoku.txt" do-file) +(with-input-from-file "sudoku-hard.txt" do-file) + +(exit) +;;; vim:syntax=scheme diff --git a/lab/sudoku-hard.txt b/lab/sudoku-hard.txt new file mode 100644 index 0000000..6068b0a --- /dev/null +++ b/lab/sudoku-hard.txt @@ -0,0 +1,1140 @@ +("grid" + "400000805" + "030000000" + "000700000" + "020000060" + "000080400" + "000010000" + "000603070" + "500200000" + "104000000") + + +("grid" + "520006000" + "000000701" + "300000000" + "000400800" + "600000050" + "000000000" + "041800000" + "000030020" + "008700000") + + +("grid" + "600000803" + "040700000" + "000000000" + "000504070" + "300200000" + "106000000" + "020000050" + "000080600" + "000010000") + + +("grid" + "480300000" + "000000071" + "020000000" + "705000060" + "000200800" + "000000000" + "001076000" + "300000400" + "000050000") + + +("grid" + "000014000" + "030000200" + "070000000" + "000900030" + "601000000" + "000000080" + "200000104" + "000050600" + "000708000") + + +("grid" + "000000520" + "080400000" + "030009000" + "501000600" + "200700000" + "000300000" + "600010000" + "000000704" + "000000030") + + +("grid" + "602050000" + "000003040" + "000000000" + "430008000" + "010000200" + "000000700" + "500270000" + "000000081" + "000600000") + + +("grid" + "052400000" + "000070100" + "000000000" + "000802000" + "300000600" + "090500000" + "106030000" + "000000089" + "700000000") + + +("grid" + "602050000" + "000004030" + "000000000" + "430008000" + "010000200" + "000000700" + "500270000" + "000000081" + "000600000") + + +("grid" + "092300000" + "000080100" + "000000000" + "107040000" + "000000065" + "800000000" + "060502000" + "400000700" + "000900000") + + +("grid" + "600302000" + "050000010" + "000000000" + "702600000" + "000000054" + "300000000" + "080150000" + "000040200" + "000000700") + + +("grid" + "060501090" + "100090053" + "900007000" + "040800070" + "000000508" + "081705030" + "000050200" + "000000000" + "076008000") + + +("grid" + "005000987" + "040050001" + "007000000" + "200048000" + "090100000" + "600200000" + "300600200" + "000009070" + "000000500") + + +("grid" + "306070000" + "000000051" + "800000000" + "010405000" + "700000600" + "000200000" + "020000040" + "000080300" + "000500000") + + +("grid" + "100000308" + "070400000" + "000000000" + "203010000" + "000000095" + "800000000" + "050600070" + "000080200" + "040000000") + + +("grid" + "600302000" + "040000010" + "000000000" + "702600000" + "000000054" + "300000000" + "080150000" + "000040200" + "000000700") + + +("grid" + "000030090" + "000200001" + "050900000" + "000000000" + "102080406" + "080500020" + "075000000" + "401006003" + "000004060") + + +("grid" + "450000030" + "000801000" + "090000000" + "000050090" + "200700000" + "800000000" + "010040000" + "000000702" + "000600800") + + +("grid" + "023700006" + "800060590" + "900000700" + "000040970" + "307096002" + "000000000" + "500470000" + "000002000" + "080000000") + + +("grid" + "008400030" + "000300000" + "900001574" + "790008000" + "000007005" + "140000020" + "009060002" + "050000400" + "000090056") + + +("grid" + "098010000" + "200000060" + "000000000" + "000302050" + "084000000" + "000600000" + "000040809" + "300500000" + "000000100") + + +("grid" + "002470058" + "000000000" + "000001040" + "000020009" + "528090400" + "009000100" + "000000030" + "300007500" + "685002000") + + +("grid" + "400000805" + "030000000" + "000700000" + "020000060" + "000050400" + "000010000" + "000603070" + "500200000" + "109000000") + + +("grid" + "020300000" + "063000005" + "800000001" + "500009030" + "000700000" + "000100008" + "087900260" + "000006070" + "006007004") + + +("grid" + "100000709" + "040007200" + "800000000" + "070010060" + "300000005" + "060040020" + "000000008" + "005300070" + "702000046") + + +("grid" + "400000300" + "000802000" + "000700000" + "000100087" + "340000000" + "600000000" + "500060000" + "000010400" + "082000000") + + +("grid" + "000000071" + "020800000" + "000403000" + "700060050" + "000200300" + "900000000" + "600070000" + "080000400" + "000050000") + + +("grid" + "600302000" + "040000080" + "000000000" + "702600000" + "000000054" + "300000000" + "080150000" + "000080200" + "000000700") + + +("grid" + "047080001" + "000000000" + "000600700" + "600003570" + "000005000" + "010060000" + "280040000" + "090100040" + "000020690") + + +("grid" + "000000801" + "700200000" + "000506000" + "000700050" + "010000300" + "080000000" + "500000020" + "040080000" + "600030000") + + +("grid" + "380600000" + "009000000" + "020030510" + "000005000" + "030010060" + "000400000" + "017050080" + "000000900" + "000007032") + + +("grid" + "000500000" + "000000506" + "970000020" + "004802000" + "250100030" + "080030000" + "000004070" + "013050090" + "020003100") + + +("grid" + "020000000" + "305062009" + "068000300" + "050000000" + "000640802" + "004700900" + "003000001" + "000006000" + "170430000") + + +("grid" + "080040000" + "300000010" + "000000020" + "005000406" + "900100800" + "200000000" + "000309000" + "060000500" + "000200000") + + +("grid" + "008090100" + "060500020" + "000006000" + "030107050" + "000000009" + "004000300" + "050000200" + "070003080" + "200700004") + + +("grid" + "400000508" + "030000000" + "000700000" + "020000060" + "000050800" + "000010000" + "000603070" + "500200000" + "108000000") + + +("grid" + "100000308" + "060400000" + "000000000" + "203010000" + "000000095" + "800000000" + "050600070" + "000080200" + "040000000") + + +("grid" + "100006080" + "064000000" + "000040007" + "000090600" + "070400500" + "500070100" + "050000320" + "300008000" + "400000000") + + +("grid" + "249060003" + "030000200" + "800000005" + "000006000" + "000200000" + "010040820" + "090500700" + "004000001" + "070003000") + + +("grid" + "000800009" + "087300040" + "600700000" + "008500970" + "000000000" + "043007500" + "000003000" + "030001450" + "400002001") + + +("grid" + "000501000" + "090000800" + "060000000" + "401000000" + "000070090" + "000000030" + "800000105" + "000200400" + "000360000") + + +("grid" + "000000801" + "600200000" + "000705000" + "000600020" + "010000300" + "080000000" + "200000070" + "030080000" + "500040000") + + +("grid" + "047600050" + "803000002" + "000009000" + "000805006" + "000100000" + "602400000" + "078000510" + "006000040" + "090004007") + + +("grid" + "000007095" + "000001000" + "860020000" + "020073008" + "500000060" + "003004900" + "305000417" + "240000000" + "000000000") + + +("grid" + "040500000" + "800090030" + "076020000" + "014600000" + "000009007" + "000003600" + "001004050" + "060000003" + "007100200") + + +("grid" + "083400000" + "000070050" + "000000000" + "040108000" + "000000027" + "000300000" + "206050000" + "500000800" + "000000100") + + +("grid" + "009000003" + "000009000" + "700000506" + "006500400" + "000300000" + "028000000" + "300750600" + "600000000" + "000120308") + + +("grid" + "026039000" + "000600001" + "900000700" + "000004009" + "050000200" + "008500000" + "300200900" + "400007620" + "000000004") + + +("grid" + "203080000" + "800700000" + "000000100" + "060507000" + "400000030" + "000100000" + "000000082" + "050000600" + "010000000") + + +("grid" + "600302000" + "010000050" + "000000000" + "702600000" + "000000084" + "300000000" + "080150000" + "000080200" + "000000700") + + +("grid" + "100000900" + "064001070" + "070040000" + "000300000" + "308900500" + "007000020" + "000060709" + "000004010" + "000129030") + + +("grid" + "000000000" + "900000084" + "062300050" + "000600045" + "300010006" + "000900070" + "000100000" + "405002000" + "030800009") + + +("grid" + "020000593" + "800500460" + "940060008" + "002030000" + "060080730" + "700200000" + "000040380" + "070000600" + "000000005") + + +("grid" + "904005000" + "250600100" + "310000008" + "070009000" + "400260000" + "001470000" + "700000002" + "000300806" + "040000090") + + +("grid" + "000520000" + "090003004" + "000000700" + "010000040" + "080045300" + "600010008" + "702000000" + "008000032" + "040080010") + + +("grid" + "530020900" + "024030050" + "009000000" + "000010827" + "000700000" + "000098100" + "000000000" + "006400009" + "102050430") + + +("grid" + "100007860" + "007008010" + "800200009" + "000000002" + "400010000" + "009005000" + "608000000" + "000050900" + "000009304") + + +("grid" + "000050001" + "100000070" + "060000080" + "000004000" + "009010300" + "000596020" + "080062007" + "007000000" + "305070200") + + +("grid" + "047020000" + "800001000" + "030000902" + "000005000" + "600810050" + "000040000" + "070000304" + "000900010" + "400270800") + + +("grid" + "000000940" + "000090005" + "300005070" + "080400100" + "463000000" + "000007080" + "800700000" + "700000028" + "050260000") + + +("grid" + "020000006" + "000041000" + "007800001" + "000000700" + "003700000" + "600412000" + "010074005" + "008050070" + "000003900") + + +("grid" + "100000308" + "060400000" + "000000000" + "203010000" + "000000075" + "800000000" + "070500060" + "000080200" + "040000000") + + +("grid" + "200001090" + "010030700" + "900800020" + "000000850" + "060400000" + "000070003" + "020300060" + "000500000" + "109000205") + + +("grid" + "007008000" + "006020300" + "030000009" + "010050060" + "000010000" + "070900002" + "000000004" + "083004000" + "260000510") + + +("grid" + "000360000" + "850000000" + "904008000" + "000006800" + "000000017" + "009004500" + "010500060" + "400009002" + "000003000") + + +("grid" + "340600000" + "007000000" + "020080570" + "000005000" + "070010020" + "000400000" + "036020010" + "000000900" + "000007082") + + +("grid" + "000000401" + "800200000" + "000607000" + "000800060" + "040000300" + "010000000" + "600000020" + "050010000" + "700030000") + + +("grid" + "040050067" + "000100040" + "000200000" + "100800300" + "000000200" + "060000000" + "000040050" + "300000800" + "200000000") + + +("grid" + "000000040" + "002004001" + "070050090" + "003007000" + "040060000" + "600100800" + "020000100" + "850900060" + "000080003") + + +("grid" + "800700004" + "050000600" + "000000000" + "030970008" + "000043005" + "000020900" + "006000000" + "200060007" + "071008302") + + +("grid" + "080004050" + "000700300" + "000000000" + "010085000" + "600000200" + "000040000" + "302600000" + "000000041" + "700000000") + + +("grid" + "000070080" + "006000500" + "020003061" + "010007002" + "008005340" + "200900000" + "002000000" + "580006030" + "400010000") + + +("grid" + "000000801" + "600200000" + "000705000" + "000600020" + "010000300" + "080000000" + "200000070" + "040080000" + "500030000") + + +("grid" + "020000000" + "000600003" + "074080000" + "000003002" + "080040010" + "600500000" + "000010780" + "500009000" + "000000040") + + +("grid" + "052006800" + "000007020" + "000000600" + "004800900" + "200410000" + "001000008" + "006100380" + "000090006" + "300600109") + + +("grid" + "000010780" + "500009000" + "000000040" + "020000000" + "000600003" + "074080000" + "000003002" + "080040010" + "600500000") + + +("grid" + "100000003" + "060300700" + "070005001" + "210700090" + "007000000" + "008010020" + "000806400" + "009020060" + "000400000") + + +("grid" + "400070100" + "001904605" + "000001000" + "000700002" + "002030000" + "847006000" + "014000806" + "020000300" + "600090000") + + +("grid" + "000000801" + "700200000" + "000506000" + "000700050" + "010000300" + "080000000" + "500000020" + "030080000" + "600040000") + + +("grid" + "963000000" + "100008000" + "000205000" + "040800000" + "010000700" + "000030025" + "700000030" + "009020407" + "000000900") + + +("grid" + "150300000" + "070040200" + "004072000" + "008000000" + "000900108" + "010080790" + "000003800" + "000000000" + "600007423") + + +("grid" + "000000000" + "057240009" + "800009470" + "009003000" + "500900120" + "003010900" + "060000250" + "000560000" + "070000006") + + +("grid" + "000075000" + "010020000" + "040003000" + "500000302" + "000800010" + "000000600" + "000100480" + "200000000" + "700000000") + + +("grid" + "600000703" + "040800000" + "000000000" + "000504080" + "700200000" + "103000000" + "020000050" + "000070900" + "000010000") + + +("grid" + "000060004" + "006030000" + "100400507" + "700000805" + "000800000" + "608000090" + "002090000" + "400003200" + "009700100") + + +("grid" + "032000005" + "800300000" + "904280001" + "000400039" + "000600050" + "000010000" + "020006708" + "000004000" + "095000060") + + +("grid" + "000503000" + "000060700" + "508000016" + "360020000" + "000401000" + "000030005" + "670000208" + "004070000" + "000200500") + + +("grid" + "050307040" + "100000000" + "030000000" + "508030610" + "000800509" + "060010000" + "000040006" + "000692700" + "002000900") + + +("grid" + "005008001" + "800000090" + "000000780" + "000400000" + "640000900" + "000053002" + "060000000" + "001380050" + "000907140") + + +("grid" + "000000000" + "072060100" + "005100082" + "080001300" + "400000000" + "037090010" + "000023800" + "504009000" + "000000790") + + +("grid" + "000658000" + "004000000" + "120000000" + "000009607" + "000300500" + "002080003" + "001900800" + "306000004" + "000047300") + + +("grid" + "020300000" + "006008090" + "830500000" + "000200080" + "709005000" + "000006004" + "000000010" + "001000402" + "200700809") + + +("grid" + "050090000" + "100000600" + "000308000" + "008040009" + "514000000" + "030000200" + "000000004" + "080006007" + "700150060") + + +("grid" + "000002000" + "000070001" + "700300090" + "800700000" + "020890600" + "013006000" + "090050824" + "000008910" + "000000000") + + +("grid" + "300080000" + "000700005" + "100000000" + "000000360" + "002004000" + "070000000" + "000060130" + "045200000" + "000000800") + + diff --git a/lab/sudoku.txt b/lab/sudoku.txt new file mode 100644 index 0000000..fc2007c --- /dev/null +++ b/lab/sudoku.txt @@ -0,0 +1,500 @@ +("Grid 01" + "003020600" + "900305001" + "001806400" + "008102900" + "700000008" + "006708200" + "002609500" + "800203009" + "005010300") +("Grid 02" + "200080300" + "060070084" + "030500209" + "000105408" + "000000000" + "402706000" + "301007040" + "720040060" + "004010003") +("Grid 03" + "000000907" + "000420180" + "000705026" + "100904000" + "050000040" + "000507009" + "920108000" + "034059000" + "507000000") +("Grid 04" + "030050040" + "008010500" + "460000012" + "070502080" + "000603000" + "040109030" + "250000098" + "001020600" + "080060020") +("Grid 05" + "020810740" + "700003100" + "090002805" + "009040087" + "400208003" + "160030200" + "302700060" + "005600008" + "076051090") +("Grid 06" + "100920000" + "524010000" + "000000070" + "050008102" + "000000000" + "402700090" + "060000000" + "000030945" + "000071006") +("Grid 07" + "043080250" + "600000000" + "000001094" + "900004070" + "000608000" + "010200003" + "820500000" + "000000005" + "034090710") +("Grid 08" + "480006902" + "002008001" + "900370060" + "840010200" + "003704100" + "001060049" + "020085007" + "700900600" + "609200018") +("Grid 09" + "000900002" + "050123400" + "030000160" + "908000000" + "070000090" + "000000205" + "091000050" + "007439020" + "400007000") +("Grid 10" + "001900003" + "900700160" + "030005007" + "050000009" + "004302600" + "200000070" + "600100030" + "042007006" + "500006800") +("Grid 11" + "000125400" + "008400000" + "420800000" + "030000095" + "060902010" + "510000060" + "000003049" + "000007200" + "001298000") +("Grid 12" + "062340750" + "100005600" + "570000040" + "000094800" + "400000006" + "005830000" + "030000091" + "006400007" + "059083260") +("Grid 13" + "300000000" + "005009000" + "200504000" + "020000700" + "160000058" + "704310600" + "000890100" + "000067080" + "000005437") +("Grid 14" + "630000000" + "000500008" + "005674000" + "000020000" + "003401020" + "000000345" + "000007004" + "080300902" + "947100080") +("Grid 15" + "000020040" + "008035000" + "000070602" + "031046970" + "200000000" + "000501203" + "049000730" + "000000010" + "800004000") +("Grid 16" + "361025900" + "080960010" + "400000057" + "008000471" + "000603000" + "259000800" + "740000005" + "020018060" + "005470329") +("Grid 17" + "050807020" + "600010090" + "702540006" + "070020301" + "504000908" + "103080070" + "900076205" + "060090003" + "080103040") +("Grid 18" + "080005000" + "000003457" + "000070809" + "060400903" + "007010500" + "408007020" + "901020000" + "842300000" + "000100080") +("Grid 19" + "003502900" + "000040000" + "106000305" + "900251008" + "070408030" + "800763001" + "308000104" + "000020000" + "005104800") +("Grid 20" + "000000000" + "009805100" + "051907420" + "290401065" + "000000000" + "140508093" + "026709580" + "005103600" + "000000000") +("Grid 21" + "020030090" + "000907000" + "900208005" + "004806500" + "607000208" + "003102900" + "800605007" + "000309000" + "030020050") +("Grid 22" + "005000006" + "070009020" + "000500107" + "804150000" + "000803000" + "000092805" + "907006000" + "030400010" + "200000600") +("Grid 23" + "040000050" + "001943600" + "009000300" + "600050002" + "103000506" + "800020007" + "005000200" + "002436700" + "030000040") +("Grid 24" + "004000000" + "000030002" + "390700080" + "400009001" + "209801307" + "600200008" + "010008053" + "900040000" + "000000800") +("Grid 25" + "360020089" + "000361000" + "000000000" + "803000602" + "400603007" + "607000108" + "000000000" + "000418000" + "970030014") +("Grid 26" + "500400060" + "009000800" + "640020000" + "000001008" + "208000501" + "700500000" + "000090084" + "003000600" + "060003002") +("Grid 27" + "007256400" + "400000005" + "010030060" + "000508000" + "008060200" + "000107000" + "030070090" + "200000004" + "006312700") +("Grid 28" + "000000000" + "079050180" + "800000007" + "007306800" + "450708096" + "003502700" + "700000005" + "016030420" + "000000000") +("Grid 29" + "030000080" + "009000500" + "007509200" + "700105008" + "020090030" + "900402001" + "004207100" + "002000800" + "070000090") +("Grid 30" + "200170603" + "050000100" + "000006079" + "000040700" + "000801000" + "009050000" + "310400000" + "005000060" + "906037002") +("Grid 31" + "000000080" + "800701040" + "040020030" + "374000900" + "000030000" + "005000321" + "010060050" + "050802006" + "080000000") +("Grid 32" + "000000085" + "000210009" + "960080100" + "500800016" + "000000000" + "890006007" + "009070052" + "300054000" + "480000000") +("Grid 33" + "608070502" + "050608070" + "002000300" + "500090006" + "040302050" + "800050003" + "005000200" + "010704090" + "409060701") +("Grid 34" + "050010040" + "107000602" + "000905000" + "208030501" + "040070020" + "901080406" + "000401000" + "304000709" + "020060010") +("Grid 35" + "053000790" + "009753400" + "100000002" + "090080010" + "000907000" + "080030070" + "500000003" + "007641200" + "061000940") +("Grid 36" + "006080300" + "049070250" + "000405000" + "600317004" + "007000800" + "100826009" + "000702000" + "075040190" + "003090600") +("Grid 37" + "005080700" + "700204005" + "320000084" + "060105040" + "008000500" + "070803010" + "450000091" + "600508007" + "003010600") +("Grid 38" + "000900800" + "128006400" + "070800060" + "800430007" + "500000009" + "600079008" + "090004010" + "003600284" + "001007000") +("Grid 39" + "000080000" + "270000054" + "095000810" + "009806400" + "020403060" + "006905100" + "017000620" + "460000038" + "000090000") +("Grid 40" + "000602000" + "400050001" + "085010620" + "038206710" + "000000000" + "019407350" + "026040530" + "900020007" + "000809000") +("Grid 41" + "000900002" + "050123400" + "030000160" + "908000000" + "070000090" + "000000205" + "091000050" + "007439020" + "400007000") +("Grid 42" + "380000000" + "000400785" + "009020300" + "060090000" + "800302009" + "000040070" + "001070500" + "495006000" + "000000092") +("Grid 43" + "000158000" + "002060800" + "030000040" + "027030510" + "000000000" + "046080790" + "050000080" + "004070100" + "000325000") +("Grid 44" + "010500200" + "900001000" + "002008030" + "500030007" + "008000500" + "600080004" + "040100700" + "000700006" + "003004050") +("Grid 45" + "080000040" + "000469000" + "400000007" + "005904600" + "070608030" + "008502100" + "900000005" + "000781000" + "060000010") +("Grid 46" + "904200007" + "010000000" + "000706500" + "000800090" + "020904060" + "040002000" + "001607000" + "000000030" + "300005702") +("Grid 47" + "000700800" + "006000031" + "040002000" + "024070000" + "010030080" + "000060290" + "000800070" + "860000500" + "002006000") +("Grid 48" + "001007090" + "590080001" + "030000080" + "000005800" + "050060020" + "004100000" + "080000030" + "100020079" + "020700400") +("Grid 49" + "000003017" + "015009008" + "060000000" + "100007000" + "009000200" + "000500004" + "000000020" + "500600340" + "340200000") +("Grid 50" + "300200000" + "000107000" + "706030500" + "070009080" + "900020004" + "010800050" + "009040301" + "000702000" + "000008006")