That’s the explanation that I was looking for. Thanks man!

Great video! One point to note regarding the bandwidth reduction through video chunking-while this won't actually save bandwidth, it does make the system more resilient. Clients can perform parallel operations, enable progressive loading, etc. However, the QPS will likely increase due to multiple requests for the same video (which, as mentioned at the end, can be managed by a CDN).

Comment for the algo. Thanks for the great content !

But calculating prefix sum takes Time Complexity-->O(n) : as you traverse throughout the array to calculate Space Complexity --> O(n) as you are taking an array prefix sum of size 'n' 1st approach has time complexity --> O(n) with constant space I think the first approach is better yah prefix sum is helpful in many other problems I think not in this as the first one itself has lesser time and space complexity 🤔

Great video! Go ahead with the system design

Hi at 14:55, the calculation of the # of servers are based on the QPS(RPS) and Server Capacity. Technically, how did you come up with the 100 for the server capacity? What is the based assumed parameters used for the server capacity? I get that there are research for a specs for a particular AWS EC2 instance based on its max QPS, but in this example, what are the basis for the assumption of 100? Thanks.

Great video! One thing I noticed at 22:19: shouldn't the video QPS increase by the extra requests we are now making to upload the videos in chunks?

Great video. Saved for my future preference. :D

hey can u clarify, why is visited array is reqd when we r already tracking currentVisitedNodes in a set, cant we use that?

Great video. Thanks!

what are the alternative solutions?

Thankk youu

Nice Explanation Expecting more like this Content

you didn't take into count, even and odd number of elements. There will be a case where fast.next.next will give NullPointer, we need to have that check

I am your 400th subscriber, keep growing, we will support you, thank for the video, keep it up

thanks a lot it was a clear explanation

that was really helpful

Great explanation ❤

Thank you❤

Excellent explanation. Keep it going

amazing explanation!

Generally a great video. I think it would help the viewers if you explain in the code section why you have +1 for the target.

One more short solution: class Solution(object): def countElements(self, nums): min_el = min(nums) max_el = max(nums) return sum(1 for num in nums if min_el < num < max_el)

Here is one more ineresting solution: class Solution: # Time Complexity: O(n) # Space Complexity: O(1) def numPairsDivisibleBy60(self, time: List[int]) -> int: remainder_counts = [0] * 60 count = 0 for t in time: remainder = t % 60 if remainder == 0: count += remainder_counts[0] else: count += remainder_counts[60 - remainder] remainder_counts[remainder] += 1 return count

Example on Python (using sorting): from collections import Counter class Solution: def frequencySort(self, s: str) -> str: # Count character frequencies using Counter char_counts = Counter(s) # Sort characters by frequency (descending) and then by character sorted_chars = sorted(char_counts.items(), key=lambda item: (-item[1], item[0])) # Build the result string character by character result = [] for char, count in sorted_chars: result.append(char * count) return ''.join(result)

Example on Python (using priority queue): from collections import Counter class Solution: def frequencySort(self, s: str) -> str: # Count character frequencies using Counter char_counts = Counter(s) # Create a min-heap to store (frequency, character) tuples min_heap = [(-count, char) for char, count in char_counts.items()] heapq.heapify(min_heap) # Build the min-heap # Build the result string character by character result = [] while min_heap: count, char = heapq.heappop(min_heap) result.append(char * -count) # Append character repeated by its count return ''.join(result) # Join the characters from the result list

Solution in Python: from collections import Counter class Solution: def topKFrequent(self, nums: List[int], k: int) -> List[int]: # Creating the counter: O(n), where n is the length of the nums list. # Building the heap and extracting elements: O(k log n) using heapq.nlargest. # Overall: O(n + k log n) which is approximately O(n log n) in most cases since k # is typically much smaller than n. counter = Counter(nums) # The counter dictionary: O(n) in the worst case (all elements are unique). # The heap created by nlargest: O(k). # Overall: O(n + k), which is also approximately O(n) in most cases due to the smaller value of k. return heapq.nlargest(k, counter.keys(), counter.get)

after hours of searching found the perfect video

It's because of you that i finally understand this question...Love from india!

You really deserve more view ❤

Nice explanation

Python doesn’t have red black tree api to get floor & ceil keys ?

It must be noted that you can only remove the second loop is k is fixed, if k can change you will have the same time complexity of O(k(n-k))

A code example would be nice

I think its a bit misleading to say that the naive algorithm has a Time Complexity of O(n²), as the runtime depends on the array size n and the number of consecutive elements k. So as the array size would increase and k stays constant the algorithm would actually have a linear runtime, but if both increase the total time Complexity would increase quadratically. Which of course the second algorithm solves.

Good video

Is this any different from just indexing the strings to compare them?

I liek 👍

Brilliant explanation

Great Job sir