https://leetcode.com/problems/contains-duplicate-ii/

Code:

class Solution:
    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
        # window = k
        seen_in_window = set()
        for i in range(len(nums)):
            if i>k:
                seen_in_window.discard(nums[i-k-1])
            if nums[i] in seen_in_window:
                return True
            else:
                seen_in_window.add(nums[i])
        return False

Key Points:

Problem in Simple Words

You are given an array of numbers and an integer k. You must check whether there are two equal numbers such that:

• Their indices differ by at most k

In short:

Same value + close enough positions → return True

Example:

• nums = [1,2,3,1], k = 3 → True

• nums = [1,0,1,1], k = 1 → True

• nums = [1,2,3,1,2,3], k = 2 → False

Core Idea (Sliding Window + Set)

We only care about duplicates within distance k. So we maintain a sliding window of size k using a set.

The set always stores:

• the last k elements we have seen

How the Algorithm Works

• Traverse the array from left to right

• For each index i:

  1. If the window size exceeds k:

     • Remove the element that just moved out of the window
       (nums[i - k - 1])

  2. Check if the current number already exists in the window:

     • If yes → duplicate within range → return True

     • If no → add it to the window

If we finish the loop without finding duplicates → return False

Why Removing nums[i - k - 1] Is Important

• It keeps the window size limited to k

• Ensures we only compare elements whose index difference ≤ k

• Prevents false positives from far-away duplicates

Why a Set Is Perfect Here

• Fast lookup: O(1)

• No duplicate storage

• Automatically tracks what’s inside the current window

Why This Works

At any index i, the set contains exactly the elements from: indices: [i - k, i - 1]

So if nums[i] is already in the set:

• There exists some j where:

  • nums[i] == nums[j]

  • |i - j| ≤ k

Which is exactly the condition asked.

Edge Cases Covered

• k = 0 → window always empty → always False

• Array with no duplicates → False

• Duplicate values but too far apart → correctly ignored

Complexity

• Time: O(n)

• Space: O(k)

Key Insight to Remember

Whenever a problem says:

“same value within a distance constraint”

👉 Think sliding window + set, not brute force.

https://leetcode.com/problems/rearrange-array-elements-by-sign/

Code:

class Solution:
    def rearrangeArray(self, nums: List[int]) -> List[int]:
        non_neg_nums = []
        neg_nums = []
        result = []

        # Segregated non-negs and negs
        for num in nums:
            if num>=0:
                non_neg_nums.append(num)
            else:
                neg_nums.append(num)

        # thinking to use zip for corresponding pairs
        for pos, neg in zip(non_neg_nums, neg_nums):
            result.append(pos)
            result.append(neg)

        return result

Key Points:

Problem in Simple Words

You are given an array with:

• equal number of positive (or zero) and negative numbers

You must rearrange the array so that:

• elements alternate by sign

• a non-negative number comes first

• the relative order within positives and negatives is preserved

Example:

• [3,1,-2,-5,2,-4] → [3,-2,1,-5,2,-4]

Core Idea (Separate → Then Interleave)

The idea is very simple and clean:

1. Separate the numbers by sign

2. Interleave them one by one in the required order

This avoids complex index juggling.

How the Solution Works

1. Traverse the array once:

   • Store all non-negative numbers in non_neg_nums

   • Store all negative numbers in neg_nums

2. Since the problem guarantees equal counts:

   • Use zip(non_neg_nums, neg_nums)

3. For each (pos, neg) pair:

   • Append pos

   • Append neg

4. The resulting list automatically follows:

   • non-negative, negative, non-negative, negative…

Why zip Is a Good Choice

• It pairs elements one-to-one

• Stops automatically at correct length

• Makes the code concise and readable

• Guarantees correct alternation

Why This Approach Is Correct

• Order inside positives is preserved

• Order inside negatives is preserved

• Alternating pattern is guaranteed

• Simple logic, no tricky pointer bugs

Edge Cases Covered

• All constraints guarantee valid input (equal positives & negatives)

• Zero is treated as non-negative (as required)

Complexity

• Time: O(n)

• Space: O(n) for temporary lists

Key Insight to Remember

Whenever a problem asks for:

“rearrange elements by categories but preserve order”

👉 Think segregate first, then merge/interleave.

https://www.geeksforgeeks.org/problems/leaders-in-an-array-1587115620/1

Code:

class Solution:
    def leaders(self, arr):
        leads = []
        n = len(arr)
        maximum = arr[-1] # till will handle negatives

        # we will collect the max seen so far from right

        for i in range(n-1, -1, -1):
            if arr[i]>=maximum:
                maximum=arr[i]
                leads.append(maximum)
        return leads[::-1]

# Below Solution is correct/brute-force, does O(n^2), very witty but not optimised
# class Solution:
#     def leaders(self, arr):
#         leaders = []

#         n=len(arr)

#         if n<2:
#             return arr

#         # Traverse trrough array
#         for traverser in range(n):
#             i=traverser+1 # i = next index
#             # check till right end, from present index
#             while i<n:
#                 if arr[i] > arr[traverser]:
#                     break
#                 i+=1

#             if i==n:
#                 leaders.append(arr[traverser])

#         return leaders

Key Points:

Problem in Simple Words

An element in an array is called a leader if:

• It is greater than or equal to all elements to its right

• The rightmost element is always a leader

Example:

• [16, 17, 4, 3, 5, 2] → leaders = [17, 5, 2]

Core Idea (Scan from Right, Track Maximum)

Instead of checking every element against all elements to its right, we scan the array from right to left and keep track of the maximum seen so far.

Why this works:

• When moving right → left, everything to the right is already known

• If the current element is ≥ max_so_far, it must be a leader

How the Optimized Solution Works

1. Start from the rightmost element

   • It is always a leader

   • Initialize maximum = arr[-1]

2. Move left one element at a time:

   • If arr[i] ≥ maximum: → it is a leader → update maximum → add it to the leaders list

3. Since leaders are collected from right to left:

   • Reverse the list before returning

Why Initializing maximum = arr[-1] Is Important

• Handles negative numbers correctly

• Ensures first comparison is valid

• Avoids incorrect assumptions like starting from 0

Why This Is Better Than Brute Force

Brute-force approach:

• For each element, scan all elements to its right

• Time complexity: O(n²)

Optimized approach:

• Single pass from right to left

• Time complexity: O(n)

Edge Cases Covered

• Single element array → that element is the leader

• All elements decreasing → all are leaders

• Negative values → handled correctly

Complexity

• Time: O(n)

• Space: O(k) for leaders list

Key Insight to Remember

Whenever a problem says:

“compare each element with everything to its right”

👉 Try reverse traversal + running maximum instead of nested loops.

https://leetcode.com/problems/intersection-of-two-arrays/

Code:

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        result = set()
        n2 = set(nums2)

        for num in nums1:
            if num in n2:
                result.add(num)

        return list(result)

# olution below is brute force, not optimised, sol above uses set effectively to make overall sol more optimized.
# class Solution:
#     def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
#         result = set()
#         for i in range(len(nums1)):
#             for j in range(len(nums2)):
#                 if nums1[i] ^ nums2[j] == 0:
#                     result.add(nums1[i])
#         return list(result)

Key Points:

Problem in Simple Words

You are given two arrays. You need to return all numbers that appear in both arrays.

• Each number should appear only once in the result

• Order does not matter

Example:

• nums1 = [1,2,2,1], nums2 = [2,2] → [2]

• nums1 = [4,9,5], nums2 = [9,4,9,8,4] → [4,9]

Core Idea (Use Sets for Fast Lookup + Uniqueness)

We use sets because they:

• Automatically remove duplicates

• Allow very fast membership checking (O(1) average)

How the Optimized Solution Works

1. Convert nums2 into a set:

   • This makes checking “is this number present?” very fast

2. Loop through each number in nums1:

   • If the number exists in the set made from nums2: → add it to the result set

3. Convert the result set to a list and return it

Why We Use a Set for nums2

• Checking num in nums2_list would take O(n) time

• Checking num in nums2_set takes O(1) time

• This reduces overall time significantly

Why the Result Is Also a Set

• The problem requires unique values only

• Set automatically ensures no duplicates in the result

Why This Is Better Than Brute Force

Brute force:

• Compare every element of nums1 with every element of nums2

• Time complexity: O(n × m)

Optimized approach:

• One pass with fast lookups

• Much more efficient for large inputs

Edge Cases Covered

• No common elements → empty list returned

• One or both arrays empty → empty list returned

• Duplicate values in input → handled automatically

Complexity

• Time: O(n + m)

• Space: O(m + k)

  • m = size of nums2 (set)

  • k = size of intersection set

Key Insight to Remember

Whenever a problem asks for:

“common elements” + “unique values”

👉 Think set + membership checking, not nested loops.

https://leetcode.com/problems/repeated-substring-pattern/

Code:

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        return s in (s + s)[1:-1]

        # Points to note:
        # - A repeated string will reappear inside its own doubled version (minus edges).
        # - If s is made by repeating a substring. Then s must appear inside (s + s) after removing first & last chars
        # - First anf Last characters are removed. This removes the trivial full-string match.

# Below is a good solution but time comlexity for worst case is still O(n^2) due to new string formations everytime.
# class Solution:
#     def repeatedSubstringPattern(self, s: str) -> bool:
#         n = len(s)
#         result=""
#         i=1
#         while i<=n//2:
#             sub_str = s[:i]
#             factor = n//i
#             result = sub_str * factor
#             i+=1
#             if result == s:
#                 return True
#         return False

Key Points:

Problem in Simple Words

You are given a string s. Check if it can be formed by repeating one of its substrings multiple times.

Example:

• "abab" → "ab" repeated → True

• "aba" → cannot be repeated → False

• "aaaa" → "a" repeated → True

Core Idea (Smart String Trick)

If a string is made by repeating a smaller substring, then:

• It will appear inside its own doubled version (s + s)

• But we must remove the first and last characters to avoid a trivial full match

So:

• Check whether s exists inside (s + s)[1:-1]

If yes → string is built by repetition
If no → it is not

Why Removing First & Last Characters Is Important

• s + s always contains s as a full match at the start and end

• Removing the edges forces us to detect only true internal repetitions

• This eliminates false positives

Why This Works

• Repeated patterns naturally shift and overlap in the doubled string

• Non-repeated strings cannot fully reappear once edges are removed

• This trick avoids checking every possible substring

Complexity

• Time: O(n)

• Space: O(n)

Key Points for the Substring Construction Approach (Commented Solution)

Core Idea (Try All Possible Substrings)

If s is made by repeating a substring:

• That substring’s length must be a divisor of len(s)

• The substring must start from index 0

• Repeating it enough times should recreate the full string

So we:

• Try all possible substring lengths from 1 to n // 2

• Check if repeating that substring forms the original string

How the Logic Works

1. Let n = len(s)

2. For each possible substring length i (from 1 to n//2):

   • Take sub_str = s[:i]

   • Calculate how many times it must repeat:

     • factor = n // i

   • Build a new string by repeating:

     • sub_str * factor

3. Compare this newly formed string with s

   • If equal → repeated pattern exists → return True

4. If no substring works → return False

Why We Only Check Up to n//2

• A repeating substring must be smaller than the full string

• Any substring longer than n//2 can repeat at most once → not useful (in simple words, if length of a substring is more than half of the length of string, then it cannot even double itself, forget, it repeats multiple times in the string)

Why This Approach Is Correct

• Every valid repeated pattern must start from index 0

• Trying all possible substring lengths ensures we don’t miss any case

• Direct comparison guarantees correctness

Why This Approach Is Slower

• Each repetition creates a new string

• In worst case:

  • We try O(n) substring lengths

  • Each string creation + comparison costs O(n)

• Overall worst-case time: O(n²)

When This Approach Is Still Useful

• Easy to understand

• Good for learning / brute-force reasoning

• Works fine for small strings

Complexity

• Time: O(n²) in worst case

• Space: O(n) due to new string creation

Key Insight to Remember

This method focuses on:

“Try every possible repeating block and rebuild the string”

It’s intuitive and correct — but not optimal compared to the
(s + s)[1:-1] trick, which achieves O(n) time.

https://leetcode.com/problems/missing-number/

Code:

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        n = len(nums)
        actual_sum = sum(nums)
        expected_sum = (n * (n + 1))//2 # including the missing number
        missing_number = expected_sum - actual_sum # common sense, diff -> missing number
        return missing_number

# This one is the 2nd best solution, good but space can still be optimised and made from O(n) to O(1)
# class Solution:
#     def missingNumber(self, nums: List[int]) -> int:
#         numbers = set(nums)
#         for i in range(0, len(nums)+1):
#             if i not in numbers:
#                 return i

# class Solution:
#     def missingNumber(self, nums: List[int]) -> int:
#         for number in range(0, len(nums)+1):
#             if number not in set(nums):
#                 return number

# =============

# class Solution:
#     def missingNumber(self, nums: List[int]) -> int:
#         numbers = set(range(len(nums)+1))
#         for n in numbers:
#             if n not in nums:
#                 return n

# ===========

# class Solution:
#     def missingNumber(self, nums: List[int]) -> int:
#         n = len(nums)
#         for number in range(n+1):
#             if not number in nums:
#                 return number

Key Points:

Problem in Simple Words

You are given an array containing n distinct numbers. The numbers are from the range 0 to n, but one number is missing. You must find and return that missing number.

Example:

• [3,0,1] → missing number = 2

• [0,1] → missing number = 2

Core Idea (Math Trick: Expected Sum vs Actual Sum)

If no number were missing, the sum of numbers from 0 to n would be:

0 + 1 + 2 + ... + n = n × (n + 1) / 2

So:

• Expected sum = sum of all numbers from 0 to n

• Actual sum = sum of numbers present in the array

The difference between these two sums is exactly the missing number.

How the Solution Works

1. Let n = len(nums)

2. Compute:

   • expected_sum = n × (n + 1) // 2

3. Compute:

   • actual_sum = sum(nums)

4. The missing number is:

   • expected_sum - actual_sum

This works because:

• Every number except one appears exactly once

• All other values cancel out in the subtraction

Why This Approach Is Optimal

• Only one pass over the array

• No extra data structures

• Clean mathematical reasoning

Edge Cases Covered

• Missing number is 0

• Missing number is n

• Array in any order

Complexity

• Time: O(n)

• Space: O(1)

Key Insight to Remember

Whenever you see:

“numbers from 0 to n with exactly one missing”

👉 Think sum formula or XOR trick instead of sets or loops.

https://leetcode.com/problems/second-largest-digit-in-a-string/

Code:

class Solution:
    def secondHighest(self, s: str) -> int:
        dgts = set()
        for ch in s:
            if ch.isdigit():
                dgts.add(int(ch)) 
        # now we have all unique digits

        # if dgts has 1 or no value, there can be no 2nd largest
        if len(dgts)<=1:
            return -1

        # if control come here, it has sufficient values
        # remove the max digit
        dgts.remove(max(dgts))
        return max(dgts)

# class Solution:
#     def secondHighest(self, s: str) -> int:
#         dgts = []
#         for ch in s:
#             if ch.isdigit():
#                 dgts.append(int(ch))

#         if not dgts:
#             return -1

#         dgts = set(dgts)
#         dgts.remove(max(dgts))

#         if len(dgts)<1:
#             return -1
#         else:
#             return max(dgts)

Key Points:

Problem in Simple Words

You are given a string that may contain letters and digits. You need to find the second largest digit that appears in the string.

• Digits are from 0 to 9

• Digits must be distinct

• If there is no second largest digit → return -1

Example:

• "dfa12321afd" → digits = {1,2,3} → second largest = 2

• "abc111" → only one digit → return -1

Core Idea (Use a Set for Unique Digits)

We only care about:

• digits, not letters

• unique digits, not duplicates

So the best structure is a set:

• Automatically removes duplicates

• Makes it easy to find max values

How the Solution Works

1. Traverse the string character by character

2. If the character is a digit:

   • Convert it to int

   • Add it to a set

3. After traversal:

   • If the set has 0 or 1 element → no second largest → return -1

4. Otherwise:

   • Remove the largest digit

   • The new maximum is the second largest digit

   • Return it

Why Removing the Maximum Works

• After removing the largest digit,

• the largest remaining digit is automatically the second largest overall

• No sorting is needed

Why This Approach Is Efficient

• Set ensures uniqueness without extra checks

• We scan the string only once

• Operations like max() on a small set (digits 0–9) are very fast

Edge Cases Covered

• No digits in string → return -1

• Only one unique digit → return -1

• Multiple same digits → handled by set

Complexity

• Time: O(n), where n = length of string

• Space: O(1), because at most 10 digits (0–9) can be stored

Key Insight to Remember

Whenever a problem asks for:

“largest / second largest unique value”

👉 Think set + remove max, instead of sorting everything.

https://leetcode.com/problems/merge-sorted-array/description/

Code:

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        i = m - 1
        j = n - 1
        write = m + n - 1

        while j>=0: # will loop till all nums2 numbers are placed
            if i>=0 and nums1[i]>nums2[j]: # i>0, if imp as nums1 can finish before nums2
                nums1[write]=nums1[i]
                i-=1
            else:
                nums1[write]=nums2[j] # if nums2 is lenthier, then remaining can get copied here
                j-=1
            write-=1

# class Solution:
#     def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
#         """
#         Do not return anything, modify nums1 in-place instead.
#         """
#         for i in range(n):
#             nums1[m+i]=nums2[i]
#         nums1.sort()

Key Points:

Problem in Simple Words

You are given two sorted arrays:

• nums1 has size m + n

  • First m elements are valid numbers

  • Last n elements are empty (0s as placeholders)

• nums2 has n valid numbers

You must merge nums2 into nums1 so that:

• The final nums1 is sorted

• The merge is done in-place

• Nothing is returned

Core Idea (Fill from the End)

Since both arrays are already sorted:

• The largest numbers are at the end

• And nums1 already has empty space at the end

So instead of merging from the front (which would overwrite values), we fill nums1 from the back.

How the Pointers Work

We use three pointers:

• i → last valid element in nums1 (m - 1)

• j → last element in nums2 (n - 1)

• write → last position in nums1 (m + n - 1)

At each step:

• Compare nums1[i] and nums2[j]

• Put the larger one at nums1[write]

• Move the corresponding pointer backward

• Decrease write

👉 Key Insight
At every step, either i or j moves — never both.
The pointer that does not provide the value stays where it is,
so its element can still be compared in the next step.

This guarantees:

• No element is skipped

• Every element is placed exactly once

Why the Loop Runs While j >= 0

• All elements of nums2 must be placed

• If nums1 finishes early (i < 0):

  • Remaining elements of nums2 are copied directly

• If nums2 finishes first:

  • Remaining nums1 elements are already in correct place

Why This Works

• We never overwrite useful data in nums1

• We always place the correct largest value first

• Sorting is preserved naturally

Why This Is Better Than Sorting Again

Alternative approach:

• Copy nums2 into nums1

• Sort nums1

That works but:

• Slower (O((m+n) log (m+n)))

• Ignores the fact that arrays are already sorted

This approach:

• Uses the sorted property fully

• Runs in linear time

Complexity

• Time: O(m + n)

• Space: O(1) (in-place)

Key Insight to Remember

When merging into an array with extra space at the end: 👉 Always merge from the back, not from the front.

https://www.geeksforgeeks.org/problems/cyclically-rotate-an-array-by-one2614/1

Code:

class Solution:
    def rotate(self, arr):
        arr.insert(0, arr[-1])
        del arr[-1]
        return arr

# Below solution creates a new list, caller may not be clling new list but may be using original list.
# So it is important to change the list in place
# class Solution:
#     def rotate(self, arr):
#         rotated_arr = [arr.pop()]
#         rotated_arr.extend(arr)
#         print(rotated_arr)
#         return rotated_arr

Key Points:

Problem in Simple Words

You are given an array. You need to rotate it to the right by one position, meaning:

• The last element moves to the front

• All other elements shift one position to the right

• The rotation must be done in-place

Example:

• [1, 2, 3, 4, 5] → [5, 1, 2, 3, 4]

Core Idea (In-Place Rotation)

We only need two simple steps:

1. Take the last element

2. Put it at the front of the array

This achieves the required cyclic rotation.

How the Solution Works

• arr[-1] gives the last element

• arr.insert(0, arr[-1]) inserts it at index 0

• del arr[-1] removes the extra copy at the end

After these steps:

• Array is rotated correctly

• The original array is modified in-place

Why In-Place Matters

• Some callers expect the same array object to be updated

• Creating a new list may break that expectation

• This solution respects the problem requirement

Why This Works

• Python lists support fast insert/delete by index

• Logic directly matches the definition of cyclic rotation

Complexity

• Time: O(n)
  (inserting at the front shifts elements)

• Space: O(1)
  (no extra array created)

Key Insight to Remember

When a problem explicitly says:

“Rotate the array in-place”

👉 Always modify the original list, not a new one.

https://leetcode.com/problems/check-if-string-is-a-prefix-of-array/description/

Code:

class Solution:
    def isPrefixString(self, s: str, words: List[str]) -> bool:
        index=0
        for word in words:
            if not s.startswith(word, index):
                return False

            index+=len(word)

            if len(s) == index:
                return True
        return False

# class Solution:
#     def isPrefixString(self, s: str, words: List[str]) -> bool:
#         index=0
#         for word in words:
#             if not s.startswith(word, index):
#                 return False

#             index+=len(word)

#             if len(s) == index:
#                 break
#         return len(s) == index

# Below solution will take more space
# class Solution:
#     def isPrefixString(self, s: str, words: List[str]) -> bool:
#         building_phrase=""
#         for word in words:
#             building_phrase+=word
#             if s == building_phrase:
#                 return True
#         return False

Key Points:

Problem in Simple Words

You are given:

• a string s

• an array of strings words

You must check whether s can be formed by joining the first few words from the array in order. You cannot skip words or rearrange them.

Example:

• s = "leetcode", words = ["leet","code","hello"] → True

• s = "applepie", words = ["apple","pear","pie"] → False

Core Idea (Match Step-by-Step Using an Index)

Instead of building a new string, we:

• Walk through s using an index

• Match each word from words exactly at the current index

This avoids extra memory and keeps the logic clean.

How the Algorithm Works

• Start with index = 0 (beginning of string s)

• For each word in words:

  • Check if s starts with word at position index

  • If not → mismatch → return False

  • If yes:

    • Move index forward by len(word)

  • If index == len(s):

    • We matched all characters of s exactly → return True

Why startswith(word, index) Is Important

• It ensures the word matches exactly where we are currently pointing

• Prevents partial or misplaced matches

• Guarantees correct order without concatenation

Why This Approach Is Better Than Building a String

• No extra string creation → memory efficient

• Stops early as soon as a mismatch is found

• Works directly on the original string

Edge Cases Covered

• s is shorter than combined words → returns False

• Exact match after a few words → returns True

• Extra words after match → safely ignored

Complexity

• Time: O(n), where n = length of s

• Space: O(1), no extra strings created

Key Insight to Remember

Whenever a problem says:

“Check if a string is built from prefixes in order”

👉 Think pointer/index walking, not string building.

https://leetcode.com/problems/sqrtx/description/

Code:

class Solution:
    def mySqrt(self, x: int) -> int:
        if x <= 1:
            return x

        low, high = 1, x // 2
        while low <= high:
            mid = (low + high) // 2
            square = mid * mid

            if square == x:
                return mid
            elif square > x:
                high = mid - 1
            else:
                low = mid + 1

        return high

Key Points:

Problem in Simple Words

You are given a non-negative number x. You need to return the integer part of √x (square root), meaning:

• Return the largest integer whose square is ≤ x

• Do NOT use built-in sqrt functions

Example:

• x = 8 → √8 ≈ 2.8 → answer = 2

• x = 16 → √16 = 4 → answer = 4

Core Idea (Binary Search on the Answer)

The square root of x lies somewhere between:

• 1 and x/2 (for x > 1)

We use binary search to efficiently find the correct integer.

Why binary search?

• The function f(n) = n² is monotonic (always increasing)

• This makes it perfect for binary search

How the Search Works

At each step:

1. Pick a middle value mid

2. Compute mid²

3. Compare mid² with x

Cases:

• If mid² == x → exact square root found → return mid

• If mid² > x → mid is too big → search left side

• If mid² < x → mid is too small → search right side

Why We Return high at the End

When the loop ends:

• low has crossed over high

• high points to the largest number whose square is ≤ x

This exactly matches the problem requirement:

“Return the integer square root (rounded down)”

Edge Cases Handled

• x = 0 → return 0

• x = 1 → return 1

• Large x → binary search avoids slow looping

Why This Approach Is Good

• Much faster than checking every number

• Works for very large inputs

• Clean and commonly expected in interviews

Complexity

• Time: O(log x)

• Space: O(1)

Key Insight to Remember

Whenever you are asked:

• “find the largest value satisfying some condition”

• and the condition is monotonic

👉 Think binary search on the answer

https://leetcode.com/problems/contains-duplicate/description/

Code:

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        return len(nums) != len(set(nums))

# class Solution:
#     def containsDuplicate(self, nums: List[int]) -> bool:
#         c = Counter(nums)
#         for k,v in c.items():
#             if v>1:
#                 return True
#         return False

Key Points:

Problem in Simple Words

You are given a list of numbers. Return True if any number appears more than once. Otherwise, return False.

Core Idea (Use a Set)

A set stores only unique values. So:

• If the list has duplicates → set size becomes smaller

• If all elements are unique → sizes stay the same

How the Check Works

• len(nums) → total number of elements

• len(set(nums)) → number of unique elements

If these two lengths are not equal: → at least one duplicate exists → return True

Why This Works

• Sets automatically remove duplicates

• Length comparison is a quick and reliable way to detect repetition

• No need to manually count frequencies

Edge Cases Covered

• Empty list → no duplicates → False

• Single element → no duplicates → False

• Multiple repeats → detected immediately

Complexity

• Time: O(n)

• Space: O(n) for the set

Alternative (When You Need More Control)

Using a frequency map (Counter) is useful if:

• You need to know which number is duplicated

• You need the count of duplicates

But for just checking existence, the set method is the cleanest.

https://leetcode.com/problems/majority-element/description/

Code:

# Original Solution
class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        elem_map = {}
        n=len(nums)
        for number in nums:
            if number not in elem_map:
                elem_map[number] = 1
            else:
                elem_map[number] = elem_map.get(number) + 1

        for k,v in elem_map.items():
            if v>n//2:
                return k

# Boyer–Moore Voting Algorithm. , O(1) Space
# count = 0
# candidate = None

# for num in nums:
#     if count == 0:
#         candidate = num
#     count += 1 if num == candidate else -1

# return candidate

Key Points:

Problem in Simple Words

You are given a list of numbers. One number appears more than half of the time (> n/2). That number is called the majority element. You must return that number.

Example:

• [3,2,3] → 3

• [2,2,1,1,1,2,2] → 2

Core Idea (Counting Frequencies)

If a number appears more than n // 2 times,
we can simply count how many times each number appears.

Steps:

1. Count frequency of every number.

2. Find the number whose count is greater than n // 2.

How the Solution Works

• Use a dictionary (elem_map) to store: number → how many times it appears

• Loop through the array and update counts.

• After counting:

• Check each (number, frequency)

• If frequency > n // 2, return that number.

Why This Works

• The problem guarantees that a majority element exists.

• So exactly one number will satisfy count > n // 2.

• Dictionary gives fast O(1) average-time updates and lookups.

Edge Cases Covered

• Single element array → that element is the majority.

• All same elements → obvious majority.

• Mixed values → counting handles it safely.

Complexity

• Time: O(n)

• One pass to count

• One pass to find majority

• Space: O(n)

• Dictionary may store all unique numbers

If solved with Boyer–Moore Voting Algorithm.

### Core Idea (Boyer–Moore Voting Algorithm)
Instead of counting frequencies, we use a **voting idea**.

Think of it like this:
- Same numbers **support each other**
- Different numbers **cancel each other out**
- Since the majority element appears more than all others combined,
  it can never be fully cancelled

---

### How the Algorithm Thinks (Intuition)
We keep:
- `candidate` → the current possible majority element
- `count` → how strong its support is

We scan the array once:
- If `count == 0`:
    → pick the current number as the new candidate
- If current number == candidate:
    → increase count (support)
- Else:
    → decrease count (cancel out)

---

### Why Cancellation Works (The “Magic”)
Every time we see:
- one majority element
- and one non-majority element

They **cancel each other**.

Because the majority element appears **more than n/2 times**:
- After all cancellations,
- the majority element is the **only one left standing** as the candidate

---

https://leetcode.com/problems/isomorphic-strings/description/

Code:

class Solution:
    def map_check(self, txt1: str,txt2: str, char_map: dict)->bool:
        for i in range(len(txt1)):
            if txt1[i] not in char_map:
                char_map[txt1[i]]=txt2[i]
            else:
                if char_map.get(txt1[i]) != txt2[i]:
                    return False
        return True

    def isIsomorphic(self, s: str, t: str) -> bool:
        # We need to check map in both directions.
        char_map_s_to_t = {}
        char_map_t_to_s = {}

        return (
            self.map_check(txt1=s, txt2=t, char_map=char_map_s_to_t) 
            and
            self.map_check(txt1=t, txt2=s, char_map=char_map_t_to_s)
        )

Key Points:

Problem in Simple Words

Two strings s and t are isomorphic if:

• Each character in s can be replaced to get t

• The replacement must be consistent

• No two different characters can map to the same character

Example:

• "egg" → "add" ✅

• "foo" → "bar" ❌

• "paper" → "title" ✅

Core Idea (Character Mapping)

We check whether characters from one string can be mapped to the other one-to-one.

Important rule:

• One character → one fixed character

• Mapping must be unique in both directions

That’s why we check mappings both ways.

Why Two Maps Are Needed

Only checking s → t is not enough.

Example:

• s = "ab"

• t = "cc"

s → t mapping:

a → c

b → c

This looks valid in one direction, but it breaks the rule: two different characters map to the same character.

So we must also check:

• t → s

How map_check Works

For each position i:

• If character from txt1 is not yet mapped: → create mapping to corresponding character in txt2

• If it is already mapped: → ensure it maps to the same character as before → otherwise return False

If the loop finishes → mapping is consistent.

Execution Flow

1. Check mapping from s → t

2. Check mapping from t → s

3. Only if both pass, the strings are isomorphic

Why This Works

• Ensures consistency (same char always maps the same way)

• Ensures uniqueness (no two chars map to one char)

• Covers all tricky cases cleanly

Complexity

• Time: O(n)

• Space: O(n) for the two maps

https://leetcode.com/problems/longest-common-prefix/

Code:

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        current_prefix = strs[0]
        for word in strs:
            while not word.startswith(current_prefix):
                current_prefix = current_prefix[:-1]
        return current_prefix

Key Points:

Problem in Simple Words

You are given a list of strings. You need to find the longest prefix (starting part of the word) that is common to all strings. If there is no common prefix, return an empty string.

Example:

• ["flower","flow","flight"] → "fl"

• ["dog","racecar","car"] → ""

Core Idea (Shrink the Prefix)

• Start by assuming the first word is the common prefix.

• Compare this prefix with every other word.

• If a word does not start with the current prefix: → shorten the prefix from the right → keep checking until it matches or becomes empty.

Why We Reduce From the Right

A prefix must start at index 0. If it doesn’t match:

• The only way to fix it is to remove characters from the end.

• Removing from the front would break the idea of a prefix.

How the Process Flows

1. Take the first string as the initial prefix.

2. For each next string:

   • While that string does NOT start with the prefix:

     • Shorten the prefix by one character.

3. If the prefix becomes empty:

   • No common prefix exists → return "".

4. After checking all strings:

   • The remaining prefix is the answer.

Why This Works

• Any common prefix must be a prefix of the first string.

• We only shrink when needed, never expand.

• Once a prefix works for all words, it’s guaranteed to be the longest possible.

Edge Cases Covered

• Only one string → that string itself is the prefix.

• No common prefix → prefix reduces to empty string.

• Strings of different lengths handled naturally.

Complexity

• Time: O(n × m) where n = number of strings, m = length of the prefix (shrinking cost)

• Space: O(1) only the prefix variable is used.

https://leetcode.com/problems/valid-anagram/description/

Code:

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        return Counter(s) == Counter(t)

# class Solution:
#     def isAnagram(self, s: str, t: str) -> bool:
#         s_freq = Counter(s)
#         t_freq = Counter(t)

#         return s_freq == t_freq

Key Points:

Problem in Simple Words

Two strings s and t are anagrams if:

• They contain exactly the same characters

• With exactly the same frequencies

• Order does NOT matter
  Example: "listen" and "silent"

Core Idea

Use a frequency counter for both strings and compare them. If both counters match exactly, the strings are anagrams.

Counter(s) → tells how many times each character appears in s
Counter(t) → same for t

If these two dictionaries are equal → same characters & same counts → anagram.

Why This Works

• An anagram must reuse letters perfectly

• Direct comparison of frequency maps guarantees:

  • No extra characters

  • No missing characters

  • No mismatched counts

• Order of characters is fully ignored (as desired)

Edge Cases Covered

• Different lengths → counters won't match → returns False

• Empty strings → both counters empty → returns True

• Mixed characters (letters, digits, symbols) → Counter handles all

Complexity

• Counting both strings: O(n + m)

• Comparing dictionaries: O(k), where k is number of unique characters

Overall: O(n) time, O(1) space for fixed character set (like ASCII)

https://leetcode.com/problems/sort-characters-by-frequency/description/

Code:

class Solution:
    def frequencySort(self, s: str) -> str:
        c = Counter(s)
        sorted_c = sorted(c.items(), key=lambda x : (-x[1], x[0])) #1st sort by descending, then sort by ascending # sort by char not req though # sorted func always retuns a list
        return ''.join(k*v for k,v in sorted_c) # here intuitively people put list comprehension [...] but directly generator can be give (on the fly)

Key Points:

Problem in Simple Words

We must reorder a string so that:

• Characters with higher frequency come first

• Characters with lower frequency come later
  If two characters have the same frequency, their order doesn't matter for LeetCode.

Example:
s = "tree" → eetr or eert

Core Idea

1. Count how many times each character appears

2. Sort characters based on frequency (descending)

3. Rebuild the string by repeating each character according to its count

This is a straightforward frequency + sorting pattern.

Why We Use Counter

• Counter(s) quickly gives us a dictionary: {char: frequency}

• Counting manually is slower and more error-prone.

Why the Sorting Key is (-x[1], x[0])

• x[1] = frequency
  We use -x[1] to sort highest frequency first ( - denotes descending order)

• x[0] = character
  Used only as a tie-breaker (not required for LeetCode correctness)

Sorting produces something like: [('e', 2), ('t', 1), ('r', 1)]

Why ''.join(k * v for k, v in sorted_c) Works

• For each (character, frequency) pair:

  • k * v repeats the character v times
    e.g., 'e' * 2 = 'ee'

• Joining them together creates the final string in sorted order.

Using a generator expression (not a list) is memory-efficient and clean.

Why This Approach Is Correct

• Sorting by frequency ensures the most common characters come first

• Repeating characters according to their count preserves correct quantities

• Exact ordering for ties is irrelevant to the output validity

Complexity

• Counting: O(n)

• Sorting: O(k log k), where k = number of unique characters (≤ 62 typically)

• Building output: O(n)

Total: O(n log k) (fast in practice)

https://leetcode.com/problems/rotate-string/description/

Code:

# OPTIMISED
class Solution:
    def rotateString(self, s: str, goal: str) -> bool:
        return len(s)==len(goal) and goal in (s+s)

# BELOW TWO SOLUTIONS NOT (O(N^2))
# class Solution:
#     def rotateString(self, s: str, goal: str) -> bool:
#         sq=deque(s)
#         goal_q=deque(goal)
#         i=0
#         while i<len(sq):
#             i+=1
#             sq.append(sq.popleft())
#             if sq==goal_q:
#                 return True
#         return False

# ======= These both are n^2 =========

# class Solution:
#     def rotateString(self, s: str, goal: str) -> bool:
#         sq=deque(s)
#         i=0
#         while i<len(sq):
#             i+=1
#             sq.append(sq.popleft())
#             if ''.join(sq) == goal:
#                 return True
#         return False

Key Points:

Problem in Simple Words

You have two strings: s and goal.

You can rotate s by moving the first character to the end any number of times.
You must check: Can we turn s into goal using such rotations?

Example:

• s = "abcde" → rotations: "abcde", "bcdea", "cdeab", "deabc", "eabcd"

• If goal is one of these, answer is True.

Core Idea (Smart Trick with s + s)

Key observation:

If goal is a rotation of s, then goal will always appear as a substring of s + s.

Example:

• s = "abcde"

• s + s = "abcdeabcde"

• All rotations of "abcde" are inside this:
  "abcde", "bcdea", "cdeab", "deabc", "eabcd"

So we just need to:

1. Check that s and goal have the same length
   (rotating doesn’t change length)

2. Check if goal is a substring of s + s

If both are true → goal is a rotation of s.

Why Length Check Is Important

• If lengths differ, rotation is impossible.
  No need to do the substring check at all.

Why This Is Better Than Simulating Rotations

A slower way is:

• Actually rotate s one step at a time

• Compare with goal after each rotation

That takes:

• Up to n rotations

• Each rotation + comparison can cost O(n)

• Total ≈ O(n²)

The s + s trick:

• Builds s + s once

• Uses substring search which is O(n) (optimized internally)

• Total ≈ O(n)

Complexity

• Time: O(n)

• Space: O(n) for s + s

Simple, clean, and very efficient.

https://leetcode.com/problems/largest-odd-number-in-string/description/

Code:

class Solution:
    def largestOddNumber(self, num: str) -> str:
        for i in range(len(num)-1,-1, -1):
            if int(num[i])%2!=0:
                return num[:i+1]
        return ""

Key Points:

Problem in Simple Words

We are given a string of digits.
We must return the largest possible odd number that can be formed by cutting it from the left side only.

Meaning:

• We can only trim digits from the right end

• The final digit must be odd

• If no odd digit exists → return empty string

Core Idea (Scan from Right)

The last digit of a number decides if it's odd or even. So, to get the largest odd number, we: 1️⃣ Start checking digits from the rightmost end
2️⃣ Find the first digit that is odd
3️⃣ Return the substring from start up to that digit

This ensures:

• We keep as many digits as possible on the left (making the number largest)

• We guarantee the final digit is odd

Why We Iterate Backwards

If we started from the left:

• We might choose an odd digit too early and lose bigger digits behind it

• Going from the right guarantees the longest valid prefix

What If No Odd Digit Exists?

• Then it's impossible to form any odd number

• Return ""

Complexity

• Time: O(n) → one backward scan

• Space: O(1) → no extra data structures used

https://leetcode.com/problems/number-of-recent-calls/

Code:

class RecentCounter:

    def __init__(self):
        self.timestamps = deque()

    def ping(self, t: int) -> int:
        self.timestamps.append(t)

        while self.timestamps[0]<t-3000: # we directly remove te timestamps that won't fall in the new range, older ones, we pop them out.
            self.timestamps.popleft()

        return len(self.timestamps)

Key Points:

Problem in Simple Words

You keep calling .ping(t) with increasing timestamps t. You must return how many calls happened in the last 3000 ms: that means in the range: [t - 3000, t]

Any older calls are no longer counted.

Core Idea (Sliding Window Using Queue)

Use a queue (deque) to store timestamps of recent calls. Since t is always increasing:

• Newest calls go to the right

• Remove old timestamps from the left

This automatically keeps only the timestamps that are still valid.

Why Removing from the Left Works

deque pops from the left efficiently → O(1) And since timestamps are sorted by arrival:

• The oldest timestamps are always in front

• Just remove them while they fall outside the valid range: any timestamp < t - 3000 must be discarded

After cleanup, the queue size = number of valid recent calls

Execution Flow of ping(t)

1️⃣ Append the new timestamp
2️⃣ Remove timestamps older than 3000 ms
3️⃣ Return how many timestamps remain inside the window

Why This Approach Is Good

• Every timestamp enters and leaves once → efficient

• No need to re-check entire history

• Maintains a clean sliding window of recent calls

Complexity

Time: O(1) amortized per ping
Space: O(n) → number of timestamps in the last 3000 ms