uodate code

Author: Danieldu

Array/2206.divide-array-into-equal-pairs.cpp

@@ -0,0 +1,31 @@
+/*
+ * @lc app=leetcode id=2206 lang=cpp
+ *
+ * [2206] Divide Array Into Equal Pairs
+ */
+
+// @lc code=start
+#include "bits/stdc++.h"
+
+class Solution {
+public:
+    bool divideArray(std::vector<int>& nums) {
+        // Fixed-size array to count occurrences (since x is in [1, 500])
+        int count[501] = {0};
+        
+        // Count each number's occurrence
+        for (int num : nums) {
+            count[num]++;
+        }
+        
+        for (int i = 1; i <= 500; ++i) {
+            if (count[i] % 2 != 0) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+};
+// @lc code=end
+

Array/3467.cpp

@@ -0,0 +1,24 @@
+#include "bits/stdc++.h"
+using namespace std;
+
+class Solution {
+public:
+    vector<int> transformArray(vector<int>& nums) {
+        int n = nums.size();
+        int odd =0;
+        for(int i = 0; i < n; i++){
+            if (nums[i]%2)
+                odd++;
+        }
+        for(int i = n-1; i>=0; i--){
+            if (odd>0){
+                nums[i]=1;
+                odd--;
+                continue;
+            }
+            nums[i]=0;
+        }
+
+        return nums;
+    }
+};

BinarySearch/2594.minimum-time-to-repair-cars.cpp

@@ -0,0 +1,44 @@
+/*
+ * @lc app=leetcode id=2594 lang=cpp
+ *
+ * [2594] Minimum Time to Repair Cars
+ */
+
+// @lc code=start
+#include "bits/stdc++.h"
+using namespace std;
+
+class Solution {
+public:
+    bool canRepairInTime(const vector<int>& ranks, int cars, long long time) {
+        long long total_cars = 0;
+        for (const auto& rank : ranks) {
+            total_cars += static_cast<long long>(std::sqrt(time / rank));
+            if (total_cars >= cars) {
+                return true;
+            }
+        }
+        return total_cars >= cars;
+    }
+
+    long long repairCars(std::vector<int>& ranks, int cars) {
+        long long left = 0;
+        long long min_rank = *std::min_element(ranks.begin(), ranks.end());
+        long long right = static_cast<long long>(min_rank) * cars * cars;
+        long long answer = right;
+
+        while (left <= right) {
+            long long mid = left + (right - left) / 2;
+            if (canRepairInTime(ranks, cars, mid)) {
+                answer = mid;
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+
+        return answer;
+    }
+};
+// @lc code=end
+

SlidingWindow/2379.minimum-recolors-to-get-k-consecutive-black-blocks.cpp

@@ -0,0 +1,36 @@
+/*
+ * @lc app=leetcode id=2379 lang=cpp
+ *
+ * [2379] Minimum Recolors to Get K Consecutive Black Blocks
+ */
+
+// @lc code=start
+#include "bits/stdc++.h"
+class Solution {
+public:
+    int minimumRecolors(std::string blocks, int k) {
+        int current_white = 0;
+        int min_white;
+
+        for (int i = 0; i < k; ++i) {
+            if (blocks[i] == 'W') {
+                ++current_white;
+            }
+        }
+        min_white = current_white;
+
+        for (int i = k; i < blocks.size(); ++i) {
+            if (blocks[i - k] == 'W') {
+                --current_white;
+            }
+            if (blocks[i] == 'W') {
+                ++current_white;
+            }
+            min_white = min(min_white, current_white);
+        }
+        return min_white;
+    }
+};
+
+// @lc code=end
+