merge change

Author: JenilGajjar20

.DS_Store

@@ -0,0 +1,27 @@
+# N-Queens
+
+## Problem Description
+The **N-Queens** puzzle requires placing `n` queens on an `n x n` chessboard such that no two queens threaten each other. A queen can attack any piece in the same row, column, or diagonal. 
+
+Given an integer `n`, the task is to find all distinct solutions to the N-Queens puzzle. Each solution should be represented as a distinct board configuration where `'Q'` denotes a queen, and `'.'` denotes an empty square.
+
+## Objective
+Return all possible configurations of the N-Queens puzzle in any order, where each configuration is a list of strings representing the chessboard.
+
+---
+
+### Constraints
+- `1 <= n <= 9`
+
+### Example
+**Input**
+```plaintext
+n = 4
+```
+
+
+**Output**
+```plaintext
+[[".Q..","...Q","Q...","..Q."],
+ ["..Q.","Q...","...Q",".Q.."]]
+```

Cpp/.DS_Store

@@ -0,0 +1,51 @@
+class Solution {
+public:
+    // Recursive function to place queens row by row
+    void rec(int r, int n, vector<string>& ve, vector<pair<int, int>>& queens, vector<vector<string>>& out) {
+        // Base case: if we've placed queens in all rows, add current board configuration to output
+        if (r == n) {
+            out.push_back(ve);
+            return;
+        }
+        
+        // Try placing a queen in each column of the current row
+        for (int c = 0; c < n; c++) {
+            bool poss = true; 
+            
+            // Check against previously placed queens to see if (r, c) is a valid position
+            for (auto& p : queens) {
+                int xr = p.first;
+                int xc = p.second;
+                
+                // A queen can attack if in the same row, column, or diagonal
+                if (xr == r || xc == c || abs(xr - r) == abs(xc - c)) {
+                    poss = false; 
+                    break;
+                }
+            }
+            
+            // If (r, c) is not a valid position, skip to the next column
+            if (!poss) continue;
+            
+            // Place the queen at (r, c) and mark it on the board
+            queens.push_back({r, c});
+            ve[r][c] = 'Q';
+            
+            // Recurse to the next row to place the next queen
+            rec(r + 1, n, ve, queens, out);
+            
+            // Backtrack: remove the queen from (r, c) and unmark it on the board
+            ve[r][c] = '.';
+            queens.pop_back();
+        }
+    }
+
+    // Main function to initiate the N-Queens solution finding
+    vector<vector<string>> solveNQueens(int n) {
+        vector<vector<string>> out;   
+        vector<string> ve(n, string(n, '.'));
+        vector<pair<int, int>> queens;
+        rec(0, n, ve, queens, out);
+        return out;
+    }
+};

Cpp/0051-N-Queen-I/problem.md

@@ -0,0 +1,40 @@
+# N-Queens II
+
+## Problem Description
+The **N-Queens puzzle** is the problem of placing `n` queens on an `n x n` chessboard so that no two queens can attack each other (no same row, column, or diagonal). This variation of the problem, N-Queens II, requires counting the number of distinct solutions rather than returning each configuration.
+
+Given an integer `n`, return the number of unique ways to arrange the queens on the chessboard.
+
+## Objective
+Return the count of all valid configurations for the N-Queens puzzle, where each configuration ensures that no two queens attack each other.
+
+---
+
+### Constraints
+- `1 <= n <= 9`
+
+### Examples
+
+**Example 1**
+
+**Input**
+```plaintext
+n = 4
+```
+
+**Output**
+```plaintext
+2
+```
+
+**Example 2**
+
+**Input**
+```plaintext
+n = 1
+```
+
+**Output**
+```plaintext
+1
+```

Cpp/0051-N-Queen-I/solution.cpp

@@ -0,0 +1,47 @@
+class Solution {
+public:
+    // Recursive function to count valid queen placements row by row
+    int rec(int r, int n, vector<pair<int, int>>& queens) {
+        // Base case: if all queens are placed, count this configuration as valid
+        if (r == n) return 1;
+        
+        int ans = 0;
+
+        // Try placing a queen in each column of the current row
+        for (int c = 0; c < n; c++) {
+            bool poss = true;
+            
+            // Check against previously placed queens to see if (r, c) is a valid position
+            for (auto& p : queens) {
+                int xr = p.first;
+                int xc = p.second;
+                
+                // A queen can attack if in the same row, column, or diagonal
+                if (xr == r || xc == c || abs(xr - r) == abs(xc - c)) {
+                    poss = false;
+                    break;
+                }
+            }
+
+            // If (r, c) is not a valid position, skip to the next column
+            if (!poss) continue;
+
+            // Place the queen at (r, c) and mark it in the queens vector
+            queens.push_back({r, c});
+            
+            // Recurse to the next row to continue placing queens
+            ans += rec(r + 1, n, queens);
+            
+            // Backtrack: remove the queen from (r, c)
+            queens.pop_back();
+        }
+        
+        return ans; 
+    }
+
+    // Main function to initiate the N-Queens solution count
+    int totalNQueens(int n) {
+        vector<pair<int, int>> queens; 
+        return rec(0, n, queens); 
+    }
+};

Cpp/0052-N-Queen-II/problem.md

@@ -0,0 +1,26 @@
+# [136. Single Number](https://leetcode.com/problems/single-number/)
+
+<div class="elfjS" data-track-load="description_content"><p>Given a <strong>non-empty</strong>&nbsp;array of integers <code>nums</code>, every element appears <em>twice</em> except for one. Find that single one.</p>
+
+<p>You must&nbsp;implement a solution with a linear runtime complexity and use&nbsp;only constant&nbsp;extra space.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [2,2,1]
+<strong>Output:</strong> 1
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [4,1,2,1,2]
+<strong>Output:</strong> 4
+</pre><p><strong class="example">Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [1]
+<strong>Output:</strong> 1
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>-3 * 10<sup>4</sup> &lt;= nums[i] &lt;= 3 * 10<sup>4</sup></code></li>
+	<li>Each element in the array appears twice except for one element which appears only once.</li>
+</ul>
+</div>

Cpp/0052-N-Queen-II/solution.cpp

@@ -0,0 +1,20 @@
+class Solution
+{
+public:
+    int singleNumber(vector<int> &nums)
+    {
+        // Initialize a variable `xorr` to 0, which will be used to store the XOR result.
+        int xorr = 0;
+
+        // Iterate through each element in the array `nums`.
+        for (int i = 0; i < nums.size(); i++)
+        {
+            // Apply XOR operation between `xorr` and the current element `nums[i]`.
+            // This will cancel out all elements that appear twice and leave only the single element.
+            xorr = xorr ^ nums[i];
+        }
+
+        // Return the remaining element, which is the single element that does not have a duplicate.
+        return xorr;
+    }
+};

Cpp/0136-Single-Number/Problem.md

@@ -0,0 +1,35 @@
+<h1><a href = "https://leetcode.com/problems/house-robber-ii/description/">213. House Robber II</h1>
+
+## Problem Statement
+
+You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed. All houses at this place are arranged in a circle. That means the first house is the neighbor of the last one. Meanwhile, adjacent houses have a security system connected, and it will automatically contact the police if two adjacent houses are broken into on the same night.
+
+Given an integer array `nums` representing the amount of money of each house, return the maximum amount of money you can rob tonight without alerting the police.
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre>
+<strong>Input: </strong> nums = [2,3,2]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> You cannot rob house 1 (money = 2) and then rob house 3 (money = 2), 
+because they are adjacent houses.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<pre>
+<strong>Input:</strong> nums = [1,2,3,1]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Rob house 1 (money = 1) and then rob house 3 (money = 3). 
+Total amount you can rob = 1 + 3 = 4.
+</pre>
+  
+<p><strong class="example">Example 3:</strong></p>
+<pre>
+<strong>Input:</strong> nums = [1,2,3]
+<strong>Output:</strong> 3
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+- `1 <= nums.length <= 100`
+- `0 <= nums[i] <= 1000`

Cpp/0136-Single-Number/Solution.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    int rob(vector<int>& nums) {
+        int n = nums.size();
+        
+        // Handle edge cases
+        if (n == 0) return 0; // No houses
+        if (n == 1) return nums[0]; // Only one house
+
+        // Helper function to calculate max loot for a linear array
+        auto robLinear = [](const vector<int>& nums, int start, int end) {
+            int prev1 = 0, prev2 = 0; // Initialize previous two max values
+            for (int i = start; i < end; ++i) {
+                int pick = nums[i] + prev1; // Value if we pick current house
+                int notPick = prev2; // Value if we do not pick current house
+                int curr = max(pick, notPick); // Max of both options
+                prev1 = prev2; // Update previous for the next iteration
+                prev2 = curr;
+            }
+            return prev2; // Return the maximum value obtained
+        };
+
+        // Rob houses excluding the last house and then excluding the first house
+        int maxLoot1 = robLinear(nums, 0, n - 1); // From house 0 to house n-2
+        int maxLoot2 = robLinear(nums, 1, n); // From house 1 to house n-1
+
+        // Return the maximum of both scenarios
+        return max(maxLoot1, maxLoot2);
+    }
+};