kk

src/main/java/com/dota/map/_1399/Solution.java

@@ -0,0 +1,32 @@
+package com.dota.map._1399;
+
+import java.util.HashMap;
+
+class Solution {
+	public int countLargestGroup(int n) {
+		int max = 0;
+    var map = new HashMap<Integer, Integer>();
+		for (int i = 1; i < n; i++) {
+			int t = sum(i);
+			map.put(t, map.getOrDefault(t, 0) + 1);
+			max = Math.max(max, map.get(t));
+		}
+		int cnt = 0;
+		int finalMax = max;
+		for (Integer v : map.values()) {
+			if (v== finalMax) {
+				cnt++;
+			}
+		}
+		return cnt;
+	}
+
+	int sum(int n) {
+		int sum = 0;
+		while (n > 0) {
+			sum += n % 10;
+			n /= 10;
+		}
+		return sum;
+	}
+}

src/main/java/com/dota/slidingWindow/_1471/Solution.java

@@ -0,0 +1,21 @@
+package com.dota.slidingWindow._1471;
+
+import java.util.Arrays;
+
+class Solution {
+	public int[] getStrongest(int[] arr, int k) {
+		var res = new int[k];
+		Arrays.sort(arr);
+		int l = 0, r = arr.length - 1;
+    int i = 0;
+		int m = arr[(arr.length-1)/2];
+		while(i<k) {
+			if(Math.abs(arr[r]-m) >= Math.abs(arr[l]-m)) {
+				res[i++] = arr[r--];
+			}else {
+				res[i++] = arr[l++];
+			}
+		}
+		return res;
+	}
+}

src/main/java/com/dota/slidingWindow/_1750/Solution.java

@@ -0,0 +1,23 @@
+package com.dota.slidingWindow._1750;
+
+class Solution {
+	public int minimumLength(String s) {
+		int i = 0;
+		int r = s.length() - 1;
+		while (i <= r && s.charAt(i) == s.charAt(r)) {
+			int a = i + 1;
+			while (s.charAt(i) == s.charAt(a) && a <= r) {
+				a++;
+			}
+
+			while (s.charAt(r) == s.charAt(i) && i <= r) {
+				r--;
+			}
+			i = a;
+		}
+		if (i>=r) {
+			return 0;
+		}
+		return r - i + 1;
+	}
+}

src/main/java/com/dota/slidingWindow/_2105/Solution.java

@@ -0,0 +1,35 @@
+package com.dota.slidingWindow._2105;
+
+class Solution {
+	public int minimumRefill(int[] plants, int capacityA, int capacityB) {
+		int l = 0, r = plants.length - 1;
+		int a = capacityA, b = capacityB;
+		int res = 0;
+		while (l < r) {
+			if (a >= plants[l]) {
+				a -= plants[l];
+			} else {
+				a = capacityA - plants[l];
+				res++;
+			}
+
+			if (b >= plants[r]) {
+				b -= plants[r];
+			} else {
+				b = capacityB - plants[r];
+				res++;
+			}
+			l++;
+			r--;
+		}
+		if (l == r) {
+			if (a >= b && a < plants[l]) {
+				res++;
+			} else if (b < plants[l]) {
+				res++;
+			}
+		}
+
+		return res;
+	}
+}

src/main/java/com/dota/slidingWindow/_2799/Solution.java

@@ -0,0 +1,32 @@
+package com.dota.slidingWindow._2799;
+
+import java.util.HashMap;
+
+class Solution {
+	public int countCompleteSubarrays(int[] nums) {
+		var map = new HashMap<Integer, Integer>();
+		for (int num : nums) {
+			map.put(num, 1);
+		}
+		int k = map.size();
+		int l = 0;
+		int res = 0;
+		int cnt = 0;
+		map.clear();
+		for (int num : nums) {
+			map.merge(num, 1, Integer::sum);
+			if (map.get(num) == 1) {
+				cnt++;
+			}
+			while (cnt == k) {
+				map.merge(nums[l], -1, Integer::sum);
+				if (map.get(nums[l]) == 0) {
+					cnt--;
+				}
+				l++;
+			}
+			res += l;
+		}
+		return res;
+	}
+}