## ~willvaughn/kata

f2ab8b520cae6d87d2ad20f2d1c6feb2be0f78f9 — William Vaughn 1 year, 5 months ago
```codewars sudoku solution validator
```
```2 files changed, 84 insertions(+), 0 deletions(-)

A codewars/src/clj/org/willvaughn/codewars/sudoku.clj
A codewars/test/clj/org/willvaughn/codewars/sudoku_test.clj
```
`A codewars/src/clj/org/willvaughn/codewars/sudoku.clj => codewars/src/clj/org/willvaughn/codewars/sudoku.clj +59 -0`
```@@ 0,0 1,59 @@
+(ns org.willvaughn.codewars.sudoku)
+
+;;; Sudoku Background
+;;; Sudoku is a game played on a 9x9 grid. The goal of the game is to fill all cells of the grid with digits from 1 to 9, so that each column, each row, and each of the nine 3x3 sub-grids (also known as blocks) contain all of the digits from 1 to 9.
+;;;
+;;; Sudoku Solution Validator
+;;; Write a function validSolution/ValidateSolution/valid_solution() that accepts a 2D array representing a Sudoku board, and returns true if it is a valid solution, or false otherwise. The cells of the sudoku board may also contain 0's, which will represent empty cells. Boards containing one or more zeroes are considered to be invalid solutions.
+;;;
+;;; The board is always 9 cells by 9 cells, and every cell only contains integers from 0 to 9.
+;;;
+;;; Examples
+;;; validSolution([
+;;;   [5, 3, 4, 6, 7, 8, 9, 1, 2],
+;;;   [6, 7, 2, 1, 9, 5, 3, 4, 8],
+;;;   [1, 9, 8, 3, 4, 2, 5, 6, 7],
+;;;   [8, 5, 9, 7, 6, 1, 4, 2, 3],
+;;;   [4, 2, 6, 8, 5, 3, 7, 9, 1],
+;;;   [7, 1, 3, 9, 2, 4, 8, 5, 6],
+;;;   [9, 6, 1, 5, 3, 7, 2, 8, 4],
+;;;   [2, 8, 7, 4, 1, 9, 6, 3, 5],
+;;;   [3, 4, 5, 2, 8, 6, 1, 7, 9]
+;;; ]); // => true
+;;; validSolution([
+;;;   [5, 3, 4, 6, 7, 8, 9, 1, 2],
+;;;   [6, 7, 2, 1, 9, 0, 3, 4, 8],
+;;;   [1, 0, 0, 3, 4, 2, 5, 6, 0],
+;;;   [8, 5, 9, 7, 6, 1, 0, 2, 0],
+;;;   [4, 2, 6, 8, 5, 3, 7, 9, 1],
+;;;   [7, 1, 3, 9, 2, 4, 8, 5, 6],
+;;;   [9, 0, 1, 5, 3, 7, 2, 1, 4],
+;;;   [2, 8, 7, 4, 1, 9, 6, 3, 5],
+;;;   [3, 0, 0, 4, 8, 1, 1, 7, 9]
+;;; ]); // => false
+
+(defn valid-set? [column]
+  (and (= 1 (apply min column))
+       (= 9 (apply max column))
+       (= 9 (count (distinct column)))))
+
+(defn board->columns [board]
+  (map (fn [col]
+         (map #(nth % col) board))
+       (range 9)))
+
+(defn board->blocks [board]
+  (->> (partition 3 (map #(partition 3 %) board))
+       (map (fn [three-rows]
+              (map (fn [n]
+                     (flatten (map #(nth % n) three-rows)))
+                   (range 3))))
+       (apply concat)))
+
+(defn valid-solution [board]
+  (let [columns (board->columns board)
+        blocks (board->blocks board)]
+    (and (every? valid-set? board)
+         (every? valid-set? columns)
+         (every? valid-set? blocks))))

```
`A codewars/test/clj/org/willvaughn/codewars/sudoku_test.clj => codewars/test/clj/org/willvaughn/codewars/sudoku_test.clj +25 -0`
```@@ 0,0 1,25 @@
+(ns org.willvaughn.codewars.sudoku-test
+  (:require [clojure.test :refer :all]
+            [org.willvaughn.codewars.sudoku :refer [valid-solution]]))
+
+(deftest sudoku-test1
+  (is (= (valid-solution [[5 3 4 6 7 8 9 1 2]
+                          [6 7 2 1 9 5 3 4 8]
+                          [1 9 8 3 4 2 5 6 7]
+                          [8 5 9 7 6 1 4 2 3]
+                          [4 2 6 8 5 3 7 9 1]
+                          [7 1 3 9 2 4 8 5 6]
+                          [9 6 1 5 3 7 2 8 4]
+                          [2 8 7 4 1 9 6 3 5]
+                          [3 4 5 2 8 6 1 7 9]]) true)))
+
+(deftest sudoku-test2
+  (is (= (valid-solution [[5 3 4 6 7 8 9 1 2]
+                         [6 7 2 1 9 0 3 4 8]
+                         [1 0 0 3 4 2 5 6 0]
+                         [8 5 9 7 6 1 0 2 0]
+                         [4 2 6 8 5 3 7 9 1]
+                         [7 1 3 9 2 4 8 5 6]
+                         [9 0 1 5 3 7 2 1 4]
+                         [2 8 7 4 1 9 6 3 5]
+                         [3 0 0 4 8 1 1 7 9]]) false)))

```