PGDCA, BCA, B-Tech, MCA, M-Tech, B.Sc computer science राजस्थान सूचना सहायक व कंप्यूटर शिक्षक विशेष नोट्स: इस अध्याय में हम Linear Search Algorithm: Working, Best O(1), Worst O(n) (लीनियर सर्च: अनसॉर्टेड एरे में क्रमिक खोज और कॉम्प्लेक्सिटी) की संपूर्ण थ्योरी, मुख्य तकनीकी बिंदु, तुलनात्मक तालिका और विगत परीक्षाओं के पैटर्न पर आधारित 20 अति-महत्वपूर्ण बहुविकल्पीय प्रश्न (MCQs) विस्तृत हिंदी व अंग्रेजी व्याख्या सहित पढ़ेंगे।
Overview: Linear Search sequentially inspects elements from index 0 to n-1, making it compatible with unsorted arrays and linked lists in O(n) worst-case time and O(1) iterative space.
अध्याय सार: लीनियर सर्च (Linear Search) इंडेक्स 0 से n-1 तक हर तत्व की क्रमिक जांच करता है, जिससे यह अनसॉर्टेड एरे और लिंक्ड लिस्ट दोनों पर O(n) वर्स्ट-केस समय तथा O(1) इटरेटिव स्पेस में कार्य करता है।
Linear Search Algorithm: Working, Best O(1), Worst O(n): Detailed Notes & Architecture (लीनियर सर्च: अनसॉर्टेड एरे में क्रमिक खोज और कॉम्प्लेक्सिटी)
1. Sequential Traversal Mechanism & Preconditions (क्रमिक खोज की कार्यप्रणाली व शर्तें)
[EN] Linear Search (also called Sequential Search) scans a collection one element at a time from the first position toward the last until either the target key matches or the container ends. Unlike Binary Search, it imposes zero ordering or random-access prerequisites, so it runs directly on unsorted arrays as well as singly linked lists. When duplicates exist, standard forward linear search returns the index of the very first occurrence and exits early.
[HI] लीनियर सर्च (जिसे सीक्वेंशियल सर्च भी कहते हैं) पहले तत्व से अंतिम तत्व तक एक-एक करके लक्ष्य कुंजी (Target Key) की तुलना करता है। बाइनरी सर्च के विपरीत इसके लिए डेटा का सॉर्टेड होना या रैंडम एक्सेस (Random Access) उपलब्ध होना आवश्यक नहीं है, अतः यह अनसॉर्टेड एरे व लिंक्ड लिस्ट पर सीधे चलता है। यदि एरे में एक ही मान कई बार हो, तो मानक लीनियर सर्च सबसे पहली मिलने वाली स्थिति (First Index) लौटाकर रुक जाता है।
2. Time & Space Complexity Analysis (समय व स्थान जटिलता विश्लेषण)
[EN] In the best case, the target sits at index 0, terminating after exactly 1 comparison in O(1) time. For an unsuccessful search or when the key lies at index n-1, all n elements are inspected, giving O(n) worst-case time. Assuming a uniform probability distribution for a successful match across n positions, the average number of comparisons is (1 + 2 + ... + n) / n = (n + 1) / 2, which simplifies to O(n). Iterative linear search takes O(1) auxiliary space, whereas a recursive version consumes O(n) call-stack space.
[HI] बेस्ट केस (Best Case) में लक्ष्य पहले ही इंडेक्स 0 पर मिल जाता है, जिससे केवल 1 तुलना और O(1) समय लगता है। असफल खोज या अंतिम इंडेक्स n-1 पर तत्व होने पर सभी n तत्वों की जांच करनी पड़ती है, अर्थात वर्स्ट केस O(n) होता है। समान प्रायिकता वाली सफल खोज में औसत तुलनाएँ (n + 1) / 2 होती हैं जो O(n) श्रेणी में आती हैं। इटरेटिव लीनियर सर्च O(1) अतिरिक्त मेमोरी लेता है, जबकि रिकर्सिव रूप O(n) कॉल-स्टैक स्पेस उपयोग करता है।
3. Sentinel Linear Search Optimization (सेंटिनल लीनियर सर्च अनुकूलन)
[EN] A standard loop performs two comparisons per iteration: one bounds check (i < n) and one value check (arr[i] == key), totaling 2n comparisons in the worst case. Sentinel Linear Search temporarily saves the last element arr[n-1], overwrites arr[n-1] = key (or places key at extra slot arr[n]), and removes the i < n bounds test from the loop because a match is now guaranteed. After the loop exits, the original last element is restored and verified, cutting per-iteration branching roughly in half while remaining asymptotically O(n).
[HI] साधारण लूप हर चरण में दो जांच करता है: सीमा जांच (i < n) और मान तुलना (arr[i] == key), जिससे वर्स्ट केस में लगभग 2n जांच होती हैं। सेंटिनल लीनियर सर्च में अंतिम तत्व को सुरक्षित रखकर अंतिम स्थान पर ही लक्ष्य कुंजी (Sentinel) रख दी जाती है, जिससे लूप के अंदर i < n की शर्त हट जाती है क्योंकि कुंजी मिलना निश्चित हो जाता है। लूप के बाद मूल अंतिम मान वापस रखकर जांच की जाती है; इससे तुलनाओं की संख्या घटती है पर असिम्प्टोटिक कॉम्प्लेक्सिटी O(n) ही रहती है।
4. Self-Organizing Lists & Practical Selection (सेल्फ-ऑर्गेनाइजिंग विधियाँ व व्यावहारिक चयन)
[EN] When query frequencies are heavily skewed, Move-to-Front swaps a newly found item directly to index 0, and Transposition swaps it one slot toward the front so hot keys are found faster on future searches. Practically, for a single lookup on an unsorted array of size n, Linear Search takes O(n), whereas sorting first (O(n log n)) plus Binary Search (O(log n)) is slower overall. Linear search becomes optimal on small arrays (n <= 32) due to sequential CPU cache prefetching.
[HI] यदि कुछ विशेष तत्व बार-बार खोजे जाते हैं, तो Move-to-Front (खोजे गए तत्व को इंडेक्स 0 पर लाना) या Transposition (एक स्थान आगे खिसकाना) जैसी तकनीकें औसत खोज समय घटाती हैं। किसी अनसॉर्टेड एरे में केवल एक बार खोज करनी हो, तो पहले O(n log n) में सॉर्ट करके बाइनरी सर्च चलाने की तुलना में सीधे O(n) लीनियर सर्च करना तेज रहता है। छोटे एरे में CPU कैश लोकैलिटी के कारण भी लीनियर सर्च बहुत प्रभावी होता है।
Syntax, Formula & Technical Example (Linear Search Algorithm: Working, Best O(1), Worst O(n))
int linearSearch(int arr[], int n, int key) {
for (int i = 0; i < n; i++) {
if (arr[i] == key)
return i; // Found: Best O(1), Worst O(n)
}
return -1; // Not found after n comparisons
}
// Dry Run: arr = [14, 7, 29, 5], key = 29
// i=0 (14!=29), i=1 (7!=29), i=2 (29==29) -> returns index 2
Linear Search Algorithm: Working, Best O(1), Worst O(n) Quick Reference & Comparison Table
| Search Scenario | Comparison Formula & Big-O | Key Operational Detail |
|---|---|---|
| Best Case (First Element Hit) | Exactly 1 comparison; Time O(1) | Target resides at arr[0], loop exits immediately |
| Average Case (Uniform Match) | (n + 1) / 2 comparisons; Time O(n) | Each of n indices has equal 1/n probability |
| Worst Case (Miss or Last Slot) | n value comparisons; Time O(n) | Scans entire array when target is at arr[n-1] or absent |
| Sentinel Variant Optimization | Drops i < n check inside loop | Places key at boundary to cut branching overhead in half |
Linear Search Algorithm: Working, Best O(1), Worst O(n) Top 20 Bilingual MCQs with Answers
Q1. What is the worst-case time complexity of Linear Search on an unsorted array of n elements?
(n तत्वों वाले अनसॉर्टेड एरे में लीनियर सर्च की वर्स्ट-केस टाइम कॉम्प्लेक्सिटी क्या होती है?)
(A) O(n)
(B) O(1)
(C) O(log n)
(D) O(n log n)
Correct Answer: (A)
[EN] In the worst case (key at the last slot or missing), Linear Search checks all n elements, taking O(n) time.
[HI] वर्स्ट केस में कुंजी अंतिम स्थान पर होने या न मिलने पर सभी n तत्वों की जांच करनी होती है, अतः समय O(n) लगता है।
Q2. For a successful Linear Search where the key is equally likely to be at any of n positions, what is the average number of comparisons?
(सफल लीनियर सर्च में यदि कुंजी के n में से किसी भी स्थान पर होने की संभावना समान हो, तो औसत तुलनाएँ कितनी होंगी?)
(A) log2(n)
(B) n / 2
(C) n - 1
(D) (n + 1) / 2
Correct Answer: (D)
[EN] Summing comparisons 1 + 2 + ... + n and dividing by n yields n(n+1)/(2n) = (n+1)/2.
[HI] 1 से n तक तुलनाओं का योग n(n+1)/2 होता है जिसे n से भाग देने पर औसत (n+1)/2 प्राप्त होता है।
Q3. What is the auxiliary space complexity of a recursive Linear Search implementation on an array of size n?
(n आकार के एरे पर रिकर्सिव लीनियर सर्च की ऑक्सिलरी स्पेस कॉम्प्लेक्सिटी कितनी होती है?)
(A) O(n)
(B) O(n^2)
(C) O(log n)
(D) O(1)
Correct Answer: (A)
[EN] Each recursive step pushes a stack frame until the end of the array in the worst case, requiring O(n) stack space (unlike O(1) iterative).
[HI] इटरेटिव लीनियर सर्च O(1) स्थान लेता है, परंतु रिकर्सिव संस्करण वर्स्ट केस में n स्टैक फ्रेम बनाता है जिससे स्पेस O(n) होता है।
Q4. Which condition triggers the O(1) best-case performance in Linear Search?
(लीनियर सर्च में O(1) बेस्ट-केस प्रदर्शन किस स्थिति में मिलता है?)
(A) When the key sits exactly at the middle index
(B) When the search key matches the very first element at index 0
(C) When the array is sorted in descending order
(D) When the target is absent from the array
Correct Answer: (B)
[EN] If arr[0] == key, the algorithm terminates after a single comparison regardless of array size n.
[HI] जब लक्ष्य कुंजी इंडेक्स 0 पर ही स्थित हो, तो एरे कितना भी बड़ा हो, केवल 1 तुलना में परिणाम मिल जाता है।
Q5. How does Sentinel Linear Search improve practical execution speed?
(सेंटिनल लीनियर सर्च व्यावहारिक निष्पादन गति को कैसे सुधारता है?)
(A) By jumping two indices per step
(B) By eliminating the loop-boundary check (i < n) during each iteration
(C) By using binary midpoints inside unsorted data
(D) By sorting the array first in O(n) time
Correct Answer: (B)
[EN] Putting the target key at the end guarantees loop termination, removing the i < n check on every step.
[HI] एरे के अंत में सेंटिनल कुंजी रखने से लूप का रुकना तय हो जाता है, जिससे हर चरण में होने वाली i < n सीमा जांच बच जाती है।
Q6. You have an unsorted array of 10,000 items and need to perform only ONE search operation. Which approach is asymptotically fastest?
(10,000 तत्वों के अनसॉर्टेड एरे में केवल एक बार खोज करने के लिए असिम्प्टोटिक रूप से सबसे तेज तरीका कौन सा है?)
(A) Building a Balanced BST then searching
(B) Heap Sort followed by Binary Search
(C) Direct Linear Search in O(n)
(D) Quick Sort in O(n log n) followed by Binary Search
Correct Answer: (C)
[EN] Sorting first costs O(n log n), which exceeds a single O(n) linear scan.
[HI] एक ही खोज के लिए पहले O(n log n) में सॉर्ट करने से बेहतर है सीधे O(n) में लीनियर सर्च चलाना।
Q7. On a singly linked list with no extra index structure, why is Linear Search generally used instead of Binary Search?
(बिना अतिरिक्त इंडेक्स वाली सिंगली लिंक्ड लिस्ट में बाइनरी सर्च के बजाय लीनियर सर्च क्यों उपयोग किया जाता है?)
(A) Linear Search runs in O(1) worst time on linked lists
(B) Linked lists cannot store sorted integers
(C) Binary Search alters pointer addresses
(D) Singly linked lists lack O(1) random access to jump directly to the middle node
Correct Answer: (D)
[EN] Finding the middle node in a linked list requires sequential traversal, degrading Binary Search to O(n) anyway.
[HI] लिंक्ड लिस्ट में मध्य नोड तक सीधे पहुंचने (O(1) रैंडम एक्सेस) की सुविधा नहीं होती, इसलिए वहां लीनियर सर्च ही व्यावहारिक है।
Q8. In the array arr = [18, 42, 7, 42, 95], what index does standard Linear Search return for key = 42 (0-based indexing)?
(एरे arr = [18, 42, 7, 42, 95] में key = 42 खोजने पर मानक लीनियर सर्च कौन सा इंडेक्स लौटाएगा (0-आधारित इंडेक्सिंग)?)
(A) 3
(B) 1
(C) Both 1 and 3
(D) 4
Correct Answer: (B)
[EN] Scanning left to right from index 0 stops immediately at the first match, which is index 1.
[HI] बाएँ से दाएँ खोजने पर index 1 पर पहला 42 मिलते ही एल्गोरिदम रुककर 1 लौटा देता है।
Q9. How many comparisons does standard Linear Search perform on [10, 20, 30, 40, 50] when searching for 99?
([10, 20, 30, 40, 50] में 99 खोजने पर मानक लीनियर सर्च कुल कितनी मान तुलनाएँ (Value Comparisons) करेगा?)
(A) 4
(B) 1
(C) 5
(D) 6
Correct Answer: (C)
[EN] 99 is absent, so all n = 5 elements are checked before returning -1.
[HI] 99 एरे में मौजूद नहीं है, इसलिए सभी 5 तत्वों की तुलना के बाद -1 लौटाया जाएगा।
Q10. What does the 'Transposition' heuristic do in a self-organizing Linear Search?
(सेल्फ-ऑर्गेनाइजिंग लीनियर सर्च में 'ट्रांसपोजिशन (Transposition)' नियम क्या करता है?)
(A) Reverses the entire array after a miss
(B) Deletes the matched element after reading
(C) Swaps the matched element one position closer to the front (with its predecessor)
(D) Moves the matched element immediately to index 0
Correct Answer: (C)
[EN] Transposition gradually promotes frequently searched items by swapping arr[i] with arr[i-1], avoiding sudden disruption.
[HI] ट्रांसपोजिशन में मिला हुआ तत्व एक कदम आगे (arr[i-1] के साथ अदला-बदली) बढ़ता है, जबकि Move-to-Front उसे सीधे इंडेक्स 0 पर लाता है।
Q11. If a standard Linear Search loop uses 'if (arr[i] == key) return i;' without sentinel, roughly how many total condition checks (loop bound + key equality) occur on a miss of size n?
(बिना सेंटिनल वाले सामान्य लीनियर सर्च में n आकार के एरे में तत्व न मिलने पर लूप सीमा व कुंजी जांच मिलाकर कुल लगभग कितनी कंडीशन जांची जाती हैं?)
(A) 2n + 1
(B) n^2
(C) n / 2
(D) log2(n)
Correct Answer: (A)
[EN] Each of n iterations checks i < n and arr[i] == key (2n checks), plus the final failing i < n check.
[HI] n बार i < n तथा arr[i] == key (2n) और अंत में एक बार असफल i < n शर्त की जांच होती है।
Q12. In Jump Search vs Linear Search, Linear Search uses step size 1. What happens if step size is increased to sqrt(n) on a sorted array?
(यदि सॉर्टेड एरे में स्टेप साइज 1 के बजाय sqrt(n) कर दिया जाए (जंप सर्च), तो वर्स्ट-केस टाइम कॉम्प्लेक्सिटी क्या हो जाती है?)
(A) O(sqrt(n))
(B) O(n^2)
(C) O(1)
(D) O(log log n)
Correct Answer: (A)
[EN] Jump Search makes n/sqrt(n) block jumps plus at most sqrt(n) linear checks, yielding O(sqrt(n)) on sorted arrays.
[HI] सॉर्टेड एरे पर sqrt(n) स्टेप से ब्लॉक जंप करने पर वर्स्ट-केस जटिलता O(n) से घटकर O(sqrt(n)) हो जाती है।
Q13. Which data structure operation naturally corresponds to Linear Search when scanning for a key?
(कुंजी खोजते समय इनमें से किस संरचना में स्वाभाविक रूप से लीनियर सर्च का उपयोग होता है?)
(A) Bucket chain traversal in a Hash Table with Separate Chaining
(B) Min-element peek in a Min-Heap
(C) Root-to-leaf lookup in a balanced AVL Tree
(D) Indexed array lookup arr[5]
Correct Answer: (A)
[EN] Separate chaining stores colliding keys in an unsorted/short linked list bucket searched sequentially.
[HI] सेपरेट चेनिंग वाली हैश टेबल के बकेट में जुड़े नोड्स को क्रमिक लीनियर सर्च से ही जांचा जाता है।
Q14. If input size doubles from 1,000 to 2,000 elements, how does the worst-case runtime of Linear Search change?
(यदि एरे का आकार 1,000 से दोगुना होकर 2,000 हो जाए, तो लीनियर सर्च का वर्स्ट-केस समय कैसे बदलेगा?)
(A) It stays constant
(B) It quadruples (4x slower)
(C) It increases by only 1 extra step
(D) It roughly doubles (linear scaling)
Correct Answer: (D)
[EN] Because worst-case time T(n) = c * n is linear in n, doubling n doubles the number of comparisons.
[HI] चूंकि वर्स्ट-केस समय n के सीधे समानुपाती (O(n)) होता है, इसलिए आकार दोगुना करने पर समय भी लगभग दोगुना हो जाता है।
Q15. Which statement is NOT true about Linear Search?
(लीनियर सर्च के बारे में इनमें से कौन सा कथन सत्य नहीं है?)
(A) It works on both arrays and linked lists
(B) It requires the input array to be sorted in ascending order before execution
(C) Its best-case time complexity is O(1)
(D) Its iterative auxiliary space complexity is O(1)
Correct Answer: (B)
[EN] Requiring sorted order is a prerequisite of Binary Search, NOT Linear Search.
[HI] सॉर्टेड एरे की आवश्यकता बाइनरी सर्च की शर्त है, लीनियर सर्च अनसॉर्टेड डेटा पर भी काम करता है।
Q16. In C/Python, if an array of 50 elements holds keys in random order and 1000 lookups must be run on it, why is sorting once + Binary Search better than 1000 Linear Searches?
(यदि 50 तत्वों (या बड़े n) पर 1000 बार खोज करनी हो, तो पहले सॉर्ट करके बाइनरी सर्च चलाना बार-बार लीनियर सर्च से बेहतर क्यों माना जाता है?)
(A) Because Linear Search mutates the array on each lookup
(B) Because sorting reduces space complexity to O(0)
(C) The O(n log n) sorting cost is amortized over many O(log n) queries instead of paying O(n) every query
(D) Because Binary Search also works without sorting
Correct Answer: (C)
[EN] Amortizing one sort O(n log n) + q * O(log n) beats q * O(n) whenever query count q is large.
[HI] अधिक खोज (Queries) होने पर एक बार सॉर्ट करने की लागत बंट जाती है और हर खोज O(log n) में तेज पूरी होती है।
Q17. Within Linear Search Algorithm: Working, Best O(1), Worst O(n), which search scenario directly maps to: "Exactly 1 comparison; Time O(1)"?
(Linear Search Algorithm: Working, Best O(1), Worst O(n) में कौन सा Search Scenario सीधे "Exactly 1 comparison; Time O(1)" से संबंधित है?)
(A) Best Case (First Element Hit)
(B) Sentinel Variant Optimization
(C) Average Case (Uniform Match)
(D) Worst Case (Miss or Last Slot)
Correct Answer: (A)
[EN] In Linear Search Algorithm: Working, Best O(1), Worst O(n), 'Best Case (First Element Hit)' handles 'Exactly 1 comparison; Time O(1)' (Target resides at arr[0], loop exits immediately).
[HI] Linear Search Algorithm: Working, Best O(1), Worst O(n) में 'Best Case (First Element Hit)' का कार्य/विवरण 'Exactly 1 comparison; Time O(1)' (Target resides at arr[0], loop exits immediately) है।
Q18. Which option accurately describes 'Average Case (Uniform Match)' in Linear Search Algorithm: Working, Best O(1), Worst O(n)?
(Linear Search Algorithm: Working, Best O(1), Worst O(n) के संदर्भ में 'Average Case (Uniform Match)' की सही विशेषता कौन सी है?)
(A) Drops i < n check inside loop
(B) (n + 1) / 2 comparisons; Time O(n)
(C) Exactly 1 comparison; Time O(1)
(D) n value comparisons; Time O(n)
Correct Answer: (B)
[EN] 'Average Case (Uniform Match)' provides '(n + 1) / 2 comparisons; Time O(n)' — key point: Each of n indices has equal 1/n probability.
[HI] 'Average Case (Uniform Match)' का मुख्य विवरण '(n + 1) / 2 comparisons; Time O(n)' है (Each of n indices has equal 1/n probability)।
Q19. In Linear Search Algorithm: Working, Best O(1), Worst O(n), identify the correct parameter for the specification: "n value comparisons; Time O(n)".
(Linear Search Algorithm: Working, Best O(1), Worst O(n) में "n value comparisons; Time O(n)" विवरण किस विकल्प के लिए सही है?)
(A) Sentinel Variant Optimization
(B) Worst Case (Miss or Last Slot)
(C) Average Case (Uniform Match)
(D) Best Case (First Element Hit)
Correct Answer: (B)
[EN] 'Worst Case (Miss or Last Slot)' corresponds to 'n value comparisons; Time O(n)' (Scans entire array when target is at arr[n-1] or absent).
[HI] 'Worst Case (Miss or Last Slot)' का संबंध 'n value comparisons; Time O(n)' (Scans entire array when target is at arr[n-1] or absent) से है।
Q20. Considering Linear Search Algorithm: Working, Best O(1), Worst O(n), what key behavior defines 'Sentinel Variant Optimization'?
(Linear Search Algorithm: Working, Best O(1), Worst O(n) में 'Sentinel Variant Optimization' की मुख्य भूमिका या मान क्या है?)
(A) Drops i < n check inside loop
(B) (n + 1) / 2 comparisons; Time O(n)
(C) n value comparisons; Time O(n)
(D) Exactly 1 comparison; Time O(1)
Correct Answer: (A)
[EN] 'Sentinel Variant Optimization' represents 'Drops i < n check inside loop' (Places key at boundary to cut branching overhead in half).
[HI] 'Sentinel Variant Optimization' का अर्थ/मान 'Drops i < n check inside loop' है (Places key at boundary to cut branching overhead in half)।
Linear Search Algorithm: Working, Best O(1), Worst O(n) — Exam FAQs
Q1: When should I prefer Linear Search over Binary Search?
बाइनरी सर्च की तुलना में लीनियर सर्च को कब प्राथमिकता देनी चाहिए?
[EN] Prefer Linear Search when the dataset is unsorted and only a few lookups are needed, when the dataset is very small (typically under 30 elements), or when using a linked list without random access.
[HI] जब डेटा अनसॉर्टेड हो और केवल एक-दो बार खोज करनी हो, डेटा बहुत छोटा हो, या लिंक्ड लिस्ट जैसी संरचना उपयोग हो रही हो जहाँ सीधे इंडेक्स एक्सेस न हो, तब लीनियर सर्च बेहतर है।
Q2: Why is recursive Linear Search discouraged in production for large arrays?
बड़े एरे के लिए रिकर्सिव लीनियर सर्च का उपयोग करने से क्यों बचना चाहिए?
[EN] Each recursive call pushes a frame onto the call stack, consuming O(n) extra memory and risking a Stack Overflow crash when n reaches tens of thousands, whereas iterative search uses O(1) space.
[HI] रिकर्सिव संस्करण हर तत्व के लिए कॉल स्टैक में एक फ्रेम जोड़ता है जिससे O(n) मेमोरी खर्च होती है और बड़े n पर Stack Overflow एरर आ सकता है, जबकि इटरेटिव रूप में केवल O(1) स्पेस लगता है।
Q3: Does Sentinel Linear Search improve Big-O complexity?
क्या सेंटिनल लीनियर सर्च से Big-O टाइम कॉम्प्लेक्सिटी बदलती है?
[EN] No. Asymptotic complexity remains O(n), though constant factors drop noticeably because the inner loop drops the boundary check (i < n).
[HI] नहीं। इसकी असिम्प्टोटिक कॉम्प्लेक्सिटी O(n) ही रहती है, लेकिन लूप के भीतर सीमा जांच (i < n) हटने से वास्तविक चलने का समय काफी कम हो जाता है।
Post a Comment
Post a Comment