sudoku-pro 1.0.0

package/README.md

@@ -0,0 +1,19 @@
+# sudoku-pro: Sudoku Generator and Sudoku Solver
+
+sudoku-pro is a Node.js package that provides functionalities to generate, solve, and print Sudoku puzzles of varying difficulty levels using the backtracking algorithm. It offers an easy-to-use interface to create Sudoku puzzles for entertainment and educational purposes. The main idea behind this package was to test the potential of the backtracking algorithm for generating Sudoku puzzles of different difficulty levels, making it suitable for both recreational and educational purposes.
+
+## Installation
+
+You can install the package via npm:
+
+```bash
+npm i sudoku-pro
+```
+
+## Usage
+
+```npm
+npm run easy
+npm run medium
+npm run hard
+```

package/license

@@ -0,0 +1,20 @@
+Copyright (c) 2011-2016 Ashish Vashisht <concur.dev@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "sudoku-pro",
+  "version": "1.0.0",
+  "description": "sudoku-pro humbly presents itself as your go-to Node.js toolkit for generating, solving, and printing Sudoku puzzles spanning different difficulty levels. Powered by the reliable backtracking algorithm, it aspires to offer enthusiasts and learners alike a simple yet effective platform to engage with Sudoku puzzles. With Sudoku-Pro, embark on a journey of brain-teasing challenges or delve into educational endeavors with ease. Our humble interface aims to make Sudoku puzzle creation and enjoyment accessible to all, ensuring a delightful experience for users of varying skill levels. Join us in exploring the possibilities of Sudoku puzzles while we humbly accompany you on your puzzle-solving adventures.",
+  "main": "sudoku-pro.js",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/concurdev/sudoku-pro.git"
+  },
+  "scripts": {
+    "easy": "node sudoku-pro e",
+    "medium": "node sudoku-pro m",
+    "hard": "node sudoku-pro h"
+  },
+  "files": [
+    "sudoku-pro.js"
+  ],
+  "keywords": [
+    "Sudoku",
+    "Puzzle",
+    "Game",
+    "Logic",
+    "Numbers",
+    "Board",
+    "Generator",
+    "Solver",
+    "Difficulty",
+    "Easy",
+    "Medium",
+    "Hard",
+    "Logic Game",
+    "Recreational Mathematics",
+    "Brain Teaser",
+    "Puzzle Game",
+    "Numbers Game"
+  ],
+  "author": "Ashish Vashisht",
+  "license": "MIT",
+  "engines": {
+    "node": ">= 10"
+  },
+  "bugs": {
+    "url": "https://github.com/concurdev/sudoku-pro/issues"
+  },
+  "homepage": "https://github.com/concurdev/sudoku-pro#readme",
+  "devDependencies": {}
+}

package/sudoku-pro.js

@@ -0,0 +1,185 @@
+// Get the difficulty level
+const args = process.argv.slice(2);
+
+function shuffle(array) {
+    // Fisher-Yates shuffle algorithm
+    for (let i = array.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [array[i], array[j]] = [array[j], array[i]];
+    }
+    return array;
+}
+
+function generateSudoku(difficulty) {
+    const sudoku = Array.from({ length: 9 }, () => Array(9).fill(0));
+
+    // Fill the diagonal blocks (3x3 sub-grids) with valid numbers
+    for (let i = 0; i < 9; i += 3) {
+        const nums = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+        shuffle(nums);
+        for (let j = 0; j < 3; j++) {
+            for (let k = 0; k < 3; k++) {
+                sudoku[i + j][i + k] = nums.pop();
+            }
+        }
+    }
+
+    // Solve the puzzle
+    solveSudoku(sudoku);
+
+    // Determine the number of cells to remove based on difficulty level
+    let numToRemove;
+    if (difficulty === 'e') {
+        numToRemove = Math.floor(Math.random() * 20) + 20; // Easy difficulty
+    } else if (difficulty === 'm') {
+        numToRemove = Math.floor(Math.random() * 25) + 40; // Medium difficulty
+    } else if (difficulty === 'h') {
+        numToRemove = Math.floor(Math.random() * 30) + 55; // Hard difficulty
+    } else {
+        throw new Error('Invalid difficulty level. Please use "e" for easy, "m" for medium, or "h" for hard.');
+    }
+
+    // Remove some numbers to create the puzzle
+    for (let i = 0; i < numToRemove; i++) {
+        const row = Math.floor(Math.random() * 9);
+        const col = Math.floor(Math.random() * 9);
+        if (sudoku[row][col] !== 0) {
+            sudoku[row][col] = 0;
+        } else {
+            i--; // Try again if the cell is already empty
+        }
+    }
+
+    return sudoku;
+}
+
+function solveSudoku(sudoku) {
+    const emptyCell = findEmptyCell(sudoku);
+    if (!emptyCell) {
+        return true; // Puzzle solved successfully
+    }
+
+    const [row, col] = emptyCell;
+    for (let num = 1; num <= 9; num++) {
+        if (isValidMove(sudoku, row, col, num)) {
+            sudoku[row][col] = num;
+            if (solveSudoku(sudoku)) {
+                return true;
+            }
+            sudoku[row][col] = 0; // Undo the assignment
+        }
+    }
+
+    return false; // No solution found, backtrack
+}
+
+function findEmptyCell(sudoku) {
+    // Function to find an empty cell in the Sudoku grid
+    for (let row = 0; row < 9; row++) {
+        for (let col = 0; col < 9; col++) {
+            if (sudoku[row][col] === 0) {
+                return [row, col];
+            }
+        }
+    }
+    return null; // No empty cell found
+}
+
+function isValidMove(sudoku, row, col, num) {
+    // Check if assigning num to the cell at (row, col) is a valid move
+    // Check row
+    for (let i = 0; i < 9; i++) {
+        if (sudoku[row][i] === num) {
+            return false; // Number already exists in the row
+        }
+    }
+
+    // Check column
+    for (let i = 0; i < 9; i++) {
+        if (sudoku[i][col] === num) {
+            return false; // Number already exists in the column
+        }
+    }
+
+    // Check 3x3 subgrid
+    const startRow = Math.floor(row / 3) * 3;
+    const startCol = Math.floor(col / 3) * 3;
+    for (let i = 0; i < 3; i++) {
+        for (let j = 0; j < 3; j++) {
+            if (sudoku[startRow + i][startCol + j] === num) {
+                return false; // Number already exists in the subgrid
+            }
+        }
+    }
+
+    return true; // Valid move
+}
+
+function printSudoku(sudoku) {
+    console.log("Sudoku Puzzle:");
+    console.log("-------------------------");
+    sudoku.forEach((row, rowIndex) => {
+        if (rowIndex % 3 === 0 && rowIndex !== 0) {
+            console.log("------|-------|-------");
+        }
+        row.forEach((cell, cellIndex) => {
+            if (cellIndex % 3 === 0 && cellIndex !== 0) {
+                process.stdout.write("| ");
+            }
+            process.stdout.write(String(cell || '.') + ' ');
+            if (cellIndex === 8) {
+                console.log();
+            }
+        });
+    });
+    console.log("-------------------------");
+}
+
+function printSudokuWithAnswers(sudoku) {
+    console.log("Sudoku Puzzle with Answers:");
+    console.log("-------------------------");
+    sudoku.forEach((row, rowIndex) => {
+        if (rowIndex % 3 === 0 && rowIndex !== 0) {
+            console.log("------|-------|-------");
+        }
+        row.forEach((cell, cellIndex) => {
+            if (cellIndex % 3 === 0 && cellIndex !== 0) {
+                process.stdout.write("| ");
+            }
+            process.stdout.write(String(cell) + ' ');
+            if (cellIndex === 8) {
+                console.log();
+            }
+        });
+    });
+    console.log("-------------------------");
+    // set flag to true and clear interval 
+    sudokuPrinted = true;
+    clearInterval(intervalId);
+}
+
+const difficulty = args[0]; // Get the difficulty level from command line arguments
+
+let sudokuPrinted = false;
+
+// Set interval to run every 5 seconds
+const intervalId = setInterval(() => {
+    // Check if sudokuPrinted is true
+    if (sudokuPrinted) {
+        // If sudokuPrinted is true, clear the interval
+        clearInterval(intervalId);
+    } else {
+        // If sudokuPrinted is false, continue executing
+        const sudoku = generateSudoku(difficulty);
+        printSudoku(sudoku);
+        solveSudoku(sudoku); // Solve the generated puzzle
+        printSudokuWithAnswers(sudoku);
+    }
+}, 5000);
+
+module.exports = {
+    generateSudoku,
+    printSudoku,
+    solveSudoku,
+    printSudokuWithAnswers
+};