Minimum Swaps to Group All 1's Together II - Leetcode 2134 - Python

[@peacefulcat3578]

0:57 In the example "0101101", you actually only need 1 swap to make "0001111" or "0111100".

[@tuandino6990]

My dumb ass brain stopped functioning and thought we can only do swap between two adjacent number and waste 1 hour on this problem...

[@jayjw1]

nah its not you, this problem is a bit evil for the beginning of the month lmao

[@blackbeard3449]

I also thought so. 😢

[@swarajandhale4088]

Same here man

[@akshatharlalka5334]

Not one hours for me but a good 20 mins.

[@finemechanic]

You can go from 2*N iterations to N + total_ones: calculate ones in the window nums[:total_ones] and then move your window of constant size from 0 to N-1.

[@mudit7394]

holy shit this is so easy when you explained it lol. I tried the greedy approach and it worked until it failed for the test case lol ur approach is amazin

[@arnavchauhan9637]

great explanation sir! Fun Fact: we can skip the if statement to add 1 as the array only contains 1 and 0 so if we blindly take sum+=arr[i] it will work same i guess :/ but anyways what a great guy!!

[@md_pedia1]

Another approach: (using sliding windows ofc) total_ones=nums.count(1) l=0 nums.extend(nums[:total_ones-1]) zero_cnt=0 res=float("inf") for r in range(len(nums)): zero_cnt+=not(nums[r]) if (r-l+1)==total_ones: res=min(res,zero_cnt) zero_cnt-=not(nums[l]) l+=1 return res if res!=float("inf") else 0

[@qulinxao]

l,f=len(n),sum(n); o=t=sum(n[:f]) for i,v in enumerate(n,f): o=max(o,t:=t+n[i%l]-v) return f-o

[@michaelroditis1952]

the left pointer needs to go only up to N-1 the for loop should be this: for r in range(N+total_ones) That way the "l" doesn't need mod, and it's faster for large N and small total_ones

[@qulinxao]

l,f=len(n),sum(n); o=t=sum(n[:f]) for i,v in enumerate(n,f): o=max(o,t:=t+n[i%l]-v) return f-o

[@sundew_ii]

this one was tough :p

[@MacintoshPlus1MB]

this is one of the greatest explanations ever

[@pastori2672]

the hints of this of this problem are pretty good they gave like 5 hints and the second hint gives it all away

[@rliu2]

i think a better idea would be realizing that by grouping 1s tgt, 0s would be group tgt too, so you just keep track of cnt of 0s for the respective 0 wnd too.

[@rliu2]

and you just take the min of the two ans

[@adityamaharshi2320]

For the circular part I tries consolidating zeros instead of ones , since if zeros are linearly together , ones also must be together , circular or otherwise.

[@AKProductionsTelugu]

It felt to easy yet amazing after watching the first 3 minutes of your video ❤❤ i was able to solve it

[@ganeshjaggineni4097]

NICE SUPER EXCELLENT MOTIVATED

[@jamestwosheep]

You probably could've made your run time a little more quicker if you exited the loops once the left pointer exceeds the length of the original array instead of going the full 2N. But yeah, this one was a doozy - I don't think I would have gotten it without the hints that they gave.

[@peacefulcat3578]

I was staring at this problem for 10 mins. Thinking about the intervals, and how to calculate average distance between dots......

[@galkk3]

my solution, more consice and the loop is running N + # of 1's: def minSwaps(self, nums: List[int]) -> int: total = sum(nums) right = total if right == len(nums): return 0 maxSub = sum(nums[:total]) window = maxSub for left in range(len(nums)): window = window - nums[left] + nums[right] maxSub = max(maxSub, window) right = (right + 1) % len(nums) return total - maxSub

[@qulinxao]

l,f=len(n),sum(n); o=t=sum(n[:f]) for i,v in enumerate(n,f): o=max(o,t:=t+n[i%l]-v) return f-o

[@vishaalkumaranandan2894]

The % idea was really brilliant

[@gmh14]

The reason why we never saw a Minimum Swaps to Group All 1's Together I is because it is premium-only. i guess it's the same problem without circular edge case

[@Codisrocks]

Another little tweak, you only have to check the max when you add another one at your right pointer.

[@chien-yuyeh9386]

Thanks for sharing!

[@MaheshKumar-mh9mj]

in line 7 we can just got til n+totalOnes . 2*n is not required

[@adamtawfik6337]

Thank you

[@user-sx7zc3ez4w]

Everyday thank you

[@haidang2452]

Thank you for sharing. You can apply Sliding Window for counting minimum 0 in K window def minSwaps(self, nums: List[int]) -> int: """ Calculate minimum sliding window for 0 """ k = nums.count(1) numZero = nums[:k].count(0) ans = numZero n = len(nums) for R in range(k, 2*n): if nums[R%n] == 0: numZero +=1 if nums[(R-k)%n] == 0: numZero -= 1 ans = min(ans, numZero) return ans

[@qulinxao]

l,f=len(n),sum(n); o=t=sum(n[:f]) for i,v in enumerate(n,f): o=max(o,t:=t+n[i%l]-v) return f-o

[@Badrsh-tk4cd]

Can you solve the ready-made function in the list? Or is it forbidden?

[@GryffindorKnowledgeSeeker]

How'd you know this solution would work?

[@mohamedsayed8697]

You consider it against all possible cases. You devise cases and say to yourself that this solution must return this valid value if it works properly and if it don't, then something is wrong with the solution (using counter-examples).

[@ajitpalsingh606]

Coded on my own

[@strangerlois7307]

Why we need window one, max_window_ones?

[@kapilkhandelwal48]

I thought it would be a cakewalk

[@raviyadav2552]

I couldn't even solve it using brute force and wasted an hour

[@riddles4013]

4:12 🤔🤔

[@SonuKumar-q5o1b]

why neetcode website not able to open??????? i am facing issue from last 3-4 days

[@v0nnyboy]

surprisingly ... i did not find this tough at all ! Simple sliding window.. with double the array size ! easy def minSwaps(self, nums: List[int]) -> int: ones = nums.count(1) double = nums+nums ct = nums[:ones].count(1) maxx = ct l=0 for i in range(ones,len(double)): if double[i]==1: ct+=1 if double[l]==1: ct-=1 maxx = max(ct,maxx) l+=1 return ones - maxx

[@qulinxao]

l,f=len(n),sum(n); o=t=sum(n[:f]) for i,v in enumerate(n,f): o=max(o,t:=t+n[i%l]-v) return f-o

[@avinavkashyap8802]

@neeetcode where to apply for the interview

[@fabricio5p]

I hate "guess the trick" questions

[@qulinxao]

l,f=len(n),sum(n); o=t=sum(n[:f]) for i,v in enumerate(n,f): o=max(o,t:=t+n[i%l]-v) return f-o

[@hasferrr]

i hate circular array