Why Ghaziabad Students Are Choosing Data Structures in 2026

# Classic problem: find two numbers that add up to a target
# Brute force is O(n^2); a dictionary makes it O(n)

def two_sum(nums, target):
    seen = {}                       # value -> index
    for i, n in enumerate(nums):
        need = target - n
        if need in seen:
            return [seen[need], i]
        seen[n] = i
    return None

print(two_sum([2, 7, 11, 15], 9))    # [0, 1]
print(two_sum([3, 2, 4], 6))         # [1, 2]
print(two_sum([1, 2, 3], 100))       # None

Explaining Two Sum in an interview

1. Restate: "Return indices of two numbers summing to target."
2. Brute force: "Check every pair - O(n^2) time."
3. Improve: "While scanning, store each value's index
   in a dictionary. For each number, check if
   target - number is already stored."
4. Complexity: "O(n) time, O(n) extra space."
5. Edge cases: "No answer, duplicates like [3, 3]."

Interviewers value this structure as much as the code.

def is_valid(s):
    pairs = {")": "(", "]": "[", "}": "{"}
    stack = []
    for ch in s:
        if ch in "([{":
            stack.append(ch)
        elif ch in pairs:
            if not stack or stack.pop() != pairs[ch]:
                return False
    return not stack

for test in ["()[]{}", "([)]", "{[()]}", "(("]:
    print(test, "->", is_valid(test))

def first_position(nums, target):
    # nums must be sorted; returns first index of target or -1
    low, high, answer = 0, len(nums) - 1, -1
    while low <= high:
        mid = (low + high) // 2
        if nums[mid] == target:
            answer = mid
            high = mid - 1          # keep searching on the left
        elif nums[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return answer

print(first_position([1, 2, 2, 2, 5, 9], 2))   # 1
print(first_position([1, 3, 5], 4))            # -1

Weekly DSA schedule for a college student

Mon-Fri  45 minutes after classes
  - 1 new concept OR 2 problems
  - write a one-line note per problem
Saturday  2 hours
  - timed set of 3 problems
  - review mistakes from the week
Sunday    1 hour
  - revise notes, redo 2 old wrong answers

Exam weeks: revision only, no new topics.

Spaced revision for DSA

After solving a problem, mark it:
  A = solved alone quickly
  B = solved with difficulty
  C = needed the solution

Revisit:
  C problems after 3 days, then after 1 week
  B problems after 1 week
  A problems before placement season

Most improvement comes from re-solving C problems
without looking at the answer.

Problem Log

Date   Problem            Topic     Mark (A/B/C)  Key idea
____   Two Sum            Hashing   ___           store value -> index
____   Valid brackets     Stack     ___           push open, match close
____   First position     Bin.search ___          keep searching left
____   _______________    ________  ___           _______________

Mock Interview Sheet (with a friend)

Problem given: _______________
Time taken: ____ minutes
Clarified the problem first?        Y / N
Explained brute force?              Y / N
Improved to a better solution?      Y / N
Stated time and space complexity?   Y / N
Tested edge cases aloud?            Y / N
Feedback: _______________

Topic Tracker

Topic             Learnt   Easy done   Medium done
Arrays/strings    Y / N    ___         ___
Hashing           Y / N    ___         ___
Stacks/queues     Y / N    ___         ___
Binary search     Y / N    ___         ___
Linked lists      Y / N    ___         ___
Trees             Y / N    ___         ___
Graphs            Y / N    ___         ___