Merge branch 'main' into gfg0100

Author: Ishita-Jena

deployment-app.yml

@@ -0,0 +1,22 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  # Unique key of the Deployment instance
+  name: my-node-app
+spec:
+  # 2 Pods should exist at all times.
+  replicas: 2
+  selector:
+    matchLabels:
+      app: node-app
+  template:
+    metadata:
+      labels:
+        # Apply this label to pods and default
+        # the Deployment label selector to this value
+        app: node-app
+    spec:
+      containers:
+        - name: node-app
+          # Run this image
+          image: #put your image name which you push in dockerhub

dsa-solutions/lc-solutions/0300-0399/0384-Shuffle-an-Array.md

@@ -0,0 +1,139 @@
+---
+id: shuffle-an-array
+title: Shuffle-an-Array
+sidebar_label: 0384-Shuffle an Array
+tags:
+  - Leet code
+description: "Solution to leetocde 384"
+---
+
+### Problem Description
+
+Given an integer array nums, design an algorithm to randomly shuffle the array. All permutations of the array should be equally likely as a result of the shuffling.
+
+Implement the Solution class:
+
+- `Solution(int[] nums)` Initializes the object with the integer array nums.
+- `int[] reset()` Resets the array to its original configuration and returns it.
+- `int[] shuffle()` Returns a random shuffling of the array.
+
+Example 1:
+
+```
+Input
+["Solution", "shuffle", "reset", "shuffle"]
+[[[1, 2, 3]], [], [], []]
+Output
+[null, [3, 1, 2], [1, 2, 3], [1, 3, 2]]
+
+Explanation
+Solution solution = new Solution([1, 2, 3]);
+solution.shuffle();    // Shuffle the array [1,2,3] and return its result.
+                       // Any permutation of [1,2,3] must be equally likely to be returned.
+                       // Example: return [3, 1, 2]
+solution.reset();      // Resets the array back to its original configuration [1,2,3]. Return [1, 2, 3]
+solution.shuffle();    // Returns the random shuffling of array [1,2,3]. Example: return [1, 3, 2]
+```
+
+### Constraints:
+
+- `1 <= nums.length <= 50`
+- `-10^6 <= nums[i] <= 10^6`
+
+### Motive
+
+Our motive in this question is to find a random permutation of an array on demand. Now this random permutation should be trully random with a uniform probability distribution.
+In other words, for any call to shuffle(), all permutations of the array should have equal probability of being returned.
+
+Let's try doing it by hand. We take the elements of the array in a bag and shuffle them, then for each position in the shuffled array, we draw one element from the bag, and put that element in that position, and so on, until the bag is empty.
+We can simulate this exact process in our code by maintaining a copy of the original array and generating a random index of the array to put at each index.
+
+But the problem arises in the exclusion of the selected elements from the bag. We could do a normal array delete `(or shift)` and that would cost us `O(n)` in the worst case, making our time complexity $O(n^2)$, but we can do better.
+
+
+### Code Implementation
+
+**Python:**
+
+```python
+class Solution(object):
+    def __init__(self, nums):
+        self.reset = lambda: nums
+        self.shuffle = lambda: random.sample(nums, len(nums))
+```
+
+**C++:**
+
+```c++
+class Solution {
+	vector<int> original;
+	int n;
+public:
+
+	Solution(vector<int>& nums) {
+		original = nums;
+		n = original.size();
+	}
+	
+	vector<int> reset() {
+		return original;
+	}
+	
+	vector<int> shuffle() {
+			//make a copy of the original
+			vector<int> shuffled = original;
+			
+			int leftSize = n;
+			for(int i = n-1; i>=0; i--) {
+				//draw from the bag
+				int j = rand()%leftSize;
+				
+				//put this element at current position
+				//and put the original element in the bag
+				swap(shuffled[i], shuffled[j]);
+				leftSize--;
+			}
+			return shuffled;
+	}
+	
+};
+```
+
+**Java:**
+
+```java
+import java.util.Random;
+
+public class Solution {
+    private int[] nums;
+    private Random random;
+
+    public Solution(int[] nums) {
+        this.nums = nums;
+        random = new Random();
+    }
+    
+    /** Resets the array to its original configuration and return it. */
+    public int[] reset() {
+        return nums;
+    }
+    
+    /** Returns a random shuffling of the array. */
+    public int[] shuffle() {
+        if(nums == null) return null;
+        int[] a = nums.clone();
+        for(int j = 1; j < a.length; j++) {
+            int i = random.nextInt(j + 1);
+            swap(a, i, j);
+        }
+        return a;
+    }
+    
+    private void swap(int[] a, int i, int j) {
+        int t = a[i];
+        a[i] = a[j];
+        a[j] = t;
+    }
+}
+```
+

dsa-solutions/lc-solutions/0300-0399/0386-Lexicographical-Numbers.md

@@ -0,0 +1,107 @@
+---
+id: lexicographical-numbers
+title: Lexicographical-Numbers
+sidebar_label: 0389-Lexicographical-Numbers
+tags:
+  - Leet code
+description: "Solution to leetocde 386"
+---
+
+### Problem Description
+
+Given an integer `n`, return all the numbers in the range `[1, n]` sorted in lexicographical order.
+
+You must write an algorithm that runs in $O(n)$ time and uses $O(1)$ extra space. 
+
+Example 1:
+
+```
+Input: n = 13
+Output: [1,10,11,12,13,2,3,4,5,6,7,8,9]
+
+```
+
+Example 2:
+
+```
+Input: n = 2
+Output: [1,2]
+
+```
+
+### Constraints:
+
+- `1 <= n <= 5 * 10^4`
+
+### Algorithm
+
+The basic idea is to find the next number to add.
+Take 45 for example: if the current number is 45, the next one will be `450 (450 == 45 * 10)(if 450 <= n)`, or `46 (46 == 45 + 1) (if 46 <= n)` or `5 (5 == 45 / 10 + 1)`(5 is less than 45 so it is for sure less than n).
+We should also consider `n = 600`, and the current number = 499, the next number is `5` because there are all "9"s after "4" in `"499"` so we should divide `499 by 10` until the last digit is not `"9"`.
+It is like a tree, and we are easy to get a sibling, a left most child and the parent of any node.
+
+### Code Implementation
+
+**Python:**
+
+```python
+def lexicalOrder(self, n):
+    top = 1
+    while top * 10 <= n:
+        top *= 10
+    def mycmp(a, b, top=top):
+        while a < top: a *= 10
+        while b < top: b *= 10
+        return -1 if a < b else b < a
+    return sorted(xrange(1, n+1), mycmp)
+    
+```
+
+**C++:**
+
+```c++
+class Solution {
+public:
+    vector<int> lexicalOrder(int n) {
+        vector<int> res(n);
+        int cur = 1;
+        for (int i = 0; i < n; i++) {
+            res[i] = cur;
+            if (cur * 10 <= n) {
+                cur *= 10;
+            } else {
+                if (cur >= n) 
+                    cur /= 10;
+                cur += 1;
+                while (cur % 10 == 0)
+                    cur /= 10;
+            }
+        }
+        return res;
+    }
+};
+```
+
+**Java:**
+
+```java
+public List<Integer> lexicalOrder(int n) {
+        List<Integer> list = new ArrayList<>(n);
+        int curr = 1;
+        for (int i = 1; i <= n; i++) {
+            list.add(curr);
+            if (curr * 10 <= n) {
+                curr *= 10;
+            } else if (curr % 10 != 9 && curr + 1 <= n) {
+                curr++;
+            } else {
+                while ((curr / 10) % 10 == 9) {
+                    curr /= 10;
+                }
+                curr = curr / 10 + 1;
+            }
+        }
+        return list;
+    }
+```
+

dsa-solutions/lc-solutions/1400-1499/1431-kids-with-the-greatest-number-of-candies.md

@@ -0,0 +1,101 @@
+---
+id: kids-with-the-greatest-number-of-candies
+title: Kids With the Greatest Number of Candies
+level: easy
+sidebar_label: Kids With the Greatest Number of Candies
+tags:
+  - Array
+  - Greedy
+  - Java
+description: "This document provides solutions for the Kids With the Greatest Number of Candies problem."
+---
+
+## Problem Statement
+
+There are `n` kids with candies. You are given an integer array `candies`, where each `candies[i]` represents the number of candies the ith kid has, and an integer `extraCandies`, denoting the number of extra candies that you have.
+
+Return a boolean array `result` of length `n`, where `result[i]` is `true` if, after giving the ith kid all the `extraCandies`, they will have the greatest number of candies among all the kids, or `false` otherwise.
+
+**Example 1:**
+
+Input: `candies = [2,3,5,1,3]`, `extraCandies = 3`
+
+Output: `[true,true,true,false,true]`
+
+Explanation: If you give all `extraCandies` to:
+- Kid 1, they will have `2 + 3 = 5` candies, which is the greatest among the kids.
+- Kid 2, they will have `3 + 3 = 6` candies, which is the greatest among the kids.
+- Kid 3, they will have `5 + 3 = 8` candies, which is the greatest among the kids.
+- Kid 4, they will have `1 + 3 = 4` candies, which is not the greatest among the kids.
+- Kid 5, they will have `3 + 3 = 6` candies, which is the greatest among the kids.
+
+**Example 2:**
+
+Input: `candies = [4,2,1,1,2]`, `extraCandies = 1`
+
+Output: `[true,false,false,false,false]`
+
+Explanation: There is only `1` extra candy.
+Kid 1 will always have the greatest number of candies, even if a different kid is given the extra candy.
+
+**Example 3:**
+
+Input: `candies = [12,1,12]`, `extraCandies = 10`
+
+Output: `[true,false,true]`
+
+**Constraints:**
+
+- `n == candies.length`
+- `2 <= n <= 100`
+- `1 <= candies[i] <= 100`
+- `1 <= extraCandies <= 50`
+
+## Solutions
+
+### Approach
+
+To determine if each kid can have the greatest number of candies after receiving `extraCandies`, follow these steps:
+
+1. **Find the Maximum Candies:**
+   - Traverse through the `candies` array to find the maximum number of candies any kid currently has.
+
+2. **Check Each Kid's Condition:**
+   - Iterate through the `candies` array again.
+   - For each kid, check if adding `extraCandies` to their current candies makes their total candies equal to or greater than the maximum number found.
+   - Store `true` if the condition is met, otherwise store `false`.
+
+### Java 
+
+```java
+
+class Solution {
+    public List<Boolean> kidsWithCandies(int[] candies, int extraCandies) {
+        int maxCandies = 0;
+        for (int candy : candies) {
+            maxCandies = Math.max(maxCandies, candy);
+        }
+        
+        List<Boolean> result = new ArrayList<>();
+        for (int candy : candies) {
+            result.add(candy + extraCandies >= maxCandies);
+        }
+        
+        return result;
+    }
+
+}
+```
+
+### Python 
+```Python
+class Solution:
+    def kidsWithCandies(self, candies: List[int], extraCandies: int) -> List[bool]:
+        maxCandies = max(candies)
+        result = []
+        
+        for candy in candies:
+            result.append(candy + extraCandies >= maxCandies)
+        
+        return result
+```

service-app.yml

@@ -0,0 +1,14 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: service-my-node-app
+spec:
+  ports:
+    - name: http
+      port: 8080
+      targetPort: 3000
+  selector:
+    # Loadbalance traffic across Pods matching
+    # this label selector
+    app: node-app
+  type: LoadBalancer