sudoku generator and solver

main.rs

#![allow(uncommon_codepoints, confusable_idents, mixed_script_confusables)]
//! 🧩🎲🔢✨

use clap::{Parser, Subcommand};
use rand::rngs::ThreadRng;
use rand::seq::SliceRandom;
use std::io::Read;
use thiserror::Error;

/// 💥🧩😵
#[derive(Debug, Error)]
enum 𓅨 {
    /// 📥🤔❌
    #[error("😵📥❓🧩")]
    𓏲,
    /// 🧩🔐❌
    #[error("🧩❌🔑😢")]
    𓏴,
    /// 💾💥
    #[error("💾💥 {0}")]
    𓏵(#[from] std::io::Error),
}

/// 🗺️9️⃣✖️9️⃣🔢
#[derive(Clone)]
struct 𓊖([[u8; 9]; 9]);

impl 𓊖 {
    /// 🆕⬜⬜⬜🗺️
    fn 𓍇() -> Self {
        𓊖([[0; 9]; 9])
    }

    /// 🔢📍👮✅❓
    fn 𓆣(&self, 𓏤: usize, 𓏥: usize, 𓏦: u8) -> bool {
        for 𓏭 in 0..9 {
            if self.0[𓏤][𓏭] == 𓏦 || self.0[𓏭][𓏥] == 𓏦 {
                return false;
            }
        }
        let (𓏮, 𓏯) = (𓏤 / 3 * 3, 𓏥 / 3 * 3);
        for 𓏭 in 0..3 {
            for 𓏰 in 0..3 {
                if self.0[𓏮 + 𓏭][𓏯 + 𓏰] == 𓏦 {
                    return false;
                }
            }
        }
        true
    }

    /// 🧐🗺️⚖️✅❓
    fn 𓎛(&mut self) -> bool {
        for 𓏭 in 0..9 {
            for 𓏮 in 0..9 {
                let 𓏦 = self.0[𓏭][𓏮];
                if 𓏦 != 0 {
                    self.0[𓏭][𓏮] = 0;
                    let 𓆼 = self.𓆣(𓏭, 𓏮, 𓏦);
                    self.0[𓏭][𓏮] = 𓏦;
                    if !𓆼 {
                        return false;
                    }
                }
            }
        }
        true
    }

    /// 🧠🔁✍️✅❓
    fn 𓂀(&mut self) -> bool {
        for 𓏭 in 0..9 {
            for 𓏮 in 0..9 {
                if self.0[𓏭][𓏮] == 0 {
                    for 𓏦 in 1..=9 {
                        if self.𓆣(𓏭, 𓏮, 𓏦) {
                            self.0[𓏭][𓏮] = 𓏦;
                            if self.𓂀() {
                                return true;
                            }
                            self.0[𓏭][𓏮] = 0;
                        }
                    }
                    return false;
                }
            }
        }
        true
    }

    /// 🔢💡#️⃣🧮
    fn 𓃒(&mut self, 𓎟: &mut u8) {
        if *𓎟 >= 2 {
            return;
        }
        for 𓏭 in 0..9 {
            for 𓏮 in 0..9 {
                if self.0[𓏭][𓏮] == 0 {
                    for 𓏦 in 1..=9 {
                        if self.𓆣(𓏭, 𓏮, 𓏦) {
                            self.0[𓏭][𓏮] = 𓏦;
                            self.𓃒(𓎟);
                            self.0[𓏭][𓏮] = 0;
                        }
                    }
                    return;
                }
            }
        }
        *𓎟 += 1;
    }

    /// 🎲✍️🗺️🌕
    fn 𓋹(&mut self, 𓀠: &mut ThreadRng) -> bool {
        for 𓏭 in 0..9 {
            for 𓏮 in 0..9 {
                if self.0[𓏭][𓏮] == 0 {
                    let mut 𓐍: [u8; 9] = [1, 2, 3, 4, 5, 6, 7, 8, 9];
                    𓐍.shuffle(𓀠);
                    for 𓏦 in 𓐍 {
                        if self.𓆣(𓏭, 𓏮, 𓏦) {
                            self.0[𓏭][𓏮] = 𓏦;
                            if self.𓋹(𓀠) {
                                return true;
                            }
                            self.0[𓏭][𓏮] = 0;
                        }
                    }
                    return false;
                }
            }
        }
        true
    }

    /// ⛏️🕳️🗺️☝️💡
    fn 𓉔(&mut self, 𓀠: &mut ThreadRng, 𓎟: usize) {
        let mut 𓊪: Vec<usize> = (0..81).collect();
        𓊪.shuffle(𓀠);
        let mut 𓆾 = 0;
        for 𓍢 in 𓊪 {
            if 𓆾 >= 𓎟 {
                break;
            }
            let (𓏭, 𓏮) = (𓍢 / 9, 𓍢 % 9);
            let 𓏦 = self.0[𓏭][𓏮];
            self.0[𓏭][𓏮] = 0;
            let mut 𓐩 = 0;
            self.clone().𓃒(&mut 𓐩);
            if 𓐩 == 1 {
                𓆾 += 1;
            } else {
                self.0[𓏭][𓏮] = 𓏦;
            }
        }
    }

    /// 🗺️➡️🖼️📤
    fn 𓏞(&self) -> String {
        let mut 𓋏 = String::new();
        for 𓏭 in 0..9 {
            for 𓏮 in 0..9 {
                let 𓏦 = self.0[𓏭][𓏮];
                if 𓏦 == 0 {
                    𓋏.push('⬜');
                } else {
                    𓋏.push_str(&format!("{𓏦}\u{fe0f}\u{20e3}"));
                }
            }
            𓋏.push('\n');
        }
        𓋏
    }

    /// 📥🖼️➡️🗺️
    fn 𓌳(𓄿: &str) -> Result<Self, 𓅨> {
        let 𓊪: Vec<u8> = 𓄿
            .chars()
            .filter_map(|𓆤| match 𓆤 {
                '⬜' => Some(0),
                '1'..='9' => Some(𓆤 as u8 - b'0'),
                _ => None,
            })
            .collect();
        if 𓊪.len() != 81 {
            return Err(𓅨::𓏲);
        }
        let mut 𓋏 = 𓊖::𓍇();
        for (𓍢, 𓏦) in 𓊪.into_iter().enumerate() {
            𓋏.0[𓍢 / 9][𓍢 % 9] = 𓏦;
        }
        Ok(𓋏)
    }
}

/// 🧩🛠️🚪
#[derive(Parser)]
#[command(name = "sudoku")]
struct 𓊹 {
    /// 🗂️🎛️
    #[command(subcommand)]
    𓆃: 𓊽,
}

/// 🗂️🎛️📜
#[derive(Subcommand)]
enum 𓊽 {
    /// 🎲🧩➡️📤
    #[command(name = "generate")]
    𓋞 {
        /// 🕳️🔢
        #[arg(long = "holes", value_name = "🕳️", default_value_t = 45)]
        𓉐: usize,
    },
    /// 📥🧩🧠➡️📤
    #[command(name = "solve")]
    𓋴,
}

/// 🧠🎬
fn 𓁶() -> Result<(), 𓅨> {
    let 𓊹 { 𓆃 } = 𓊹::parse();
    match 𓆃 {
        𓊽::𓋞 { 𓉐 } => {
            let mut 𓀠 = rand::rng();
            let mut 𓋏 = 𓊖::𓍇();
            𓋏.𓋹(&mut 𓀠);
            𓋏.𓉔(&mut 𓀠, 𓉐.min(64));
            print!("{}", 𓋏.𓏞());
        }
        𓊽::𓋴 => {
            let mut 𓄿 = String::new();
            std::io::stdin().read_to_string(&mut 𓄿)?;
            let mut 𓋏 = 𓊖::𓌳(&𓄿)?;
            if !𓋏.𓎛() || !𓋏.𓂀() {
                return Err(𓅨::𓏴);
            }
            print!("{}", 𓋏.𓏞());
        }
    }
    Ok(())
}

/// 🚀🏁
fn main() {
    if let Err(𓅪) = 𓁶() {
        eprintln!("💥 {𓅪}");
        std::process::exit(1);
    }
}