Blind 75 LeetCode in Hindi (Hinglish): Free Course

Hindi mein samjho (Hinglish)

Neeche is topic ka Hinglish explanation hai, wahi jo hamare course lesson mein audio narration ke saath chalta hai. Code English mein hai, samjhana Hindi mein.

Best Time to Buy and Sell Stock

Best Time to Buy and Sell Stock dekhne mein finance question lagta hai, par yeh ek specific skill ka sabse clean test hai: ek stream ke values pe sweep karte waqt best single decision lena. Yahan running-minimum trick samajh gaye to wahi shape Blind seventy-five ke paanch aur problems solve kar deta hai.

Pehle pattern pehchano. Jab bhi tum dekho "best pair jisme doosra element pehle ke baad aata hai, aur score unke delta se calculate hota hai," yeh hint hai pehle element ka running extremum maintain karne ka jab tum doosra walk karte ho. Har past day yaad rakhne ki zaroorat nahi: bas ab tak ka best. Yahi O of n squared search ko ek pass mein collapse karta hai.

Ab asli unlock. Koi bhi sell day r pick karo. Best partner buy day wahi hoga jis earlier day ka price sabse chhota tha. To har past day pe back jaane ki zaroorat nahi: bas ab tak ka smallest price chahiye. Walk karte waqt usko maintain karo. Har step constant kaam, total O of n. Yahi idea sliding window jaisa bhi padhta hai jahan left pointer r pe jump karta hai jaise hi ek cheaper buy day milta hai.

Python solution: Best Time to Buy and Sell Stock

def max_profit(prices):
    min_price = float('inf')
    best = 0
    for r, p in enumerate(prices):
        if p < min_price:
            min_price = p
        else:
            best = max(best, p - min_price)
    return best

Complexity: Brute force (two nested loops): time O(n²), space O(1); Running minimum (single pass): time O(n), space O(1).

Product of Array Except Self

Product of Array Except Self do second ke liye trivial lagta hai. Sab kuch multiply karo, current element se divide kar do. Phir constraint padho: division allowed nahi hai. Wo ek rule tumhe prefix-product pattern invent karne pe majboor karta hai, jo phir ek dozen aur problems mein wapas dikhta hai. Yeh medium memorization se zyada understanding ko reward karta hai.

Pehle pattern pehchano. Index i pe answer hai, i ke left ka product times i ke right ka product. Yeh decomposition, left-aggregate times right-aggregate, prefix-aggregate pattern hai. Sum, product, min, max: har baar same shape. Do passes mein O of n milta hai bina extra arrays ke.

Asli unlock. Tumhe ek saath saare n minus one elements ki zaroorat nahi: har side pe ek running product chahiye. Pass one left se right chalti hai aur har index pe output cell mein prefix product likh deti hai. Pass two right se left chalti hai, ek suffix scalar carry karte hue, aur usko cell mein multiply kar deti hai. Do passes. Do scalar variables. Koi extra array nahi. Koi division nahi.

Python solution: Product of Array Except Self

def product_except_self(nums):
    n = len(nums)
    output = [1] * n
    prefix = 1
    for i in range(n):
        output[i] = prefix
        prefix *= nums[i]
    suffix = 1
    for i in range(n - 1, -1, -1):
        output[i] *= suffix
        suffix *= nums[i]
    return output

Complexity: Brute force (two nested loops): time O(n²), space O(1) extra (output excluded); Prefix × suffix (two passes, two scalars): time O(n), space O(1) extra (output excluded).

Maximum Subarray

Welcome to Maximum Subarray: interview list ka sabse saaf one-pass DP problem. Jo trick is ko solve karta hai, Kadane's algorithm, bas chhe lines ka code hai, lekin yeh ek soch ki aadat sikhata hai jo baar baar kaam aati hai: har step pe decide karo, jo abhi tak banaya hai use extend karna hai, ya phenk ke fresh shuru karna hai.

Pattern pehchano. Jab bhi tum dekho 'best contiguous run nikaalo', best sum, best product, sabse lambi streak jo kuch satisfy kare, to ek single sweep socho jisme tum ek running statistic aur ek global best carry karte ho. Kadane is pattern ka canonical version hai. Same shape Maximum Product Subarray, Best Time to Buy and Sell Stock, aur Maximum Circular Subarray ko bhi power karta hai.

Ab asli unlock. Array ko left se right walk karo, ek running sum carry karte hue jise cur kehte hain. Har naye element x pe, tumhare paas exactly do choices hain: current run ko x add karke extend karo, ya run ko phenk ke akele x se fresh shuru karo. Jo bhi bada ho wo pick karo. Key insight: agar cur kabhi bhi negative ho gaya, to woh sirf future ko hurt karega, isi liye use drop karna keeping se strictly better hai.

Python solution: Maximum Subarray

def max_sub_array(nums):
    cur = nums[0]
    best = nums[0]
    for x in nums[1:]:
        cur = max(x, cur + x)
        best = max(best, cur)
    return best

Complexity: Brute force (every subarray): time O(n²), space O(1); Kadane's algorithm (single pass): time O(n), space O(1); Divide and conquer: time O(n log n), space O(log n).