question_slug stringlengths 3 77 | title stringlengths 1 183 | slug stringlengths 12 45 | summary stringlengths 1 160 ⌀ | author stringlengths 2 30 | certification stringclasses 2
values | created_at stringdate 2013-10-25 17:32:12 2025-04-12 09:38:24 | updated_at stringdate 2013-10-25 17:32:12 2025-04-12 09:38:24 | hit_count int64 0 10.6M | has_video bool 2
classes | content stringlengths 4 576k | upvotes int64 0 11.5k | downvotes int64 0 358 | tags stringlengths 2 193 | comments int64 0 2.56k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
minimum-number-of-operations-to-make-array-continuous | C++ sorting + Binary Search | c-sorting-binary-search-by-vinyr-4ar3 | \nclass Solution {\npublic:\n int minOperations(vector<int>& A) {\n int n = A.size();\n if(n == 1) return 0;\n sort(A.begin(), A.end()); | vinyr | NORMAL | 2021-09-18T16:27:56.887539+00:00 | 2021-09-19T04:10:26.440961+00:00 | 249 | false | ```\nclass Solution {\npublic:\n int minOperations(vector<int>& A) {\n int n = A.size();\n if(n == 1) return 0;\n sort(A.begin(), A.end());\n \n vector<int> nums = {A[0]};\n for(int i=1; i<n; ++i)\n if(A[i] != A[i-1]) nums.push_back(A[i]); //remove duplicates\n\n int maxContinuos = 1;\n for(int i= 1; i<nums.size(); ++i) {\n int val = nums[i] - n +1;\n\t\t\t//for every nums[i], we are finding how many numbers are there in range [val, nums[i]]\n int index = lower_bound(nums.begin(), nums.begin()+i, val) - nums.begin() ;\n\n maxContinuos = max(maxContinuos, i - index+1);\n }\n return n - maxContinuos;\n }\n};\n```\n\nTime Complexity: O(N LogN) for sorting\nSpace Complexity: O(N), for using one array\n | 3 | 0 | ['Binary Search', 'C', 'Sorting'] | 0 |
minimum-number-of-operations-to-make-array-continuous | [C++] Sorting + Binary Search || Easy solution with comments | c-sorting-binary-search-easy-solution-wi-vsp3 | \nclass Solution {\npublic:\n int minOperations(vector<int>& nums) {\n sort(nums.begin(),nums.end());\n unordered_map<int,int> mp; // store | manishbishnoi897 | NORMAL | 2021-09-18T16:02:02.214993+00:00 | 2021-09-18T16:42:49.398413+00:00 | 330 | false | ```\nclass Solution {\npublic:\n int minOperations(vector<int>& nums) {\n sort(nums.begin(),nums.end());\n unordered_map<int,int> mp; // stores the frequency of each element\n vector<int> dp(nums.size(),0); // dp[i] represents no of duplicate elements from 0....i\n dp[0]=0;\n mp[nums[0]]++;\n for(int i=1;i<nums.size();i++){\n dp[i]+=dp[i-1] + (mp[nums[i]] > 0 ? 1 : 0); \n mp[nums[i]]++;\n }\n int ans = INT_MAX;\n // For each index, consider this is the smallest element and then calculate no of elements we need to change.\n for(int i = 0;i<nums.size();i++){\n int idx = upper_bound(nums.begin(),nums.end(),nums[i]+nums.size()-1) - nums.begin();\n int d = dp[idx-1] - (i==0 ? 0 : dp[i-1]); // Counting duplicate elements from i.....idx\n int curr = i + nums.size() - idx + d ;\n ans = min(ans,curr);\n }\n return ans;\n }\n};\n```\n**Hit Upvote if you like :)** | 3 | 0 | ['Binary Search', 'C', 'Sorting'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Easy to understand Python Solution using Sliding Window | easy-to-understand-python-solution-using-jv42 | Code | Vinit_K_P | NORMAL | 2025-01-09T19:17:55.261231+00:00 | 2025-01-09T19:17:55.261231+00:00 | 53 | false |
# Code
```python3 []
class Solution:
def minOperations(self, nums: List[int]) -> int:
i = 0
ans = 0
unique_nums = sorted(set(nums))
for j in range(len(unique_nums)):
while unique_nums[j]-unique_nums[i]>=(len(nums)):
i+=1
ans = max(ans, j-i+1)
return len(nums) - ans
``` | 2 | 0 | ['Sliding Window', 'Python3'] | 0 |
minimum-number-of-operations-to-make-array-continuous | 10 lines of Code using Binary Search Easy Approach | 10-lines-of-code-using-binary-search-eas-ueqo | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n\n\n# Complexity\n- Time complexity:\nO(NlogN)\n\n- Space complexity:\nO( | GodX07 | NORMAL | 2023-10-10T19:42:52.801922+00:00 | 2023-10-10T19:42:52.801939+00:00 | 294 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n\n\n# Complexity\n- Time complexity:\nO(NlogN)\n\n- Space complexity:\nO(1)\n\n# Code\n```\nclass Solution {\npublic:\n int minOperations(vector<int>& nums) {\n int n = nums.size(); // Get the number of elements in the input list \'nums\'.\n int ans = n; // Initialize a variable \'ans\' to the total number of elements in \'nums\'.\n\n // Sort the elements in \'nums\' in ascending order.\n sort(nums.begin(), nums.end());\n\n // Remove duplicate elements from \'nums\' and keep only the unique elements.\n nums.erase(unique(nums.begin(), nums.end()), nums.end());\n\n // Now, \'nums\' contains only unique elements, sorted in ascending order.\n // We want to find the minimum number of operations to make all elements in \'nums\' unique.\n\n for (int i = 0; i < n; i++) {\n // For each element in \'nums\', we calculate the maximum value it can be increased to while keeping it unique.\n int maxElement = nums[i] + n - 1;\n\n // We use the \'upper_bound\' function to find where \'maxElement\' would fit if we were to insert it while keeping \'nums\' sorted.\n // Subtracting \'nums.begin()\' from the result gives us its position in \'nums\'.\n int upperBound = upper_bound(nums.begin(), nums.end(), maxElement) - nums.begin();\n\n // Calculate the number of unique elements in the range from the current element to \'upperBound\'.\n int unique = upperBound - i;\n\n // Update \'ans\' with the minimum number of operations needed to make all elements unique.\n ans = min(ans, n - unique);\n }\n // Finally, \'ans\' contains the minimum number of operations needed to make all elements in \'nums\' unique.\n // Return \'ans\' as the result.\n return ans;\n }\n};\n``` | 2 | 0 | ['Binary Search', 'C++'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Java Solution✅||Beats 100%💯||Easy to understand||Detailed Explanation||Sliding Window | java-solutionbeats-100easy-to-understand-l7vx | \n# Approach\n Describe your approach to solving the problem. \n- Sort the array and than run a loop to find the unique elements.\n- When encounters a unique el | Vishu6403 | NORMAL | 2023-10-10T18:41:08.401674+00:00 | 2023-10-10T18:41:08.401698+00:00 | 164 | false | \n# Approach\n<!-- Describe your approach to solving the problem. -->\n- Sort the array and than run a loop to find the unique elements.\n- When encounters a unique element (one that is not equal to the previous element), it stores it at the beginning of the array, effectively reducing the array size to only include unique elements. The count of unique elements is tracked using the variable `m`.\n- Then using a Sliding window Approach , it iterates through the unique elements, represented by the first m elements in the array, and maintains a window of size n(same ti the size of array).\n - The j pointer tracks the right end of the sliding window.\n - For each unique element at index i, it checks how many more elements from the right can be included in the window without exceeding the range of n. The condition `nums[j] < nums[i] + n` ensures that the elements in the window remain within a range of n from the current unique element.\n - It calculates` n - j + i`, which represents the minimum operations needed to make the elements within the window consecutive, and updates the answer (ans) with the minimum value.\n\n# Complexity\n- Time complexity:$$O(nlogn)$$\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:$$O(n)$$\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\n public int minOperations(int[] nums) {\n int n = nums.length;\n int ans = n; // Initialize the answer to the length of the input array\n Arrays.sort(nums); // Sort the input array in ascending order\n int m = 1; // Initialize a variable to keep track of unique elements count\n int j = 0;\n\n // Loop to find unique elements and count them\n for (int i = 1; i < n; i++) {\n if (nums[i] != nums[i - 1]) {\n nums[m] = nums[i]; // Store unique elements at the beginning of the array\n m++; // Increment the count of unique elements\n }\n }\n\n // Iterate through unique elements to calculate the minimum operations\n for (int i = 0; i < m; i++) {\n while (j < m && nums[j] < nums[i] + n) {\n j++; // Move the \'j\' pointer until the condition is met\n }\n // Calculate and update the minimum operations\n ans = Math.min(ans, n - j + i);\n }\n\n return ans; // Return the minimum operations required\n }\n}\n\n```\n---\n# Please upvote if you find the solution helpful, and feel free to ask any questions or any concerns about the solution \uD83D\uDE0A\n\n | 2 | 0 | ['Array', 'Java'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Easy Solution || C++ | easy-solution-c-by-prakas_h-on84 | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | prakas_h | NORMAL | 2023-10-10T16:50:17.546028+00:00 | 2023-10-10T16:50:17.546053+00:00 | 65 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\npublic:\n int minOperations(vector<int>& nums) {\n int n = nums.size();\n\n sort(nums.begin(), nums.end());\n for(int i=0;i<n-1;i++){\n if(nums[i]==nums[i+1]){\n nums[i] = INT_MAX;\n }\n }\n sort(nums.begin(), nums.end());\n int ans = INT_MAX;\n for(int i=0;i<n;i++){\n int maxm = nums[i] + nums.size()-1;\n int it = upper_bound(nums.begin()+i, nums.end(), maxm) - nums.begin();\n it = n-it+i;\n ans = min(ans, it);\n }\n\n return ans;\n \n }\n};\n``` | 2 | 0 | ['Array', 'Binary Search', 'C++'] | 1 |
minimum-number-of-operations-to-make-array-continuous | Easy java Solution using Binary Search | easy-java-solution-using-binary-search-b-soey | \n\n# Code\n\nclass Solution {\n public int minOperations(int[] nums) {\n int m=nums.length;\n Set<Integer> set=new HashSet<>();\n for(in | SagarRuhela | NORMAL | 2023-10-10T16:24:35.364264+00:00 | 2023-10-10T16:24:35.364282+00:00 | 85 | false | \n\n# Code\n```\nclass Solution {\n public int minOperations(int[] nums) {\n int m=nums.length;\n Set<Integer> set=new HashSet<>();\n for(int i=0;i<m;i++){\n set.add(nums[i]);\n } \n int arr[]=new int[set.size()];\n int idx=0;\n int minAns=Integer.MAX_VALUE;\n for(int i:set){\n arr[idx++]=i;\n }\n Arrays.sort(arr);\n int n=arr.length;\n for(int i=0;i<n;i++){\n int left= arr[i];\n int right=left+m-1;\n int idexOfRight=BS(arr,right);\n int count=idexOfRight-i;\n minAns=Math.min(minAns,m-count);\n }\n return minAns;\n }\n public int BS(int arr[],int target){\n int left=0;\n int right=arr.length-1;\n while(left<=right){\n int mid=(left+right)/2;\n if(arr[mid]==target){\n return mid+1;\n }\n else if(arr[mid]>target){\n right=mid-1;\n }\n else{\n left=mid+1;\n }\n }\n return left;\n }\n}\n``` | 2 | 0 | ['Array', 'Binary Search', 'Java'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Easy c++ solution | easy-c-solution-by-geetanjali-18-ost9 | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | geetanjali-18 | NORMAL | 2023-10-10T16:15:42.401131+00:00 | 2023-10-10T16:15:42.401154+00:00 | 20 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\npublic:\n int minOperations(vector<int>& nums) {\n int n = nums.size();\n int ans = INT_MAX;\n vector<int>dup(n,0);\n\n sort(nums.begin() , nums.end());\n\n for(int i=1;i<n;i++){\n if(nums[i]==nums[i-1]){\n dup[i] = dup[i-1]+1;\n }\n else{\n dup[i]=dup[i-1];\n }\n }\n for(int i=0;i<n;i++){\n cout<<nums[i]<<" ";\n int left = nums[i];\n int right = left+n-1;\n int index = upper_bound(nums.begin()+i,nums.end() , right)-nums.begin();\n int duplicates = -dup[i];\n if(index<n)\n duplicates+= dup[index];\n else\n duplicates+= dup[n-1];\n\n ans = min(ans , (n-index)+(i)+duplicates);\n }\n return ans;\n }\n};\n``` | 2 | 0 | ['C++'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Easy Solution using python | easy-solution-using-python-by-jaya_surya-7xwa | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | Jaya_Surya_3 | NORMAL | 2023-10-10T14:39:07.463937+00:00 | 2023-10-10T14:39:07.463966+00:00 | 153 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n ans = n\n nums = sorted(set(nums))\n\n for i, start in enumerate(nums):\n end = start + n - 1\n index = bisect_right(nums, end)\n uniqueLength = index - i\n ans = min(ans, n - uniqueLength)\n\n return ans\n\n``` | 2 | 0 | ['Array', 'Binary Search', 'Python3'] | 0 |
minimum-number-of-operations-to-make-array-continuous | ✅☑[C++/C/Java/Python/JavaScript] || O(nlogn) || Sliding Window || EXPLAINED🔥 | ccjavapythonjavascript-onlogn-sliding-wi-e1cx | PLEASE UPVOTE IF IT HELPED\n\n---\n\n\n# Approaches\n(Also explained in the code)\n1. The code aims to find the minimum operations required to make the array "c | MarkSPhilip31 | NORMAL | 2023-10-10T14:30:26.577822+00:00 | 2023-10-12T20:25:17.416718+00:00 | 384 | false | # *PLEASE UPVOTE IF IT HELPED*\n\n---\n\n\n# Approaches\n***(Also explained in the code)***\n1. The code aims to find the minimum operations required to make the array "consecutive," where consecutive elements have a difference of at most `n-1`.\n\n1. We first insert all unique elements from the input array `nums` into a set `s`. This step ensures that we have a sorted and unique set of elements.\n\n1. We convert the set `s` back into a vector `unique` to work with the elements in sorted order.\n\n1. We iterate through the `unique` vector and use a pointer `j` to find the rightmost element within the current range (defined by `unique[i]` and `unique[i] + n)`.\n\n1. For each range, we calculate the minimum operations required by subtracting the count of elements within the range (`j - i`) from `n`.\n\n1. Finally, we return the minimum operations required as the answer.\n\n*Let\'s illustrate the approach with an example:*\n\n**Example:**\nInput: **[1, 3, 6, 2, 7]**\n\n- After sorting and removing duplicates, `unique` becomes **[1, 2, 3, 6, 7]**.\n\n- The code will iterate through the `unique` vector and determine the minimum operations for each range:\n\n - Range **[1, 2, 3]** requires `2` operations to make them consecutive.\n - Range **[6, 7]** requires `0` operations as they are already consecutive.\n- The final answer is the minimum of the operations required for these two ranges, which is `0`.\n\n# Complexity\n- **Time complexity:**\n$$O(nlogn)$$\n\n- **Space complexity:**\n$$O(n)$$\n\n# Code\n```C++ []\nclass Solution {\npublic:\n int minOperations(vector<int>& nums) {\n int n = nums.size();\n int ans = n; // Initialize the answer as the maximum possible value \'n\'.\n set<int> s; // Create a set to store unique elements from \'nums\'.\n\n // Step 1: Insert all unique elements from \'nums\' into the set \'s\'.\n for (auto a : nums) {\n s.insert(a);\n }\n\n // Step 2: Convert the set \'s\' back to a vector \'unique\'.\n vector<int> unique(s.begin(), s.end());\n\n int j = 0; // Initialize a pointer \'j\'.\n int m = unique.size(); // Get the size of the \'unique\' vector.\n\n // Step 3: Iterate through the \'unique\' vector.\n for (int i = 0; i < m; i++) {\n // Step 4: Move the pointer \'j\' to find the rightmost element within the current range.\n while (j < m && unique[j] < unique[i] + n) {\n j++;\n }\n // Step 5: Calculate the minimum operations required for the current range.\n ans = min(ans, n - (j - i));\n }\n // Step 6: Return the minimum operations required.\n return ans;\n }\n};\n\n```\n```C []\n#include <stdio.h>\n#include <stdlib.h>\n\nint compare(const void *a, const void *b) {\n return (*(int *)a - *(int *)b);\n}\n\nint minOperations(int *nums, int numsSize) {\n int n = numsSize;\n int ans = n; // Initialize the answer as the maximum possible value \'n\'.\n int *unique = (int *)malloc(n * sizeof(int));\n if (unique == NULL) {\n return -1; // Memory allocation failed.\n }\n\n // Step 1: Sort \'nums\' array to make duplicate elements adjacent.\n qsort(nums, n, sizeof(int), compare);\n\n int j = 0; // Initialize a pointer \'j\'.\n int m = 0; // Initialize the size of the \'unique\' array.\n\n // Step 2: Create an array \'unique\' containing unique elements from \'nums\'.\n for (int i = 0; i < n; i++) {\n if (i == 0 || nums[i] != nums[i - 1]) {\n unique[m++] = nums[i];\n }\n }\n\n // Step 3: Iterate through the \'unique\' array.\n for (int i = 0; i < m; i++) {\n // Step 4: Move the pointer \'j\' to find the rightmost element within the current range.\n while (j < m && unique[j] < unique[i] + n) {\n j++;\n }\n // Step 5: Calculate the minimum operations required for the current range.\n ans = (ans < (n - (j - i))) ? ans : (n - (j - i));\n }\n\n // Step 6: Release memory allocated for \'unique\' array.\n free(unique);\n\n // Step 7: Return the minimum operations required.\n return ans;\n}\n\n```\n```Java []\nimport java.util.*;\n\nclass Solution {\n public int minOperations(int[] nums) {\n int n = nums.length;\n int ans = n; // Initialize the answer as the maximum possible value \'n\'.\n Set<Integer> s = new HashSet<>(); // Create a set to store unique elements from \'nums\'.\n\n // Step 1: Insert all unique elements from \'nums\' into the set \'s\'.\n for (int a : nums) {\n s.add(a);\n }\n\n // Step 2: Convert the set \'s\' back to a list \'unique\'.\n List<Integer> unique = new ArrayList<>(s);\n\n int j = 0; // Initialize a pointer \'j\'.\n int m = unique.size(); // Get the size of the \'unique\' list.\n\n // Step 3: Iterate through the \'unique\' list.\n for (int i = 0; i < m; i++) {\n // Step 4: Move the pointer \'j\' to find the rightmost element within the current range.\n while (j < m && unique.get(j) < unique.get(i) + n) {\n j++;\n }\n // Step 5: Calculate the minimum operations required for the current range.\n ans = Math.min(ans, n - (j - i));\n }\n // Step 6: Return the minimum operations required.\n return ans;\n }\n}\n\n```\n```Python []\nclass Solution:\n def minOperations(self, nums: List[int]) -> int:\n n = len(nums)\n ans = n # Initialize the answer as the maximum possible value \'n\'.\n s = set() # Create a set to store unique elements from \'nums\'.\n\n # Step 1: Insert all unique elements from \'nums\' into the set \'s\'.\n for a in nums:\n s.add(a)\n\n # Step 2: Convert the set \'s\' back to a list \'unique\'.\n unique = list(s)\n\n j = 0 # Initialize a pointer \'j\'.\n m = len(unique) # Get the size of the \'unique\' list.\n\n # Step 3: Iterate through the \'unique\' list.\n for i in range(m):\n # Step 4: Move the pointer \'j\' to find the rightmost element within the current range.\n while j < m and unique[j] < unique[i] + n:\n j += 1\n # Step 5: Calculate the minimum operations required for the current range.\n ans = min(ans, n - (j - i))\n # Step 6: Return the minimum operations required.\n return ans\n\n```\n\n```javascript []\n/**\n * @param {number[]} nums\n * @return {number}\n */\nvar minOperations = function(nums) {\n const n = nums.length;\n let ans = n; // Initialize the answer as the maximum possible value \'n\'.\n const s = new Set(); // Create a set to store unique elements from \'nums\'.\n\n // Step 1: Insert all unique elements from \'nums\' into the set \'s\'.\n for (const a of nums) {\n s.add(a);\n }\n\n // Step 2: Convert the set \'s\' back to an array \'unique\'.\n const unique = [...s];\n\n let j = 0; // Initialize a pointer \'j\'.\n const m = unique.length; // Get the size of the \'unique\' array.\n\n // Step 3: Iterate through the \'unique\' array.\n for (let i = 0; i < m; i++) {\n // Step 4: Move the pointer \'j\' to find the rightmost element within the current range.\n while (j < m && unique[j] < unique[i] + n) {\n j++;\n }\n // Step 5: Calculate the minimum operations required for the current range.\n ans = Math.min(ans, n - (j - i));\n }\n // Step 6: Return the minimum operations required.\n return ans;\n};\n\n```\n# *PLEASE UPVOTE IF IT HELPED*\n\n---\n\n---\n\n | 2 | 0 | ['Array', 'Hash Table', 'Binary Search', 'C', 'Sliding Window', 'Ordered Set', 'C++', 'Java', 'Python3', 'JavaScript'] | 3 |
minimum-number-of-operations-to-make-array-continuous | Standard approach | standard-approach-by-deepakvrma-43w9 | \n# Code\n\nclass Solution {\npublic:\n int minOperations(std::vector<int>& nums) {\n int n = nums.size();\n std::sort(nums.begin(), nums.end() | DeepakVrma | NORMAL | 2023-10-10T12:15:11.496048+00:00 | 2023-10-10T12:15:11.496092+00:00 | 21 | false | \n# Code\n```\nclass Solution {\npublic:\n int minOperations(std::vector<int>& nums) {\n int n = nums.size();\n std::sort(nums.begin(), nums.end());\n std::vector<int> uniqueNums(nums.begin(), std::unique(nums.begin(), nums.end()));\n int ans = std::numeric_limits<int>::max();\n\n for (int i = 0; i < uniqueNums.size(); ++i) {\n int s = uniqueNums[i];\n int e = s + n - 1;\n auto it = std::upper_bound(uniqueNums.begin(), uniqueNums.end(), e);\n\n int idx = std::distance(uniqueNums.begin(), it);\n ans = std::min(ans, n - (idx - i));\n }\n return ans;\n }\n};\n``` | 2 | 0 | ['Sorting', 'C++'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Efficient Approach Using Sliding window and Sorting | efficient-approach-using-sliding-window-ffv8y | Intuition\nThe provided code uses a sliding window technique to efficiently find the minimum number of operations required to \nmake all elements in the input a | gautam309 | NORMAL | 2023-10-10T12:05:49.754401+00:00 | 2023-10-10T12:05:49.754421+00:00 | 34 | false | # Intuition\nThe provided code uses a sliding window technique to efficiently find the minimum number of operations required to \nmake all elements in the input array distinct. It begins by sorting the array and removing duplicates, resulting in \na sorted array with unique elements.\n\nThe sliding window mechanism is employed during the main loop, where two pointers (s and e) traverse the sorted array. \nThese pointers define a subarray that spans from s to e, and the code aims to maximize the length of this subarray \nwhile ensuring that the difference between the maximum and minimum values within the subarray is less than or equal to n,\nwhere n represents the size of the original array.\n\nAs the pointers move, the code calculates the length of the current subarray (sw) and keeps track of the maximum subarray \nlength (ans) encountered during the iteration. \nFinally, it returns n - ans, which represents the minimum operations needed to achieve distinct elements.\n\n# Approach\n1. Sort the input array arr in non-decreasing order.\n2. Remove duplicates to obtain a sorted array with distinct elements.\n3. Initialize ans to store the maximum subarray length and e as a pointer.\n4. Iterate through arr, moving e to maximize subarray length where the max-min difference is <= n.\n5. Return n - ans, where n is the original array size, as the minimum operations.\n\n# Complexity\n- Time complexity:O(n log n) due to sorting\n- Space complexity:O(n) for the distinct array\n- \n# Code\n```\nclass Solution {\npublic:\n int minOperations(vector<int>& arr) \n {\n int n = arr.size();\n sort(arr.begin(), arr.end());\n arr.erase(unique(arr.begin(), arr.end()), arr.end());\n\n int ans = INT_MIN;\n int e = 0;\n \n for (int s = 0; s < n; s++) \n {\n while (e < arr.size() && arr[e] < arr[s] + n) \n e++ ; \n\n int sw = e - s;\n ans = max(ans, sw);\n }\n return n - ans;\n }\n};\n``` | 2 | 0 | ['Sliding Window', 'Sorting', 'C++'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Easy solution using set | easy-solution-using-set-by-samarthnag-chae | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | samarthnag | NORMAL | 2023-10-10T11:25:07.988675+00:00 | 2023-10-10T11:25:07.988694+00:00 | 163 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\npublic:\n int minOperations(vector<int>& nums) {\n sort(nums.begin(),nums.end());\n int n=nums.size();\n int res=n;\n set<int>s(nums.begin(),nums.end());\n vector<int>v;\n for(auto i:s){\n v.push_back(i);\n }\n int j=0;\n for(int i=0;i<v.size();i++){\n while(j<v.size() && v[j]<v[i]+n){\n j++;\n }\n int count=j-i;\n res=min(res,n-count);\n }\n return res;\n \n }\n};\n``` | 2 | 0 | ['C++'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Simple Binery search Implementation | simple-binery-search-implementation-by-s-okgp | Intuition\n Describe your first thoughts on how to solve this problem. \n\n\n\n\n# Approach\n\n1. Sort the input array nums in ascending order.\n2. Create a new | seefat | NORMAL | 2023-10-10T09:21:11.798848+00:00 | 2023-10-10T09:21:11.798870+00:00 | 94 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n\n\n\n# Approach\n\n1. Sort the input array `nums` in ascending order.\n2. Create a new array `uniqueNums` to store the unique elements of `nums` using a Set.\n3. Define a binary search function to find the maximum consecutive length of elements in `uniqueNums`.\n - Start with two pointers, `start` and `end`, initially pointing to the first and last indices of `uniqueNums`.\n - Calculate the middle index `middle` as `(start + end) / 2`.\n - Check three conditions:\n - If `uniqueNums[middle]` is less than the target value, and `uniqueNums[middle + 1]` is greater than the target, return `middle`.\n - If `uniqueNums[middle]` is greater than the target value, and `uniqueNums[middle - 1]` is less than the target, return `middle - 1`.\n - If `uniqueNums[middle]` is equal to the target, return `middle`.\n - If none of the conditions are met, update the pointers (`start` or `end`) based on whether `uniqueNums[middle]` is greater or less than the target value and continue the binary search.\n4. Initialize `maxLength` to 0 to keep track of the maximum consecutive length found.\n5. Iterate through the unique elements in `uniqueNums`:\n - Calculate the `targetValue` as the current unique element plus the length of the original array `nums` minus 1.\n - Use the binary search function to find the maximum consecutive length starting from the current unique element.\n - Update `maxLength` with the maximum of its current value and `1 - index + length` obtained from the binary search.\n6. The minimum number of operations required to make all elements equal is `nums.length - maxLength`.\n\n\n\n# Complexity\n- Sorting the array takes O(n * log(n)) time, where n is the number of elements in `nums`.\n- Creating the `uniqueNums` array takes O(n) time.\n- The binary search function has a time complexity of O(log(n)).\n- The loop that iterates through the unique elements has a time complexity of O(n).\n- Therefore, the overall time complexity is O(n * log(n)).\n- Additional space complexity is O(n) to store the `uniqueNums` array.\n- The space complexity for other variables and function calls is O(1).\n- Thus, the overall space complexity is O(n).\ntwo po\n\n\n# Code\n```\n/**\n * @param {number[]} nums\n * @return {number}\n */\nvar minOperations = function(nums) {\n // Sort the input array in ascending order\n nums.sort((a, b) => a - b);\n \n // Create a new array \'uniqueNums\' with unique elements from \'nums\'\n const uniqueNums = [...new Set(nums)];\n\n // Define a binary search function\n const binarySearch = (start, end, target) => {\n let middle = parseInt((start + end) / 2);\n\n // Base cases for binary search\n if (start === end) return start;\n if (uniqueNums[middle] < target && uniqueNums[middle + 1] > target) {\n return middle;\n }\n if (uniqueNums[middle] > target && uniqueNums[middle - 1] < target) {\n return middle - 1;\n }\n if (uniqueNums[middle] === target) {\n return middle;\n } else if (middle === 0) {\n return 0;\n } else if (middle === uniqueNums.length - 1) {\n return middle;\n } else if (uniqueNums[middle] > target) {\n return start === middle ? middle : binarySearch(start, middle - 1, target);\n } else if (uniqueNums[middle] < target) {\n return middle === end ? middle : binarySearch(middle + 1, end, target);\n }\n }\n\n let maxLength = 0;\n const uniqueNumsLength = uniqueNums.length;\n\n // Iterate through unique elements of \'uniqueNums\'\n for (let i = 0; i < uniqueNumsLength; i++) {\n const targetValue = uniqueNums[i] + nums.length - 1;\n maxLength = Math.max(maxLength, 1 - i + binarySearch(i, uniqueNumsLength - 1, targetValue));\n }\n\n // Calculate and return the result\n return nums.length - maxLength;\n};\n\n``` | 2 | 0 | ['Two Pointers', 'Binary Search', 'JavaScript'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Java ✅: O(n2) HashSet & O(nlogn) SW approach | java-on2-hashset-onlogn-sw-approach-by-a-yoow | TC - O(n2) - Using HashSet - TLE\n\n // O(n2) approach considering every element as minimum \n public int minOperations(int[] nums){\n int n = nums | Ayush7865 | NORMAL | 2023-08-05T06:36:35.140465+00:00 | 2023-09-18T19:00:42.447902+00:00 | 19 | false | ### TC - O(n2) - Using HashSet - TLE\n```\n // O(n2) approach considering every element as minimum \n public int minOperations(int[] nums){\n int n = nums.length;\n int min = Integer.MAX_VALUE;\n HashSet<Integer> set = new HashSet<>();\n for(int num : nums){\n set.add(num);\n }\n for(int num : nums){\n set.remove(num);\n int op = 0;\n for(int i = num + 1; i <= num + n - 1; i++){\n if(!set.contains(i)){\n op++;\n }\n }\n min = Math.min(min, op);\n set.add(num);\n }\n return min;\n }\n\n```\n\n\n\n### TC - O(nlogn) - Using Sliding Window - Accepted\n```\n public int minOperations(int[] nums){\n int n = nums.length;\n\n // duplicates will not contribute in making array continous \n int[] arr = Arrays.stream(nums).sorted().distinct().toArray();\n \n int j = 0;\n int max = Integer.MIN_VALUE;\n // find maxm sliding window size any element outside it need to be change \n for(int i = 0; i < arr.length; i++){\n int curr = arr[i];\n int Uprange = curr + n - 1;\n while(j < arr.length && arr[j] <= Uprange){\n j++;\n }\n max = Math.max(max, j - i);\n }\n return n - max;\n }\n``` | 2 | 0 | ['Java'] | 0 |
minimum-number-of-operations-to-make-array-continuous | o(nlogn) | onlogn-by-anil-budamakuntla-q88c | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | ANIL-BUDAMAKUNTLA | NORMAL | 2023-06-12T02:08:57.589414+00:00 | 2024-06-18T04:49:42.535491+00:00 | 175 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:0(nlogn)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\npublic:\n int minOperations(vector<int>& nums) {\n \n int n=nums.size(), m,i, j,k, ans=n;\n set<int>s;\n m=n;\n for(i = 0 ; i < n ; i++){\n \n s.insert(nums[i]);\n \n }\n n=s.size();\n \n int a[n];\n i=0;\n for(auto it:s){\n a[i++]=it;\n }\n\n \n for(i = 0;i < n; i++){\n // j=upper_bound(a,a+n,a[i])-a;\n k=lower_bound(a,a+n,a[i]-m+1)-a;\n j=n-i-1;\n \n ans=min(ans,j+k+m-n);}\n return ans;\n }\n};\n```\n\n | 2 | 0 | ['C++'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Java Sliding Windows | java-sliding-windows-by-mra-0qmu | java\npublic int minOperations(int[] nums) {\n\tint[] arr = Arrays.stream(nums).sorted().distinct().toArray();\n\tint res = nums.length;\n\tfor (int i = 0, j = | mra | NORMAL | 2022-10-20T13:39:04.338452+00:00 | 2022-10-20T13:41:10.082442+00:00 | 407 | false | ```java\npublic int minOperations(int[] nums) {\n\tint[] arr = Arrays.stream(nums).sorted().distinct().toArray();\n\tint res = nums.length;\n\tfor (int i = 0, j = 0; j < arr.length; j++) {\n\t\twhile (arr[j] - arr[i] >= nums.length) {\n\t\t\ti++;\n\t\t}\n\n\t\tres = Integer.min(res, nums.length - (j - i + 1));\n\t}\n\treturn res;\n}\n``` | 2 | 0 | ['Java'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Simple Solution Explained Python | simple-solution-explained-python-by-sart-kor2 | ending - starting = n - 1\nwe want something like [a, a+1, ......, a+n-1] (sorted representation)\nmax operations = n-1, min operations = 0\neach value in nums | sarthakBhandari | NORMAL | 2022-10-14T14:33:38.519522+00:00 | 2022-10-14T14:49:18.989225+00:00 | 301 | false | ending - starting = n - 1\nwe want something like [a, a+1, ......, a+n-1] (sorted representation)\nmax operations = n-1, min operations = 0\neach value in nums can be a valid starting point\neach value in nums can be a valid ending point\n\nif each value can be a valid starting point, find the number of elements outside the window\nelements outside window will be smaller than starting point & larger than n - 1 + starting\nyou can use binary search to find the elements outside the window,\nand smaller elements are to the left of starting point\nyou should treat repeated elements as infinity because they are always going to change\n\nafter you realise that you just need to find the elements out of window\nyou can just apply the sliding window technique\n```\ndef minOperations(self, nums: List[int]) -> int:\n #binary search\n n = len(nums)\n ans = n-1\n nums = sorted(set(nums))\n extra = n - len(nums) #repeated elements\n for i in range(len(nums)):\n right = bisect_right(nums, n-1+nums[i]) #index of first element larger than n-1+nums[i]\n ans = min(ans, len(nums) - right + i + extra)\n return ans\n\n #sliding window\n n = len(nums)\n ans = n - 1\n nums = sorted(set(nums))\n extra = n - len(nums)\n\n j = 0\n for i in range(len(nums)):\n while j<len(nums) and nums[j] <= n - 1 + nums[i]:\n j += 1\n ans = min(ans, n - (j - i))\n return ans\n``` | 2 | 0 | ['Binary Search', 'Sliding Window', 'Python'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Java | Binary Search | O(nlogn) | java-binary-search-onlogn-by-harshraj998-5qf0 | Inuition:\nConsidering each element as the last element of answer array, we will find how many numbers are present between the element and (element - array.leng | HarshRaj9988 | NORMAL | 2022-10-01T05:32:19.034488+00:00 | 2022-10-01T05:32:19.034533+00:00 | 750 | false | Inuition:\nConsidering each element as the last element of answer array, we will find how many numbers are present between the element and (element - array.length +1), inclusive these two. keep track of maximum number of valid elements. and at last return the difference between total number of element of array and the maximum number of elements that we calculated earlier.\n\n```\npublic int minOperations(int[] nums) {\n int totalEle = nums.length;\n int[] uniqueSortedArray = getUniqueSortedArray(nums);\n int maxCorrEle = Integer.MIN_VALUE;\n int sortedEle = uniqueSortedArray.length;\n for(int i = 0; i<sortedEle; i++) {\n int toFind = uniqueSortedArray[i] - totalEle + 1;\n int ind = Arrays.binarySearch(uniqueSortedArray, toFind);\n if(ind<0){\n ind = (-1 * ind) - 1;\n }\n maxCorrEle = Math.max(maxCorrEle, i-ind+1);\n }\n return totalEle-maxCorrEle;\n \n }\n\n private int[] getUniqueSortedArray(int[] nums) {\n TreeSet<Integer> set = new TreeSet<>();\n for (int i : nums) {\n set.add(i);\n }\n int un = set.size();\n int[] arr = new int[un];\n int i = 0;\n for (Integer s : set) {\n arr[i++] = s;\n }\n set.clear();\n set = null;\n return arr;\n }\n``` | 2 | 1 | [] | 0 |
minimum-number-of-operations-to-make-array-continuous | C++|| Sliding Window || Sorting || Solution with explaination | c-sliding-window-sorting-solution-with-e-b0jj | The idea is to remove the duplicate elements and sort the array \nduplicate elements are removed as they are definitely not the part of our continuous array \nn | jahnavimahara | NORMAL | 2022-08-21T17:33:01.539844+00:00 | 2022-08-21T17:33:01.539886+00:00 | 516 | false | **The idea is to remove the duplicate elements and sort the array \nduplicate elements are removed as they are definitely not the part of our continuous array \nnow iterate through the array and consider every element as the minimum element of continuous subarray\nmake a sliding window from that element and increase its length to cover all the elements in the range of current+(length-1)\nstore the maximum size of sliding window (maxi)\nlength-maxi is the minimum number of elements to be changed\n **\n```\n int minOperations(vector<int>& nums) {\n int n=nums.size();\n set<int>set;\n for(auto it:nums){\n set.insert(it);\n }\n vector<int>v;\n for(auto it:set){\n v.push_back(it);\n }\n sort(v.begin(),v.end());\n int right=0;\n int maxi=INT_MIN;\n int p=v.size();\n for(int left=0;left<n;left++){\n while(right<p&&v[right]-v[left]<=n-1) {\n right++;\n }\n int cur_count=right-left;\n maxi=max(cur_count,maxi);\n }\n return n-maxi;\n }\n``` | 2 | 0 | ['C', 'Sliding Window', 'Sorting'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Java | O(NLog(N) Time | O(1) Space | Sliding Window with Comments | java-onlogn-time-o1-space-sliding-window-1z8l | \nclass Solution {\n public int minOperations(int[] nums) {\n int n = nums.length;\n Arrays.sort(nums); // Sort in ascending order | hawtsauce-iwnl | NORMAL | 2022-08-03T14:58:38.127101+00:00 | 2022-08-03T14:59:17.820588+00:00 | 347 | false | ```\nclass Solution {\n public int minOperations(int[] nums) {\n int n = nums.length;\n Arrays.sort(nums); // Sort in ascending order, so left points to min element and right to max element in window\n \n int left = 0, right = 0; \n int maxDiff = n - 1; // max diff between the min and max element\n int maxLen = 1; // Length of longest sub array without duplicates such that min - max <= maxDiff\n int dupCount = 0; // count of duplicate elements in the window\n \n for(right = 0; right < n; right ++) {\n if(right > 0 && nums[right] == nums[right - 1]) {\n dupCount ++;\n }\n \n while(nums[right] - nums[left] > maxDiff) { // if max - min > maxDiff, decrease size of window\n if(left < n && nums[left] == nums[left + 1]) {\n dupCount --;\n }\n left ++;\n \n }\n maxLen = Math.max(maxLen, right - left + 1 - dupCount);\n }\n \n return n - maxLen; // modifications required\n }\n}\n``` | 2 | 0 | ['Sliding Window', 'Java'] | 0 |
minimum-number-of-operations-to-make-array-continuous | C++ | Sets | c-sets-by-__ikigai-bz4k | \nclass Solution {\npublic:\n int minOperations(vector<int>& nums) {\n int len=nums.size()-1;\n int mini=INT_MAX, maxi=INT_MIN;\n set<in | __ikigai__ | NORMAL | 2022-08-01T16:13:06.737510+00:00 | 2022-08-01T16:13:06.737541+00:00 | 103 | false | ```\nclass Solution {\npublic:\n int minOperations(vector<int>& nums) {\n int len=nums.size()-1;\n int mini=INT_MAX, maxi=INT_MIN;\n set<int> count;\n for(auto &it:nums) {\n count.insert(it);\n mini=min(mini, it); \n maxi=max(maxi, it);\n }\n if(count.size()==len+1&&maxi-mini==len) return 0;\n int ans=INT_MIN, si=0, ei=0;\n auto itr=count.begin();\n for(auto it=count.begin(); it!=count.end(); it++) {\n int num=0, maxi=*it+len;\n while(itr!=count.end()&&(*itr<=maxi)) {\n itr++; ei++;\n } \n ans=max(ans, ei-si);\n if(ans==len+1) return 0;\n si++;\n }\n return len+1-ans;\n }\n};\n``` | 2 | 0 | ['Ordered Set'] | 0 |
minimum-number-of-operations-to-make-array-continuous | HEAVILY COMMENTED CODE + SIMPLEST EXPLANATION-USING BINARY SEARCH | heavily-commented-code-simplest-explanat-4xrk | \n/*Intution : while pondering at the problem, I was thinking of o(n2) solution wherein, I\'ll deem every element as the minimum element and will see how many e | user2085X | NORMAL | 2022-07-29T06:20:19.195108+00:00 | 2022-07-29T06:20:19.195147+00:00 | 221 | false | `\n/*Intution : while pondering at the problem, I was thinking of o(n2) solution wherein, I\'ll deem every element as the minimum element and will see how many elements are there in the array that together with this element will form a "continuous array" with minimum changes. \nSomething like this :*/ `\n\n```\nfor(int idx -> 0 to n) {\n\t another loop to check how many elements are there in the array that together with nums[idx] will form a "continuous array" with minimum changes\n}\n```\n\n\n***But looking at the constraints o(n2) solution won\'t get passed. So I need to work on my inner loop and if possible bring inner loop\'s complexity down to o(logn or 1)***\n\nOne more thing to consider : elements in the continuous array should be unique. For that I can remove all the repeating elements. (By using set containers, probably!!)\n\n`There\'s another intution : for every start(minE) element, it\'s end(maxE) counterpart can be decided using the given relation, (maxE - minE = size - 1), if the array is sorted, then maxE and minE will be our end and start elements.\nso we can use binary search to find an element just greater than our required end element, and the difference between end_idx and start_idx will give us the number of elements present in our array that can be used in the continuous array. The start element that will have max number of usable elements in the given array will be our start element for the "continuous array", and will give us a continuous array with minimum replacements. (Greedy Approach)\n` \n\n\n# code with comments : \n```\nclass Solution {\npublic:\n \n //tc : o(nlogn); sc : o(n);\n //the test cases here are deceptive, none of them cover the case where, nums will have repeating elements.\n int minOperations(vector<int>& nums) {\n //as nums should have unique values, all non-unique values should be \n //removed. Infact non-unique ones will be have to be replaced, costing one operation\n //so it\'s fine to remove all of them.\n int n = nums.size(); \n \n set<int> container; //container To Remove Repeating Elements Plus To Sort the Left Ones\n \n for(int idx = 0; idx < nums.size(); idx++) container.insert(nums[idx]);\n nums.clear();\n for(auto u: container) nums.push_back(u);\n //nums now contain only unique values and that too in sorted fashion.\n \n //the sole idea behind a continuous array is that it should be continuous from the start element till the end element\n //we\'ll take each element as the start element and then we\'ll check how many elements are missing from the \n //array if it was continuous, we\'ll choose the element for which max number of elements will be present for our \n //array to be continuous, in other words we\'ll choose the element for which minimum no. of chages would be required\n \n int minOp = INT_MAX;\n for(int idx=0; idx<n; idx++) {\n int start = nums[idx];\n int end = start + n - 1; //from : (end - start = n - 1), difference between max and min should be equal to size - 1;\n \n //BS to find element just greater than end element, so the difference will give the no. of elements between start & end.\n auto itToEnd = upper_bound(nums.begin(), nums.end(), end);\n int end_idx = itToEnd - nums.begin();\n \n int eleBetween = end_idx - idx; //no. of elements between end & start\n int nOfMissingElements = n - eleBetween; //no. of elements required to make nums continuous.\n \n minOp = min(minOp, nOfMissingElements);\n }\n \n \n return minOp;\n }\n};\n\n\n//initial mistake, n should be the size of original nums as that size can only tell us how much elements are required exactly.\n```\n\n\n```\nComplexity analysis, \n\ttc : o(nlogn + nlogn) ~ o(nlogn) //we are using set plus binary search within a loop.\n\tsc : o(n) //maintaining a set of size at max n\n```\n\n\n\n\n | 2 | 0 | ['Binary Tree', 'Ordered Set'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Binary Search | binary-search-by-diyora13-l0ka | \nclass Solution {\npublic:\n int minOperations(vector<int>& a) \n {\n map<int,int> mp;\n int n=a.size(),ans=1e9;\n for(int i=0;i<n;i | diyora13 | NORMAL | 2022-06-07T01:45:00.171938+00:00 | 2022-06-07T01:45:00.172005+00:00 | 408 | false | ```\nclass Solution {\npublic:\n int minOperations(vector<int>& a) \n {\n map<int,int> mp;\n int n=a.size(),ans=1e9;\n for(int i=0;i<n;i++)\n mp[a[i]]++;\n a.clear();\n for(auto i:mp)\n a.push_back(i.first);\n sort(a.begin(),a.end());\n for(int i=0;i<a.size();i++)\n {\n int len=lower_bound(a.begin(),a.end(),a[i]+n)-a.begin()-i;\n ans=min(ans,n-len);\n }\n return ans;\n }\n};\n``` | 2 | 0 | ['Binary Search', 'C', 'C++'] | 0 |
minimum-number-of-operations-to-make-array-continuous | C++ short | c-short-by-abhishekaaru-wykm | \tclass Solution {\n\tpublic:\n\t\tint minOperations(vector& nums) {\n\t\t\tint n = nums.size();\n\t\t\t\n\t\t\tint ans=INT_MAX;\n\t\t\tsort(nums.begin(),nums.e | abhishekaaru | NORMAL | 2022-04-07T11:18:34.581927+00:00 | 2022-04-07T11:18:34.581958+00:00 | 311 | false | \tclass Solution {\n\tpublic:\n\t\tint minOperations(vector<int>& nums) {\n\t\t\tint n = nums.size();\n\t\t\t\n\t\t\tint ans=INT_MAX;\n\t\t\tsort(nums.begin(),nums.end());\n\t\t\tnums.erase(unique(nums.begin(),nums.end()),nums.end());\n\t\t\tint m = nums.size();\n\t\t\t\n\t\t\tint j=0;\n\t\t\tfor(int i=0;i<m;i++){\n\t\t\t\twhile(j<m && nums[j] < nums[i]+n){\n\t\t\t\t\tj++;\n\t\t\t\t}\n\t\t\t\tans = min(ans,n-j+i);\n\t\t\t}\n\t\t\treturn ans;\n\t\t}\n\t}; | 2 | 0 | ['C'] | 0 |
minimum-number-of-operations-to-make-array-continuous | JAVA solution (sorting+ treeset) | java-solution-sorting-treeset-by-flyroko-8gqi | \n \n\t class Solution {\n public int minOperations(int[] nums) {\n\t\t//using treeset to store them in sorted fashion and ignoring duplicates\n | flyRoko123 | NORMAL | 2021-12-19T14:50:44.468547+00:00 | 2021-12-19T14:50:44.468586+00:00 | 154 | false | \n \n\t class Solution {\n public int minOperations(int[] nums) {\n\t\t//using treeset to store them in sorted fashion and ignoring duplicates\n \n TreeSet<Integer> s=new TreeSet<>();\n int max=Integer.MIN_VALUE;\n int range=nums.length-1;\n \n //sorting the array to make the elements continuous which will be easy to do\n //[1,2,3,50,51,56] have this array\n //now checking for each no. range i.e\n //[1,2,3,4,5,6] like this so,when 50-1 encounters that goes out of range so we remove it\n //from set and stores max size of the set list and then try for the next\n //continuous range,i.e[2,3,4,5,6,7] like this continues...\n //and maximum size of the set is stored\n //so minimum operation required will be (array length-max(size of set stored))\n Arrays.sort(nums);\n \n for(int x:nums){\n \n while(!s.isEmpty() && x-s.first()>range){\n s.pollFirst();\n }\n \n s.add(x);\n max=Math.max(max,s.size());\n }\n return nums.length-max;\n\t}\n}\n\t\n | 2 | 0 | [] | 0 |
minimum-number-of-operations-to-make-array-continuous | Pigeonhole Principle | pigeonhole-principle-by-throwaway1973-xei8 | Didn\'t see anyone mention this, but here\'s how I thought of the problem. You can kind of think of this according to the pigeonhole principle used to reason ab | throwaway1973 | NORMAL | 2021-11-19T09:28:31.755324+00:00 | 2021-11-19T09:28:55.305147+00:00 | 227 | false | Didn\'t see anyone mention this, but here\'s how I thought of the problem. You can kind of think of this according to the pigeonhole principle used to reason about hash tables. Think of it this way, I have a range of numbers (buckets) between the maximum and minimum number candidates of the array, and I want to cram the rest of the array into it such that each number fits into each bucket. Or in other words, I want to fit \'n\' items in less than or equal to \'m\' buckets.\n\nExample:\n[1,2,4,4,5,9] => i starts at zero with 1 as my candidate minimum, my candidate maximum here would be 7. I need to cram the rest of the array in that range. I need to know if I essentially have collisions. To track this, check what numbers do not need to be moved. The numbers that do not need to be moved are going to be the numbers already within the range (in this case, 2,4,5). Any numbers that are duplicates need to be moved as they occupy the same bucket already. Any numbers outside of the range (either to the left of the candidate minumum or to the right of the candidate maximum) need to also be moved within the range.\n\nHere\'s my code below, I used a treemap to find the closest number to the candidate maximum as well as a prefix array to track duplicates. The closet number to my candidate maximum (which might be the maximum itself) would be the index that\'s used find numbers outside of the range and to the right of the candidate maximum.\n\n```\nclass Solution {\n public int minOperations(int[] nums) {\n Arrays.sort(nums);\n int [] prefixArr = new int[nums.length];\n TreeMap<Integer,Integer> lowTreeMap = new TreeMap<>();\n boolean isDupe = false;;\n int totalDupes = 0;\n int minOps = nums.length-1;\n lowTreeMap.put(nums[0], 0);\n for(int i=1;i<nums.length;i++){\n isDupe = nums[i] == nums[i-1];\n totalDupes += (isDupe) ? 1 : 0;\n prefixArr[i] = totalDupes;\n lowTreeMap.putIfAbsent(nums[i], i);\n }\n for(int i=0;i<nums.length;i++){\n if(nums[i]+(nums.length-1) < 0){\n break;\n }\n Map.Entry<Integer,Integer> maxEntry = lowTreeMap.ceilingEntry(nums[i]+(nums.length-1)); // May be null which is a case that should be checked. So the candidate maximum is greater than any other number in the array.\n\n int maxNum = nums[i]+(nums.length-1); // This number may not correspond with an element in the array\n int maxKey = (maxEntry != null) ? maxEntry.getKey() : maxNum;\n int maxIndex = (maxEntry != null) ? maxEntry.getValue() : nums.length-1;\n int numDupes = prefixArr[maxIndex]-prefixArr[i];\n\n int numTaken = (maxEntry != null) ? (maxIndex-i-1) - numDupes : (maxIndex-i) - numDupes;\n int numLeft = i;\n int numRight = nums.length-1-maxIndex;\n int range = (maxEntry != null) ? maxNum - nums[i] - 1 : maxNum - nums[i];\n int addKey = (maxKey > maxNum) ? 1 : 0;\n\n if(numLeft + numRight + numDupes + numTaken <= range){ // Check if \'n\' items can fit in \'m\' buckets.\n minOps = Math.min(numLeft+numRight+numDupes+addKey, minOps);\n }\n\n }\n return minOps;\n}\n}\n```\n\n | 2 | 0 | [] | 0 |
minimum-number-of-operations-to-make-array-continuous | C++ Simple Solution using Set | c-simple-solution-using-set-by-lunatic_p-3afn | Idea is sort the array and erase duplicates if any,\nSo set is bettter compare to erase in a vector.\n\n\nint minOperations(vector<int>& A) {\n int N = | lunatic_peace | NORMAL | 2021-10-05T02:04:13.740575+00:00 | 2021-10-05T02:04:28.797049+00:00 | 201 | false | Idea is sort the array and erase duplicates if any,\nSo set is bettter compare to erase in a vector.\n\n```\nint minOperations(vector<int>& A) {\n int N = A.size(), i = 0, j = 0; \n set<int> st(A.begin(), A.end());\n vector<int> B (st.begin(), st.end());\n \n for (int M = B.size(); j < M; ++j) {\n if (B[i] + N <= B[j]) \n ++i;\n }\n return N - j + i;\n }\n```\n | 2 | 0 | ['C'] | 1 |
minimum-number-of-operations-to-make-array-continuous | Sorting + Dedup + Binary Search with Java | sorting-dedup-binary-search-with-java-by-s3kr | LC2009. Minimum Number of Operations to Make Array Continuous\n## Method. Sorting + Dedup + Binary Search\n### Main Idea\nObservations\n1. Since the length of t | leungogogo | NORMAL | 2021-09-24T17:07:42.839694+00:00 | 2021-09-24T17:16:48.600304+00:00 | 206 | false | # LC2009. Minimum Number of Operations to Make Array Continuous\n## Method. Sorting + Dedup + Binary Search\n### Main Idea\n**Observations**\n1. Since the length of the input array is fixed, once the starting point is determined, the end point is also fixed, which is `end = start + n - 1`.\n2. To see how many modifications we need to make if we choose `start` as the starting point, just check the number of unique elements in the array that fall within the range `[start, end]`, say `count`, and `n - count` will be the number of operations needed if we choose `start` as the starting point.\n3. It\'s obvious that the starting point can only be one of the elements in the array, since modifying a starting point doesn\'t make any sense.\n\nSo the main idea is to use each element in the array as the starting point, and check the number of operations needed using the above observations, finally take the minimum among them.\n\n**Algorithm**\n1. Sort the array, so if a starting point `i` is given, we know that all the elements in its LHS will be out of the range (since they are smaller than the starting point), and we can use binary search to find the largest element smaller than `nums[i] + n - 1` on the RHS. Any numbers greater than `nums[i] + n - 1` will also be excluded and modified.\n2. We also need to deduplicate the array since even within the range, we need to modify duplicate elements.\n3. Use binary search as 1. mentioned.\n4. Take the min among all the results.\n\n### Code\n* Java\n```java\nclass Solution {\n public int minOperations(int[] nums) {\n int n = nums.length, res = n;\n Arrays.sort(nums);\n\t\t// Dedup and store in a new array A\n List<Integer> A = new ArrayList<>();\n for (int i = 0; i < n; ++i) {\n if (A.isEmpty() || A.get(A.size() - 1) != nums[i]) {\n A.add(nums[i]);\n }\n }\n for (int i = 0; i < A.size(); ++i) {\n int idx = binarySearch(A, i + 1, A.size() - 1, A.get(i) + n - 1);\n if (idx != -1) {\n int cnt = n - (idx - i + 1);\n res = Math.min(res, cnt);\n }\n }\n return res;\n }\n \n \n // Search for the index of largest element smaller equal to tar\n private int binarySearch(List<Integer> A, int start, int end, int tar) {\n int l = start, r = end;\n while (l < r - 1) {\n int m = l + (r - l) / 2;\n if (A.get(m) == tar) {\n return m;\n } else if (A.get(m) < tar) {\n l = m;\n } else {\n r = m - 1;\n }\n }\n \n return A.get(r) <= tar ? r : A.get(l) <= tar ? l : -1;\n }\n}\n```\n\n### Complexity Analysis\nTime: `O(nlogn)`, since we sorted the array, and performed `n` binary search, each takes `O(logn)`\nSpace: `O(n)`, since we used a new array to store the dedup array `A`. | 2 | 0 | [] | 0 |
minimum-number-of-operations-to-make-array-continuous | Simple Java Sliding Window | simple-java-sliding-window-by-fang2018-pbov | \nclass Solution {\n public int minOperations(int[] nums) {\n int n = nums.length, maxNum = 0; \n Arrays.sort(nums);\n Map<Integer, Inte | fang2018 | NORMAL | 2021-09-19T04:35:45.701271+00:00 | 2021-09-19T04:35:45.701294+00:00 | 106 | false | ```\nclass Solution {\n public int minOperations(int[] nums) {\n int n = nums.length, maxNum = 0; \n Arrays.sort(nums);\n Map<Integer, Integer> map = new HashMap<>();\n for (int i = 0, j = 0; i < n; i++) {\n map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);\n while (nums[i] - nums[j] >= n) {\n map.put(nums[j], map.get(nums[j]) - 1);\n if (map.get(nums[j]) == 0) map.remove(nums[j]); \n j++;\n }\n maxNum = Math.max(maxNum, map.size());\n }\n return n - maxNum;\n }\n}\n``` | 2 | 0 | [] | 0 |
minimum-number-of-operations-to-make-array-continuous | [C++] Upper_bound || Faster than 100% -O[nlogn] with Simple Explanation | c-upper_bound-faster-than-100-onlogn-wit-820l | Conclusion from the question\n1) Final array will be a continious series of unique elements of length nums.size().\n2) Intuitively, It is not very difficult to | Shivu__122 | NORMAL | 2021-09-18T20:59:08.061777+00:00 | 2021-09-18T21:11:38.436814+00:00 | 149 | false | **Conclusion from the question**\n1) Final array will be a continious series of unique elements of length nums.size().\n2) Intuitively, It is not very difficult to see that the resulting series will start from any optimal element which is already present in the array. \n\n3) Now we only need to find from **which element I should start my series** so that I required minimum updation.\n\n**Idea**\nHere I will be computing for every element in the array, that How many minimum number of elements required to add in the array if I am starting from the current element, and the ans will be the minimum count among all the array elements.\n\n**Logic For computing the minimum number of element those are required to add if I am starting my series from current element**\nFirst I will create another array after removing all the duplicate from the nums array in sorted order. \nNow suppose my array is 1 2 5 6 7 11 12 and I want to find the count for starting element lets say 1 . \n\n```Already_exists_Number_of_elements=upper_bound(arr.begin(), arr.end(), currelement+nums.size()-1)-itr``` \n(Here itr is the position of the current element , as 1 is the first element of the array so here itr=arr.begin())\n\n```Elements_required_to_add = (nums.size()-Already_exists_Number_of_elements)```\n\n**ans=min for all i (Elements_required_to_add)**\n\n[C++Code] O(nlogn)\n```\nclass Solution {\npublic:\n int minOperations(vector<int>& nums) {\n sort(nums.begin(), nums.end());\n vector<int> arr; arr.push_back(nums[0]);\n // arr will store all the unique elements from nums in sorted order\n for(int i=1;i<nums.size();i++){\n if(nums[i]!=nums[i-1])\n arr.push_back(nums[i]);\n }\n \n int n=nums.size(); int ans=n;\n for(auto itr=arr.begin();itr!=arr.end();itr++){\n // ele:- represents the number of elements those are already exists in the array \n // if i am starting my series from the element (*itr)\n int ele=upper_bound(itr, arr.end(), *itr+n-1)-itr;\n ans=min(ans, n-ele);\n }\n return ans;\n }\n};\n``` | 2 | 0 | [] | 1 |
minimum-number-of-operations-to-make-array-continuous | Simple solution in c++ | simple-solution-in-c-by-dhruvppatel2506-9trn | Simple solution using order statistics tree.\nRefered this \n\n#include <ext/pb_ds/assoc_container.hpp>\n#include <ext/pb_ds/tree_policy.hpp>\n\n\nusing namespa | dhruvppatel2506 | NORMAL | 2021-09-18T16:13:43.076376+00:00 | 2021-09-18T16:15:32.264422+00:00 | 87 | false | Simple solution using order statistics tree.\nRefered [this](https://codeforces.com/blog/entry/11080) \n```\n#include <ext/pb_ds/assoc_container.hpp>\n#include <ext/pb_ds/tree_policy.hpp>\n\n\nusing namespace __gnu_pbds;\n\ntemplate <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;\n\nclass Solution {\npublic:\n int minOperations(vector<int>& a) \n {\n Tree<int>s;\n \n for( auto x : a )\n s.insert(x);\n \n int ans = INT_MAX , n = a.size();\n \n for( auto x : a )\n {\n int k1 = s.order_of_key(x+n);\n k1 -= s.order_of_key(x);\n \n ans = min( ans , n-k1 );\n }\n \n return ans;\n }\n};\n``` | 2 | 1 | [] | 2 |
minimum-number-of-operations-to-make-array-continuous | [Python 3] O(nlogn) solution with visualization | python-3-onlogn-solution-with-visualizat-ocqw | Explanation with visualization\n\nObservation 1:\nWe can consider only unique elements (No duplicates)\n\nObservation 2: \nFor the difference between maximum an | sbh69840 | NORMAL | 2021-09-18T16:01:30.461688+00:00 | 2021-09-19T02:28:17.320199+00:00 | 124 | false | **Explanation with visualization**\n\n**Observation 1:**\nWe can consider only unique elements (No duplicates)\n\n**Observation 2:** \nFor the difference between maximum and minimum number to be equal to len(nums)-1 we want the elements to be a contiguous sequence. \n\n**Solution:**\nSince the final result has to be a contiguous sequence we can go over all the current contiguous sequences and for each sequence we can see how many numbers will be in the window of size len(nums) (with duplicates) to the left and the right of the contiguous sequence. We consider the side which encloses most numbers. Since we know how many numbers are not going to be replaced we can subtract that from the len(nums) (with duplicates) to get the ans for the current contiguous sequence. We repeat the same process over all the sequences and return the minimum replacements. \n\nConsider an Example:\n\nLet\'s say nums = [2,3,5,6,11]\nThere are 3 contiguous sequences: \n[2,3], [5,6], [11]\nWe start from [2,3] and check the number of points to the left and right in a window of size 5. There are no points on the left and there are 2 points on the right of [2,3], which can be seen in the figure below. \n\n\nSimilarly, for [5,6] there are points on the left and not on the right. Above figure applies to this one as well for the left window. The right window is:\n\n\nFor [11], there are no points on the right or left. The left window is as shown below: \n\n\nHence, the minimum number of points to be removed are in the case of right window of [2,3] and left window of [5,6] which is 1.\n\n**Implementation:**\n\n```\nclass Solution:\n def minOperations(self, nums: List[int]) -> int:\n i = 0\n initial_length = len(nums)\n nums = list(set(nums))\n nums.sort()\n n = len(nums)\n continuous_segments = []\n while i<n:\n j = i+1\n while j<n and nums[j]==nums[j-1]+1:\n j+=1\n continuous_segments.append([j-i,i,j-1])\n i = j\n res = float(\'inf\')\n for ans,ans_l,ans_r in continuous_segments:\n # Find number of points from nums[ans_r]+1 to nums[ans_r]+(initial_length-ans)\n right_points = bisect.bisect_right(nums,nums[ans_r]+(initial_length-ans))-bisect.bisect_left(nums,nums[ans_r]+1)\n # Find number of points from nums[ans_l]-(initial_length-ans) to nums[ans_l]-1\n left_points = bisect.bisect_left(nums,nums[ans_l]-1)-bisect.bisect_left(nums,nums[ans_l]-(initial_length-ans))\n res = min(res, initial_length-(ans+max(right_points,left_points)))\n return res\n```\n\n**Update:**\n\nSince we are considering a sorted nums sequence we don\'t have to check both the left and right windows, as the previous contiguous sequence will have the left window of current contiguous sequence as it\'s right window. In short, it suffices to just check the right window of every contiguous sequence. \n\n**Updated code:**\n\n```\nclass Solution:\n def minOperations(self, nums: List[int]) -> int:\n i = 0\n initial_length = len(nums)\n nums = list(set(nums))\n nums.sort()\n n = len(nums)\n continuous_segments = []\n while i<n:\n j = i+1\n while j<n and nums[j]==nums[j-1]+1:\n j+=1\n continuous_segments.append([j-i,i,j-1])\n i = j\n res = float(\'inf\')\n for ans,ans_l,ans_r in continuous_segments:\n # Find number of points from nums[ans_r]+1 to nums[ans_r]+(initial_length-ans)\n right_points = bisect.bisect_right(nums,nums[ans_r]+(initial_length-ans))-bisect.bisect_left(nums,nums[ans_r]+1)\n res = min(res, initial_length-(ans+right_points))\n return res\n```\nIf you like the solution, please consider upvoting! | 2 | 0 | [] | 0 |
minimum-number-of-operations-to-make-array-continuous | [Kotlin] Simple Short O(nlogn) Solution | kotlin-simple-short-onlogn-solution-by-c-556z | \nclass Solution {\n fun minOperations(nums: IntArray): Int {\n val distinctNums = nums.sorted().distinct()\n var maxCount = 1\n var fir | catcatcute | NORMAL | 2021-09-18T16:01:27.447856+00:00 | 2021-09-18T16:04:12.473335+00:00 | 94 | false | ```\nclass Solution {\n fun minOperations(nums: IntArray): Int {\n val distinctNums = nums.sorted().distinct()\n var maxCount = 1\n var firstNumIndex = 0\n for (i in 1..distinctNums.lastIndex) {\n while (distinctNums[i] - distinctNums[firstNumIndex] >= nums.size) {\n ++firstNumIndex\n }\n maxCount = maxOf(maxCount, i - firstNumIndex + 1)\n }\n return nums.size - maxCount\n }\n}\n``` | 2 | 0 | ['Kotlin'] | 1 |
minimum-number-of-operations-to-make-array-continuous | Python TC O(n log(n)), SC O(n): Proof that a Best Window Ends with a Value in nums | python-tc-on-logn-sc-on-proof-that-a-bes-h4la | Intuition\n\nThe idea is that we want to find the sliding window of range n-1 that involves the fewest moves to make all elements unique in the window.\n\nSuppo | biggestchungus | NORMAL | 2024-08-18T04:31:28.233005+00:00 | 2024-08-18T04:31:28.233030+00:00 | 10 | false | # Intuition\n\nThe idea is that we want to find the sliding window of range `n-1` that involves the fewest moves to make all elements unique in the window.\n\nSuppose we have `u` unique elements in some window `lo..hi` where `hi-lo+1 == n` as described in the problem statement. Then we have to move the other `n-u` elements into unique positions.\n\n# Solution: Iterate Over Sorted Uniques\n\nWe can prove below that a best window ends with some number in `nums`.\n\nSupposing that\'s true for the moment then we can use a two-pointer method:\n* for each unique value in `nums` at index `r`\n * the next candidate window ends at `nums[r]`\n * while `nums[l] < nums[r]-n+1`, the value at `l` is no longer in range so we need to increment it\n * then we know that the uniques at `l..r` are in the current window, `r-l+1` values\n * and thus the operations required for this window are `n-(r-l+1)`\n\n# Proof that a Best Window Ends at A Value in nums\n\nThe best window doesn\'t end past the last number because\n* suppose we need `ops` to make a window ending at the last number\n* then if we moved the window one to the right, then we\'d have to spend one more operation to move an element at `max-n+1` upward\n* if we moved it two to the right, then we\'d need to spend up to 2 more ops to also move `max-n+2`\n* and so on\n\nThe number of operations increases, so the window definitely doesn\'t end past the last element.\n\nNow suppose that the best window doesn\'t end with the last element.\n\nThen the next latest best window candidate must end at the second highest element. That\'s because\n* we\'re moving the value `max(nums)` no matter what (otherwise we contradicted the assertion the window ends before `max(nums)`)\n* if we end at `secondHighest` then the window is `secondHighest-n+1..secondHighest`\n* if we move the window one to the right, then if we have a copy of `secondHighest-n+1`, we have to spend a new operation to move it\n* if we move the window two to the right, then if we have a copy of `secondHighest-n+2`, we have to move it as well\n* so the more we shift right, the more operations we spend\n\nTherefore for each element we remove, the latest next window candidate ends at the remaining highest value.\n\nThis is why iterating over all relevant window endpoints is as simple as iterating over `nums`.\n\n**Note: the same proof approach shows a best window *starts* at a value in `nums` as well.** Same idea: if we start after some value in nums, then we\'ll start at least at the next largest value. That\'s because if we shifted the window left then we\'d have to move more and more elements to the left.\n\n**Note 2: I say *a* best window and not *the* best window because there can be many best windows.** For example if we have `nums=[2, 2, 2]`, then we can have best windows 0..2, 1..3, 2..4. All are valid.\n\n# Approach\n\nFind the unique numbers with `set` and then sort them.\n\nThen for each unique value `e` ("end") at index `r` ("right window index"), advance `l` ("left window index\') until `uniques[l]` is in bounds.\n\nThe values in `uniques[l:r+1]` are all unique by construction and all in the same range of `n` values. Therefore we have `r-l+1` uniques in this window, and need to spend `n - (r-l+1)` operations to move the rest of the values to unique positions. The values we move are either\n * out of range\n * duplicates of values in the range\n\n# Complexity\n- Time complexity: n log(n) because we have to sort. The two-pointer sliding window stuff is just O(n)\n\n- Space complexity: O(n), need to form a set of numbers and sort; Python\'s default sort is mergesort and uses O(n) space, you\'d have to write/import a quicksort algorithm to get log(n) space complexity\n\n# Optimizations\n\nWe could use the C++ `std::sort` and then `std::unique` approach to reduce space complexity to `log(n)`:\n* first we could quicksort the `n` values in place in `O(n log(n))` time and `O(log(n))` space\n* then we can use a two-pointer algorithm to shift the `u <= n` unique elements in place to the first `u` positions of `nums` (a bit tricky, but doable)\n* then we can iterate over the first `u` positions in `nums` for the endpoints and ignore the `n-u` remaining elements\n\n\n# Code\n```\nclass Solution:\n def minOperations(self, nums: List[int]) -> int:\n # one op: replace any int with any int\n\n # goal:\n # all elements unique\n # elements are a permutation of lo..hi\n # where hi-lo = n-1\n\n # cost to get 1..n:\n # count distinct values in 1..n, cost is n - numDistinct\n #\n # what about 2..n+1?\n # start with cost of 1..n\n # then we\'d need to add a value with n+1 and remove 1\n # if there\'s an original value with n+1 then we subtract one\n # because that\'s an element that no longer needs change\n # if there\'s an original value with 1 then we need to change it\n\n # n = len(nums)\n\n # hi = max(nums)\n # lo = min(nums)\n\n # if hi - lo <= n-1:\n # return n - len(set(nums))\n\n # uniques = set(nums)\n # r = lo+n-1\n # cost = n - sum(n <= r for n in uniques)\n\n # # find the sliding window of values l..r of size n\n # # that has the minimum cost\n # min_cost = cost\n # for r in range(lo+n, hi+1):\n # l = r-n+1\n # if r in uniques: cost -= 1\n # if l-1 in uniques: cost += 1\n # min_cost = min(min_cost, cost)\n\n # return min_cost\n\n ### nums are in 1..1e9\n\n # better idea: boundary candidates either start with\n # a number we have or end with a number we have\n \n # even BETTER: the best window always ends with one of the elements\n\n n = len(nums)\n uniques = sorted(set(nums))\n\n min_cost = n\n l = 0\n for r, e in enumerate(uniques):\n s = e-n+1\n while uniques[l] < s: l += 1\n\n min_cost = min(min_cost, n - (r-l+1))\n\n return min_cost\n\n\n # But why does a best window always end with a number?\n\n # makes sense that we wouldn\'t want to move the max up any higher,\n # because that would require moving at least as many elements up\n # as a window with end == max(nums)\n #\n # so latest candidate is max(nums)\n # if not max(nums), then we have to move that max\n # therefore we\'d find the best earlier window and move the max\n # similarly that latest window wouldn\'t involve moving elements\n # past the second-highest element\n #\n # and so on\n\n # same logic applies for starting before lo\n``` | 1 | 0 | ['Python3'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Using diference array | using-diference-array-by-aditya3435-cezm | \n\n# Code\n\nclass Solution {\npublic:\n int minOperations(vector<int>& nums) {\n int f = nums.size();\n set<int> st(nums.begin(), nums.end()) | aditya3435 | NORMAL | 2023-11-02T14:11:02.862154+00:00 | 2023-11-02T14:11:02.862182+00:00 | 4 | false | \n\n# Code\n```\nclass Solution {\npublic:\n int minOperations(vector<int>& nums) {\n int f = nums.size();\n set<int> st(nums.begin(), nums.end());\n nums.clear();\n for(auto c : st) nums.push_back(c);\n int mn = INT_MIN, mni = 0;\n for(int i=0; i<nums.size(); i++) {\n int ct = upper_bound(nums.begin(), nums.end(), nums[i] + f - 1) - nums.begin() - i - 1;\n if(mn < ct) {\n mn = ct;\n mni = i;\n }\n }\n mn = nums[mni];\n int l = mn, r = mn + f - 1;\n map<int,int> dif;\n dif[0] = 0, dif[l] = 1, dif[r+1] = -1;\n vector<int> pos, pre;\n long long t = 0;\n for(auto m : dif) {\n t += m.second;\n pos.push_back(m.first);\n pre.push_back(t);\n }\n int ans = f - nums.size();\n for(int e : nums) {\n int i = upper_bound(pos.begin(), pos.end(), e) - pos.begin() - 1;\n ans += (pre[i] == 0);\n }\n return ans;\n\n \n }\n};\n``` | 1 | 0 | ['C++'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Python | Easy | Queue | Heap | Minimum Number of Operations to Make Array Continuous | python-easy-queue-heap-minimum-number-of-p8u3 | \nsee the Successfully Accepted Submission\nPython\nclass Solution:\n def minOperations(self, nums):\n n = len(nums)\n nums.sort() # Sort the | Khosiyat | NORMAL | 2023-10-12T14:21:30.138380+00:00 | 2023-10-12T14:21:30.138431+00:00 | 27 | false | \n[see the Successfully Accepted Submission](https://leetcode.com/submissions/detail/1071611939/)\n```Python\nclass Solution:\n def minOperations(self, nums):\n n = len(nums)\n nums.sort() # Sort the input nums in non-decreasing order.\n \n if n == 1:\n return 0 # If there\'s only one element, no operations are needed.\n \n mini = float(\'inf\') # Initialize the minimum operations to a very large value.\n v = [0] * (n + 1) # Create a list to store prefix sums.\n mp = {} # Create a dictionary to store the frequency of each element.\n\n count = 0 # Initialize a count variable.\n \n # Calculate prefix sums and update the count of repeated elements.\n for i in range(n):\n mp[nums[i]] = mp.get(nums[i], 0) + 1\n if mp[nums[i]] != 1:\n count += 1\n v[i] = count\n v[n] = v[n - 1] # Set the last element of v to be the same as the second-to-last.\n\n for i in range(n - 1):\n idx = self.lower_bound(nums, nums[i] + n - 1) # Find the index of the upper bound.\n x = i\n\n if idx != n and nums[idx] != nums[i] + n - 1:\n x += 1\n if idx == n:\n x += 1\n\n x += n - 1 - idx\n x += v[idx] - v[i] # Calculate the number of operations required.\n mini = min(mini, x) # Update the minimum operations.\n\n return mini # Return the minimum operations required.\n\n def lower_bound(self, nums, target):\n left, right = 0, len(nums)\n while left < right:\n mid = left + (right - left) // 2\n if nums[mid] < target:\n left = mid + 1\n else:\n right = mid\n return left # Return the index of the lower bound.\n```\n\n\n | 1 | 0 | ['Queue', 'Python'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Java | Sliding Window | Full Explanation | java-sliding-window-full-explanation-by-7xpxe | Intuition\nThe problem requires finding the minimum number of operations to make the array continuous. To achieve this, we can use a HashSet to remove duplicate | harshs29 | NORMAL | 2023-10-10T18:12:44.879775+00:00 | 2023-10-10T18:12:44.879805+00:00 | 27 | false | # Intuition\nThe problem requires finding the minimum number of operations to make the array continuous. To achieve this, we can use a HashSet to remove duplicates, then sort the array. Next, we use a sliding window approach to find the smallest subarray containing n unique elements.\n\n\n# Approach\n1. Initialize variables: Initialize a variable `ans` to n. Create a HashSet called `unique` to store unique elements from the input array `nums`.\n2. Convert HashSet to Array: Convert the `HashSet` to an array called `newNums` and sort it.\n3. Sliding Window: Use a two-pointer approach (`i` and `j`) to find the minimum number of operations. Iterate through `newNums` with index `i`:\n - Initialize `j` to `i` and loop while `j` is less than the length of `newNums` and the element at `j` is within the range of `newNums[i]` to `newNums[i] + n`.\n - Calculate the size of the sliding window (`window`) as `j - i`.\n - Update `ans` to be the minimum of `ans` and `n - window`.\n4. Return `ans`.\n\n# Complexity\n- Time complexity: **O(n log n)** due to the sorting step.\n\n- Space complexity: **O(n)** for the HashSet and `newNums` array.\n\n\n# Code\n```\nclass Solution {\n public int minOperations(int[] nums) {\n int n = nums.length;\n int ans = n;\n \n HashSet<Integer> unique = new HashSet<>();\n for (int num : nums) {\n unique.add(num);\n }\n \n int[] newNums = new int[unique.size()];\n int index = 0;\n \n for (int num : unique) {\n newNums[index++] = num;\n }\n \n Arrays.sort(newNums);\n \n int j = 0;\n for (int i = 0; i < newNums.length; i++) {\n while (j < newNums.length && newNums[j] < newNums[i] + n) {\n j++;\n }\n\n int window = j - i;\n ans = Math.min(ans, n - window);\n }\n \n return ans; \n }\n}\n``` | 1 | 0 | ['Array', 'Sliding Window', 'Java'] | 0 |
minimum-number-of-operations-to-make-array-continuous | C++ Binary Search , Understandable to Beginners as well | c-binary-search-understandable-to-beginn-wjrr | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | Ankita2905 | NORMAL | 2023-10-10T17:10:19.313880+00:00 | 2023-10-10T17:10:19.313902+00:00 | 14 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\npublic:\n int minOperations(vector<int>& nums) {\n int n = nums.size();\n \n //set for finding unique element \n set<int>s;\n for(int i=0;i<nums.size();i++)\n {\n s.insert(nums[i]);\n }\n vector<int>unique;\n for(int item:s){\n unique.push_back(item);\n }\n \n //sort the array(let unique.size= m m*log(m))\n sort(unique.begin(),unique.end());\n \n int ans = INT_MAX;\n for(int i=0;i<unique.size();i++)\n {\n int start = unique[i];\n int last = start+n-1;\n \n //search for element just grater than last\n vector<int>::iterator upper=upper_bound(unique.begin(),unique.end(),last);\n int len = upper- unique.begin();\n ans = min(ans,n-(len-i));\n \n }\n return ans;\n }\n};\n``` | 1 | 0 | ['C++'] | 0 |
minimum-number-of-operations-to-make-array-continuous | [Rust] | Idiomatic Iterator Chain | rust-idiomatic-iterator-chain-by-marktan-ozhi | \nimpl Solution {\n pub fn min_operations(mut nums: Vec<i32>) -> i32 {\n let n: usize = nums.len();\n let n: i32 = n as i32;\n\n nums.so | MarkTanashchukID | NORMAL | 2023-10-10T16:57:26.055504+00:00 | 2023-10-10T16:57:26.055535+00:00 | 6 | false | ```\nimpl Solution {\n pub fn min_operations(mut nums: Vec<i32>) -> i32 {\n let n: usize = nums.len();\n let n: i32 = n as i32;\n\n nums.sort();\n nums.dedup();\n\n nums.iter()\n .enumerate()\n .map(|(i, num)| nums.partition_point(|&p| p < num + n) - i)\n .map(|point| n - point as i32)\n .min()\n .unwrap()\n }\n}\n``` | 1 | 0 | ['Rust'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Simple Solution || Beginner Friendly || Easy to Understand C++ | simple-solution-beginner-friendly-easy-t-djcv | Intuition\n\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Tim | Ishu-Gupta-9-ISHGPT | NORMAL | 2023-10-10T15:56:08.579298+00:00 | 2023-10-10T15:56:08.579316+00:00 | 12 | false | # Intuition\n\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:O(nlogn)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:O(n)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\npublic:\n int minOperations(vector<int>& nums) {\n int n = nums.size();\n\n sort(nums.begin(), nums.end());\n\n vector<int> duplicate(n, 0);\n\n for(int i = 1; i < n; i++)\n {\n if(nums[i] == nums[i - 1])\n {\n duplicate[i] = duplicate[i - 1] + 1;\n }\n else\n {\n duplicate[i] = duplicate[i - 1];\n }\n }\n int ans = INT_MAX;\n for(int i = 0; i < n; i++)\n {\n int tmp = i;\n int s = nums[i] + n - 1;\n\n auto it = lower_bound(nums.begin(), nums.end(), s) - nums.begin();\n\n if(it == n)it--;\n if(nums[it] > s)it--;\n\n tmp += n - it - 1;\n tmp += duplicate[it] - duplicate[i];\n\n ans = min(tmp, ans);\n }\n\n return ans;\n }\n};\n``` | 1 | 0 | ['C++'] | 0 |
minimum-number-of-operations-to-make-array-continuous | ||easy solution||O(1) space|| | easy-solutiono1-space-by-sainiankur0508-cst9 | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | sainiankur0508 | NORMAL | 2023-10-10T14:27:18.077702+00:00 | 2023-10-10T14:27:18.077733+00:00 | 33 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n$$O(nlogn)$$\n\n- Space complexity:\n$$O(1)$$\n\n# Code\n```\nclass Solution {\npublic:\n int minOperations(vector<int>& nums) {\n int n = nums.size();\n sort(nums.begin(),nums.end());\n int i=0,j=0,mn = INT_MAX,cnt=0;\n while(i<n){\n while(j+1<n && nums[j+1]-nums[i]<=n-1){\n j++;\n if(nums[j]==nums[j-1]) cnt++;\n }\n mn = min(mn,n-(j-i+1-cnt));\n i++;\n if(i<n && nums[i]==nums[i-1]) cnt--;\n }\n return mn;\n }\n};\n``` | 1 | 0 | ['Array', 'Sliding Window', 'Sorting', 'C++'] | 0 |
minimum-number-of-operations-to-make-array-continuous | binary search | binary-search-by-mr_stark-hepv | \nclass Solution {\npublic:\n \n \n int minOperations(vector<int>& nums) {\n int nn = nums.size();\n set<int> st(nums.begin(),nums.end());\n | mr_stark | NORMAL | 2023-10-10T14:11:29.477535+00:00 | 2023-10-10T14:11:48.228397+00:00 | 9 | false | ```\nclass Solution {\npublic:\n \n \n int minOperations(vector<int>& nums) {\n int nn = nums.size();\n set<int> st(nums.begin(),nums.end());\n vector<int> v(st.begin(),st.end());\n int n = v.size();\n int res = INT_MAX;\n for(int i = 0;i<n;i++)\n {\n int L = v[i];\n int R = L+nn-1;\n \n int j = upper_bound(v.begin(),v.end(),R)-v.begin();\n \n int range = j-i;\n int out = nn-range;\n res = min(out,res);\n }\n \n return res;\n \n }\n};\n``` | 1 | 0 | [] | 0 |
minimum-number-of-operations-to-make-array-continuous | Binary Search | O(nlogn) | Problem seems trickier, but it's not. | binary-search-onlogn-problem-seems-trick-plh0 | Intuition\n Describe your first thoughts on how to solve this problem. \nFirst, we need to understand that a solution always exists for this problem. Why? Let\' | Nik28 | NORMAL | 2023-10-10T13:38:43.455472+00:00 | 2023-10-10T13:38:43.455490+00:00 | 75 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nFirst, we need to understand that a solution always exists for this problem. Why? Let\'s see.\n\nIf we\'ve an array `[1,2,4,6]`, any set of 4 consecutive elements is a contiguous array. \n`[1,2,3,4], [5,6,7,8], [100,101,102,103]`, any. \nAll of them satisfies the given conditions.\n\nSo, the max no. of operations would be \'n\' (n-1) to be more precise.\nNow, we need to find the min no. of operations.\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n# 1. Binary Search\nTo know the min. no of operations means the min no of elements that we need to replace, We need to find out the max no. of elements that are already in place.\n\nOnce, we have got all the unique sorted elements, we can traverse it linearly and in each iteration do the following:\n1. For index i, take $$nums[i]$$ as the starting ele of subarray.\n2. To find out the max len of subarray, we need to find the ele that\'s just greater than $$nums[i]+n-1$$.\nBecause, for a contiguous array $$max-min=n-1$$.\n3. And, this subarray will have all the elements that are already in place. We can get the remaining elements in place by doing $$n-len$$ operations.\n\nLet\'s see the code now!\n# Code\n```\nclass Solution {\npublic:\n int minOperations(vector<int>& nums) {\n \n int n=nums.size();\n\n //Get all unique elements\n\n sort(begin(nums),end(nums));\n\n //unique only works on sorted elements, and returns the \n //new end of your array\n nums.erase(unique(begin(nums),end(nums)), end(nums));\n\n int ans= n;\n for(int i=0;i<nums.size();i++)\n {\n int low = nums[i]; //start of subarray\n int high = nums[i]+n-1; //possible end of subarray\n\n auto it = upper_bound(nums.begin(),nums.end(),high);\n\n int lastPos = it-nums.begin();\n int len = lastPos - i; // length of subarray\n ans = min(ans,n-len); // min no of operations\n\n }\n\n return ans;\n\n }\n};\n```\n\n# Complexity\n- Time complexity: $$O(nlogn)$$, for doing the binary search inside loop and sorting, erasing elements.\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:$$O(1)$$\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\nWe are just finding the max len of subarray which satisfies the condition of end-start=N-1. This can also be done using Sliding Window.\nIt\'s beutifually explained here. Check it out! \n[Sliding Window Approach](https://leetcode.com/problems/minimum-number-of-operations-to-make-array-continuous/solutions/1470857/c-sliding-window/?envType=daily-question&envId=2023-10-10)\n\nIt\'s always better to expand your range of ideas.\n\nHappy Coding \u2665 | 1 | 0 | ['Binary Search', 'C++'] | 0 |
minimum-number-of-operations-to-make-array-continuous | ✅Accepted Java Code || Beats 100% | accepted-java-code-beats-100-by-thilaknv-7vw1 | Complexity\n- Time complexity : O(nlog(n))\n Add your time complexity here, e.g. O(n) \n\n- Space complexity : O(1)\n Add your space complexity here, e.g. O(n) | thilaknv | NORMAL | 2023-10-10T12:55:36.229728+00:00 | 2023-10-10T12:55:36.229751+00:00 | 82 | false | # Complexity\n- Time complexity : $$O(nlog(n))$$\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity : $$O(1)$$\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\npublic int minOperations(int[] nums) {\n Arrays.sort(nums);\n int max = 1, temp = 1;\n int max_range = nums[0] + nums.length;\n int j = 0;\n for(int i = 1; i < nums.length; i++){\n if(nums[i] == nums[i - 1])\n continue;\n else if(nums[i] < max_range){\n temp++;\n if(max < temp) max = temp;\n }\n else{\n int x = nums[j];\n while(j < nums.length && nums[j] == x) j++;\n max_range = nums[j] + nums.length;\n i--; temp--;\n }\n }\n return nums.length - max;\n}\n}\n```\n>>> ## Upvote\uD83D\uDC4D if you find helpful | 1 | 0 | ['Array', 'Binary Search', 'Java'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Java easy solution 👨💻💕😎 | java-easy-solution-by-ziddiraj-a683 | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | ZIDDIRAJ | NORMAL | 2023-10-10T12:39:02.158600+00:00 | 2023-10-10T12:39:02.158624+00:00 | 59 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\n public int minOperations(int[] nums) {\n int n = nums.length;\n int ans = n;\n HashSet<Integer> hashSet = new HashSet<>();\n for (int x : nums) {\n hashSet.add(x);\n }\n int[] unique = new int[hashSet.size()];\n int i = 0;\n \n for (int x : hashSet) {\n unique[i++] = x;\n }\n \n Arrays.sort(unique);\n \n int j = 0;\n int m = unique.length;\n for (i = 0; i < m; i++) {\n while (j < m && unique[j] < unique[i] + n) {\n j++;\n }\n ans = Math.min(ans, n - j + i);\n }\n \n return ans;\n \n }\n}\n``` | 1 | 0 | ['Array', 'Binary Search', 'Java'] | 0 |
minimum-number-of-operations-to-make-array-continuous | Beats 99.02%of users with Java | beats-9902of-users-with-java-by-kushal_5-z1h4 | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# Complexity\n- Time | kushal_589 | NORMAL | 2023-10-10T11:38:05.346063+00:00 | 2023-10-10T11:38:05.346088+00:00 | 75 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\n public int minOperations(int[] nums) {\n Arrays.sort(nums);\n int uniqueLen = 1;\n for (int i = 1; i < nums.length; ++i) {\n if (nums[i] != nums[i - 1]) {\n nums[uniqueLen++] = nums[i];\n }\n }\n \n int ans = nums.length;\n for (int i = 0, j = 0; i < uniqueLen; ++i) {\n while (j < uniqueLen && nums[j] - nums[i] <= nums.length - 1) {\n ++j;\n }\n ans = Math.min(ans, nums.length - (j - i));\n }\n \n return ans;\n }\n}\n``` | 1 | 0 | ['Java'] | 1 |
minimum-number-of-operations-to-make-array-continuous | Python super easy solution with intuition. Concept( set & binary search) | python-super-easy-solution-with-intuitio-uhbg | Intuition\n Describe your first thoughts on how to solve this problem. \n If you observe the question carefully you can see that\n1. the frequency of the number | mkrishnendu079 | NORMAL | 2023-10-10T11:11:38.179166+00:00 | 2023-10-10T11:11:38.179183+00:00 | 101 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n If you observe the question carefully you can see that\n1. the frequency of the numbers does not matter the same number comes up once or many times does not matter in the end you just need to find maximum **unique** numbers that are agreable with the given condition.\n2. the position of the numbers does not matter\n\n# Approach\n\nAt first take a **sorted set** of the numbers. Now imagine the 1st element in the set is your starting element of your answer. Then the last element would be n+s[0]-1 (total length required + value of the 1st element). \nAs the set is sorted just binary search this value to check how many elements in between the first and last element you have. Do the same for, 2nd element in the set is your starting element of your answer. And so on ...\n\n\n# Complexity\n- Time complexity:\nO(nlog(n))\n\n- Space complexity:\nO(n)\n\n# Code\n```\nclass Solution:\n\n def minOperations(self, nums: List[int]) -> int:\n if len(nums)==1:\n return 0\n n=len(nums)\n s=set(nums)\n s=list(s)\n s.sort()\n maax=0\n for i in range(len(s)-1):\n lo=i\n hi=len(s)-1\n ans=-1\n target=s[i]+n-1\n while lo<=hi:\n mid=(lo+hi)//2\n if s[mid]<=target:\n ans=mid\n lo=mid+1\n else:\n hi=mid-1\n maax=max(maax,ans-i+1)\n return n-maax\n\n\n\n``` | 1 | 0 | ['Python3'] | 0 |
minimum-number-of-operations-to-make-array-continuous | C solution | c-solution-by-hoouhoou-i4f6 | \nint cmp(const void *a, const void *b){\n return *(int*)a - *(int*)b;\n}\n\nint binarySearch(int target, int *nums, int size){\n int l = 0, r = size, mid | HoouHoou | NORMAL | 2023-10-10T10:00:09.504226+00:00 | 2023-10-10T10:00:09.504242+00:00 | 19 | false | ```\nint cmp(const void *a, const void *b){\n return *(int*)a - *(int*)b;\n}\n\nint binarySearch(int target, int *nums, int size){\n int l = 0, r = size, mid;\n while (l < r){\n mid = (l + r) >> 1;\n if (nums[mid] > target)\n r = mid;\n else\n l = mid + 1;\n }\n return l;\n}\n\nint minOperations(int* nums, int numsSize){\n \n qsort(nums, numsSize, sizeof(int), cmp);\n \n int len = 1;\n\n for (int i = 1; i < numsSize; i++)\n if (nums[i] != nums[i - 1])\n nums[len++] = nums[i];\n \n int ans = numsSize;\n \n for (int i = 0; i < len; i++){\n int r = nums[i] + numsSize - 1, temp = binarySearch(r, nums, len);\n ans = fmin(ans, numsSize - temp + i);\n }\n \n return ans;\n}\n``` | 1 | 0 | ['C'] | 0 |
minimum-number-of-operations-to-make-array-continuous | C# Two Pointers With Explanation | c-two-pointers-with-explanation-by-yulin-pf5x | Approach\nFirst, by reading the description, we know array can be sorted and will not affect the result, and not expecting any duplicated element.\nBy these rul | yulinchao | NORMAL | 2023-10-10T09:14:06.335715+00:00 | 2023-10-10T09:14:06.335733+00:00 | 43 | false | # Approach\nFirst, by reading the description, we know array can be sorted and will not affect the result, and not expecting any duplicated element.\nBy these rules, we know the numbers in nums are continous and unique.\n\nTo make the actions as less as possible, we wish the interval formed by left and right(left and right as the boundary of the interval ) as big as possible, but the area size should smaller than nums.Length. \n\nTake [1,2,3,5,6] as the case.\n[1,2,3,5] we will take 1,5 as the left and right, due to the length of the array is 5, 5 - 1 < 5, so this is valid interval, with this left and right, we only need to take one more element out of this interval to fuifll the rule.\n\n[1,2,3,5,6] we can take 1,5 or 2,6 as the left and right, 5 - 1 or 2 -6 both less than 5.\n1,6 is not a valid boundary of the interval, due to 6 - 1 = 5 and 5 is not less than 5.\n\nSo after we get the biggest interval to make the operation to be minimum, the needed operation is the total elements(nums.Length) - elements selected(fulfill the interval, 1,2,3,5).\n\nKeep iterate all the values in the unique sorted array and find out the minimum value, that will be the answer.\n\n# Code\n```\npublic class Solution {\n public int MinOperations(int[] nums) {\n Array.Sort(nums);\n var st = new HashSet<int>(nums).ToArray();\n var n = nums.Length;\n var ans = n - 1;\n var right = 0;\n for(var left = 0; left < st.Length; left++){\n while(right < st.Length && (st[right] - st[left]) < n){\n right++;\n }\n var size = right - left;\n var times = n - size;\n ans = Math.Min(ans, times);\n }\n return ans;\n }\n}\n``` | 1 | 0 | ['C#'] | 2 |
minimum-number-of-operations-to-make-array-continuous | Fast and Simple 8-line solution | Deque | fast-and-simple-8-line-solution-deque-by-bq9n | Complexity\n- Time complexity: O(NLogN)\n Add your time complexity here, e.g. O(n) \n\n- Space complexity: O(N)\n Add your space complexity here, e.g. O(n) \n\ | swapniltyagi17 | NORMAL | 2023-10-10T08:49:19.568660+00:00 | 2023-10-10T09:02:17.685268+00:00 | 22 | false | # Complexity\n- Time complexity: O(NLogN)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: O(N)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\npublic:\n\n int minOperations(vector<int>& nums) {\n sort(nums.begin(),nums.end());\n int n = nums.size(), i=0, ans=0; deque<int> q;\n while(i<n){\n if(q.empty() or nums[i]-q.front()<=n-1){\n if(q.empty()) q.push_back(nums[i]);\n else if(q.back()!=nums[i]) q.push_back(nums[i]);\n ans = max((int)q.size(),ans);\n i++;\n }\n else q.pop_front();\n }\n return n-ans;\n }\n};\n``` | 1 | 0 | ['C++'] | 0 |
flip-string-to-monotone-increasing | C++ one-pass DP solution, 0ms O(n) | O(1), one line, with explaination. | c-one-pass-dp-solution-0ms-on-o1-one-lin-pslr | This is a typical case of DP. Let's see the sub-question of DP first. Suppose that you have a string s, and the solution to the mono increase question is alread | liamhuang | NORMAL | 2018-11-05T03:45:46.753674+00:00 | 2018-11-05T03:45:46.753717+00:00 | 26,691 | false |
This is a typical case of DP.
Let's see the sub-question of DP first.
Suppose that you have a string `s`, and the solution to the mono increase question is already solved. That is, for string `s`, `counter_flip` flips are required for the string, and there were `counter_one` `'1'`s in the original string `s`.
Let's see the next step of DP.
Within the string `s`, a new incoming character, say `ch`, is appended to the original string. The question is that, how should `counter_flip` be updated, based on the sub-question? We should discuss it case by case.
* When `'1'` comes, no more flip should be applied, since `'1'` is appended to the tail of the original string.
* When `'0'` comes, things become a little bit complicated. There are two options for us: flip the newly appended `'0'` to `'1'`, after `counter_flip` flips for the original string; or flip `counter_one` `'1'` in the original string to `'0'`. Hence, the result of the next step of DP, in the `'0'` case, is `std::min(counter_flip + 1, counter_one);`.
Based on these analysis, the solution comes.
```cpp
class Solution {
public:
int minFlipsMonoIncr(const std::string& S, int counter_one = 0, int counter_flip = 0) {
for (auto ch : S) counter_flip = std::min(counter_one += ch - '0', counter_flip + '1' - ch);
return counter_flip;
}
};
```
If you find the above snippet of code is somewhat difficult to understand, try the below one.
```cpp
class Solution {
public:
int minFlipsMonoIncr(const std::string& S, int counter_one = 0, int counter_flip = 0) {
for (auto ch : S) {
if (ch == '1') {
++counter_one;
} else {
++counter_flip;
}
counter_flip = std::min(counter_one, counter_flip);
}
return counter_flip;
}
};
```
Enjoy coding! | 625 | 8 | [] | 36 |
flip-string-to-monotone-increasing | ✅[C++]Easy solution with explaination[Without Dp]✅ | ceasy-solution-with-explainationwithout-1b88t | \uD83C\uDFA5\uD83D\uDD25 Exciting News! Join my Coding Journey! Subscribe Now! \uD83D\uDD25\uD83C\uDFA5\n\n\uD83D\uDD17 Link in the leetcode profile \n\nNew cod | vishnoi29 | NORMAL | 2023-01-17T00:29:24.675938+00:00 | 2023-06-14T02:09:29.883062+00:00 | 18,013 | false | \uD83C\uDFA5\uD83D\uDD25 Exciting News! Join my Coding Journey! Subscribe Now! \uD83D\uDD25\uD83C\uDFA5\n\n\uD83D\uDD17 Link in the leetcode profile \n\nNew coding channel alert! \uD83D\uDE80\uD83D\uDCBB Subscribe to unlock amazing coding content and tutorials. Help me reach 1K subs to start posting more videos! Join now! \uD83C\uDF1F\uD83D\uDCAA\n\nThanks for your support! \uD83D\uDE4F\uD83C\uDF89\n# Approach\nWhen We are traversing in the string S there will be two possibility\n1. **Char==\'1\'**\n - It will not impact our minimum flips just keep the record of count of 1\n2. **Char==\'0\'**\n - Here will be **2 cases**\n 1. Keep is as 0 and flip all the 1 so far ,for that we need to know about the count the one so far\n 2. Flip it to 1 and update our count_flip\n 3. Take the minmum of count_flip and count_one and update the count_flip because we want minimum(dry run for 1110000)\n \n Example: **string S= 00110**\n**after 1st iteration** : count_one = 0,count_flip = 1,\n *count_flip=min(1,0)=0;*\n**after 2nd iteration** : count_one = 0,count_flip = 1,\n *count_flip=min(1,0)=0;*\n**after 3rd iteration** : count_one = 1,count_flip = 0,\n**after 4th iteration** : count_one = 2,count_flip = 0,\n**after 5th iteration** : count_one = 2,count_flip = 1,\n * count_flip=min(1,2)=1;*\n**it will return 1 as answer**\n\nTry to dry run with string S=010110 and string S=111100000 \n \n# Complexity\n- Time complexity:- O(N)\n- Space complexity:- O(1)\n\n# Code\n```\nclass Solution\n{\npublic:\n int minFlipsMonoIncr(string S)\n {\n int count_flip = 0, count_one = 0;\n for (auto i : S)\n { \n //keep track of all one (we will use count_one in else condition if we need) \n//if we want flip one into 0\n if (i == \'1\')\n count_one++;\n else{\n count_flip++;\n count_flip = min(count_flip, count_one);\n }\n }\n return count_flip;\n }\n};\n```\nIf you really found my solution helpful **please upvote it**, as it motivates me to post such kind of codes.\n***Let me know in comment if i can do better***.\nLet\'s connect on **[LINKDIN](https://www.linkedin.com/in/mahesh-vishnoi-a4a47a193/)**\n\n\n\n | 415 | 3 | ['C++'] | 20 |
flip-string-to-monotone-increasing | Prefix-Suffix Java O(N) One Pass Solution - Space O(1) | prefix-suffix-java-on-one-pass-solution-eghnf | Algorithm:\n1. Skip 0\'s until we encounter the first 1.\n2. Keep track of number of 1\'s in onesCount (Prefix).\n3. Any 0 that comes after we encounter 1 can b | vicky_11 | NORMAL | 2018-10-21T03:26:43.762711+00:00 | 2018-10-24T12:29:41.770616+00:00 | 18,867 | false | Algorithm:\n1. Skip 0\'s until we encounter the first 1.\n2. Keep track of number of 1\'s in onesCount (Prefix).\n3. Any 0 that comes after we encounter 1 can be a potential candidate for flip. Keep track of it in flipCount.\n4. If flipCount exceeds oneCount - (Prefix 1\'s flipped to 0\'s)\n\t\ta. Then we are trying to flip more 0\'s (suffix) than number of 1\'s (prefix) we have. \n\t\tb. Its better to flip the 1\'s instead.\n```\npublic int minFlipsMonoIncr(String S) {\n\tif(S == null || S.length() <= 0 )\n\t\treturn 0;\n\n\tchar[] sChars = S.toCharArray();\n\tint flipCount = 0;\n\tint onesCount = 0;\n\n\tfor(int i=0; i<sChars.length; i++){\n\t\tif(sChars[i] == \'0\'){\n\t\t\tif(onesCount == 0) continue;\n\t\t\telse flipCount++;\n\t\t}else{\n\t\t\tonesCount++;\n\t\t}\n\t\tif(flipCount > onesCount){\n\t\t\tflipCount = onesCount;\n\t\t}\n\t}\n\treturn flipCount;\n}\n``` | 242 | 5 | [] | 22 |
flip-string-to-monotone-increasing | C++/Java 4 lines O(n) | O(1), DP | cjava-4-lines-on-o1-dp-by-votrubac-t1hv | We need to split the array into left \'0\' and right \'1\' sub-arrays, so that sum of \'1\' -> \'0\' flips (left) and \'0\' -> \'1\' flips (right) is minimal.\ | votrubac | NORMAL | 2018-10-21T03:02:15.588980+00:00 | 2022-01-05T23:45:56.994365+00:00 | 16,762 | false | We need to split the array into left \'0\' and right \'1\' sub-arrays, so that sum of \'1\' -> \'0\' flips (left) and \'0\' -> \'1\' flips (right) is minimal.\n- Count of \'1\' -> \'0\' flips going left to right, and store it in ```f0```.\n- Count of \'0\' -> \'1\' flips going right to left, and store it in ```f1```.\n- Find a the smallest ```f0[i] + f1[i]```.\n```\nint minFlipsMonoIncr(string S, int res = INT_MAX) {\n vector<int> f0(S.size() + 1), f1(S.size() + 1);\n for (int i = 1, j = S.size() - 1; j >= 0; ++i, --j) {\n f0[i] += f0[i - 1] + (S[i - 1] == \'0\' ? 0 : 1);\n f1[j] += f1[j + 1] + (S[j] == \'1\' ? 0 : 1);\n }\n for (int i = 0; i <= S.size(); ++i) res = min(res, f0[i] + f1[i]);\n return res;\n}\n```\n\nThis reminds me of [122. Best Time to Buy and Sell Stock III](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/description/). That problem has a DP solution with O(1) memory complexity, so we can try to apply it here. We can go left to right, and virtually \'move\' the split point every time we see that we need less \'0\' -> \'1\' than \'1\' -> \'0\' flips (``` f1 = min(f0, f1 + 1 - (c - \'0\'))```).\n```\nint minFlipsMonoIncr(string S, int f0 = 0, int f1 = 0) {\n for (auto c : S) {\n f0 += c - \'0\';\n f1 = min(f0, f1 + 1 - (c - \'0\'));\n }\n return f1;\n}\n```\nHere is Java version. Note that I am using ```charAt(i)``` instead of ```toCharArray()``` to keep the memory complexity a constant.\n```\npublic int minFlipsMonoIncr(String S) {\n int f0 = 0, f1 = 0;\n for (int i = 0; i < S.length(); ++i) {\n f0 += S.charAt(i) - \'0\';\n f1 = Math.min(f0, f1 + 1 - (S.charAt(i) - \'0\'));\n }\n return f1;\n}\n``` | 211 | 7 | [] | 21 |
flip-string-to-monotone-increasing | Two concepts, four implementation with explanation for beginners. | two-concepts-four-implementation-with-ex-na9k | The idea:\nLike many question, the description of this question is overly complicated and we can simplify it greatly. One of the best things you can do before s | haoran_xu | NORMAL | 2021-06-13T15:36:35.190962+00:00 | 2021-07-24T13:07:03.557932+00:00 | 6,795 | false | The idea:\nLike many question, the description of this question is overly complicated and we can simplify it greatly. One of the best things you can do before starting to write code is figure out exactly what you want. This might seem obvious but if you miss this step, it can cause a lot of pain down the road. First, I\'m going to refer the string as an array, this does not really change anything but I find it easier to explain it this way. Essentially, we want to find the minimum number of flips to create an array where we can draw a seperation point such that all elements to the right are 1s and all elements to the left are 0s. For example, take a look at the following array:\n```\n0,0,0,0, | 1,1\n```\nThis is a monotone increasing array. We can find the `|` for all monotone inscreasing array. Ok, let us further simplify the problem. Suppose we already know where the `|` is, take a look at the following example:\n```\n0,1,0, | 0,0,1\n```\nWhat is the minimum amount of flips we have to do to make all the left side `0` and all the right side `1`? The answer is `3`, we just count the number of `1`s in the left side and the number of `0`s in the right side. How does this help us? Well, given the input array, let us iterate through all possible positions for the `|` seperator. For each position, we will count the minimum number of flips needed and keep track of the global minimum. To make it more efficient, we will keep track of two arrays, where one counts the number of `1`s from `[0..i]` and the other one counts the number of `0`s from `[i..n]`. This way, we can immediately calculate the amount of invalid bits. \n\nImplementation 1:\n```\nclass Solution {\npublic:\n int minFlipsMonoIncr(string s) {\n int n = s.size();\n vector<int> ones(n);\n vector<int> zeros(n);\n \n for(int i = 0; i < n; i++) {\n if(s[i] == \'1\') {\n ones[i] = (i == 0 ? 0 : ones[i - 1]) + 1;\n } else {\n ones[i] = (i == 0 ? 0 : ones[i - 1]);\n }\n }\n \n for(int i = n - 1; i >= 0; i--) {\n if(s[i] == \'0\') {\n zeros[i] = (i == n - 1 ? 0 : zeros[i + 1]) + 1;\n } else {\n zeros[i] = (i == n - 1 ? 0 : zeros[i + 1]);\n }\n }\n \n int min_flips = INT_MAX;\n for(int i = 0; i <= n; i++) {\n int curr_flips = (i == 0 ? 0 : ones[i - 1]);\n curr_flips += (i == n ? 0 : zeros[i]);\n \n min_flips = min(min_flips, curr_flips);\n }\n \n return min_flips;\n }\n};\n```\nThe time complexity is `O(n)` albeit with a high constant. Similarly, the space complexity is `O(n)` with a hidden high constant.\n\nImplementation 2:\nOk, the previous code works and pass the test cases, but can we improve upon it? Certainly, some observation will tell us that we don\'t actually need to use the second array at all! By using only the first array, we can get the number of `0`s on the right side by first finding the number of `1`s on the right side (subtract the number of `1`s on the left side from the total number of `1`s), then subtract the number of `1`s on the right side from the total number of elements on the right side. This is basic math and you should get it by just staring at the string for a little while. Anyway, here is the improved version:\n```\nclass Solution {\npublic:\n int minFlipsMonoIncr(string s) {\n int n = s.size();\n vector<int> ones(n);\n \n for(int i = 0; i < n; i++) {\n if(s[i] == \'1\') {\n ones[i] = (i == 0 ? 0 : ones[i - 1]) + 1;\n } else {\n ones[i] = (i == 0 ? 0 : ones[i - 1]);\n }\n }\n \n \n \n int min_flips = INT_MAX;\n for(int i = 0; i <= n; i++) {\n int curr_flips = (i == 0 ? 0 : ones[i - 1]);\n curr_flips += (n - i) - (ones[n - 1] - (i == 0 ? 0 : ones[i - 1]));\n \n min_flips = min(min_flips, curr_flips);\n }\n \n return min_flips;\n }\n};\n```\nTime and space complexity is the same, but we improve the hidden constant.\n\nImplementation 3:\nBut can we go above and beyond? Yes, but we need to think of the problem from a different perspective. Let us iterate through the array from left to right. Suppose we know that `s[0...i - 1]` is a monotone increasing array, if `s[i]` is `1` then we maintain the monotone increasing property and don\'t have to do anything. However, what if `s[i]` is `0`? Well, we have two choice, we can either do flip that element or flips every `1` in `s[0...i]`. Both of these action maintain the monotone increasing property. Therefore, we get the following recurrence relationship, let `T(i)` be the minimum number of flips needed to make `s[0...i]` a monotone increasing array:\n```\nif(s[i] == \'0\') T(i) = mininmum of (numberof1(i - 1) or T(i - 1) + 1)\nelse T(i) = T(i - 1)\n```\nWith this recurrence relationship we can construct a recursion solution, but I\'m going to skip this step and go straight to dynamic programming.\n```\nclass Solution {\npublic:\n int minFlipsMonoIncr(string s) {\n int n = s.size();\n int one_counts = 0;\n vector<int> dp(n + 1);\n dp[0] = 0;\n \n for(int i = 1; i <= n; i++) {\n if(s[i - 1] == \'1\') {\n dp[i] = dp[i - 1];\n one_counts++;\n } else {\n dp[i] = min(dp[i - 1] + 1, one_counts);\n }\n }\n \n return dp[n];\n }\n};\n```\nSame time and space complexity but we even reduced the hidden constant more, now it\'s only 1 pass. But we can go even crazier. Notice that we don\'t use any other part of the `dp` array other than the immediate one before our current iteration. Therefore we can apply 1 last optmization\n```\nclass Solution {\npublic:\n int minFlipsMonoIncr(string s) {\n int n = s.size();\n int one_counts = 0;\n int dp = 0;\n \n for(int i = 1; i <= n; i++) {\n if(s[i - 1] == \'1\') {\n one_counts++;\n } else {\n dp = min(dp + 1, one_counts);\n }\n }\n \n return dp;\n }\n};\n```\nFinally, we now have a `O(1)` space complexity solution...talk about squeezing water out of rock. | 208 | 1 | [] | 25 |
flip-string-to-monotone-increasing | C++ Simple and Short O(n) Solution, With Explanation | c-simple-and-short-on-solution-with-expl-xsxw | idea:\nThis is simple dynamic programming.\nWe loop through the string.\nIf we got a 1, go on. No need to flip. We just increment the 1 counter.\nIf we got a 0, | yehudisk | NORMAL | 2021-08-10T08:08:43.240588+00:00 | 2021-08-10T08:08:43.240613+00:00 | 5,375 | false | **idea:**\nThis is simple dynamic programming.\nWe loop through the string.\nIf we got a 1, go on. No need to flip. We just increment the 1 counter.\nIf we got a 0, we increment the flips counter.\nNow, we have two options. Either to flip the new zero to one or to flip all previous ones to zeros.\nSo we take the min between flips and counter.\n```\nclass Solution {\npublic:\n int minFlipsMonoIncr(string s) {\n int flips = 0, counter = 0;\n for (auto c : s) {\n if (c == \'1\') counter++;\n else flips++;\n \n flips = min(flips, counter);\n }\n return flips;\n }\n};\n```\n**Like it? please upvote!** | 128 | 6 | ['C'] | 9 |
flip-string-to-monotone-increasing | python O(n) time O(1) space solution with explanation(with extra Chinese explanation) | python-on-time-o1-space-solution-with-ex-ijpe | you can get Chinese explanation in \nhttps://buptwc.github.io/2018/10/21/Leetcode-926-Flip-String-to-Monotone-Increasing/\n\nwe assume the string after flip is | bupt_wc | NORMAL | 2018-10-21T14:39:19.127681+00:00 | 2018-10-24T18:40:56.570397+00:00 | 8,612 | false | you can get Chinese explanation in \nhttps://buptwc.github.io/2018/10/21/Leetcode-926-Flip-String-to-Monotone-Increasing/\n\nwe assume the string after flip is `s = \'0\'*i + \'1\'*j`, the index of first \'1\' is `i`\n\nwe just need to find the `i` in the initial string. We make all `1` before index `i` flip to `0`, and make all `0` after index `i` flip to `1`. Then, we get the right answer.\n\nfor instance, `s = 010110`.\nif we choose the first `1`(index=1) as `i`, we need to make all `1` before i flip to `0`(all 0), make all `0` after `i` flip to `1`(all 2),so the answer is 2.\nif we choose the second `1`(index=3) as `i`, the answer is `1 + 1 = 2`\nif we choose the third `1`(index=4) as `i`, the answer is `2 + 1 = 3`\nand so on.\n\nI use `cnt0` to record the number of `0` after `i`, `cnt1` to record th number of `1` before `i`\n\n```python\n# 68ms\nclass Solution(object):\n def minFlipsMonoIncr(self, s):\n n = len(s)\n cnt0 = s.count(\'0\')\n cnt1 = 0\n res = n - cnt0\n for i in range(n):\n if s[i] == \'0\': \n cnt0 -= 1\n elif s[i] == \'1\':\n res = min(res, cnt1+cnt0)\n cnt1 += 1\n return res\n``` | 125 | 2 | [] | 20 |
flip-string-to-monotone-increasing | Python 3 || 7 lines, w/ explanation and example || T/S: 96% / 98% | python-3-7-lines-w-explanation-and-examp-x3o2 | Here\'s the plan:\n- We iterate throughs, but for all0before the initial 1, we count nothing. It only becomes interesting once we hit a1. We could rephrase the | Spaulding_ | NORMAL | 2023-01-17T00:57:20.096096+00:00 | 2024-05-31T17:43:05.718139+00:00 | 6,697 | false | Here\'s the plan:\n- We iterate through`s`, but for all`0`before the initial `1`, we count nothing. It only becomes interesting once we hit a`1`. We could rephrase the problem to: "Discard all the initial`0`, then determine which requires fewer flips: changing the remaining string to all`1`, or flip the`1` and start over with the remaining string. \n\n- For each `1` we hit, we increment`ones`.\n- For each`0`we hit after the initial`1`, we decrement`ones` and increment `ans`, but only if `ones`is positive. Here\'s the reason why\u2013in order to achieve a monotonic string, we need to flip either this`0`or the most recent`1`. We won\'t know which flip would actually happen until the end, but either way it would cause a flip.\n- Once we iterate through the string, we return`ans`.\n```\nclass Solution:\n def minFlipsMonoIncr(self, s: str) -> int:\n\n ones, ans = 0, 0 # Example: s = "010110"\n #\n for digit in s: # num ones ans \n # \u2013\u2013\u2013\u2013 \u2013\u2013\u2013\u2013 \u2013\u2013\u2013\u2013 \n if digit ==\'1\': ones += 1 # 0 0 0\n # 1 1 0\n elif ones: # 0 0 1\n ones -= 1 # 1 1 1\n ans += 1 # 1 2 1\n # 0 1 2\n return ans\n```\n[https://leetcode.com/problems/flip-string-to-monotone-increasing/submissions/1273508367/](https://leetcode.com/problems/flip-string-to-monotone-increasing/submissions/1273508367/)\n\nI could be wrong, but I think that time complexity is *O*(*N*) and space complexity is *O*(1), in which *N* ~ `len(s)`. | 99 | 0 | ['Python3'] | 15 |
flip-string-to-monotone-increasing | Simple Explanation With Images || O(n) time, O(1) Space | simple-explanation-with-images-on-time-o-uxb3 | Intuition\nHow about we think about the cost and gain? As we go from left to right, the zeroes we get are our costs and the ones we get are our gains.\n Describ | hridoy100 | NORMAL | 2023-01-17T05:05:18.070117+00:00 | 2023-01-17T05:10:52.072277+00:00 | 4,347 | false | # Intuition\nHow about we think about the cost and gain? As we go from left to right, the zeroes we get are our costs and the ones we get are our gains.\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n\n\n\nWe will first store the count of zeroes. Then from left to right we will decrease the count of `zeroes` if we find any \'0\'. We will also increase the count of `ones` if we find any \'1\'.\n\n\n\nAfter each iteration we will calculate the minimum of `zeroes + ones`. The minimum count of zeroes and ones count is the answer.\n\n# Algorithm\n\n- Initialize variables `zeroes` and `ones` to 0.\n- First, we need to keep the count of the zeroes. We will determine it by iterating the loop.\n- Initialize variable `output` equals to `zeores`.\n- Now, iterate the loop again. While Iterating:\n - Decrease the count of `zeroes` if \'0\' is found.\n - Increase the count of `ones` if \'1\' is found.\n - after each calculations, we determine the output. The output will be the minimum value. So, we do `output = Math.min(output, zeroes+ones)`.\n- Return the `output`.\n\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity: $$O(n)$$\nActually, it is $$O(n + n)$$, because we iterate the loop twice. So, we can write, $$O(2n) = O(n)$$.\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: $$O(1)$$\nWe haven\'t used any n length array or, string or any other datastructure. So, space is fixed and constant.\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code [Java]\nFor other Languages just follow the syntax of that language.\n```\nclass Solution {\n public int minFlipsMonoIncr(String s) {\n int zeroes = 0;\n int ones = 0;\n for(char ch : s.toCharArray()){\n if(ch == \'0\'){\n zeroes++;\n }\n }\n int output = zeroes;\n for(char ch : s.toCharArray()){\n if(ch == \'0\'){\n zeroes--;\n }\n else if(ch == \'1\'){\n ones++;\n }\n output = Math.min(output, zeroes+ones);\n }\n return output;\n }\n}\n```\n\n\n | 87 | 1 | ['Java'] | 8 |
flip-string-to-monotone-increasing | ✅ Flip String to Monotone Increasing | Simple One Pass w/Explanation | flip-string-to-monotone-increasing-simpl-z3j8 | Solution :\n\n\n#observation:\nEvery character in the string has 2 choices,\n1) it can retain its value.\n2) it can be flipped.\n\n- We can have all 0s in the s | shivaye | NORMAL | 2021-08-10T10:13:47.632136+00:00 | 2021-08-10T10:13:47.632172+00:00 | 2,676 | false | **Solution :**\n***\n```\n#observation:\nEvery character in the string has 2 choices,\n1) it can retain its value.\n2) it can be flipped.\n\n- We can have all 0s in the string,\n- We can have all 1s in the string,\n- We can have mixture of 0s and 1s but with the condition that no 0 should occur after 1\n -But the 1s can occur after 0s right!!\n\nLet us now try to build the logic,\nIf in the string 1s are occuring after 0s , then there is no problem.\nBut if 0s are coming after 1s then we have to think about options:\n\t1) Either we can flips 1s to 0s\n\t2) Flip 0s to 1s\n\n#Note: \nWe actually want 1s at the tail of string,\nso when we encounter 1 dont do anything but store its count,\nbut when we encounter 0 then we have a option to flip it.\n\nLet us try to analyse this,\nAt every iteration , we will calculate how many 0s are there to be flipped, and how many 1s we encountered,\nlet us say,\nwhenever we encounter \'0\' we will increment flip,\nand whenever we encounter \'1\' we will increment cnt,\n\nIf there are no 1s then we are good,\nIf there are no 0s then also we are good,\nBut if there is combination of 0s and 1s then we need to consider,\nthat among 1s and 0s which one to flipped,\nAs we want to find out the minimum cost,\nWe will consider the minimum among them,\nflip = min(flip,cnt)\n```\n**C++:**\n***\n```\nclass Solution {\npublic:\n int minFlipsMonoIncr(string s) {\n int cnt=0;\n int flip=0;\n for(auto i:s)\n {\n if(i==\'0\')\n flip++;\n else\n cnt++;\n flip=min(flip,cnt);\n }\n return flip;\n \n }\n};\n``` | 66 | 3 | [] | 4 |
flip-string-to-monotone-increasing | ✅✅C++ ||Most Easy Solution || 💯💯DP Approach || Heavily Commented | c-most-easy-solution-dp-approach-heavily-otki | \u2705\u2705C++ || Easy Solution || \uD83D\uDCAF\uD83D\uDCAFDP Approach || Heavily Commented\n# Please Upvote as it really motivates me\n\nclass Solution {\npub | Conquistador17 | NORMAL | 2023-01-17T04:01:19.234366+00:00 | 2023-01-17T04:01:19.234414+00:00 | 4,986 | false | # **\u2705\u2705C++ || Easy Solution || \uD83D\uDCAF\uD83D\uDCAFDP Approach || Heavily Commented**\n# **Please Upvote as it really motivates me**\n```\nclass Solution {\npublic:\n int func(int idx,string&s,char ch,vector<vector<int>>&dp){\n int n=s.size();\n\t\t//If our index idx is more than n then we will return 0 as no operation can be done\n if(idx>=n){\n return 0;\n }\n\t\t//If we have already visited the index and char we would simply return its value\n if(dp[idx][ch-\'0\']!=-1){\n return dp[idx][ch-\'0\'];\n }\n\t\t//If we have our prev char as \'0\' then we have 2 choices to toggle it or to move to next idx\n int res1=1e9,res2=1e9;\n if(ch==\'0\'){\n if(s[idx]==\'0\'){\n res1=func(idx+1,s,s[idx],dp);\n res2=func(idx+1,s,\'1\',dp)+1;\n }\n else{\n res1=func(idx+1,s,s[idx],dp);\n res2=func(idx+1,s,\'0\',dp)+1;\n }\n }\n\t\t\n\t\t//If we have our prev char as \'1\' then we will simply \n\t\t//toggling every \'0\' char and adding one operation to it\n else{\n if(s[idx]==\'0\'){\n res1=func(idx+1,s,\'1\',dp)+1;\n }\n else{\n res1=func(idx+1,s,s[idx],dp);\n }\n }\n return dp[idx][ch-\'0\']=min(res1,res2);\n }\n \n int minFlipsMonoIncr(string s) {\n\t//First we will create a 2d vector of size of string.size()*2\n vector<vector<int>>dp(s.size(),vector<int>(2,-1));\n\t\t//Now we will call our recursive function \n int ans=func(0,s,\'0\',dp);\n return ans;\n \n }\n};\n```\n\n\n\n | 47 | 0 | ['Dynamic Programming', 'Memoization', 'C', 'C++'] | 7 |
flip-string-to-monotone-increasing | Java DP solution O(n) time O(1) space | java-dp-solution-on-time-o1-space-by-sel-1gyj | ``` / tranverse the string * use two variables to record the minimim number of flip need to make the substring from (0 - i) to be MonoIncr with end with 1 or 0 | self_learner | NORMAL | 2018-10-21T03:04:18.763665+00:00 | 2018-10-26T14:21:20.097984+00:00 | 4,580 | false | ```
/* tranverse the string
* use two variables to record the minimim number of flip need to make the substring from (0 - i) to be MonoIncr with end with 1 or 0;
* (1) for position i + 1, if preceding string is end with 1, the current string can only end with one,
* so cntEndWithOne can only be used to update the next cntEndWithOne
* (2) if the preceding string is end with zero, current string can either end with zero or one
* so cntEndWithZero can be used to update for both next cntEndWithOne and cntEndWithZero;
*/
class Solution {
public int minFlipsMonoIncr(String S) {
if (S == null || S.length() <= 1) return 0;
int n = S.length();
int cntEndWithOne = 0, cntEndWithZero = 0;
for (int i = 0; i < n; i++) {
char c = S.charAt(i);
cntEndWithOne = Math.min(cntEndWithZero, cntEndWithOne) + (c == '1' ? 0 : 1);
cntEndWithZero += (c == '0' ? 0 : 1);
}
return Math.min(cntEndWithOne, cntEndWithZero);
}
} | 47 | 2 | [] | 9 |
flip-string-to-monotone-increasing | Easy Python | Explained | O(n) time, O(1) space | easy-python-explained-on-time-o1-space-b-grvb | Easy Python | Explained | O(n) time, O(1) space\n\nThe Python code below presents a simple solution for this problem, where we track the cost of generating diff | aragorn_ | NORMAL | 2020-07-21T23:33:09.785947+00:00 | 2020-07-21T23:37:53.073099+00:00 | 3,142 | false | **Easy Python | Explained | O(n) time, O(1) space**\n\nThe Python code below presents a simple solution for this problem, where we track the cost of generating different sorted arrays with the form "[0] * a + [1] * b". Initially, we compute the cost of having an array of "ones" exclusively. Then, we start allowing the presence of "zeros" up to x=S[i]. Any zero up to that point doesn\'t generate a cost anymore, so we subtract it from our balance. However, each "one" encountered up to x=S[i] must be changed, so it\'s a new cost.\n\nThe code sweeps through the string S in O(n) time with O(1) space complexity. The variable "best" tracks our lowest cost found for any configuration.\n\nI hope the explanations are helpful.\n\nCheers,\n\n```\nclass Solution:\n def minFlipsMonoIncr(self, S):\n # Explanation: Our array "S" must be generally sorted as [0]*a + [1]*b\n # - Examples: 000, 001, 011, 111\n # - We can sweep through each configuration computing their cost\n # To get started, we assume that we have an array of 1\'s (111), and every zero must be changed\n # Compute this cost:\n cost = 0\n for x in S:\n if x==\'0\':\n cost += 1\n # This is our baseline guess for the best answer\n best = cost\n # Now we will start allowing zeros up to x=S[i] (last allowed zero)\n # Check how many zeros can stay for free, and..\n # How many 1\'s must be force to change as we advance\n #\n for x in S: # last 0 allowed\n if x==\'0\':\n cost -= 1 # this "zero" no longer is a problem (subtract from original cost)\n else:\n cost += 1 # this "one" must be forced to change (higher cost)\n best = min(best,cost)\n return best\n``` | 44 | 0 | ['Python', 'Python3'] | 7 |
flip-string-to-monotone-increasing | Java Solution with Explanation | java-solution-with-explanation-by-sartha-gmt0 | \n\n# Approach and Explanation\n Describe your approach to solving the problem. \n\n1. This is a solution in Java for the problem of finding the minimum number | Sarthak_Singh_ | NORMAL | 2023-01-17T03:15:09.299673+00:00 | 2023-01-17T03:18:22.141473+00:00 | 5,666 | false | \n\n# Approach and Explanation\n<!-- Describe your approach to solving the problem. -->\n\n1. This is a solution in Java for the problem of finding the minimum number of flips required to make a binary string monotonically increasing. A monotonically increasing string is one in which the characters are in increasing order, so for example \'001\' is monotonically increasing but \'110\' is not.\n\n2. The approach used in this solution is to iterate through the string, keeping track of two variables: `ans` and `noOfFlip`. ans is initially set to 0 and will be used to store the final answer, while noOfFlip is used to keep track of the number of \'1\' characters that have been encountered so far.\n\n3. For each character in the string, the following logic is applied:\n\n4. If the current character is \'0\', then the minimum of `noOfFlip` and `ans+1` is taken and assigned to `ans`. This is because flipping a \'0\' to a \'1\' does not affect the monotonicity of the string, so the number of flips required to make the string monotonically increasing will be the same as the number of \'1\' characters that have been encountered so far.\n5. If the current character is \'1\', then the value of `noOfFlip` is incremented by 1. This is because a \'1\' character has been encountered, and this will have to be flipped in order to make the string monotonically increasing.\n6. After the iteration, the final value of ans is returned as the solution.\n\nIn a summary, the solution iterates through the string and keeps track of the number of \'1\' characters encountered so far and the number of flips required to make the string monotonically increasing. At each step, it compares the number of flips required to the number of \'1\' characters encountered so far and chooses the minimum of the two as the number of flips required for the current substring.\n\n# Code\n```\nclass Solution {\n public int minFlipsMonoIncr(String s) {\n // Initialize variables to store the minimum number of flips and the number of flips currently needed\n int ans = 0, noOfFlip = 0;\n \n // Iterate through each character in the input string\n for(int i =0; i < s.length(); i++){\n // If the current character is a \'0\', update the minimum number of flips and add 1 to the current number of flips\n if(s.charAt(i) == \'0\') ans = Math.min(noOfFlip,ans+1);\n // If the current character is a \'1\', increment the number of flips\n else noOfFlip++;\n }\n // Return the minimum number of flips\n return ans;\n }\n}\n\n``` | 41 | 1 | ['Java'] | 4 |
flip-string-to-monotone-increasing | [Python] two O(n) solutions: dp and accumulate, explained | python-two-on-solutions-dp-and-accumulat-3idy | Solution 1 - dp\nThe first idea I thought about when I saw this problem is to use dynamic programming. Let us define by dp(i, k) the state where we are on index | dbabichev | NORMAL | 2021-08-10T08:30:08.904300+00:00 | 2021-08-10T18:14:54.995924+00:00 | 2,654 | false | #### Solution 1 - dp\nThe first idea I thought about when I saw this problem is to use dynamic programming. Let us define by `dp(i, k)` the state where we are on index `i` at the moment and we make last element equal to `k`. From what states we can get to this state? It is for sure `dp(i-1, j)` and the question is what `j` we can use? We want our string be increasing, so we must have `k>=j`, that is `j in range(k+1)`. What price we need to pay? If `k == s[i]`, that is we do not change our sequence, we pay nothing, in opposite case we pay `1`.\n\n#### Complexity\nWe have `O(n)` states and at most `2` transactions from one state to another, so overall time and space complexity is `O(n)`. Note, that it works quite slow, because we use `lru_cache` and not table, but it is fast enough to get AC.\n\n#### Code\n```python\nclass Solution:\n def minFlipsMonoIncr(self, s):\n s = [int(i) for i in s] + [1]\n \n @lru_cache(None)\n def dp(i, k):\n if i == -1: return 0\n return min([dp(i-1, j) + int(k != s[i]) for j in range(k + 1)])\n \n return dp(len(s) - 1, 1)\n```\n\n#### Solution 2, accumulate\nWe can notice, that our monotonic sequence should look like this: `00...0011...11`, that is we have some zeroes and then some ones. So, if we find efficient way to check how many flips we need to do to get zeroes on ones on range, we are done. For this we can use cumulative sums: indeed, number of flips can be evaluated in `O(1)` then! Imagine, that we want ot make first `i` elements zeroes and the rest ones, then we have two parts:\n1. `acc[i]` for the first part to make them all zeroes.\n2. `n - i - (acc[-1] - acc[i])` for the second part to make all elements ones.\n\nWhat we need to do now is to traverse all possible `i` - note there will be `n+1` cases, not `n`, and return minimum.\n\n#### Complexity\nIt is `O(n)` for time and space as well but in practice it works like 10 times faster than previous appaorach.\n\n#### Code\n```python\nclass Solution:\n def minFlipsMonoIncr(self, s):\n acc, n = [0] + list(accumulate(map(int, s))), len(s)\n return min(2*acc[i] + n - i - acc[-1] for i in range(n+1))\n```\n\n\nIf you have any questions, feel free to ask. If you like solution and explanations, please **Upvote!** | 39 | 2 | ['Dynamic Programming'] | 4 |
flip-string-to-monotone-increasing | ⛱ Easy Javascript Solution with Detailed Explanation - o(n) time, o(1) space 😎 | easy-javascript-solution-with-detailed-e-6rh9 | Explanation\nWe want our string to be monotonic. \nStrings "0000", "00111" and "1111" are monotonic.\nWhat if string is already monotonic and we add one more ch | avakatushka | NORMAL | 2021-08-11T07:26:33.215367+00:00 | 2021-08-11T07:35:14.186967+00:00 | 1,718 | false | ## Explanation\nWe want our string to be monotonic. \nStrings "0000", "00111" and "1111" are monotonic.\nWhat if string is already monotonic and we add one more character?\n* If this character is \'1\', string will always remain monotonic. No problem here \n\uD83E\uDD17 "0000" + "1", "0000111" + "1" or "1111" + "1".\n* What if this character is \'0\'? \n\t* We can flip it to \'1\' to make sure string remains monotonic.\n\t* We can flip all the \'1\'s we had seen before to \'0\'s making the string to "0000...000".\n## Code\nWe will build solution bit by bit, using result from **first i - 1 characters** to get to result for **ith character**. As discussed before, we are just adding **one character to the end** each time. \n```\nlet onesAlreadySeen = 0;\nlet res = 0;\nfor (let i = 0; i < s.length; i++) {\n\tif (s[i] == \'0\') {\n\t\tres = Math.min(res + 1 /* flip this \'0\' to \'1\' */,\n\t\t\t\t\t onesAlreadySeen /* flip all \'1\' we\'ve seen before to \'0\'*/);\n\t} else {\n\t\t// s[i] is \'1\'\n\t\tonesAlreadySeen++;\n\t}\n}\nreturn res;\n```\n## Complexity\nThis solution takes o(1) space - only two variables are being used and o(n) time for 1 for loop. \n | 37 | 0 | ['Dynamic Programming', 'JavaScript'] | 6 |
flip-string-to-monotone-increasing | [Python] DP is EASY - From O(N) to O(1) space - Clean & Concise | python-dp-is-easy-from-on-to-o1-space-cl-li02 | \u2714\uFE0F Solution 1: Top down DP\n- Supper easy, with each s[i], we have two choices:\n\t- Don\'t flip s[i].\n\t- Flip s[i]\n- Choose the choice which has t | hiepit | NORMAL | 2021-08-10T07:09:38.910467+00:00 | 2021-08-11T04:48:31.689323+00:00 | 2,466 | false | **\u2714\uFE0F Solution 1: Top down DP**\n- Supper easy, with each `s[i]`, we have two choices:\n\t- Don\'t flip `s[i]`.\n\t- Flip `s[i]`\n- Choose the choice which has the minimum number of flips.\n- Let `dp(i, last)` is the minimum number of flips to make `s[i..n-1]` monotone increasing, where `s[i]` must be >= `last`.\n\n```python\nclass Solution:\n def minFlipsMonoIncr(self, s: str) -> int:\n @cache\n def dp(i, last):\n if i == len(s): return 0 # Reach to the end\n d = ord(s[i]) - ord(\'0\')\n cand = []\n if d >= last: cand.append(dp(i + 1, d)) # Don\'t flip\n if 1 - d >= last: cand.append(dp(i + 1, 1 - d) + 1) # Flip\n return min(cand) # Choose the minimum number of flips\n\n return dp(0, 0)\n```\n**Complexity**\n - Time: `O(N * 4)`, where `N <= 10^5` is length of string `s`.\n\tExplain: There is total `N * 2` dp states, which are `dp[0][0], dp[0],[1]..., d[N][1]`, each dp state needs up to 2 operations to calculate the result. So total is `O(N * 4)` in time complexity.\n - Space: `O(N * 2)`\n\n---\n\n**Solution 2: Bottom up DP**\n- Just convert from **Top down DP** to **Bottom up DP**.\n- Let `dp[i][j]` is the minimum number of flips to make `s[i..n-1]` monotone increasing, where `s[i]` must be >= `j`.\n```python\nclass Solution:\n def minFlipsMonoIncr(self, s: str) -> int:\n n = len(s)\n INF = n # There are maxmimum N flips we can use to make the string monotone increasing!\n \n dp = [[INF] * 2 for _ in range(n + 1)]\n dp[n][0] = dp[n][1] = 0 # Base case\n for i in range(n - 1, -1, -1):\n for j in range(2):\n d = ord(s[i]) - ord(\'0\')\n if d >= j:\n dp[i][j] = min(dp[i][j], dp[i + 1][d]) # Don\'t flip\n if 1 - d >= j:\n dp[i][j] = min(dp[i][j], dp[i + 1][1 - d] + 1) # Flip\n return dp[0][0]\n```\n**Complexity**\n - Time: `O(N * 4)`, where `N <= 10^5` is length of string `s`.\n - Space: `O(N * 2)`\n\n---\n\n**Solution 3: Bottom up DP (Space Optimized)**\n- Since our dp only maintains 2 states, they are current state `dp` and previous state `dpPrev`. So we can optimize space to `O(1)`.\n```python\nclass Solution:\n def minFlipsMonoIncr(self, s: str) -> int:\n n = len(s)\n INF = n # There are maxmimum N flips we can use to make the string monotone increasing!\n \n dp, dpPrev = [INF] * 2, [INF] * 2\n dpPrev[0] = dpPrev[1] = 0 # Base case\n for i in range(n - 1, -1, -1):\n dp[0] = dp[1] = INF # Reset\n for j in range(2):\n d = ord(s[i]) - ord(\'0\')\n if d >= j:\n dp[j] = min(dp[j], dpPrev[d]) # Don\'t flip\n if 1 - d >= j:\n dp[j] = min(dp[j], dpPrev[1 - d] + 1) # Flip\n dp, dpPrev = dpPrev, dp\n return dpPrev[0]\n```\n**Complexity**\n - Time: `O(N * 4)`, where `N <= 10^5` is length of string `s`.\n - Space: `O(1)`\n\n\nIf you think this **post is useful**, I\'m happy if you **give a vote**. Any **questions or discussions are welcome!** Thank a lot. | 37 | 4 | [] | 7 |
flip-string-to-monotone-increasing | Python/JS/Java/Go/C++ O(n) by pattern analysis [w/ Hint] | pythonjsjavagoc-on-by-pattern-analysis-w-eavk | Observe and analyze two possible cases on binary string pattern\n\nLet S start on empty string "", and add either \'0\' or \'1\' on the tail to make it longer.\ | brianchiang_tw | NORMAL | 2021-08-10T09:06:47.681480+00:00 | 2022-10-22T10:48:19.291772+00:00 | 2,491 | false | Observe and analyze two possible cases on binary string pattern\n\nLet S start on empty string "", and add either \'0\' or \'1\' on the tail to make it longer.\n\n---\nCase #1\nS + \'**1**\' : No need to flip, because \'**1**\' **keeps monotone increasing** always.\n\n---\n\n---\nCase #2\nS + \'**0**\' : Need **flip operation** to **maintain** monotone increasing.\n\n**Option 1** for case #2: \n**Flip current 0 to 1**, **keep leading digits**, then substring is monotone increasing.\nS + \'0\' becomes S + \'1\'\n\n---\n\n**Option 2** for case #2:\n**Flip leading 1s to 0s**, **keep current 0**, then substring is monotone increasing.\nS + \'0\' becomes S\' + \'0\' where S\' is modified from S and all leading 1s is flipped to 0s\n\n---\n\n**Implementation** in Python\n\n```\nclass Solution:\n def minFlipsMonoIncr(self, s: str) -> int:\n \n # occurrence of 1 in strings s\n occ_of_1 = 0\n \n # counter of flips of 1->0 and 0->1\n flip = 0\n \n \n # scan each digit on substring s[:i], i = 1 ~ len(s)\n for char in s:\n \n if char == \'1\':\n \n\t\t\t\t# update occurrence of \'1\'\n occ_of_1 += 1\n \n\t\t\t\t# current digit is \'1\'\n # no need to flip when 1 is on the tail of current substring\n \n else:\n \n\t\t\t\t# current digit is \'0\'\n # need to flip when 0 is on the tail of current substring\n \n # option_1: flip current 0 to 1, keep leading digits, then substring is monotone increasing\n \n # option_2: flip leading 1s to 0s, keep current 0, then substring is monotone increasing\n \n # select optimal solution\n flip = min(flip+1, occ_of_1)\n \n return flip\n```\n\n---\n\n**Implementation** in Java:\n\n```\nclass Solution {\n public int minFlipsMonoIncr(String s) {\n \n\t\t// occurrence of 1 in strings s\n int occOf1 = 0;\n\t\t\n\t\t// counter of flips of 1->0 and 0->1\n int flips = 0;\n \n\t\t// scan each digit on substring\n for( char ch : s.toCharArray() ){\n \n if( ch == \'1\' ){\n\t\t\t\t\n\t\t\t\t// update occurrence of \'1\'\n occOf1 += 1;\n\t\t\t\t\n\t\t\t\t// current digit is \'1\'\n // no need to flip when 1 is on the tail of current substring\n \n }else{\n\t\t\t\n\t\t\t\t// current digit is \'0\'\n // need to flip when 0 is on the tail of current substring\n \n // option_1: flip current 0 to 1, keep leading digits, then substring is monotone increasing\n \n // option_2: flip leading 1s to 0s, keep current 0, then substring is monotone increasing\n \n // select optimal solution\n flips = Math.min(flips+1, occOf1);\n }\n \n }\n return flips;\n }\n}\n```\n\n---\n\n**Implementation** in Javascript:\n\n```\nvar minFlipsMonoIncr = function(s) {\n\n\t// occurrence of 1 in strings s\n\t// counter of flips of 1->0 and 0->1\n let [occOf1, flips] = [0, 0];\n \n\t// scan each character in input string\n for( const char of s){\n \n if( char == "1" ){\n\t\t\t\n\t\t\t// update occurrence of \'1\'\n occOf1 += 1;\n\n // current digit is \'1\'\n // no need to flip when 1 is on the tail of current substring\n\n }else{\n\n // current digit is \'0\'\n // need to flip when 0 is on the tail of current substring\n\n // option_1: flip current 0 to 1, keep leading digits, then substring is monotone increasing\n\n // option_2: flip leading 1s to 0s, keep current 0, then substring is monotone increasing\n\n // select optimal solution \n flips = Math.min(flips+1, occOf1);\n }\n \n }\n \n return flips;\n \n};\n```\n\n\n---\n\n**Implementation** in Golang\n\n```\nfunc Min(x, y int)int{\n if x <= y {\n return x\n } \n return y\n}\n\nfunc minFlipsMonoIncr(s string) int {\n \n // occurrence of 1 in string s\n occ_of_1 := 0\n \n // counter of flips of 1->0 and 0->1\n flip := 0\n \n // scan each digit on substring\n for _, char := range(s){\n \n if char == \'1\'{\n \n // update occurrence of 1\n occ_of_1 += 1\n \n // current digit is \'1\'\n // no need to flip when 1 is on the tail of current substring\n \n }else{\n\n // current digit is \'0\'\n // need to flip when 0 is on the tail of current substring\n\n // option_1: flip current 0 to 1, keep leading digits, then substring is monotone increasing\n\n // option_2: flip leading 1s to 0s, keep current 0, then substring is monotone increasing\n\n // select optimal solution \n flip = Min(flip+1, occ_of_1)\n \n }\n }\n return flip\n}\n```\n\n---\n\n**Implementation** in C++\n\n```\nclass Solution {\npublic:\n int minFlipsMonoIncr(string s) {\n \n\t\t// occurrence of 1 in strings s\n int occOf1 = 0;\n\t\t\n\t\t// counter of flips of 1->0 and 0->1\n int flips = 0;\n \n\t\t// scan each digit on substring\n for( const char& ch : s){\n \n if( ch == \'1\' ){\n\t\t\t\t\n\t\t\t\t// update occurrence of \'1\'\n occOf1 += 1;\n\t\t\t\t\n\t\t\t\t// current digit is \'1\'\n // no need to flip when 1 is on the tail of current substring\n \n }else{\n\t\t\t\n\t\t\t\t// current digit is \'0\'\n // need to flip when 0 is on the tail of current substring\n \n // option_1: flip current 0 to 1, keep leading digits, then substring is monotone increasing\n \n // option_2: flip leading 1s to 0s, keep current 0, then substring is monotone increasing\n \n // select optimal solution\n flips = min(flips+1, occOf1);\n }\n \n }\n return flips;\n }\n};\n``` | 33 | 0 | ['Math', 'Dynamic Programming', 'C', 'Python', 'C++', 'Java', 'Go', 'Python3', 'JavaScript'] | 4 |
flip-string-to-monotone-increasing | Count prefix ones and suffix zeros | count-prefix-ones-and-suffix-zeros-by-wa-1owz | leftOne[i] represents count of 1s in S[0...i]\nrightZero[i] represents count of 0s in S[i...n-1]\nThen min = min(leftOne[i] + rightZero[i + 1]), where i = 0, .. | wangzi6147 | NORMAL | 2018-10-21T03:07:10.851135+00:00 | 2018-10-23T02:49:02.594272+00:00 | 2,794 | false | `leftOne[i]` represents count of `1`s in `S[0...i]`\n`rightZero[i]` represents count of `0`s in `S[i...n-1]`\nThen `min = min(leftOne[i] + rightZero[i + 1])`, where `i = 0, ... n-1`\n```\nclass Solution {\n public int minFlipsMonoIncr(String S) {\n int n = S.length();\n int[] leftOne = new int[n];\n int[] rightZero = new int[n];\n if (S.charAt(0) == \'1\') {\n leftOne[0] = 1;\n }\n if (S.charAt(n - 1) == \'0\') {\n rightZero[n - 1] = 1;\n }\n for (int i = 1; i < n; i++) {\n leftOne[i] = S.charAt(i) == \'1\' ? leftOne[i - 1] + 1 : leftOne[i - 1];\n rightZero[n - 1 - i] = S.charAt(n - 1 - i) == \'0\' ? rightZero[n - i] + 1 : rightZero[n - i];\n }\n int min = n;\n for (int i = -1; i < n; i++) {\n int left = i == -1 ? 0 : leftOne[i];\n int right = i == n - 1 ? 0 : rightZero[i + 1];\n min = Math.min(min, left + right);\n }\n return min;\n }\n}\n``` | 31 | 0 | [] | 8 |
flip-string-to-monotone-increasing | 🔥 [LeetCode The Hard Way] 🔥 Explained Line By Line | leetcode-the-hard-way-explained-line-by-slkps | \uD83D\uDD34 Check out LeetCode The Hard Way for more solution explanations and tutorials. \n\uD83D\uDFE0 Check out our Discord for live discussion.\n\uD83D\uDF | __wkw__ | NORMAL | 2023-01-17T02:12:31.445157+00:00 | 2023-01-17T14:44:12.297524+00:00 | 2,055 | false | \uD83D\uDD34 Check out [LeetCode The Hard Way](https://wingkwong.github.io/leetcode-the-hard-way/) for more solution explanations and tutorials. \n\uD83D\uDFE0 Check out our [Discord](https://discord.gg/Nqm4jJcyBf) for live discussion.\n\uD83D\uDFE2 Give a star on [Github Repository](https://github.com/wingkwong/leetcode-the-hard-way) and upvote this post if you like it.\n\uD83D\uDD35 Check out [Screencast](https://www.youtube.com/watch?v=couER-yTn-M&list=PLBu4Bche1aEWMj1TdpymXbD8Tn8xKVYwj&index=17) if you are interested.\n\n---\n\nLet `dp[i]` be the min flips to make `[0, i)` monotone increasing. Starting from `i = 1`, if `s[i] = 1`, we check the previous character `s[i - 1]`. If it is `1` (e.g. `11...`), then it is monotone increasing already, so`dp[i] = dp[i - 1]`. However, if `s[i - 1] = 0` (e.g. `10...`), then we have two choices - we either flip this zero to make like `11...` or we flip all the ones before this zero (e.g. `00...`). Therefore, we can see the DP transition here.\n\n- if `s[i - 1]` is `1`, then `dp[i] = dp[i - 1]`\n- else `dp[i] = min(dp[i - 1] + 1, cnt1)`\n\nsince `dp[i]` is always based on `dp[i - 1]`, we can space-optimize it using two variables - `cnt0` and `cnt1` where `cnt0` is `dp[i]` at index `i` and `cnt1` is the number of 1s.\n\n```\nif (s[i] == 0) cnt0 = min(cnt0 + 1, cnt1);\nelse cnt1 += 1;\n```\n\nwhich is essentially same as \n\n```\nif (s[i] == 0) cnt0 += 1;\nelse cnt1 += 1;\ncnt0 = min(cnt0, cnt1);\n```\n\nAlternatively, we can count the max of `cnt0` and `cnt1` and return `s.size() - cnt1`.\n\n<iframe src="https://leetcode.com/playground/jQN2JfEE/shared" frameBorder="0" width="100%" height="500"></iframe> | 29 | 0 | ['Python', 'C++', 'Java', 'Rust'] | 3 |
flip-string-to-monotone-increasing | C++ Bruteforce O(n2) -> Optimal (Prefix - Suffix) Easy to understand | c-bruteforce-on2-optimal-prefix-suffix-e-o2ns | Intuition:\n\n\tAll characters in left side of the string should be 0\'s\n \tAll characters in right side of the string should be 1\'s\n\t\n\twe cut string at | madhu20 | NORMAL | 2021-08-11T09:47:59.116531+00:00 | 2021-08-11T09:56:40.085752+00:00 | 1,132 | false | **Intuition:**\n\n\tAll characters in left side of the string should be 0\'s\n \tAll characters in right side of the string should be 1\'s\n\t\n\twe cut string at each index\n\t\tbefore cut all characters should be 0\'s ( so left side we convert 1\'s to 0\'s if present)\n\t\tafter cut all characters should be 1\'s (so right side we convert 0\'s to 1\'s if present)\n\n\tEg: string str = "010001" => if we convert first 1 to 0 => 000001 which is monotonic string => ans = 1\n\n\t\t010001\t\t\t flipsInLeft flipsInRight\t\t Total flips\n\t\t| 010001 => 111111 => \t0\t\t 4\t\t = 4\t\t(convert all 0\'s to 1\'s)\n 0 | 10001 => 0 11111 => \t0\t\t 3\t\t = 3\n 01 | 0001 => 00 1111 => \t1\t \t 3\t\t = 4\n 010 | 001 => 000 111 => \t1\t\t 2\t\t = 3\n 0100 | 01 => 0000 11 => \t1\t\t 1\t\t = 2\t\t\n 01000 | 1 => 00000 1 => \t1\t\t 0\t = 1\n 010001 | => 000000 => \t2\t\t 0\t\t = 2\t\t(convert all 1\'s to 0\'s)\n \n\t\t\t\t\tminimum TotalFlips among all the above = 1\n**Code**\n```\nint minFlipsMonoIncr(string s)\n{\n int n = s.size();\n int totalFlips = INT_MAX;\n for(int cut=0;cut<=n;cut++)\n {\n int ones = 0;\n for(int j=0;j<cut;j++) //count no of 1\'s in the left side\n {\n if(s[j]==\'1\')\n ones++;\n }\n \n int zeroes = 0;\n for(int j=cut;j<n;j++) //count no of 0\'s in the right side\n {\n if(s[j]==\'0\')\n zeroes++;\n }\n int flipsInLeft = ones; //we convert 1\' to 0\'s => so flips = no of ones\n int flipsInRight = zeroes; //we convert 0\' to 1\'s => so flips = no of zeroes\n totalFlips = min(totalFlips,flipsInLeft+flipsInRight);\n }\n return totalFlips;\n}\n\n\nTime Complexity : O(n^2) \tSpace Complexity : O(1)\nVerdict: TLE\n\n```\n**Optimization:**\n\n\tWhy do we have to count number of 1\'s and number of 0\'s for every cut.\n\tTo count these every time we have to traverse whole string which takes O(n) time for every cut\n\n\tWe can get count in O(1) time if we put those counts in arrays\n\tcountOnesInLeft[] ==> which counts number of 1\'s from starting to cut ( traverse from left to right)\n\tcountZeroesInRight[] ==> which counts number of 0\'s until cut from ending (traverse form right to left) \n\n\tEg : s = "010110"\n\t\t\t\t 0 1 0 1 1 0\n\tcountOnesInLeft[]\t 0 1 1 2 3 3\t(presum of 1\'s)\n\tcountzeroesInRight[] 3 2 2 1 1 1\t(suffixSum of 0\'s)\n\t\n\t\n\t0 | 1 0 1 1 0 => flipsInLeft = countOnesInLeft[0] = 0\t\ttotalFlips = filpsInLEft+flipsInRight\n\t\t\t\t\t flipsInRight = countZeroesInRight[1] = 2\t\t 2\n\n\t0 1 | 0 1 1 0 => flipsInleft = countOnesInLeft[1] = 1\t\t\t 3\n\t\t\t flipsInRight = countZeroesInRight[2] = 2\n\n\t0 1 0 | 1 1 0 => flipsInLeft = countOnesInLeft[2] = 1\t\t\t 2\n\t\t\t flipsInRight = countZeroesInRight[3] = 1\n\n\t0 1 0 1 | 1 0 => flipsInLeft = countOnesInLeft[3] = 2\t\t\t 3\n\t\t\t flipsInRight = countZeroesInRight[4] = 1\n\n\t0 1 0 1 1 | 0 => flipsInLeft = countOnesInLeft[4] = 3\t\t\t 4\n\t\t\t flipsInRight = countZeroesInRight[5] = 1\n\t\n\t\n\tWe have to consider two extra cases\t\t\t\t\t \n\t\t(i.e all are 1s i.e cut before index 0)\t\t 3\n\t| 010110 => flipsInLeft = 0\n\t\t flipsInRight = countZeroesInRight[0]=3;\n\n\tall are 0s i.e cut after (n-1) th index\n\t\n\t010110 | => flipsInLeft = countOnesInLeft[n-1] = 3\t\t\t 3\n\t\t flipsInRight = 0\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tans = min(totalFlips) = 2\n\n**Code**\n```\n int minFlipsMonoIncr(string s)\n {\n int n = s.size();\n vector<int> countOnesInLeft(n,0);\n vector<int> countZeroesInRight(n,0);\n \n int ones = 0;\n for(int i=0;i<n;i++) // preSum of 1\'s\n {\n if(s[i]==\'1\')\n ones++;\n countOnesInLeft[i] = ones;\n }\n int zeroes = 0;\n for(int i=n-1;i>=0;i--) //Suffix sum of 0\'s\n {\n if(s[i]==\'0\')\n zeroes++;\n countZeroesInRight[i] = zeroes;\n }\n \n int totalFlips = INT_MAX;\n for(int cut=0;cut<n-1;cut++)\n {\n int flipsInLeft = countOnesInLeft[cut];\n int flipsInRight = countZeroesInRight[cut+1];\n totalFlips = min(totalFlips,flipsInLeft+flipsInRight);\n }\n \n //cut before index 0 i.e convert all 0\'s to 1\'s \n totalFlips = min(totalFlips,countZeroesInRight[0]);\n \n //cut after index (n-1) i.e convert all 1\'s to 0\'s \n totalFlips = min(totalFlips,countOnesInLeft[n-1]);\n \n return totalFlips;\n }\n\nTime Complexity: O(n) \tSpace complexity: O(n)\nVerdict: Accepted\n``` | 26 | 0 | ['C', 'Prefix Sum', 'C++'] | 3 |
flip-string-to-monotone-increasing | Java DP using O(N) time and O(1) space | java-dp-using-on-time-and-o1-space-by-ev-9vw0 | Idea is to keep two variables storing min flips to be done for current digit to be one or to be zero.\n\n\nclass Solution {\n public int minFlipsMonoIncr(Str | evilnearby | NORMAL | 2018-10-21T03:05:13.047130+00:00 | 2018-10-23T02:38:12.284957+00:00 | 2,069 | false | Idea is to keep two variables storing min flips to be done for current digit to be one or to be zero.\n\n```\nclass Solution {\n public int minFlipsMonoIncr(String S) {\n char[] arr = S.toCharArray();\n int one = 0, zero = 0;\n \n for (int i = 0; i < arr.length; i++) {\n if (arr[i] == \'0\') {\n one = Math.min(one, zero) + 1;\n } else {\n one = Math.min(one, zero);\n zero += 1;\n }\n }\n \n return (int) Math.min(one ,zero);\n }\n}\n``` | 23 | 0 | [] | 5 |
flip-string-to-monotone-increasing | C++ prefix sum ✅ | c-prefix-sum-by-deleted_user-9gxh | Intuition\n Describe your first thoughts on how to solve this problem. \nwe are using prefix sum method to solve the problme\n\n# Approach\n Describe your appro | deleted_user | NORMAL | 2023-01-17T00:29:17.356126+00:00 | 2023-01-17T00:29:17.356173+00:00 | 2,651 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nwe are using prefix sum method to solve the problme\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\nSkip the loop until we find the first \'1\' \nafter finding first occurrence of \'1\' we have to keep a count of number of \'1\'s in countOnes \n\nif we find any \'0\' after occurrence of \'1\' it means turning that \'0\' to one may be one possible solution so we have to keep number of flip needed in countFlips variable \n\nif value of countFlips is greater than countOnes(number of ones) then converting all \'1\' to \'0\' would be better option so assign value of countOnes to the countFlips \n\nin the end we will return countFlips\n\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\nTime complexity is O(N) as we are looping through the string one time\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\nSpace complexity of this solution is O(1) as we are only using two extra integers \n\n# Code\n```\nclass Solution {\npublic:\n int minFlipsMonoIncr(string s) {\n if(s.size()==0){\n return 0;\n }\n int countFlips = 0;\n int countOnes = 0;\n for(auto ele:s){\n if(ele==\'0\'){\n if(countOnes==0)\n continue;\n else\n countFlips++;\n }else{\n countOnes++;\n }\n if(countFlips>countOnes){\n countFlips = countOnes;\n }\n }\n return countFlips;\n }\n};\n\n\n``` | 22 | 4 | ['C++'] | 7 |
flip-string-to-monotone-increasing | An Intuitive & Visual Explanation in Detail | an-intuitive-visual-explanation-in-detai-3c05 | THE CORE IDEA\nThe idea is simple. 0...01...1 kind of sequence is beautiful. A bunch of zeros, followed by a bunch of ones. Given a random string, we determine | chaudhary1337 | NORMAL | 2021-08-10T09:17:41.451361+00:00 | 2021-08-10T09:41:45.197328+00:00 | 775 | false | **THE CORE IDEA**\nThe idea is simple. `0...01...1` kind of sequence is beautiful. A bunch of zeros, followed by a bunch of ones. Given a random string, we determine the **breaking point** of that string, to the left will then be *only* 0s and to the right be *only* 1s. \n\nExample: A string like `00110` has breaking point as: `00 | 110`. The cost thus incurred is the last zero that has to be converted to 1.\n\n\n\nExample: A string like `010110` has two breaking points, `0 | 10110` and `010 | 110`. Both take the same cost!\n\n\nHere\'s what\'s happening:\n- **red part** wants the entire string to be **0**\n- the red levels are telling the **cost of flipping 1->0**\n- **purple part** wants the entire string to be **1**\n- the purple levels are telling the **cost of flipping 0->1**\n- Green represents the total cost of flipping at any point.\n\nAt the end, they both fight at each index, and wherever the total cost is minimum, we win!\n\n**IMPLEMENTATION DETAILS**\n- we start from index `0`\n- at that point, the purple has won. Thus, the cost is initially = number of zeros (think why!)\n- for each `0` we see now on, we reduce the number of zeros to be flipped (since the breaking point has now shifted). \n- for the same reason, we increase the cost of converting a `1` to a `0` \n```\nclass Solution:\n def minFlipsMonoIncr(self, s: str) -> int:\n n = len(s)\n zeros_flipped, ones_to_zeros = s.count("0"), 0\n result = zeros_flipped\n \n for c in s:\n zeros_flipped -= c == "0"\n ones_to_zeros += c == "1"\n result = min(result, zeros_flipped+ones_to_zeros)\n return result\n```\n**If you found this helpful, please upvote! Comments and discussions are most welcome.** | 19 | 1 | [] | 2 |
flip-string-to-monotone-increasing | Java Solutions with Full Explanations (B-F, DP x2, Constant Time & Space) | java-solutions-with-full-explanations-b-95nk8 | Reference: LeetCode\nDifficulty: Medium\n\n## Problem\n\n> A string of \'0\'s and \'1\'s is monotone increasing if it consists of some number of \'0\'s (possibl | junhaowanggg | NORMAL | 2019-10-16T06:27:05.676305+00:00 | 2019-10-16T06:27:05.676340+00:00 | 1,385 | false | Reference: [LeetCode](https://leetcode.com/problems/flip-string-to-monotone-increasing)\nDifficulty: <span class="orange">Medium</span>\n\n## Problem\n\n> A string of `\'0\'`s and `\'1\'`s is monotone increasing if it consists of some number of `\'0\'`s (possibly 0), followed by some number of `\'1\'`s (also possibly 0.)\n\n> We are given a string `s` of `\'0\'`s and `\'1\'`s, and we may flip any `\'0\'` to a `\'1\'` or a `\'1\'` to a `\'0\'`.\n\n> Return the minimum number of flips to make `s` monotone increasing.\n\n**Note:** \n\n1. `1 <= s.length() <= 20000`\n2. `s` only consists of `\'0\'` and `\'1\'` characters.\n\n**Example:** \n\n```java\nInput: "00000"\nOutput: 0\n\nInput: "00110"\nOutput: 1\n\nInput: "010110"\nOutput: 2\n\nInput: "00011000"\nOutput: 2\n```\n\n**Follow up:** Reduce `O(N^2)` to `O(N)`\n\n\n## Analysis\n\n### Brute-Force\n\nIn a brute-force fashion, We are going to consider all monotone increasing strings. For example, if the length is $4$, we consider `"1111", "0111", "0011", "0001" , "0000"`. Specifically, we separate the array in zero-part `[0, k]` and one-part in `[k+1, n-1]`, where `-1 <= k <= n - 1`.\n\n```java\npublic int minFlipsMonoIncr(String s) {\n int n = s.length();\n int minCount = Integer.MAX_VALUE;\n for (int k = -1; k <= n - 1; ++k) { // k is ranging from [-1, n-1]\n int count = 0;\n // zero-part\n for (int i = 0; i <= k; ++i) {\n if (s.charAt(i) == \'1\') ++count;\n }\n // one-part\n for (int i = k + 1; i <= n - 1; ++i) {\n if (s.charAt(i) == \'0\') ++count;\n }\n minCount = Math.min(minCount, count);\n }\n return minCount;\n}\n```\n\n**Time:** `O(N^2)`\n**Space:** `O(1)`\n\nSince `N` could be 20000 at most, we cannot use $O(N^2)$ solution. Usually, if `N` is greater than 5000, we cannot use $O(N^2)$ approach.\n\n\n### DP (prefix + suffix)\n\nIn the counting part, we do a lot of repeated calculation. We denote:\n\n- `prefix[i]` as the minimum number of flips (1 to 0) for prefix `s[0, i]`, where `0 <= i <= n - 1`.\n- `suffix[i]` as the minimum number of flips (0 to 1) for suffix `s[i, n - 1]`, where `0 <= i <= n - 1`.\n\n```java\npublic int minFlipsMonoIncr(String s) {\n int n = s.length();\n // calculate prefix[] and suffix[]\n int[] prefix = new int[n];\n int[] suffix = new int[n];\n prefix[0] = s.charAt(0) == \'1\' ? 1 : 0;\n suffix[n - 1] = s.charAt(n - 1) == \'0\' ? 1 : 0;\n for (int i = 1, j = n - 2; i < n; ++i, --j) {\n prefix[i] = prefix[i - 1] + (s.charAt(i) == \'1\' ? 1 : 0);\n suffix[j] = suffix[j + 1] + (s.charAt(j) == \'0\' ? 1 : 0);\n }\n // calculate the count\n int minCount = Integer.MAX_VALUE;\n for (int k = -1; k <= n - 1; ++k) {\n // 0: [0, k], 1: [k+1, n-1]\n int left = (k == -1) ? 0 : prefix[k];\n int right = (k + 1 == n) ? 0 : suffix[k + 1];\n minCount = Math.min(minCount, left + right);\n }\n return minCount;\n}\n```\n\n**Time:** `O(N)`\n**Space:** `O(N)`\n\n\n### DP (Extra Dimension for States)\n\nDefine:\n- `dp[i][0]` is the minimum number of flips for prefix `s[0, i]` when `s[i]` is required to be `0`.\n- `dp[i][1]` is the minimum number of flips for prefix `s[0, i]` when `s[i]` is required to be `1`.\n- Our goal is to calculate `min(dp[n - 1][0], dp[n - 1][1])`.\n\n```java\nConsider a prefix s[0, i-1]: "001101" + "1" or "0"\na) if new value is s[i] == 0\n - dp[i][0] = dp[i-1][0]\n - new value is 0, s[i] is required to be 0,\n - thus do not flip the new value\n - dp[i][1] = min(dp[i-1][0], dp[i-1][1]) + 1\n - new value is 0, s[i] is required to be 1,\n - thus flip the new value from 0 to 1\n - notice whether the last second is 1 or 0 is okay\nb) if new value is s[i] == 1\n - dp[i][0] = dp[i-1][0] + 1\n - new value is 1, s[i] is required to be 0,\n - thus flip the new value from 1 to 0\n - notice the last second must be 0 (or it is illegal)\n - dp[i][1] = min(dp[i-1][0], dp[i-1][1])\n - new value is 1, s[i] is required to be 1,\n - thus do not flip the new value\n```\n\nRecurrence: \n- If `s[i]` == `0`:\n - `dp[i][0]` = `dp[i-1][0]`\n - `dp[i][1]` = min(`dp[i-1][0]`, `dp[i-1][1]`) + 1\n- Else `s[i]` == `1`:\n - `dp[i][0]` = `dp[i-1][0]` + 1\n - `dp[i][1]` = min(`dp[i-1][0]`, `dp[i-1][1]`)\n\nInitialization:\n- If `s[i]` == `0`:\n - `dp[0][0]` = 0\n - `dp[0][1]` = 1\n- Else `s[i]` == `1`:\n - `dp[0][0]` = 1\n - `dp[0][1]` = 0\n\n\n```java\npublic int minFlipsMonoIncr(String s) {\n int n = s.length();\n int[][] dp = new int[n][2];\n // init\n if (s.charAt(0) == \'0\') {\n dp[0][0] = 0;\n dp[0][1] = 1;\n } else {\n dp[0][0] = 1;\n dp[0][1] = 0;\n }\n for (int i = 1; i < n; ++i) {\n if (s.charAt(i) == \'0\') {\n dp[i][0] = dp[i - 1][0];\n dp[i][1] = Math.min(dp[i - 1][0], dp[i - 1][1]) + 1;\n } else { // == \'1\'\n dp[i][0] = dp[i - 1][0] + 1;\n dp[i][1] = Math.min(dp[i - 1][0], dp[i - 1][1]);\n }\n }\n return Math.min(dp[n - 1][0], dp[n - 1][1]);\n}\n```\n\n**Time:** `O(N)`\n**Space:** `O(N)`\n\n\n**Reduce Space Complexity to Constant Time:**\n\n```java\npublic int minFlipsMonoIncr(String s) {\n int n = s.length();\n int f0, f1;\n // init\n if (s.charAt(0) == \'0\') f0 = 0; f1 = 1;\n else f0 = 1; f1 = 0;\n // dp\n for (int i = 1; i < n; ++i) {\n if (s.charAt(i) == \'0\') {\n // int minTemp = Math.min(f0, f1);\n f0 = f0;\n f1 = Math.min(f0, f1) + 1; // actually do not need minTemp\n } else { // == \'1\'\n int minTemp = Math.min(f0, f1);\n f0 = f0 + 1;\n f1 = minTemp; // or calculate the f1 first then get rid of minTemp\n }\n }\n return Math.min(f0, f1);\n}\n```\n\n**Time:** `O(N)`\n**Space:** `O(1)` | 18 | 0 | ['Dynamic Programming', 'Java'] | 4 |
flip-string-to-monotone-increasing | Java DP solution | java-dp-solution-by-lf963-yzts | DP Solution\n\nMantain two variables flipToZero and flipToOne\nflipToZero: how many flips we need so that we can flip current digit to zero.\nflipToOne: how man | lf963 | NORMAL | 2018-10-28T06:35:10.873860+00:00 | 2018-10-28T06:35:10.873904+00:00 | 922 | false | DP Solution\n\nMantain two variables ```flipToZero``` and ```flipToOne```\n```flipToZero```: how many flips we need so that we can flip current digit to zero.\n```flipToOne```: how many flips we need so that we can flip current digit to one.\n\nDP recursion:\n```\nif current digit is zero\n\tflipToZero[i] = 0 + flipToZero[i-1] //no need to flip the current digit and the previous digit must be zero\n\tflipToOne[i] = 1 + min(flipToZero[i-1], flipToOne[i-1]) // need flip zero to one and the previous digit can be either zero or one\nif current digit is one\n\tflipToZero[i] = 1 + flipToZero[i-1] //need to flip one to zero and the previous digit must be zero\n\tflipToOne[i] = 0 + min(flipToZero[i-1], flipToOne[i-1]) // no need to flip the current digit and the previous digit can be either zero or one\n```\nHere is an example:\n\n\n```\npublic int minFlipsMonoIncr(String S) {\n int flipToZero = S.charAt(0) - \'0\';\n int flipToOne = 1 - (S.charAt(0) - \'0\');\n for(int i=1; i<S.length(); i++){\n int n = S.charAt(i) - \'0\';\n int tempZero = flipToZero;\n int tempOne = flipToOne;\n flipToZero = n + tempZero;\n flipToOne = 1 - n + Math.min(tempZero, tempOne);\n }\n return Math.min(flipToZero, flipToOne);\n }\n``` | 18 | 0 | [] | 1 |
flip-string-to-monotone-increasing | C++ || Explanations and Comments || 4 Solutions || Greedy || DP | c-explanations-and-comments-4-solutions-p5f6t | Intuition\nWe want to iterate over the string and for each index calc the best answer on it\n\n# Approach\nTraverse on the string and for each index treat it l | 7oskaa | NORMAL | 2023-01-17T11:02:14.007315+00:00 | 2023-01-17T12:13:31.078657+00:00 | 905 | false | # Intuition\nWe want to iterate over the string and for each index calc the best answer on it\n\n# Approach\nTraverse on the string and for each index treat it like all previous number are `0`\'s and all next numbers are `1`\'s\n\n# Complexity\n- Time complexity:\n$O(n)$ - where $n$ is the number of characters\n\n- Space complexity:\n$O(1)$ - only declare three variables\n\n***Note: These complexity calculated on the `Greedy` Solution because it\'s the best one of all `4` solutions***\n\n# Solutions\n***There are `4` solutions in the bellow section:***\n- Greedy\n- DP Recursive\n- DP Iterative\n- Dp Iterative with Rolling Back\n\n$\\newline$\n\n```cpp []\nclass Solution {\npublic:\n int minFlipsMonoIncr(string& s) {\n \n // number of zeros and ones so far\n int ones = 0, zeros = count(s.begin(), s.end(), \'0\');\n\n // store the best answer while traversing\n int min_flips = s.size();\n\n for(auto& c : s){\n // update number of zeros\n zeros -= (c == \'0\');\n\n // update the minimum flips\n min_flips = min(min_flips, ones + zeros);\n\n // update number of ones while traverse\n ones += (c == \'1\');\n }\n\n return min_flips;\n }\n};\n```\n```cpp []\nclass Solution {\npublic:\n\n int n;\n vector < vector < int > > dp;\n string s;\n static constexpr int MAX = 1e9; \n\n int min_flip(int idx, int prev){\n // base case if we reach the end of the string\n if(idx == n) return 0;\n \n // check if this state is calculated before\n int& ret = dp[idx][prev];\n if(~ret) return ret;\n\n // initial the answer with 1e9\n ret = MAX;\n\n /*\n if the previous char is zero so we have two choices\n - go with out change any thing with cost 0\n - flip the character with cost 1\n\n if the previous char is one so we have two choices\n - if the current char is one so we wil go without any update with cost 0\n - if the current char is zero i will flip it with cost 1 \n */\n\n if(prev == 0){\n ret = min(ret, min_flip(idx + 1, s[idx] - \'0\'));\n ret = min(ret, 1 + min_flip(idx + 1, s[idx] == \'0\'));\n }else\n ret = min(ret, (s[idx] == \'0\') + min_flip(idx + 1, 1));\n\n // return the best answer of the choices\n return ret;\n }\n\n int minFlipsMonoIncr(string s) {\n // initial the global variables\n n = s.size();\n dp = vector < vector < int > > (n, vector < int > (2, -1));\n this -> s = s;\n \n // return the minimum flips\n return min_flip(0, 0);\n }\n};\n```\n```cpp []\nclass Solution {\npublic:\n\n int minFlipsMonoIncr(string s) {\n // initial the global variables\n int n = s.size();\n static constexpr int MAX = 1e9; \n vector < vector < int > > dp(n + 1, vector < int > (2, MAX));\n \n // base case\n dp[n][0] = dp[n][1] = 0;\n \n /*\n if the previous char is zero so we have two choices\n - go with out change any thing with cost 0\n - flip the character with cost 1\n\n if the previous char is one so we have two choices\n - if the current char is one so we wil go without any update with cost 0\n - if the current char is zero i will flip it with cost 1 \n */\n\n for(int i = n - 1; i >= 0; i--){\n\n // for case the current char is zero\n dp[i][0] = min(dp[i][0], dp[i + 1][s[i] - \'0\']);\n dp[i][0] = min(dp[i][0], 1 + dp[i + 1][s[i] == \'0\']);\n \n // for case the current char is one\n dp[i][1] = min(dp[i][1], (s[i] == \'0\') + dp[i + 1][1]);\n }\n \n // return the minimum flips\n return min(dp[0][0], dp[0][1]);\n }\n};\n```\n```cpp []\nclass Solution {\npublic:\n\n int minFlipsMonoIncr(string s) {\n int n = s.size();\n static constexpr int MAX = 1e9; \n vector < vector < int > > dp(2, vector < int > (2, MAX));\n \n // base case\n dp[n % 2][0] = dp[n % 2][1] = 0;\n \n /*\n if the previous char is zero so we have two choices\n - go with out change any thing with cost 0\n - flip the character with cost 1\n\n if the previous char is one so we have two choices\n - if the current char is one so we wil go without any update with cost 0\n - if the current char is zero i will flip it with cost 1 \n */\n\n for(int i = n - 1; i >= 0; i--){\n \n // re initial the current state before take the minimum\n dp[i % 2][0] = dp[i % 2][1] = MAX;\n\n // for case the current char is zero\n dp[i % 2][0] = min(dp[i % 2][0], dp[(i + 1) % 2][s[i] - \'0\']);\n dp[i % 2][0] = min(dp[i % 2][0], 1 + dp[(i + 1) % 2][s[i] == \'0\']);\n \n // for case the current char is one\n dp[i % 2][1] = min(dp[i % 2][1], (s[i] == \'0\') + dp[(i + 1) % 2][1]);\n }\n \n // return the minimum flips\n return min(dp[0][0], dp[0][1]);\n }\n};\n```\n\n<div align= "center">\n<h3>Upvote me</h3>\n\n\n\n</div> | 17 | 0 | ['Dynamic Programming', 'Greedy', 'Prefix Sum', 'C++'] | 2 |
flip-string-to-monotone-increasing | Python O(N)/O(1), One Pass, Very Simple | python-ono1-one-pass-very-simple-by-dudu-lv75 | This question should be quite straightforward and no need to over think.\nWe check the string from left or right, and keep the substring prior to current positi | dudupipi | NORMAL | 2022-03-04T20:57:07.755691+00:00 | 2022-03-13T06:06:55.162205+00:00 | 690 | false | This question should be quite straightforward and no need to over think.\nWe check the string from left or right, and keep the substring prior to current position monotone increasing.\n\nIf we encounter a 1, do nothing since appending this won\'t break the monotonicity.\nIf we encounter a 0, then two options to keep substring with current char monotonic:\n1. Flip this 0 to 1\n2. Flip all previous 1 to 0\n\nFor second option, we need to know how many 1s are there up to now, simply by couting prefix sum.\n\n\n```\nclass Solution:\n def minFlipsMonoIncr(self, s: str) -> int:\n total = flip = 0\n for c in s:\n total += c == \'1\'\n if c == \'0\':\n flip = min(flip + 1, total)\n return flip\n``` | 17 | 0 | ['Dynamic Programming', 'Python'] | 3 |
flip-string-to-monotone-increasing | Python 3-liner | python-3-liner-by-cenkay-bi2u | We start with assuming "111.." section occupies all string, s.\n Then we update "000.." section as s[:i + 1] and "111.." section as s[i + 1:] during iteration a | cenkay | NORMAL | 2018-10-21T11:00:15.986407+00:00 | 2018-10-21T16:18:26.691852+00:00 | 1,214 | false | * We start with assuming "111.." section occupies all string, s.\n* Then we update "000.." section as s[:i + 1] and "111.." section as s[i + 1:] during iteration as well as the result\n* "zeros" variable counts all misplaced "0"s and "ones" variable counts all misplaced "1"s\n```\nclass Solution:\n def minFlipsMonoIncr(self, s, ones = 0):\n res = zeros = s.count("0")\n for c in s:\n ones, zeros = (ones + 1, zeros) if c == "1" else (ones, zeros - 1)\n res = min(res, ones + zeros)\n return res\n```\n* More concise:\n```\nclass Solution:\n def minFlipsMonoIncr(self, s):\n res = cur = s.count("0")\n for c in s:\n cur = cur + 1 if c == "1" else cur - 1\n res = min(res, cur)\n return res\n```\n* Even more concise for fun:\n```\nclass Solution:\n def minFlipsMonoIncr(self, s):\n dp = [s.count("0")]\n for c in s: dp += [dp[-1] + 1 if c == "1" else dp[-1] - 1]\n return min(dp)\n```\n* And another one w/ O(1) space :)\n```\nclass Solution:\n def minFlipsMonoIncr(self, s):\n res = cur = s.count("0")\n for c in s: res, cur = c == "1" and (res, cur + 1) or (min(res, cur - 1), cur - 1)\n return res\n``` | 17 | 1 | [] | 1 |
flip-string-to-monotone-increasing | [C++/Java/Python] Real-World Problem Explained ✅ | cjavapython-real-world-problem-explained-nwxy | Real-World Problem:\nDo you know why these problem is quite an easy yet and important problem? Here\'s what i know:\n\nThis problem is inspired by a Real-World | prantik0128 | NORMAL | 2023-01-17T05:10:24.990762+00:00 | 2023-01-17T05:55:35.987187+00:00 | 1,079 | false | **Real-World Problem:**\nDo you know why these problem is quite an easy yet and important problem? Here\'s what i know:\n\nThis problem is inspired by a **Real-World Scenario** of:\n\n\tOptimizing Data Storage & Retrieval In a Computer\'s Memory.\n\nIn this scenario, we might have a` large amount of data` that needs to be stored in a `binary` format, such as `images` or `videos`. \nTo optimize the `storage` and `retrieval` of this data, we want to make sure that it is stored in a `monotonically` increasing format, that is, **a sequence of \'0\'s followed by a sequence of \'1\'s**.\n\n**Intuition:**\nThe problem is to find the minimum number of "`flips`" (or operations) needed to make a binary string monotonically `increasing`. A binary string is considered monotonically increasing if it consists of a sequence of `\'0\'s` followed by a sequence of \'`1\'s.`\n\nHere we are using clever approach to keep track of the number of flips and ones needed to make the string monotonically increasing, and it does so in a single linear pass through the input string, which makes it an efficient algorithm.\n\n**Approach:**\n* Initialize `two` variables, `ones` and `flips`, to zero.\n* Iterate through each character in the input string `S`.\n* If the character is `\'0\'`, `increment` the flips variable. If the character is `\'1\'`, increment the `ones` variable.\n* Update the flips variable to be the minimum of flips and ones.\n* After the end of the `loop` return the value of `flips`, which is the `minimum` number of flips needed to make the input string monotonically `increasing`.\n\n-----\n**C++:**\n```\nclass Solution {\npublic:\n int minFlipsMonoIncr(string S) {\n int ones=0,flips=0;\n for(auto c:S){\n if(c==\'0\') flips++;\n else ones++;\n flips=min(flips,ones);\n }\n return flips;\n }\n};\n```\n**Java:**\n```\nclass Solution {\n public int minFlipsMonoIncr(String s) {\n int ones = 0, flips = 0;\n for (int i = 0; i < s.length(); i++) {\n if (s.charAt(i) == \'0\') {\n flips++;\n } else {\n ones++;\n }\n flips = Math.min(flips, ones);\n }\n return flips;\n }\n}\n```\n**Python:**\n```\nclass Solution:\n def minFlipsMonoIncr(self, s: str) -> int:\n ones = 0\n flips = 0\n for c in s:\n if c == \'0\':\n flips += 1\n else:\n ones += 1\n flips = min(flips, ones)\n return flips\n```\n\n\n-----\n**Time Complexity:** **O(n)**, as we are iterating through the input string only once.\n**Space Complexity:** **O(1)**, as it only uses a constant amount of extra space to store the two variables ones and flips. The size of these variables does not depend on the size of the input string, making the space complexity constant.\n\n-----\n\nMy [LinkedIn ](https://www.linkedin.com/in/prantikmukherjee/)\n\n### Please **upvote** the post if you actually **learned** something! | 15 | 0 | ['C', 'Python', 'Java'] | 1 |
flip-string-to-monotone-increasing | 🚀Easy Explanation🚀|| C++ || Python || O(N)✅ | easy-explanation-c-python-on-by-naman_ag-hhok | Consider\uD83D\uDC4D\uD83D\uDC4D\n\n Please Upvote If You Find It Helpful.\n\n# Intuition:\nCounting the no. of 1\'s to flip on left side | naman_ag | NORMAL | 2023-01-17T02:18:47.853771+00:00 | 2023-01-17T05:36:14.316505+00:00 | 1,004 | false | # Consider\uD83D\uDC4D\uD83D\uDC4D\n```\n Please Upvote If You Find It Helpful.\n```\n# Intuition:\nCounting the no. of 1\'s to flip on left side + no. of 0\'s to flip on right side of each index i and then select minimum flips from it.\n\n# Approach:\nStep 1. For each index i, store sum of (no. of 1\'s on LHS + no .of 0\'s on RHS of i) in an array.\nStep 2. For each index i, check if a[i] <min, update min.\nStep 3. Return min.\n\n# Complexity\n- Time complexity: O(N)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: O(N)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```C++ []\nclass Solution {\npublic:\n int minFlipsMonoIncr(string s) {\n // Initialize variables\n int zero=0, one=0, totalzeroes=0, n = s.size(), mn = INT_MAX;\n \n // Initialize an array to store the number of flips needed at each index\n int res[n];\n \n // Loop through the input string and count the total number of zeroes\n for(char i : s)\n if(i == \'0\')\n totalzeroes++;\n\n // Loop through the input string\n for(int i=0;i<n;i++){\n // If the current character is \'0\', increment the zero count\n if(s[i]==\'0\')\n zero++;\n \n // Calculate the number of flips needed at this index\n res[i] = one+totalzeroes-zero;\n \n // If the current character is \'1\', increment the one count\n if(s[i]==\'1\')\n one++;\n \n // Update the minimum number of flips needed if needed\n if(mn>res[i])\n mn = res[i];\n }\n \n // Return the minimum number of flips needed\n return mn;\n }\n};\n```\n```python []\nclass Solution:\n def minFlipsMonoIncr(self, s: str) -> int:\n # Initialize variables\n zero = 0\n one = 0\n totalzeroes = 0\n n = len(s)\n mn = float(\'inf\')\n\n # Initialize an array to store the number of flips needed at each index\n res = [0] * n\n\n # Loop through the input string and count the total number of zeroes\n for i in s:\n if i == \'0\':\n totalzeroes += 1\n\n # Loop through the input string\n for i in range(n):\n # If the current character is \'0\', increment the zero count\n if s[i] == \'0\':\n zero += 1\n\n # Calculate the number of flips needed at this index\n res[i] = one + totalzeroes - zero\n\n # If the current character is \'1\', increment the one count\n if s[i] == \'1\':\n one += 1\n\n # Update the minimum number of flips needed if needed\n if mn > res[i]:\n mn = res[i]\n\n # Return the minimum number of flips needed\n return mn\n\n```\n\n```\n Give a \uD83D\uDC4D\n``` \nLet\'s connect on [Linkedin](https://www.linkedin.com/in/naman-agarwal-0551aa1aa/) | 15 | 0 | ['String', 'C++', 'Python3'] | 2 |
flip-string-to-monotone-increasing | ✅Flip String to Monotone Increasing || Basic Implementation w/o DP || C++ | Python | Java | flip-string-to-monotone-increasing-basic-qv14 | ALGORITHM:\n\n Set n - length of the string , flipCount = 0 and oneCount = 0\n For i in range 0 to n \u2013 1\n\t If S[i] is 0, then\n\t\t If oneCount = 0, then | Maango16 | NORMAL | 2021-08-10T07:17:14.182927+00:00 | 2021-08-10T07:25:29.986939+00:00 | 722 | false | **ALGORITHM:**\n\n* Set `n - length of the string` , `flipCount = 0` and `oneCount = 0`\n* For i in range `0 to n \u2013 1`\n\t* If `S[i] is 0`, then\n\t\t* If `oneCount = 0`, then skip to the next iteration\n\t\t* Increase the flipCount by 1\n\t* Otherwise `increase oneCount` by 1\n\t* If `oneCount < flipCount`, then set `flipCount = oneCount` (Find the minimum)\n\t* Return flipCount\n\n**SOLUTION:**\n`In C++`\n```\nclass Solution {\npublic:\n int minFlipsMonoIncr(string s) {\n int flip = 0 ;\n int onecount = 0 ;\n for(auto i:s)\n {\n if(i == \'0\')\n {\n if(onecount != 0)\n {\n flip++ ;\n }\n }\n else\n {\n onecount++ ;\n }\n if(onecount < flip)\n {\n flip = onecount ;\n }\n }\n return flip ;\n }\n};\n```\n`In JAVA`\n```\nclass Solution {\n public int minFlipsMonoIncr(String s) {\n int n = s.length() ;\n int flip = 0 ;\n int onecount = 0 ;\n for(int i = 0 ; i < n ; i++)\n {\n if(s.charAt(i) == \'0\')\n {\n if(onecount != 0)\n {\n flip++ ;\n }\n }\n else\n {\n onecount++ ;\n }\n flip = Math.min(flip , onecount);\n }\n return flip ;\n }\n}\n```\n`In Python`\n```\nclass Solution(object):\n def minFlipsMonoIncr(self, s):\n """\n :type s: str\n :rtype: int\n """\n onecount = 0 \n flip = 0 \n for c in s:\n if c == "0":\n if onecount != 0:\n flip += 1\n else:\n onecount += 1\n flip = min(flip , onecount)\n return flip\n \n``` | 15 | 5 | [] | 5 |
flip-string-to-monotone-increasing | Python greedy solution, count 1s and 0s solution, 1 pass | python-greedy-solution-count-1s-and-0s-s-0k03 | When there are equal 0s following 1s, we flip all the 1s.\npython\nones = zeros = 0\nresult = 0\n\nfor c in s:\n\tif c == "1":\n\t\tones += 1\n\telse:\n\t\n\t\t | FACEPLANT | NORMAL | 2021-08-10T16:07:14.713853+00:00 | 2021-08-10T16:11:53.605299+00:00 | 372 | false | When there are equal 0s following 1s, we flip all the 1s.\n```python\nones = zeros = 0\nresult = 0\n\nfor c in s:\n\tif c == "1":\n\t\tones += 1\n\telse:\n\t\n\t\t# We start to count 0s after 1s\n\t\tif ones:\n\t\t\tzeros += 1\n\t\t\t\n\t\t\t# when 0s are equal to 1s, we flip all 1s, and reset counters\n\t\t\tif zeros == ones:\n\t\t\t\tresult += ones\n\t\t\t\tones = zeros = 0\n\t\t\t\t\n# The remaining 0s should be flipped\t\t\t\t\nresult += zeros\n\nreturn result\n``` | 12 | 0 | [] | 1 |
flip-string-to-monotone-increasing | Clean Codes🔥|| Dynamic Programming ✅|| C++|| Java || Python3 | clean-codes-dynamic-programming-c-java-p-rm7c | Request \uD83D\uDE0A :\n- If you find this solution easy to understand and helpful, then Please Upvote\uD83D\uDC4D\uD83D\uDC4D\n# Code [C++| Java| Python3] :\nC | N7_BLACKHAT | NORMAL | 2023-01-17T04:58:17.294179+00:00 | 2023-01-17T05:05:43.927764+00:00 | 1,682 | false | # Request \uD83D\uDE0A :\n- If you find this solution easy to understand and helpful, then Please Upvote\uD83D\uDC4D\uD83D\uDC4D\n# Code [C++| Java| Python3] :\n```C++ []\nclass Solution {\n public:\n int minFlipsMonoIncr(string S) {\n vector<int> dp(2);\n\n for (int i = 0; i < S.length(); ++i) {\n int temp = dp[0] + (S[i] == \'1\');\n dp[1] = min(dp[0], dp[1]) + (S[i] == \'0\');\n dp[0] = temp;\n }\n\n return min(dp[0], dp[1]);\n }\n};\n```\n```Java []\nclass Solution {\n public int minFlipsMonoIncr(String S) {\n int[] dp = new int[2];\n\n for (int i = 0; i < S.length(); ++i) {\n int temp = dp[0] + (S.charAt(i) == \'1\' ? 1 : 0);\n dp[1] = Math.min(dp[0], dp[1]) + (S.charAt(i) == \'0\' ? 1 : 0);\n dp[0] = temp;\n }\n\n return Math.min(dp[0], dp[1]);\n }\n}\n```\n```Python3 []\nclass Solution:\n def minFlipsMonoIncr(self, S: str) -> int:\n dp = [0] * 2\n\n for i, c in enumerate(S):\n dp[0], dp[1] = dp[0] + (c == \'1\'), min(dp[0], dp[1]) + (c == \'0\')\n\n return min(dp[0], dp[1])\n```\n | 10 | 0 | ['String', 'Dynamic Programming', 'C++', 'Java', 'Python3'] | 0 |
flip-string-to-monotone-increasing | Easy Java Solution | easy-java-solution-by-amanchandna-80h0 | Code\n\nclass Solution {\n public int minFlipsMonoIncr(String s) {\n //intuition : reach first one\n //after reaching first one I can count the | amanchandna | NORMAL | 2023-01-17T01:45:24.511908+00:00 | 2023-01-17T01:45:24.511950+00:00 | 2,750 | false | # Code\n```\nclass Solution {\n public int minFlipsMonoIncr(String s) {\n //intuition : reach first one\n //after reaching first one I can count the number of zeros : those zeros are having possibility to get flipped\n //if count of 0s > count of 1s -> will flip ones\n\n int n = s.length();\n if(s == null || n == 0)\n return 0;\n \n int countOfOnes = 0;\n int countOfZeros = 0;\n char[] arr = s.toCharArray();\n\n for(int i = 0; i < n; i++){\n char c = arr[i];\n if(c == \'0\'){\n if(countOfOnes == 0)\n continue;\n else\n countOfZeros++;\n }else\n countOfOnes++;\n if(countOfZeros > countOfOnes)\n countOfZeros = countOfOnes;\n }\n return countOfZeros;\n }\n}\n``` | 10 | 0 | ['Prefix Sum', 'Java'] | 2 |
flip-string-to-monotone-increasing | Recursive DP Solution Easy to Understand with Detail Explanation | recursive-dp-solution-easy-to-understand-qysl | In the problem, you have to create a monotonic increasing sequence i.e a sequence of 0\'s followed by 1\'s or a sequence of all 0\'s or perhaps a sequence of al | Arnav_Tiwari | NORMAL | 2021-08-10T19:05:44.733626+00:00 | 2021-08-10T19:09:54.629347+00:00 | 816 | false | In the problem, you have to create a monotonic increasing sequence i.e a sequence of 0\'s followed by 1\'s or a sequence of all 0\'s or perhaps a sequence of all 1\'s whichever might cost the least number of flips.\nThe problem can be solved using the following idea:\n**1. 0 can be followed by either 1 or 0.**\n**2. 1 can only be followed by 1 and nothing else.**\n\n**For the first case we recursively compute the minimum of the two cases when the actual digit is 0 and is followed by 0 or if it is followed by 1.\nFor the second case, we recursively compute only the case when a digit is 1, then it can only be followed 1.\nIf the digit we set and the actual digit match then we do nothing or else we add 1 to the answer because it corresponds to a flip.**\nThis will eventually result in TLE, because we are recalculating some already calculated subproblems.\nTo improve the complexity what we can do is create a 2d DP to cache a particular subproblem, so we do not have to calculate it again.\n\n**Explanation about DP caching.\n1.dp[i][j]=Minimum number of flips till that index.\n2. The first row of the DP corresponds to the 1 to 0 flip.\n3. The second row of DP corresponds to the 0 to 1 flip.**\n\n```\nclass Solution {\n int [][]dp;\n public int minFlipsMonoIncr(String s) {\n dp=new int[2][s.length()];\n for(int i=0;i<2;i++){\n Arrays.fill(dp[i],Integer.MAX_VALUE);}\n return Math.min(Flip(s,0,\'0\'),Flip(s,0,\'1\'));\n }\n public int Flip(String s,int index,char set){\n if(index>=s.length())\n return 0;\n if(dp[set-\'0\'][index]!=Integer.MAX_VALUE)\n return dp[set-\'0\'][index];\n char ch=s.charAt(index);\n int min=Integer.MAX_VALUE;\n int val=ch==set?0:1;\n if(set==\'0\')\n min=Math.min(Flip(s,index+1,\'0\'),Flip(s,index+1,\'1\'));\n else\n min=Flip(s,index+1,\'1\');\n dp[set-\'0\'][index]=min+val;\n return dp[set-\'0\'][index];\n }\n}\n```\n | 10 | 0 | ['String', 'Dynamic Programming', 'Recursion', 'Memoization'] | 2 |
flip-string-to-monotone-increasing | Prefix-Suffix Python O(n) time, Very Easy Explanation. | prefix-suffix-python-on-time-very-easy-e-oq7w | For Monotone Increasing String, there must be an index where all the values on the left hand side are "0" and all the values on the right hand side are "1".\n S | raja_nikshith_katta | NORMAL | 2021-08-10T08:13:00.875483+00:00 | 2021-08-10T08:13:00.875532+00:00 | 394 | false | * For Monotone Increasing String, there must be an index where all the values on the left hand side are "0" and all the values on the right hand side are "1".\n* So now to convert the input string into Monotone Increasing String, We need to choose an index and flip all "1"s to "0" on the left and flip all "0"s to "1".\n* So we need to choose an index such that (Count of "1"s on the left hand side + Count of "0"s on the right hand side) is minimum.\n```\nclass Solution:\n def minFlipsMonoIncr(self, s: str) -> int:\n\t # ones array calculates count of "1"s on the left hand side of the index\n ones = [0] * (len(s))\n\t\t# zeros array calculates count of "0"s on the right hand side of the index\n zeros = [0] * (len(s))\n\t\t\n for i in range(1,len(s)):\n if s[i-1] == \'1\':\n ones[i] = 1 + ones[i-1]\n else:\n ones[i] = ones[i-1]\n for i in range(len(s)-2,-1,-1):\n if s[i+1] == \'0\':\n zeros[i] = 1 + zeros[i+1]\n else:\n zeros[i] = zeros[i+1]\n mini = len(s)\n for i in range(len(s)):\n mini = min(mini,zeros[i] + ones[i])\n return mini | 10 | 0 | ['Suffix Array', 'Python'] | 0 |
flip-string-to-monotone-increasing | ✅Easy C++ solution || ✅Short & Simple || ✅Best Method || ✅Easy-To-Understand | easy-c-solution-short-simple-best-method-rtkx | Intuition\n Describe your first thoughts on how to solve this problem. \n\n# Approach\n Describe your approach to solving the problem. \n\n# ComplexityBold\n- T | akajayraj001 | NORMAL | 2023-01-17T04:45:52.526011+00:00 | 2023-01-17T04:45:52.526052+00:00 | 1,508 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity**Bold**\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\n\n// \uD83D\uDE09\uD83D\uDE09\uD83D\uDE09\uD83D\uDE09Please upvote if it helps \uD83D\uDE09\uD83D\uDE09\uD83D\uDE09\uD83D\uDE09\n\nclass Solution {\npublic:\n int minFlipsMonoIncr(string s) {\n int count_flip = 0, count_one = 0;\n for (auto i : s)\n {\n if (i == \'1\')\n count_one++;\n else\n count_flip++;\n count_flip = min(count_flip, count_one);\n }\n return count_flip;\n }\n};\n``` | 9 | 1 | ['C++'] | 6 |
flip-string-to-monotone-increasing | ✅ C++ || Easy Detailed Solution || Beginner friendly || O(n), O(1) | c-easy-detailed-solution-beginner-friend-8mxz | Approach\n##### My entire approach is based on the idea that all the ones to the left (including pointer) of the pointer and all the zeros to the right of the p | underground_coder | NORMAL | 2023-01-17T04:05:53.246395+00:00 | 2023-01-17T04:05:53.246428+00:00 | 1,033 | false | # Approach\n##### My entire approach is based on the idea that all the `ones` to the left (including pointer) of the pointer and all the `zeros` to the right of the pointer must be flipped.\n- Initially I\'ve stored all the zeros of string in `totalZero` variable to initialize my `rightZero` and `ans` variables.\n- As we traverse through each element, we modify our `leftOne` and `rightZero` variables accordingly.\n- In each iteration we can make a required string by flipping `leftOne` number of `ones into zeros` and `rightZero` number of `zeros into ones`.\n- We will store the minimum flips between existing `ans` and the current flips (`leftOne + rightZero`)\n- Return ans\n\n\n\n\n# Complexity\n- Time complexity: O(n), \nbecause we have traversed n times to store `totalZero` and then n times to calculate minimum flips - `O(n) + O(n) = O(n)`\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: O(1)\nWe have used extra space for our few variables only, so constant space will be required\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n### Once you\'ve read the code, you\'ll understand everything \uD83D\uDC47 \n\n# Code\n```\nclass Solution {\npublic:\n int minFlipsMonoIncr(string s) {\n \n int totalZero = 0;\n int leftOne = 0;\n int rightZero = 0;\n\n int n = s.length();\n\n for(int i=0;i<n;i++){\n if(s[i] == \'0\')\n totalZero++;\n }\n\n \n rightZero = totalZero;\n int ans = rightZero;\n\n\n for(int i=0;i<n;i++){\n if(s[i]== \'0\' ){\n rightZero--;\n }else{\n leftOne++;\n }\n\n ans = min(ans, leftOne+rightZero);\n\n }\n\n return ans;\n\n }\n};\n```\n\n# If you found this helpful, kindly give it an upvote \uD83D\uDE4F \n#### Thank you in advance :) | 9 | 0 | ['C++'] | 2 |
flip-string-to-monotone-increasing | One-pass intuitive python solution | one-pass-intuitive-python-solution-by-yi-akas | Very similar to @LiamHuang\'s solution. For case we encounter \'1\', we actually do no action. I wanted to make it more clear:\n\n\nclass Solution:\n def min | yilmazali | NORMAL | 2022-01-05T09:34:01.412827+00:00 | 2022-01-05T09:34:01.412860+00:00 | 607 | false | Very similar to @LiamHuang\'s solution. For case we encounter \'1\', we actually do no action. I wanted to make it more clear:\n\n```\nclass Solution:\n def minFlipsMonoIncr(self, s: str) -> int:\n \n n = len(s)\n min_flip, one_count = 0, 0\n \n for i in range(n):\n char = s[i]\n \n if char == \'1\':\n # if last char is 1, we don\'t flip it (yet). min_flip remains the same\n one_count += 1 \n continue\n \n # char is zero. let\'s decide if we flip this zero or still stick to \'one\' count\n min_flip += 1 # try flipping zeros\n min_flip = min(min_flip, one_count) # if we have less 1\'s, stick to flipping ones\n \n return min_flip\n``` | 8 | 0 | ['Python'] | 1 |
flip-string-to-monotone-increasing | Python One Liner (Actually good, unexplained) | python-one-liner-actually-good-unexplain-c2y7 | \nclass Solution:\n def minFlipsMonoIncr(self, s: str) -> int:\n return min(0,*accumulate([[-1,1][int(c)]for c in s]))+s.count(\'0\')\n | likey_00 | NORMAL | 2023-01-17T17:59:59.506718+00:00 | 2023-01-17T17:59:59.506761+00:00 | 1,071 | false | ```\nclass Solution:\n def minFlipsMonoIncr(self, s: str) -> int:\n return min(0,*accumulate([[-1,1][int(c)]for c in s]))+s.count(\'0\')\n``` | 7 | 0 | ['Python3'] | 0 |
flip-string-to-monotone-increasing | Picture Explanation || Java Recursion, and Memo and another fast Solution | picture-explanation-java-recursion-and-m-bl3g | \n\nRecursive Solution: (Gives TLE)\nbut forms the base for using dp\n\n\nclass Solution { \n private int solve(String s, int index, int prev){\n if(i | as-15 | NORMAL | 2023-01-17T11:22:56.609462+00:00 | 2023-01-17T11:42:52.102582+00:00 | 335 | false | \n\n**Recursive Solution: (Gives TLE)**\nbut forms the base for using dp\n\n```\nclass Solution { \n private int solve(String s, int index, int prev){\n if(index >= s.length())\n return 0;\n int flip = Integer.MAX_VALUE; \n int notFlip = Integer.MAX_VALUE;\n if(s.charAt(index) == \'0\'){\n if(prev == 0){\n flip = 1 + solve(s, index+1, 1);\n notFlip = 0 + solve(s, index+1, 0);\n }\n else{\n flip = 1 + solve(s, index+1, 1); \n } \n }\n else{\n if(prev == 0){\n flip = 1 + solve(s, index+1, 0);\n notFlip = 0 + solve(s, index+1, 1);\n }\n else{\n notFlip = 0 + solve(s, index+1, 1); \n } \n }\n return Math.min(flip, notFlip);\n }\n \n public int minFlipsMonoIncr(String s) {\n return solve(s,0,0);\n }\n}\n```\n\n**Memoized Solution**\n\n```\nclass Solution {\n \n private int solveMemo(String s, int index, int prev, int[][] dp){\n if(index >= s.length())\n return 0;\n if(dp[index][prev] != -1)\n return dp[index][prev];\n int flip = Integer.MAX_VALUE; \n int notFlip = Integer.MAX_VALUE;\n if(s.charAt(index) == \'0\'){\n if(prev == 0){\n flip = 1 + solveMemo(s, index+1, 1, dp);\n notFlip = 0 + solveMemo(s, index+1, 0, dp);\n }\n else{\n flip = 1 + solveMemo(s, index+1, 1, dp); \n } \n }\n else{\n if(prev == 0){\n flip = 1 + solveMemo(s, index+1, 0, dp);\n notFlip = 0 + solveMemo(s, index+1, 1, dp);\n }\n else{\n notFlip = 0 + solveMemo(s, index+1, 1, dp); \n } \n }\n return dp[index][prev] = Math.min(flip, notFlip);\n }\n \n public int minFlipsMonoIncr(String s) {\n int[][] dp = new int[s.length() + 1][2];\n for(int[] row : dp){\n Arrays.fill(row, -1);\n }\n return solveMemo(s,0,0,dp);\n }\n}\n```\n\n**Another Fast Solution:**\nIn case you are still reading:\n\n```\nclass Solution {\n public int minFlipsMonoIncr(String s) {\n int zeroes = 0;\n int ones = 0;\n for(char ch : s.toCharArray()){\n if(ch == \'0\'){\n zeroes++;\n }\n }\n int output = zeroes;\n for(char ch : s.toCharArray()){\n if(ch == \'0\'){\n zeroes--;\n }\n else if(ch == \'1\'){\n ones++;\n }\n output = Math.min(output, zeroes+ones);\n }\n return output;\n }\n}\n```\n\nPlease upvote if helpful. It will make my day :) | 7 | 0 | ['Dynamic Programming', 'Recursion', 'Memoization', 'Java'] | 1 |
flip-string-to-monotone-increasing | JAVA | Easy solution | Explained ✅ | java-easy-solution-explained-by-sourin_b-om2w | Please Upvote :D\n\njava []\nclass Solution {\n public int minFlipsMonoIncr(String s) {\n // variable \'flips\' will store the number of flips we will | sourin_bruh | NORMAL | 2023-01-17T09:07:14.152626+00:00 | 2023-01-17T13:04:14.543766+00:00 | 242 | false | # Please Upvote :D\n\n``` java []\nclass Solution {\n public int minFlipsMonoIncr(String s) {\n // variable \'flips\' will store the number of flips we will perform\n // variable \'ones\' will store the number of 1s\n // we initially want to flip 0s to 1s\n int flips = 0, ones = 0;\n int i = 0; \n\n // iterate till we surpass all prefix consecutive zeros\n // because they are already monotonic in nature, hence we won\'t disturb them\n // if we don\'t have any prefix 0s, i pointer will remain at the beginning\n while (i < s.length() && s.charAt(i) == \'0\') {\n i++;\n }\n\n // Now that we have left some prefix zeros (or even if we did\'t), \n // we will see how many 0s can be turned to 1s\n for (; i < s.length(); i++) {\n if (s.charAt(i) == \'0\') {\n flips++; // if its a 0, increment the count (We are trying to turn the 0s to 1s initially)\n } else { \n ones++; // if its a 1, increment the count\n }\n // if at any point we see that 0s are more in number than 1s, we change our decision\n // we will now try to flip 1s to 0s\n // so frequency of 1s would be our number of flips\n if (flips > ones) {\n flips = ones;\n }\n }\n\n return flips; // return the number of flips we can perform\n }\n}\n\n```\n---\n### Let\'s simplify our solution:\n- We can skip the part of surpassing the prefix consecutive 0s and begin from the 0th index. `ct0` will store the count of `0` and `ct1` will store the count of `1`.\n\n- We will treat `ct0` as the variable to store the number of flips.\n\n- We will initialy begin with the intention of flipping the 0s to 1s.\n\n- If at any point of time, the number of 0s become greater than the number of 1s, we will change our decision and we will try to flip the 1s to 0s. `ct0 = Math.min(ct0, ct1)` will take care of it.\n\n``` java []\nclass Solution {\n public int minFlipsMonoIncr(String s) {\n int ct0 = 0, ct1 = 0;\n for (char c : s.toCharArray()) {\n ct0 += (c == \'0\')? 1 : 0;\n ct1 += (c == \'1\')? 1 : 0;\n ct0 = Math.min(ct0, ct1);\n }\n\n return ct0;\n }\n}\n```\n---\n**Time Complexity:** $$O(n)$$ - Its a one pass algorithm.\n**Space Complexity:** $$O(1)$$ - We don\'t use any extra space. | 7 | 0 | ['String', 'Java'] | 0 |
flip-string-to-monotone-increasing | ✅C++| Simple O(n)|O(1) | 5 lines clear soln '✔✔ | c-simple-ono1-5-lines-clear-soln-by-xaho-bqnk | Intuition\n Describe your first thoughts on how to solve this problem. \nJust check if flipping into one\'s has minimum answer or flipping into zeroes and we al | Xahoor72 | NORMAL | 2023-01-17T06:28:53.410280+00:00 | 2023-01-17T14:04:26.227407+00:00 | 686 | false | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nJust check if flipping into one\'s has minimum answer or flipping into zeroes and we also want first 0\'s then 1\'s ,so we can check like this :\n- If we got a 1 just do nothing only store its occurence i.e do countOne++.\n- If we got a 0 increase 1 in flips counter .\n- Now, we got two options:\n 1. Either to flip the new `\'0\' to \'1\'` or\n 2. Flip all previous` \'1\'s to \'0\'s`.\n- So we will choose the one which is less i.e\n- Take the` min between flips and countOne`.\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:O(n)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:O(1)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\npublic:\n int minFlipsMonoIncr(string s) {\n int count1=0;\n int flips=0;\n for(auto x:s){\n if(x==\'1\')count1++;\n else{\n flips=min(++flips,count1);\n } \n }\n return flips;\n }\n};\n``` | 7 | 0 | ['C++'] | 3 |
flip-string-to-monotone-increasing | Go Greedy !! | go-greedy-by-yadivyanshu-033w | Approach\n Describe your approach to solving the problem. \nAt any \'i\', if count(1) < count(0), then increase your count(ans) by count(1) as at instance \'i\' | yadivyanshu | NORMAL | 2023-01-17T05:35:49.113473+00:00 | 2023-01-17T05:35:49.113524+00:00 | 65 | false | # Approach\n<!-- Describe your approach to solving the problem. -->\nAt any \'i\', if count(1) < count(0), then increase your count(ans) by count(1) as at instance \'i\' we are making all previous elements 0 and reinitialize the count variables.\n\nAnd at the end we are taking minimum of count(0) and count(1) to flip and add to the count(ans).\n\n# Complexity\n- Time complexity: O(N)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: O(1)\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```\nclass Solution {\npublic:\n int minFlipsMonoIncr(string s) {\n int n = s.length(), i = 0, cnt1 = 0, cnt0 = 0, ans = 0;\n while(i < n) {\n if(s[i++] == \'1\') cnt1++;\n else cnt0++;\n if(cnt1 < cnt0) {\n ans += cnt1;\n cnt1 = cnt0 = 0;\n }\n }\n return ans + min(cnt0, cnt1);\n }\n};\n``` | 7 | 0 | ['C++'] | 0 |
flip-string-to-monotone-increasing | Easiest Recursive Solution C++ | easiest-recursive-solution-c-by-asmitpap-x1qm | \nclass Solution {\npublic:\n \n int t[20005][2] ;\n \n int Solve(string &s , int i , bool ones)\n {\n if(i==s.size())\n return | asmitpapney | NORMAL | 2021-07-15T00:59:08.709764+00:00 | 2021-07-15T00:59:08.709790+00:00 | 281 | false | ```\nclass Solution {\npublic:\n \n int t[20005][2] ;\n \n int Solve(string &s , int i , bool ones)\n {\n if(i==s.size())\n return 0 ;\n \n if(t[i][ones]!=-1) \n return t[i][ones] ;\n \n if(s[i]==\'0\') // check if there is one before , if yes set it to zero else you may continue \n {\n if(ones==true){\n return t[i][ones] = 1+Solve(s,i+1,ones) ;\n }\n else\n return t[i][ones] = Solve(s,i+1,ones) ;\n }\n \n if(s[i]==\'1\') // check if there is one before , if yes then continue or else you can flip it\n {\n if(ones==true)\n return t[i][ones] = Solve(s,i+1,ones) ;\n else\n return t[i][ones] = min(1+Solve(s,i+1,ones) , Solve(s,i+1,true) ) ;\n }\n \n return -1;\n }\n \n int minFlipsMonoIncr(string s) {\n memset(t,-1,sizeof(t)) ;\n return Solve(s,0,false) ; \n }\n};\n``` | 7 | 0 | [] | 1 |
flip-string-to-monotone-increasing | Java clean solution with explanation | java-clean-solution-with-explanation-by-9fg3x | \nclass Solution {\n public int minFlipsMonoIncr(String s) {\n int flipCount = 0, oneCount = 0;\n for (int i = 0; i < s.length(); i++) {\n | akiramonster | NORMAL | 2020-01-28T16:55:35.298694+00:00 | 2020-01-28T16:55:35.298728+00:00 | 342 | false | ```\nclass Solution {\n public int minFlipsMonoIncr(String s) {\n int flipCount = 0, oneCount = 0;\n for (int i = 0; i < s.length(); i++) {\n char c = s.charAt(i);\n if (c == \'0\') {\n if (oneCount == 0) continue; // if all beginning char is zero, no need to flip\n else flipCount++; // flip 0 -> 1\n } else {\n oneCount++; // flip 1 -> 0\n }\n if (flipCount > oneCount) { // if flip 0-> 1 greater than flip 1 -> 0 then \n flipCount = oneCount; // then we choose flip 1 -> 0 for the left part\n }\n }\n return flipCount;\n }\n}\n``` | 7 | 0 | [] | 0 |
flip-string-to-monotone-increasing | Java DP easy to understand | java-dp-easy-to-understand-by-grhb-56i3 | \npublic int minFlipsMonoIncr(String S) {\n int l = S.length();\n int[] f = new int[l];// f[i] means flips need for substring S[0..i]\n f[0 | grhb | NORMAL | 2019-02-20T03:48:26.222687+00:00 | 2019-02-20T03:48:26.222727+00:00 | 431 | false | ```\npublic int minFlipsMonoIncr(String S) {\n int l = S.length();\n int[] f = new int[l];// f[i] means flips need for substring S[0..i]\n f[0] = 0;//no matter \'0\' or \'1\', no need to flip\n int numOne = S.charAt(0) == \'1\' ? 1 : 0;\n for(int i = 1; i<l; i++){\n if(S.charAt(i) == \'1\'){\n f[i] = f[i-1];//no flip i needed \n numOne++;\n }else{\n f[i] = Math.min(numOne, f[i-1] +1);//(no flip i and change all previous 1\'s to 0\'s) vs. flip i to 1\n }\n }\n return f[l-1];\n }\n``` | 7 | 0 | [] | 1 |
flip-string-to-monotone-increasing | Python 148ms solution beaten by 92% - three passes, but DEAD SIMPLE | python-148ms-solution-beaten-by-92-three-dwia | For each i, find # of 1s to its left. (first pass) For each i, find # of 0s to its right. (second pass) For each i, sum of 1s to its left and 0s to its right is | lawrence7 | NORMAL | 2018-10-24T07:29:54.777596+00:00 | 2018-10-24T14:50:04.555660+00:00 | 493 | false | For each i, find # of 1s to its left. (first pass)
For each i, find # of 0s to its right. (second pass)
For each i, sum of 1s to its left and 0s to its right is the # of flips required. A third pass to find minimum.
```
class Solution:
def minFlipsMonoIncr(self, S):
"""
:type S: str
:rtype: int
"""
l1 = [0] * len(S)
r0 = [0] * len(S)
l = 0
r = 0
for i in range(len(S)):
l1[i] = l
if S[i] == "1":
l += 1
for i in range(len(S)-1, -1, -1):
r0[i] = r
if S[i] == "0":
r += 1
m = 30000
for i in range(len(S)):
m = min(m, l1[i] + r0[i])
return m
``` | 7 | 0 | [] | 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.