Add more questions

Author: Sanajit Jana

Easy_Backup_$(date +%Y%m%d_%H%M%S)/0231-power-of-two.java

@@ -0,0 +1,34 @@
+/**
+ * 231. Power of Two
+ * Difficulty: Easy
+ * URL: https://leetcode.com/problems/power-of-two/description/
+ *
+ * ---------------------
+ * Approach 1: Iterative Division
+ *
+ * - A number `n` is a power of two if it can be written as 2^k (where k ≥ 0).
+ * - If `n` is positive and divisible by 2, we keep dividing it by 2.
+ * - If after dividing repeatedly, the result becomes 1, then it was a power of two.
+ * - Otherwise, it is not.
+ *
+ * Example:
+ *   n = 16 → 16/2=8 → 8/2=4 → 4/2=2 → 2/2=1 ✅ Power of Two
+ *   n = 12 → 12/2=6 → 6/2=3 ❌ not 1 → Not a Power of Two
+ *
+ * ---------------------
+ * Time Complexity: O(log n)
+ *   - In each step we divide by 2 → about log₂(n) steps.
+ *
+ * Space Complexity: O(1)
+ *   - Only using a few variables, no extra space.
+ */
+class Solution {
+    public boolean isPowerOfTwo(int n) {
+        if (n <= 0)
+            return false;
+        while (n % 2 == 0) {
+            n = n / 2;
+        }
+        return n == 1;
+    }
+}

Easy_Backup_$(date +%Y%m%d_%H%M%S)/0342-power-of-four.java

@@ -0,0 +1,26 @@
+/**
+ * 342. Power of Four
+ * Difficulty: Easy
+ * URL: https://leetcode.com/problems/power-of-four/
+ *
+ * ---------------------
+ * Approach: Iterative Division
+ * ---------------------
+ * - If n <= 0, return false (negative numbers and zero can’t be powers of 4).
+ * - Repeatedly divide n by 4 while it is divisible by 4.
+ * - After the loop, if n reduces to 1 → it’s a power of 4, otherwise not.
+ *
+ * Time Complexity:  O(log₄ n)  // dividing by 4 each time
+ * Space Complexity: O(1)
+ */
+
+
+class Solution {
+    public boolean isPowerOfFour(int n) {
+        if (n <= 0)
+            return false;
+        while (n % 4 == 0)
+            n = n / 4;
+        return n == 1;
+    }
+}

Easy_Backup_$(date +%Y%m%d_%H%M%S)/0812-largest-triangle-area.java

@@ -0,0 +1,53 @@
+/*
+    Question: Largest Triangle Area
+    Link: https://leetcode.com/problems/largest-triangle-area/
+
+    Question Info:
+    You are given an array of points on a 2D plane. Each point is represented as an integer coordinate [x, y].
+    Your task is to return the largest area of a triangle formed by any three points in the given array.
+
+    Approach:
+    1. Use the shoelace formula (determinant method) to compute the area of a triangle formed by three points (x1,y1), (x2,y2), (x3,y3).
+       Formula:
+         Area = 0.5 * |x1(y2 − y3) + x2(y3 − y1) + x3(y1 − y2)|
+    2. Iterate over all possible triplets of points using three nested loops.
+    3. For each triplet, calculate the area using the formula and update the maximum area found.
+    4. Return the maximum area.
+
+    Dry Run:
+    Example: points = [[0,0],[0,1],[1,0],[0,2],[2,0]]
+
+    - Pick (0,0), (0,1), (1,0) → Area = 0.5
+    - Pick (0,0), (0,2), (2,0) → Area = 2
+    - Pick (0,1), (0,2), (2,0) → Area = 1
+    - After checking all triplets, maximum = 2
+
+    Time Complexity: O(n^3), since we check all triplets of points.
+    Space Complexity: O(1), only a few variables used.
+*/
+
+class Solution {
+    public double largestTriangleArea(int[][] points) {
+        int length = points.length;
+        double maxArea = Double.MIN_VALUE;
+
+        for (int i = 0; i < length - 2; i++) {
+            for (int j = i + 1; j < length - 1; j++) {
+                for (int k = j + 1; k < length; k++) {
+
+                    int x1 = points[i][0], y1 = points[i][1];
+                    int x2 = points[j][0], y2 = points[j][1];
+                    int x3 = points[k][0], y3 = points[k][1];
+
+                    double area = 0.5 * Math.abs(
+                            x1 * (y2 - y3) +
+                            x2 * (y3 - y1) +
+                            x3 * (y1 - y2));
+
+                    maxArea = Math.max(maxArea, area);
+                }
+            }
+        }
+        return maxArea;
+    }
+}

Easy_Backup_$(date +%Y%m%d_%H%M%S)/0830-positions-of-large-groups.java

@@ -0,0 +1,55 @@
+/**
+ * Title: Positions of Large Groups
+ * LeetCode Link: https://leetcode.com/problems/positions-of-large-groups/
+ *
+ * Question Info:
+ * In a string s of lowercase letters, a group is a consecutive run of the same character.
+ * A large group is defined as a group that has length >= 3.
+ * Return the intervals [start, end] of every large group sorted in increasing order of start index.
+ *
+ * Example:
+ * Input: s = "abbxxxxzzy"
+ * Output: [[3,6]]
+ *
+ * Approach:
+ * - Use two pointers to track the start of a group and the current index.
+ * - Iterate through the string from i = 1 to n.
+ * - If we reach the end OR the current char differs from the start char:
+ *     - Check if the group length >= 3.
+ *     - If yes, record the interval [start, i-1].
+ *     - Move start = i to begin a new group.
+ * - Return the list of all intervals.
+ *
+ * Dry Run (s = "abbxxxxzzy"):
+ * i=1: s[1]='b', s[0]='a' => different, group size=1 (<3), skip, start=1
+ * i=2: s[2]='b', s[1]='b' => same, continue
+ * i=3: s[3]='x', s[1]='b' => different, group size=2 (<3), skip, start=3
+ * i=4,5,6: still 'x', continue
+ * i=7: s[7]='z', s[3]='x' => different, group size=4 (>=3), record [3,6], start=7
+ * i=8: s[8]='z', s[7]='z' => same
+ * i=9: s[9]='y', s[7]='z' => different, group size=2 (<3), skip, start=9
+ * i=10: reached end, group size=1 (<3), skip.
+ * Result: [[3,6]]
+ *
+ * Time Complexity: O(n), where n = length of string (single pass).
+ * Space Complexity: O(1), ignoring output list.
+ */
+
+class Solution {
+    public List<List<Integer>> largeGroupPositions(String s) {
+        List<List<Integer>> ans = new ArrayList<>();
+        int n = s.length();
+        int start = 0;
+
+        for (int i = 1; i <= n; i++) {
+            if (i == n || s.charAt(i) != s.charAt(start)) {
+                if (i - start >= 3) {
+                    ans.add(Arrays.asList(start, i - 1));
+                }
+                start = i;
+            }
+        }
+
+        return ans;
+    }
+}

Easy_Backup_$(date +%Y%m%d_%H%M%S)/0976-largest-perimeter-triangle.java

@@ -0,0 +1,97 @@
+/*
+ * Problem Link:
+ * https://leetcode.com/problems/largest-perimeter-triangle/?envType=daily-question&envId=2025-09-28
+ *
+ * Q: Largest Perimeter Triangle
+ *
+ * You are given an array nums of non-negative integers.
+ * Return the largest perimeter of a triangle with non-zero area, formed from three of these lengths.
+ * If it is impossible to form any triangle of non-zero area, return 0.
+ *
+ * ------------------------------------------------------
+ * Approach 1: Brute Force (O(n^3))
+ * ------------------------------------------------------
+ * Idea:
+ *  - Sort the array.
+ *  - Try every possible triplet (i, j, k).
+ *  - Check the triangle inequality: 
+ *      a + b > c, a + c > b, b + c > a
+ *  - Keep track of the maximum perimeter.
+ *
+ * Dry Run Example:
+ * nums = [2, 1, 2]
+ * After sort = [1, 2, 2]
+ * Pick (1,2,2):
+ *    1 + 2 > 2 (yes)
+ *    1 + 2 > 2 (yes)
+ *    2 + 2 > 1 (yes)
+ * Valid triangle, perimeter = 5
+ * Answer = 5
+ *
+ * Time Complexity: O(n^3)
+ * Space Complexity: O(1)
+ */
+
+import java.util.Arrays;
+
+class SolutionBruteForce {
+    public int largestPerimeter(int[] nums) {
+        Arrays.sort(nums);
+        int max = 0;
+        for (int i = 0; i < nums.length - 2; i++) {
+            int x = nums[i];
+            for (int j = i + 1; j < nums.length - 1; j++) {
+                int y = nums[j];
+                for (int k = j + 1; k < nums.length; k++) {
+                    int z = nums[k];
+                    if (x + y > z && x + z > y && y + z > x) {
+                        max = Math.max(max, x + y + z);
+                    }
+                }
+            }
+        }
+        return max;
+    }
+}
+
+
+/*
+ * ------------------------------------------------------
+ * Approach 2: Optimized Greedy (O(n log n))
+ * ------------------------------------------------------
+ * Idea:
+ *  - Sort the array.
+ *  - The largest perimeter will always come from the three largest numbers
+ *    that can form a valid triangle.
+ *  - Starting from the end of the sorted array, check triplets (i, i-1, i-2).
+ *  - As soon as we find a valid triangle, return its perimeter.
+ *
+ * Why consecutive triplets are enough:
+ *  - After sorting, if nums[i-2] + nums[i-1] > nums[i], then
+ *    (nums[i-2], nums[i-1], nums[i]) is valid and maximizes perimeter.
+ *  - If not, moving left reduces the largest side, so we must keep checking.
+ *
+ * Dry Run Example:
+ * nums = [2, 1, 2]
+ * After sort = [1, 2, 2]
+ * Start from i = 2:
+ *   nums[0] + nums[1] = 1 + 2 = 3 > 2 → valid
+ *   perimeter = 1 + 2 + 2 = 5
+ * Answer = 5
+ *
+ * Time Complexity: O(n log n) (due to sorting)
+ * Space Complexity: O(1)
+ */
+
+class SolutionOptimized {
+    public int largestPerimeter(int[] nums) {
+        Arrays.sort(nums);
+        int n = nums.length;
+        for (int i = n - 1; i >= 2; i--) {
+            if (nums[i - 2] + nums[i - 1] > nums[i]) {
+                return nums[i] + nums[i - 1] + nums[i - 2];
+            }
+        }
+        return 0;
+    }
+}

Easy_Backup_$(date +%Y%m%d_%H%M%S)/1304-find-n-unique-integers-sum-up-to-zero.java

@@ -0,0 +1,66 @@
+/**
+ * Problem: Generate an array of n unique integers such that their sum is 0.
+ * 
+ * Approach 1:
+ * - Start from 1 and alternate adding -num and +num into the array.
+ * - If n is odd, include 0 in the array.
+ * - This ensures symmetry and guarantees the sum is zero.
+ * 
+ * Time Complexity: O(n)
+ * Space Complexity: O(n)
+ */
+class Solution {
+    public int[] sumZero(int n) {
+        if (n == 1) return new int[n];
+        
+        int[] arr = new int[n];
+        int index = 0;
+        if (n % 2 == 1) {
+            index = 1; // Leave space for 0 if n is odd
+        }
+        
+        boolean flag = true;
+        int num = 1;
+        
+        while (index < n) {
+            if (flag) {
+                arr[index++] = -num;
+                flag = false;
+            } else {
+                arr[index++] = num;
+                flag = true;
+                num++;
+            }
+        }
+        
+        return arr;
+    }
+}
+
+/**
+ * Approach 2 (Optimized and Cleaner):
+ * - Pair numbers symmetrically: -1 & 1, -2 & 2, ..., until n/2 pairs.
+ * - If n is odd, append 0 at the end.
+ * - Cleaner logic without flags or while-loops.
+ * 
+ * Time Complexity: O(n)
+ * Space Complexity: O(n)
+ */
+class Solution {
+    public int[] sumZero(int n) {
+        int[] arr = new int[n];
+        int pairs = n / 2;
+        int index = 0;
+        
+        for (int i = 1; i <= pairs; i++) {
+            arr[index++] = -i;
+            arr[index++] = i;
+        }
+        
+        if (n % 2 == 1) {
+            arr[index] = 0;
+        }
+        
+        return arr;
+    }
+}

Easy_Backup_$(date +%Y%m%d_%H%M%S)/1317-convert-integer-to-the-sum-of-two-no-zero-integers.java

@@ -0,0 +1,52 @@
+/**
+ * Problem:
+ * https://leetcode.com/problems/convert-integer-to-the-sum-of-two-no-zero-integers/
+ * 
+ * Given an integer n, return two integers a and b such that:
+ * - a + b == n
+ * - Neither a nor b contains the digit zero in their decimal representation.
+ * You can return any valid pair [a, b].
+ * 
+ * Example:
+ * Input: n = 11
+ * Output: [2, 9]
+ * Explanation: 2 + 9 = 11 and neither 2 nor 9 contains zero.
+ * 
+ * Constraints:
+ * - 2 <= n <= 10^4
+ * 
+ * Approach:
+ * We iterate from i = 1 to n - 1. For each i, we check if both i and (n - i)
+ * do not contain any zero digit by using the containsZero helper method.
+ * As soon as we find such a pair, we return it.
+ * The containsZero method checks if a number has the digit 0 by iterating
+ * through its digits using modulo and division.
+ * 
+ * Time Complexity:
+ * O(n * log(n)) — In the worst case, we iterate up to n and for each number,
+ * checking if it contains zero takes O(log n) time (based on the number of digits).
+ * 
+ * Space Complexity:
+ * O(1) — We only use a constant amount of extra space for variables.
+ */
+class Solution {
+    public int[] getNoZeroIntegers(int n) {
+        for (int i = 1; i < n; i++) {
+            if (!containsZero(i) && !containsZero(n - i)) {
+                return new int[] { i, n - i };
+            }
+        }
+        return new int[] { 1, n - 1 };
+    }
+
+    private boolean containsZero(int num) {
+        while (num > 0) {
+            int digit = num % 10;
+            if (digit == 0) {
+                return true;
+            }
+            num = num / 10;
+        }
+        return false;
+    }
+}