BST Search Operation: Best, Average O(log n) and Worst O(n) Notes in Hindi & English : BST सर्च ऑपरेशन: समय जटिलता और स्क्यूड ट्री स्थिति और 20 महत्वपूर्ण MCQ प्रश्न (Rajasthan IT Exam)

Post a Comment

PGDCA, BCA, B-Tech, MCA, M-Tech, B.Sc computer science राजस्थान सूचना सहायक व कंप्यूटर शिक्षक विशेष नोट्स: इस अध्याय में हम BST Search Operation: Best, Average O(log n) and Worst O(n) (BST सर्च ऑपरेशन: समय जटिलता और स्क्यूड ट्री स्थिति) की संपूर्ण थ्योरी, मुख्य तकनीकी बिंदु, तुलनात्मक तालिका और विगत परीक्षाओं के पैटर्न पर आधारित 20 अति-महत्वपूर्ण बहुविकल्पीय प्रश्न (MCQs) विस्तृत हिंदी व अंग्रेजी व्याख्या सहित पढ़ेंगे।

Overview: BST Search locates a target key by comparing it with the current node and pruning half the remaining search tree at each step. It achieves O(1) best-case time at the root, O(log n) average-case time in balanced or randomly built BSTs, and degrades to O(n) worst-case time when the tree becomes skewed.

अध्याय सार: BST सर्च ऑपरेशन में लक्ष्य कुंजी की वर्तमान नोड से तुलना कर प्रत्येक चरण पर आधे सबट्री को छोड़ा जाता है। इसमें रूट पर मिलने पर सर्वोत्तम O(1), संतुलित ट्री में औसत O(log n), तथा स्क्यूड ट्री होने की सबसे खराब स्थिति में O(n) समय जटिलता लगती है।

BST Search Operation: Best, Average O(log n) and Worst O(n): Detailed Notes & Architecture (BST सर्च ऑपरेशन: समय जटिलता और स्क्यूड ट्री स्थिति)

1. Recursive vs Iterative BST Search Mechanics (रिकर्सिव बनाम इटरेटिव BST सर्च कार्यप्रणाली)

[EN] Starting at `curr = root`, BST Search checks if `curr == NULL` (unsuccessful search) or `curr->key == target` (match found). If `target < curr->key`, it eliminates the entire right subtree and moves to `curr->left`; if `target > curr->key`, it eliminates the entire left subtree and moves to `curr->right`. Because BST search is strictly tail-recursive (making at most one branch decision per level), an iterative `while` loop reduces auxiliary space from O(h) call-stack frames down to O(1) constant space.

[HI] रूट से शुरू करके लक्ष्य मान की तुलना वर्तमान नोड से की जाती है: बराबर होने पर सर्च सफल, छोटा होने पर पूरा दायां सबट्री छोड़कर लेफ्ट में, और बड़ा होने पर पूरा बायां सबट्री छोड़कर राइट में बढ़ते हैं। चूंकि इसमें केवल एक ही मार्ग पर नीचे जाना होता है, इसलिए रिकर्सिव सर्च O(h) स्टैक लेता है जबकि `while` लूप वाला इटरेटिव सर्च केवल O(1) स्पेस में चलता है।

2. Best O(1), Average O(log n) & Worst O(n) Complexity Cases (बेस्ट O(1), एवरेज O(log n) और वर्स्ट O(n) जटिलता)

[EN] Time complexity of BST search is always bounded by O(h), where h is the height of the tree. Best Case is O(1) (1 comparison) when the target key sits at the root node. Average Case across randomly inserted keys is O(log n)—the expected height of a random BST is ~4.31 ln n and average successful search takes ~1.39 log2(n) comparisons. Worst Case is Theta(n) when n keys were inserted in sorted ascending or descending order, creating a degenerate skewed chain of height h = n - 1.

[HI] BST सर्च का समय सदैव ट्री की ऊंचाई O(h) के समानुपाती होता है। बेस्ट केस में यदि कुंजी रूट पर मिल जाए तो O(1) समय लगता है। रैंडम कुंजियों से बने ट्री में औसत ऊंचाई O(log n) होने से सर्च O(log n) (लगभग 1.39 log2(n) तुलनाएं) में पूरी होती है। वर्स्ट केस में यदि डेटा पहले से सॉर्टेड हो तो ट्री स्क्यूड होकर ऊंचाई n-1 हो जाती है और सर्च O(n) समय लेता है।

3. Valid vs Invalid BST Search Sequence Validation (वैध बनाम अवैध BST सर्च अनुक्रम की जांच)

[EN] A favorite competitive exam problem asks whether a probe sequence (e.g., searching for key 363 in a BST) is structurally valid. As search moves downward from root to target k, moving RIGHT at node x establishes a strict lower bound (`all subsequent keys > x`), and moving LEFT at node y establishes a strict upper bound (`all subsequent keys < y`). Any subsequent node on the search path that violates the active `(minBound, maxBound)` interval proves the sequence CANNOT come from any valid BST!

[HI] प्रतियोगी परीक्षाओं में पूछा जाता है कि क्या कोई दिया गया तुलना अनुक्रम (Search Sequence) किसी वैध BST का हिस्सा हो सकता है। नियम यह है कि जब भी हम किसी नोड x से दाईं ओर मुड़ते हैं तो आगे के सभी नोड्स x से बड़े होंगे, और जब बाईं ओर मुड़ते हैं तो आगे के सभी नोड्स y से छोटे होंगे—इस रेंज का उल्लंघन करने वाला अनुक्रम असंभव होता है।

4. Preventing O(n) Skew via Self-Balancing BSTs (सेल्फ-बैलेंसिंग ट्री से O(n) वर्स्ट-केस से बचाव)

[EN] Because plain BST search degrades linearly to O(n) on ordered workloads (like sequential timestamps or auto-increment IDs), production systems pair BST semantics with automatic height balancing. AVL Trees maintain strict height balance (`|height(L) - height(R)| <= 1`) for ultra-fast O(log n) lookups, while Red-Black Trees allow slightly looser 2x height ratio to reduce rotations during updates—both guaranteeing O(log n) worst-case search.

[HI] टाइमस्टैम्प या क्रमिक ID जैसे सॉर्टेड डेटा पर सामान्य BST O(n) तक धीमा हो जाता है। इससे बचने के लिए AVL ट्री (सख्त ऊंचाई संतुलन) और रेड-ब्लैक ट्री (कम रोटेशन के साथ संतुलन) जैसे सेल्फ-बैलेंसिंग BST उपयोग किए जाते हैं, जो वर्स्ट-केस में भी पक्की O(log n) सर्च गति सुनिश्चित करते हैं।

Syntax, Formula & Technical Example (BST Search Operation: Best, Average O(log n) and Worst O(n))

// Iterative BST Search: O(1) Space, O(h) Time (O(log n) avg, O(n) worst)
Node* searchBST(Node* root, int target) {
    Node* curr = root;
    while (curr != NULL) {
        if (target == curr->data) return curr;          // Found!
        else if (target < curr->data) curr = curr->left; // Prune right
        else curr = curr->right;                         // Prune left
    }
    return NULL; // Not found
}

BST Search Operation: Best, Average O(log n) and Worst O(n) Quick Reference & Comparison Table

BST Search CaseTime & Space ComplexityTriggering Tree Condition
Best Case SearchO(1) time; O(1) iterative spaceTarget key resides directly at root node
Average Case (Random BST)O(log n) (~1.39 log2(n) comparisons)Balanced or randomly ordered key insertions
Worst Case (Skewed BST)O(n) time (up to n comparisons)Sorted input creates chain of height n - 1
Recursive Search SpaceO(h) stack frames (vs O(1) iterative)Stack depth equals tree height along path

BST Search Operation: Best, Average O(log n) and Worst O(n) Top 20 Bilingual MCQs with Answers

Q1. What is the Best-Case time complexity of searching for a key in a Binary Search Tree?

(बाइनरी सर्च ट्री (BST) में किसी कुंजी को खोजने की सर्वोत्तम (Best-case) समय जटिलता क्या है?)

(A) O(log n)

(B) O(1)

(C) O(n log n)

(D) O(n)

Correct Answer: (B)

[EN] When the target key matches the root node on the very first comparison, search finishes in O(1) time.

[HI] यदि खोजी जाने वाली कुंजी पहले ही कदम में रूट नोड पर मिल जाए, तो सर्च O(1) समय में पूरी हो जाती है।

Q2. What is the Average-Case time complexity of BST Search for n randomly inserted distinct keys?

(n रैंडम भिन्न कुंजियों से बने BST में सर्च ऑपरेशन की औसत (Average-case) समय जटिलता क्या होती है?)

(A) O(n)

(B) O(log n)

(C) O(sqrt(n))

(D) O(1)

Correct Answer: (B)

[EN] A randomly constructed BST has expected height O(log n), making search logarithmic on average.

[HI] रैंडम क्रम में कुंजियां डालने पर ट्री की अपेक्षित ऊंचाई O(log n) रहती है, अतः औसत सर्च O(log n) होती है।

Q3. When does BST Search degrade to its Worst-Case time complexity of O(n)?

(BST सर्च ऑपरेशन अपनी सबसे खराब स्थिति (Worst-case) O(n) समय जटिलता तक कब गिर जाता है?)

(A) Whenever the tree has an even number of nodes

(B) Whenever searching for the root key

(C) When the BST is skewed (e.g., built from already sorted keys) and the target sits at the bottom or is absent

(D) When the tree is a Perfect Binary Tree

Correct Answer: (C)

[EN] Inserting sorted keys builds a skewed chain of height n - 1, forcing O(n) linear traversal.

[HI] सॉर्टेड डेटा डालने से ट्री एक सीधी श्रृंखला (Skewed) बन जाता है जिसकी ऊंचाई n-1 होने पर सर्च में O(n) समय लगता है।

Q4. How does Iterative BST Search improve upon Recursive BST Search?

(इटरेटिव (Iterative) BST सर्च, रिकर्सिव BST सर्च से किस प्रकार बेहतर होता है?)

(A) It changes worst-case time from O(n) to O(log n)

(B) It prevents skewed trees automatically

(C) It reduces auxiliary space complexity from O(h) call-stack space down to O(1)

(D) It works even on unsorted binary trees

Correct Answer: (C)

[EN] Replacing the single tail-recursive call with a `while` loop eliminates recursion stack frames entirely.

[HI] एक ही शाखा पर उतरने के कारण `while` लूप लगाने से कॉल-स्टैक की O(h) मेमोरी बचकर O(1) हो जाती है।

Q5. In a balanced BST containing n = 1,023 nodes, what is the MAXIMUM number of node comparisons needed for any search?

(n = 1,023 नोड्स वाले संतुलित (Perfect) BST में किसी भी खोज के लिए अधिकतम कितनी तुलनाएं (Comparisons) करनी होंगी?)

(A) 10

(B) 11

(C) 512

(D) 1023

Correct Answer: (A)

[EN] A Perfect Binary Tree of 1,023 nodes has 10 levels (h = 9 edges, levels 0..9), so at most 10 nodes are visited.

[HI] 1,023 = 2^10 - 1 नोड्स में कुल 10 स्तर होते हैं, अतः रूट से पत्ती तक अधिकतम 10 नोड्स से तुलना होगी।

Q6. Suppose we search for key `363` in a BST. Which probe sequence CANNOT possibly occur in ANY valid BST?

(मान लें हम किसी BST में कुंजी `363` खोज रहे हैं। इनमें से कौन सा क्रम किसी भी वैध BST का सर्च पथ नहीं हो सकता?)

(A) 2, 399, 387, 219, 266, 382, 381, 278, 363

(B) 935, 278, 347, 621, 299, 392, 358, 363

(C) 2, 252, 401, 398, 330, 344, 397, 363

(D) 925, 202, 911, 240, 912, 245, 363

Correct Answer: (D)

[EN] In `925, 202, 911, ...`: moving right from 202 to 911 sets lower bound 202, then left to 240 sets upper bound 911, then right to 912 (> 911) VIOLATES the upper bound 911!

[HI] `925, 202, 911, 240, 912` में 911 से बाएं 240 जाने के बाद सभी अगले मान 911 से छोटे होने चाहिए, पर 912 (>911) नियम तोड़ता है!

Q7. In an unsuccessful BST search (target not present), where does the traversal terminate?

(किसी असफल BST सर्च (जब कुंजी ट्री में न हो) में खोज प्रक्रिया कहाँ जाकर समाप्त होती है?)

(A) Always at the root

(B) It loops infinitely

(C) At the global maximum node always

(D) At a NULL left or right child pointer

Correct Answer: (D)

[EN] The loop stops precisely when `curr` becomes NULL—which is also the exact spot where the missing key would be inserted!

[HI] जब कोई लेफ्ट या राइट पॉइंटर NULL मिलता है वहीं खोज रुकती है (और यही नया मान डालने की जगह भी होती है)।

Q8. What is the approximate average number of comparisons in a successful search on a randomly built BST of n nodes?

(n नोड्स वाले रैंडम BST में सफल सर्च के लिए औसत तुलनाओं की संख्या लगभग कितनी होती है?)

(A) n / 2

(B) 0.5 * log2(n)

(C) log2(n) / 4

(D) 1.386 * log2(n) (i.e. 2 ln n)

Correct Answer: (D)

[EN] Classic Knuth/CLRS analysis shows average path length in a random BST is ~1.39 * log2(n), roughly 39% deeper than optimal.

[HI] रैंडम BST में औसत सर्च पथ इष्टतम से ~39% अधिक अर्थात लगभग 1.386 * log2(n) तुलनाएं लेता है।

Q9. Why can't standard Binary Search on a sorted array replace BST Search in all applications?

(सभी अनुप्रयोगों में BST सर्च की जगह सॉर्टेड एरे पर बाइनरी सर्च क्यों नहीं इस्तेमाल किया जा सकता?)

(A) Binary search on an array takes O(n) time

(B) Sorted arrays take O(n) time to shift elements during dynamic insertions and deletions, whereas balanced BSTs do them in O(log n)

(C) BST uses less RAM per key than arrays

(D) Sorted arrays cannot store integers

Correct Answer: (B)

[EN] Static search favors arrays (better cache locality, O(1) space), while dynamic insert/delete + search requires balanced BSTs.

[HI] एरे में बार-बार नया डेटा डालने या हटाने में तत्व खिसकाने से O(n) समय लगता है, जबकि संतुलित BST O(log n) में काम करता है।

Q10. Which self-balancing BST guarantees strict O(log n) worst-case search with tighter height limits (`|bf| <= 1`) than Red-Black Trees?

(कौन सा सेल्फ-बैलेंसिंग BST रेड-ब्लैक ट्री से भी सख्त ऊंचाई संतुलन (`|bf| <= 1`) रखकर तेज O(log n) सर्च देता है?)

(A) Skewed BST

(B) Splay Tree

(C) Treap

(D) AVL Tree

Correct Answer: (D)

[EN] AVL trees enforce maximum height <= 1.44 log2(n), offering faster lookups than Red-Black trees (height <= 2 log2(n)).

[HI] AVL ट्री में हर नोड का बैलेंस फैक्टर -1, 0, +1 रहता है जिससे ऊंचाई कम और सर्च सबसे तेज रहती है।

Q11. During BST search for a target smaller than the current node, why is it mathematically safe to ignore the entire right subtree?

(वर्तमान नोड से छोटे लक्ष्य को खोजते समय पूरे दाएं सबट्री को अनदेखा करना गणितीय रूप से सुरक्षित क्यों है?)

(A) Because every key in the right subtree is guaranteed strictly greater than the current node, and hence greater than the target

(B) Because BFS checks the right subtree later

(C) Because right subtrees contain only negative values

(D) Because the right subtree is always empty

Correct Answer: (A)

[EN] By transitivity (`target < curr < rightSubtree`), target cannot exist anywhere in `curr->right`.

[HI] संक्रामकता (`target < curr < right`) के कारण दाएं सबट्री का हर मान लक्ष्य से बड़ा होगा, इसलिए वहां खोज व्यर्थ है।

Q12. How many nodes does an AVL or balanced BST search examine in the worst case for n = 1,000,000 keys?

(10 लाख (n = 10^6) कुंजियों वाले संतुलित BST में सर्च ऑपरेशन अधिकतम लगभग कितने नोड्स की जांच करेगा?)

(A) About 20 to 30 nodes (Theta(log2(10^6)))

(B) Exactly 1,000 nodes

(C) 1,000,000 nodes

(D) About 500,000 nodes

Correct Answer: (A)

[EN] Since 2^20 = 1,048,576, logarithmic height examines only ~20 nodes out of a million!

[HI] 2^20 लगभग 10 लाख होता है, इसलिए संतुलित BST में 10 लाख तत्वों में से केवल ~20-29 नोड्स जांचने पड़ते हैं।

Q13. What does searching a BST for key `k` return if `k` is smaller than the minimum key in the BST?

(यदि खोजी जाने वाली कुंजी `k` ट्री की सबसे छोटी कुंजी से भी छोटी है, तो सर्च किस नोड के पास रुककर NULL लौटाएगी?)

(A) At the NULL left pointer of the leftmost (minimum) node

(B) At the global root's right child

(C) At the rightmost leaf node

(D) At the root's parent

Correct Answer: (A)

[EN] Every comparison satisfies `k < curr`, descending strictly left until hitting `minNode->left == NULL`.

[HI] हर तुलना पर बाएं मुड़ते हुए सर्च सबसे बाएं (न्यूनतम) नोड के खाली लेफ्ट पॉइंटर पर पहुंचकर NULL लौटाएगी।

Q14. Which statement is NOT true about BST Search?

(BST सर्च ऑपरेशन के संबंध में इनमें से कौन सा कथन असत्य (NOT true) है?)

(A) BST Search always runs in O(log n) worst-case time regardless of insertion order

(B) Best-case BST search takes O(1) time

(C) Searching a skewed BST takes O(n) worst-case time

(D) Iterative BST search uses O(1) auxiliary space

Correct Answer: (A)

[EN] Unbalanced BSTs do NOT guarantee O(log n) worst-case—sorted insertions degrade search to O(n).

[HI] सामान्य BST में इन्सर्शन क्रम पर ऊंचाई निर्भर करती है, अतः सदैव O(log n) वर्स्ट-केस समय की गारंटी नहीं होती।

Q15. Given keys 50, 30, 70, 20, 40, 60, 80 inserted in order, which nodes are compared when searching for 45?

(क्रमशः 50, 30, 70, 20, 40, 60, 80 डालकर बनाए गए BST में कुंजी 45 को खोजते समय किन नोड्स से तुलना होगी?)

(A) 50 -> 30 -> 20 -> 40

(B) 50 -> 30 -> 40 (then NULL, not found)

(C) 50 -> 40 -> 45

(D) 50 -> 70 -> 60

Correct Answer: (B)

[EN] 45 < 50 (go left to 30); 45 > 30 (go right to 40); 45 > 40 (go right -> NULL).

[HI] 45 < 50 से बाएं 30 पर, 45 > 30 से दाएं 40 पर, फिर 45 > 40 के दाएं NULL मिलने पर असफल समाप्त होगा।

Q16. In a Splay Tree (self-adjusting BST), what happens to a frequently searched key to optimize subsequent lookups?

(स्प्ले ट्री (Splay Tree) में बार-बार खोजी जाने वाली कुंजी को तेज करने के लिए सर्च के बाद क्या किया जाता है?)

(A) It is locked in read-only memory

(B) The accessed node is rotated upward to become the new root of the tree

(C) It is moved to the deepest leaf

(D) It is deleted and copied to an array

Correct Answer: (B)

[EN] Splaying brings hot keys to the root so repeated lookups hit near O(1) time (O(log n) amortized).

[HI] स्प्ले ट्री खोजे गए नोड को रोटेशन द्वारा ट्री के रूट पर ले आता है ताकि अगली बार तुरंत मिल सके।

Q17. Within BST Search Operation: Best, Average O(log n) and Worst O(n), which bst search case directly maps to: "O(1) time; O(1) iterative space"?

(BST Search Operation: Best, Average O(log n) and Worst O(n) में कौन सा BST Search Case सीधे "O(1) time; O(1) iterative space" से संबंधित है?)

(A) Recursive Search Space

(B) Best Case Search

(C) Worst Case (Skewed BST)

(D) Average Case (Random BST)

Correct Answer: (B)

[EN] In BST Search Operation: Best, Average O(log n) and Worst O(n), 'Best Case Search' handles 'O(1) time; O(1) iterative space' (Target key resides directly at root node).

[HI] BST Search Operation: Best, Average O(log n) and Worst O(n) में 'Best Case Search' का कार्य/विवरण 'O(1) time; O(1) iterative space' (Target key resides directly at root node) है।

Q18. Which option accurately describes 'Average Case (Random BST)' in BST Search Operation: Best, Average O(log n) and Worst O(n)?

(BST Search Operation: Best, Average O(log n) and Worst O(n) के संदर्भ में 'Average Case (Random BST)' की सही विशेषता कौन सी है?)

(A) O(1) time; O(1) iterative space

(B) O(h) stack frames (vs O(1) iterative)

(C) O(log n) (~1.39 log2(n) comparisons)

(D) O(n) time (up to n comparisons)

Correct Answer: (C)

[EN] 'Average Case (Random BST)' provides 'O(log n) (~1.39 log2(n) comparisons)' — key point: Balanced or randomly ordered key insertions.

[HI] 'Average Case (Random BST)' का मुख्य विवरण 'O(log n) (~1.39 log2(n) comparisons)' है (Balanced or randomly ordered key insertions)।

Q19. In BST Search Operation: Best, Average O(log n) and Worst O(n), identify the correct parameter for the specification: "O(n) time (up to n comparisons)".

(BST Search Operation: Best, Average O(log n) and Worst O(n) में "O(n) time (up to n comparisons)" विवरण किस विकल्प के लिए सही है?)

(A) Average Case (Random BST)

(B) Recursive Search Space

(C) Best Case Search

(D) Worst Case (Skewed BST)

Correct Answer: (D)

[EN] 'Worst Case (Skewed BST)' corresponds to 'O(n) time (up to n comparisons)' (Sorted input creates chain of height n - 1).

[HI] 'Worst Case (Skewed BST)' का संबंध 'O(n) time (up to n comparisons)' (Sorted input creates chain of height n - 1) से है।

Q20. Considering BST Search Operation: Best, Average O(log n) and Worst O(n), what key behavior defines 'Recursive Search Space'?

(BST Search Operation: Best, Average O(log n) and Worst O(n) में 'Recursive Search Space' की मुख्य भूमिका या मान क्या है?)

(A) O(h) stack frames (vs O(1) iterative)

(B) O(log n) (~1.39 log2(n) comparisons)

(C) O(1) time; O(1) iterative space

(D) O(n) time (up to n comparisons)

Correct Answer: (A)

[EN] 'Recursive Search Space' represents 'O(h) stack frames (vs O(1) iterative)' (Stack depth equals tree height along path).

[HI] 'Recursive Search Space' का अर्थ/मान 'O(h) stack frames (vs O(1) iterative)' है (Stack depth equals tree height along path)।

BST Search Operation: Best, Average O(log n) and Worst O(n) — Exam FAQs

Q1: Why is average-case BST search O(log n) even without AVL rotations?

बिना AVL रोटेशन के भी रैंडम BST में औसत सर्च O(log n) क्यों रहती है?

[EN] When keys arrive in uniformly random order, the root sits near the median with high probability, partitioning remaining keys evenly enough that expected tree height stays ~4.31 ln n = O(log n).

[HI] रैंडम क्रम में कुंजियां आने पर रूट प्रायः मध्य मान के पास पड़ता है जिससे पेड़ दोनों तरफ लगभग संतुलित बढ़ता है और ऊंचाई O(log n) बनी रहती है।

Q2: Does BST Search ever modify the structure of a standard Binary Search Tree?

क्या सामान्य BST में सर्च ऑपरेशन ट्री की संरचना में कोई बदलाव करता है?

[EN] No. Standard BST search is strictly read-only. (Only specialized adaptive variants like Splay Trees rotate searched nodes to the root.)

[HI] नहीं। मानक BST सर्च पूरी तरह रीड-ओनली होता है। (केवल स्प्ले ट्री जैसे विशेष अनुकूली ट्री ही खोजे गए नोड को ऊपर लाते हैं।)

Q3: Is Iterative BST Search faster in practice than Recursive BST Search?

क्या व्यावहारिक रूप से इटरेटिव BST सर्च रिकर्सिव की तुलना में तेज है?

[EN] Yes—eliminating function call overhead, stack frame allocation, and return jumps makes an iterative `while` loop slightly faster and immune to stack overflow on huge skewed trees.

[HI] हाँ — फ़ंक्शन कॉल व स्टैक फ्रेम बनाने का समय बचने से `while` लूप वाला इटरेटिव सर्च अधिक तेज व स्टैक ओवरफ्लो से सुरक्षित होता है।

Related Posts

  • Loading related posts...

Post a Comment

Search Topic Notes & 20 MCQs (Hindi / English)