Working solved sudoku generator

1 files changed, 158 insertions, 0 deletions

diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..bde649a
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,158 @@
+fn draw_board(val: [[u8; 9]; 9]) {
+	let mut board: [[u8; 9]; 9] = [[0; 9]; 9];
+	for (i, v) in val.iter().enumerate() {
+		for j in v {
+			board[(*j as usize)/9][(*j as usize)%9] = 1+i as u8;
+		}
+	}
+	println!("___________________\n|{} {} {}|{} {} {}|{} {} {}|\n|{} {} {}|{} {} {}|{} {} {}|\n|{} {} {}|{} {} {}|{} {} {}|\n-------------------\n|{} {} {}|{} {} {}|{} {} {}|\n|{} {} {}|{} {} {}|{} {} {}|\n|{} {} {}|{} {} {}|{} {} {}|\n-------------------\n|{} {} {}|{} {} {}|{} {} {}|\n|{} {} {}|{} {} {}|{} {} {}|\n|{} {} {}|{} {} {}|{} {} {}|\n¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯\n", 
+	board[0][0], board[0][1], board[0][2], board[0][3], board[0][4], board[0][5], board[0][6], board[0][7], board[0][8],
+	board[1][0], board[1][1], board[1][2], board[1][3], board[1][4], board[1][5], board[1][6], board[1][7], board[1][8],
+	board[2][0], board[2][1], board[2][2], board[2][3], board[2][4], board[2][5], board[2][6], board[2][7], board[2][8],
+	board[3][0], board[3][1], board[3][2], board[3][3], board[3][4], board[3][5], board[3][6], board[3][7], board[3][8],
+	board[4][0], board[4][1], board[4][2], board[4][3], board[4][4], board[4][5], board[4][6], board[4][7], board[4][8],
+	board[5][0], board[5][1], board[5][2], board[5][3], board[5][4], board[5][5], board[5][6], board[5][7], board[5][8],
+	board[6][0], board[6][1], board[6][2], board[6][3], board[6][4], board[6][5], board[6][6], board[6][7], board[6][8],
+	board[7][0], board[7][1], board[7][2], board[7][3], board[7][4], board[7][5], board[7][6], board[7][7], board[7][8],
+	board[8][0], board[8][1], board[8][2], board[8][3], board[8][4], board[8][5], board[8][6], board[8][7], board[8][8]);
+}
+
+fn layer(squares: &Vec<Vec<u8>>) -> impl Iterator<Item = [u8; 9]> { 
+    let a = {
+    let s0 = squares[0].iter();
+    s0.flat_map(move |&o| {
+        let s1 = squares[1].iter().filter(move |&&d| d / 3 != o / 3 + 1);
+        s1.flat_map(move |&tw| {
+            let s2 = squares[2].iter().filter(move |&&d| (d / 3 != o / 3 + 2) & (d / 3 != tw / 3 + 1));
+            s2.flat_map(move |&th| {
+                let s3 = squares[3].iter().filter(move |&&d| d % 3 != o % 3);
+                s3.flat_map(move |&fo| {
+                    let s4 = squares[4].iter().filter(move |&&d| (d % 3 != tw % 3) & (d / 3 != fo / 3 + 1));
+                    s4.flat_map(move |&fi| {
+                        let s5 = squares[5].iter().filter(move |&&d| (d % 3 != th % 3) & (d / 3 != fo / 3 + 2) & (d / 3 != fi / 3 + 1));
+                        s5.flat_map(move |&si| {
+                            let s6 = squares[6].iter().filter(move |&&d| (d % 3 != o % 3) & (d % 3 != fo % 3));
+                            s6.flat_map(move |&se| {
+                                let s7 = squares[7].iter().filter(move |&&d| (d % 3 != tw % 3) & (d % 3 != fi % 3) & (d / 3 != se / 3 + 1));
+                                s7.flat_map(move |&e| {
+                                    let s8 = squares[8].iter().filter(move |&&d| (d % 3 != th % 3) & (d % 3 != si % 3) & (d / 3 != se / 3 + 2) & (d / 3 != e / 3 + 1));
+                                    s8.map(move |&n| [o, tw, th, fo, fi, si, se, e, n])
+                                })
+                            })
+                        })
+                    })
+                })
+            })
+        })
+    })};
+    a
+}
+
+fn all() {
+    let squares = vec![
+        vec![0, 1, 2, 9, 10, 11, 18, 19, 20],
+        vec![3, 4, 5, 12, 13, 14, 21, 22, 23],
+        vec![6, 7, 8, 15, 16, 17, 24, 25, 26],
+        vec![27, 28, 29, 36, 37, 38, 45, 46, 47],
+        vec![30, 31, 32, 39, 40, 41, 48, 49, 50],
+        vec![33, 34, 35, 42, 43, 44, 51, 52, 53],
+        vec![54, 55, 56, 63, 64, 65, 72, 73, 74],
+        vec![57, 58, 59, 66, 67, 68, 75, 76, 77],
+        vec![60, 61, 62, 69, 70, 71, 78, 79, 80],
+    ];
+    
+    let mut a = layer(&squares);
+    let mut count: usize = 0;
+    loop {
+        let _ = match a.next() {
+        None => break,
+        Some(val) => {
+            let mut squares2 = squares.clone();
+			for i in 0..9 {
+			let index = squares2[i].iter().position(|x| *x == val[i]).unwrap();
+			squares2[i].remove(index);
+			}
+			let mut b = layer(&squares2);
+			loop {
+			let _ = match b.next() {
+			None => break,
+			Some(val2) => {
+				let mut squares3 = squares2.clone();
+				for i in 0..9 {
+				let index = squares3[i].iter().position(|x| *x == val2[i]).unwrap();
+				squares3[i].remove(index);
+				}
+				let mut c = layer(&squares3);
+				loop {
+				let _ = match c.next() {
+				None => break,
+				Some(val3) => {
+					let mut squares4 = squares3.clone();
+					for i in 0..9 {
+					let index = squares4[i].iter().position(|x| *x == val3[i]).unwrap();
+					squares4[i].remove(index);
+					}
+					let mut d = layer(&squares4);
+					loop {
+					let _ = match d.next() {
+					None => break,
+					Some(val4) => {
+						println!("{}", count);
+						let mut squares5 = squares4.clone();
+						for i in 0..9 {
+						let index = squares5[i].iter().position(|x| *x==val4[i]).unwrap();
+						squares5[i].remove(index);
+						}
+						let mut e = layer(&squares5);
+						loop {
+						let _ = match e.next() {
+						None => break,
+						Some(val5) => {
+							let mut squares6 = squares5.clone();
+							for i in 0..9 {
+							let index = squares6[i].iter().position(|x| *x==val5[i]).unwrap();
+							squares6[i].remove(index);
+							}
+							let mut f = layer(&squares6);
+							loop {
+							let _ = match f.next() {
+							None => break,
+							Some(val6) => {
+								let mut squares7 = squares6.clone();
+								for i in 0..9 {
+								let index = squares7[i].iter().position(|x| *x==val6[i]).unwrap();
+								squares7[i].remove(index);
+								}
+								let mut g = layer(&squares7);
+								loop {
+								let _ = match g.next() {
+								None => break,
+								Some(val7) => {
+									let mut squares8 = squares7.clone();
+									for i in 0..9 {
+									let index = squares8[i].iter().position(|x| *x==val7[i]).unwrap();
+									squares8[i].remove(index);
+									}
+									let mut h = layer(&squares8);
+									loop {
+									let _ = match h.next() {
+									None => break,
+									Some(val8) => {
+										let mut squares9 = squares8.clone();
+										let mut val9: [u8; 9] = [0; 9];
+										for i in 0..9 {
+										let index = squares9[i].iter().position(|x| *x==val8[i]).unwrap();
+										squares9[i].remove(index);
+										val9[i] = squares9[i][0];
+										}
+										count +=1;
+										//println!("{:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?} {:?}", val,val2,val3,val4,val5,val6,val7,val8,val9);
+										//draw_board([val, val2, val3, val4, val5, val6, val7, val8, val9]);
+										}};};}};};}};};}};};}};};}};};}};};}};};
+	println!("{}", count);
+}
+
+fn main() {
+	all();
+}
+