Myntra & Meesho: Data Scientist / Analyst

• Users: many are first-time internet shoppers with sparse histories, so handle cold start with popularity by region and category, plus onboarding preferences.
• Pipeline: 1. Candidate generation: item-to-item co-view/co-buy, two-tower embeddings, trending in the user's region and price band. 2. Ranking: a GBM or DNN predicts P(click), P(order) and P(return); combine into expected value = P(order) × margin × (1 − P(return)). 3. Re-ranking: diversity, seller fairness, price band, out-of-stock filtering.
• Evaluation: offline recall@k and NDCG; online A/B on orders per user, GMV and return rate (a guardrail).
• Serving: precompute candidates, run real-time ranking under 100 ms, refresh features hourly.

• LoRA: freeze the base model and train low-rank adapters (ΔW = BA) on chosen layers. The base runs in FP16/BF16.
• QLoRA: the same adapters, but the frozen base is quantized to 4-bit (NF4) with double quantization and paged optimisers. A 7–70B model can be fine-tuned on a single GPU.
• Trade-off: QLoRA uses far less memory and is slightly slower; quality is usually close to LoRA.

• Lazy evaluation: transformations (filter, select, join) build a logical plan. Nothing runs until an action (count, collect, write). That lets the Catalyst optimiser push down filters and combine stages.
• Left semi join: returns the left rows that have a match (columns from the left only), like EXISTS.
• Left anti join: returns the left rows with no match, like NOT EXISTS. Example: users who never ordered.

active = users.join(orders, "user_id", "left_semi")
never_ordered = users.join(orders, "user_id", "left_anti")

• Type I (α): a false positive, rejecting a true null hypothesis (shipping a feature that does nothing).
• Type II (β): a false negative, missing a real effect. Power = 1 − β.
• A lower α (stricter p-value threshold) lowers power, unless you increase the sample size. Power also rises with the effect size and lower variance.
• Plan the sample size before the test, with α = 0.05 and power 0.8 as typical values.

WITH rev AS (
  SELECT p.category, p.brand, SUM(oi.price * oi.qty) AS revenue
  FROM order_items oi
  JOIN products p ON p.product_id = oi.product_id
  LEFT JOIN returns r ON r.order_item_id = oi.order_item_id
  WHERE r.order_item_id IS NULL
  GROUP BY p.category, p.brand
)
SELECT category, brand, revenue
FROM (SELECT rev.*, DENSE_RANK() OVER (PARTITION BY category ORDER BY revenue DESC) AS rk FROM rev) t
WHERE rk <= 3;

def asteroid_collision(a):
    st = []
    for x in a:
        while st and x < 0 < st[-1]:
            if st[-1] < -x: st.pop(); continue
            if st[-1] == -x: st.pop()
            break
        else:
            st.append(x)
    return st
print(asteroid_collision([5, 10, -5]))   # [5, 10]

• Use a stack for asteroids moving right. Each element is pushed and popped at most once, so it is O(n).