बाइनरी सर्च ट्री: क्रम का नियम और खोज

बाइनरी ट्री से खोज के नियम तक

पिछले पाठ में बाइनरी ट्री का रूट, बाएँ और दाएँ बच्चे, सबट्री तथा ट्रैवर्सल के क्रम पढ़े थे। सामान्य बाइनरी ट्री में कोई भी मान रख सकते हैं; केवल आकृति से यह तय नहीं होता कि माँगा गया मान किस शाखा में होगा। इस पाठ में क्रम का अनुबंध जोड़कर नीचे जाने वाले एक ही रास्ते पर खोज करेंगे।

पूर्वज्ञान: पिछला बाइनरी-ट्री पाठ, ऐरे-इंडेक्स लिंक, struct, const ऐरे पैरामीटर, if, while, for और फ़ंक्शन के लौटाए मान। वही सीमित रिकॉर्ड मॉडल value, left, right, CAP = 7 और END = -1 रखेंगे। आप वैध बाइनरी सर्च ट्री (BST) पहचानेंगे, मौजूद और अनुपस्थित मान की खोज ट्रेस करेंगे तथा समझेंगे कि एक शाखा को क्यों छोड़ा जा सकता है। यह GATE CS की तैयारी का आधारभूत पाठ है, पूरे पाठ्यक्रम का कवरेज नहीं।

क्रम का नियम पूरे सबट्री पर लागू होता है

हमारे BST में अलग-अलग पूर्णांक कुंजियाँ (keys) हैं। हर नोड पर:

• उसके पूरे बाएँ सबट्री में प्रत्येक कुंजी उस नोड की कुंजी से सख्ती से छोटी है।
• उसके पूरे दाएँ सबट्री में प्रत्येक कुंजी उस नोड की कुंजी से सख्ती से बड़ी है।
• दोनों सबट्री अपने भीतर भी यही नियम मानते हैं।

“पूरे” में बच्चे, उनके बच्चे और सभी गहरे वंशज शामिल हैं। केवल सीधे बच्चों को जाँचना पर्याप्त नहीं। मानें रूट 50 का बायाँ बच्चा 30 है और उस 30 का दायाँ बच्चा 55 है। सीधे संबंधों की दोनों तुलना 30 < 50 और 55 > 30 सही हैं। फिर भी 55, रूट 50 के बाएँ सबट्री में है और 50 से बड़ा है। यह बाइनरी ट्री है, लेकिन हमारे अनुबंध का BST नहीं। यह केवल अवधारणात्मक प्रतिउदाहरण है; इसे नीचे दिए खोज प्रोग्राम में न दें।

पूर्वजों की सीमाएँ साथ-साथ लागू होती हैं। 30 के दाएँ सबट्री और 50 के बाएँ सबट्री में आने वाले नोड का मान 30 से बड़ा और 50 से छोटा दोनों होना चाहिए। कागज़ पर जाँचते समय रास्ते के साथ अनुमत खुला अंतराल रख सकते हैं। C में value - 1 या value + 1 निकालने की आवश्यकता नहीं; int की अंतिम सीमाओं पर ये गणनाएँ ओवरफ़्लो कर सकती हैं।

डुप्लिकेट की स्पष्ट नीति

यह पाठ केवल अलग-अलग कुंजियों वाले ट्री में खोज करता है। दोहराई गई कुंजियाँ वैध इनपुट अनुबंध के बाहर हैं। यहाँ जोड़ने, डुप्लिकेट अस्वीकार करने, हटाने या संतुलन बनाने का फ़ंक्शन नहीं है। आगे इस मॉडल में insertion जोड़ें, तो बराबर कुंजी मिलने पर नया नोड बनाने के बजाय “पहले से मौजूद” बताना चाहिए। दूसरे BST डिज़ाइन डुप्लिकेट की गिनती रख सकते हैं या बराबर कुंजियाँ किसी निर्धारित ओर रख सकते हैं, लेकिन तब उनके नियम और सभी ऑपरेशन उसी नीति के अनुसार बनाने होंगे। उन नीतियों को इस सख्त क्रम वाले पाठ में चुपचाप न मिलाएँ। एक ही कुंजी को दो बार खोजने से डुप्लिकेट नहीं बनता और ट्री बदलता नहीं।

सीमित निरूपण और कॉलर की ज़िम्मेदारी

Node में क्रम से तीन int फ़ील्ड हैं: रखी कुंजी value, बाएँ बच्चे का इंडेक्स left और दाएँ बच्चे का इंडेक्स right। nodes[2].left लिंक पढ़ता है, बाएँ बच्चे का डेटा नहीं। रूट या बच्चे के लिंक में END का अर्थ कोई नोड नहीं है। डेटा में -1 एक साधारण कुंजी है। खोज का लौटा पूर्णांक एक इंडेक्स है, कुंजी नहीं।

हर bst_search कॉल के लिए कॉलर को यह सुनिश्चित करना है:

1. CAP आरंभिक मानों वाले Node रिकॉर्ड का जीवित ऐरे हो, जो कॉल के दौरान बदले नहीं। C में const Node nodes[] पॉइंटर पैरामीटर बनता है; फ़ंक्शन क्षमता न खोजता है, न उसके लिए मेमोरी बनाता है।
2. root, END या 0 से CAP - 1 तक वैध इंडेक्स हो। रूट से पहुँचने वाले हर बच्चे का लिंक भी END या वैध इंडेक्स हो।
3. पहुँचने योग्य नोड एक सीमित, चक्र-रहित रूट वाला ट्री बनाएँ: कोई चक्र नहीं और दो parent लिंक एक ही नोड को साझा न करें। हर ट्री सदस्य तक रूट से पहुँचना चाहिए। न पहुँचने वाले ऐरे स्लॉट अतिरिक्त भंडारण हैं, सदस्य नहीं; इस मॉडल में used गिनती नहीं है।
4. ऊपर का सख्त, पूरे सबट्री वाला BST क्रम और अद्वितीय कुंजियों का नियम लागू हो।

खाली ट्री में root = END होता है, भले ही पीछे के ऐरे रिकॉर्ड में आरंभिक मान रखे हों। सदस्यता केवल पहुँच से तय होती है। फ़ंक्शन इस अनुबंध पर भरोसा करता है; मनमाने लिंक की वैधता जाँचने वाला फ़ंक्शन नहीं है। गलत इंडेक्स से अमान्य C पठन, चक्र से कभी न रुकने वाला लूप और गलत क्रम से मौजूद कुंजी का छूटना संभव है। अविश्वसनीय रिकॉर्ड के लिए पहले अलग संरचना और क्रम जाँच फ़ंक्शन चाहिए; केवल इंडेक्स की सीमा जाँचना पर्याप्त नहीं। इस पाठ के सभी चलाने योग्य उदाहरण और परीक्षण अनुबंध पूरा करते हैं।

एक ट्री, दो अलग क्रम

प्रोग्राम के रिकॉर्ड नीचे हैं; root का इंडेक्स 2 है:

रूट का डेटा 50 है; उसके बाएँ सबट्री में 30, 20, 40 और दाएँ सबट्री में 70, 60, 80 हैं। ऐरे में भौतिक क्रम 30, 70, 50, 20, 40, 60, 80 है। इसका क्रमबद्ध होना आवश्यक नहीं। इनऑर्डर (बायाँ, नोड, दायाँ) ट्रैवर्सल से 20, 30, 40, 50, 60, 70, 80 मिलता है। अद्वितीय कुंजियों वाले वैध BST का इनऑर्डर डेटा सख्ती से बढ़ता है। प्रीऑर्डर और पोस्टऑर्डर सामान्यतः क्रमबद्ध नहीं होते।

यहाँ 2*i + 1 और 2*i + 2 से बच्चे के इंडेक्स न निकालें। यह स्पष्ट लिंक वाला निरूपण है और रूट इंडेक्स 2 पर है; यह स्तर-क्रम में भरे हीप का निरूपण नहीं है।

खोज के निर्णय और उनका कारण

मौजूदा नोड x पर पहले बराबरी जाँचें। बराबर होने पर x का इंडेक्स लौटाएँ। key < x.value हो तो x.left पर जाएँ: x उत्तर नहीं है और दाएँ सबट्री की हर कुंजी बहुत बड़ी है। key > x.value हो तो इसी तर्क से x.right पर जाएँ। END आने का अर्थ बचा उम्मीदवार सबट्री खाली है; अनुपस्थिति के लिए END लौटाएँ। nodes[END] न पढ़ें।

लूप का अपरिवर्तित कथन (invariant) है: माँगी कुंजी मूल ट्री में मौजूद है और अभी नहीं मिली है, तो वह current वाले सबट्री में होगी। हर तुलना दूसरी शाखा छोड़ते हुए इस कथन को सही रखती है। वैध सीमित ट्री में हर कदम बच्चे की ओर जाता है, इसलिए अंततः बराबरी या END मिलेगा। current चलता है; रखा हुआ root और सभी रिकॉर्ड वैसे ही रहते हैं।

हल सहित ट्रेस 1: मौजूद कुंजी 60

तीन नोड जाँचे गए। उत्तर 5 है, 60 नहीं। परिणाम END नहीं है, यह सुनिश्चित करने के बाद ही nodes[5].value पढ़ें। खोज 30, 20, 40 या 80 पर नहीं जाती।

हल सहित ट्रेस 2: अनुपस्थित कुंजी 65

इसका अर्थ 65 संख्या अमान्य होना नहीं, केवल उसका ट्री में न होना है। BST नियम सही हो तो इस विफलता के बाद रूट 50 के बाएँ सबट्री में खोजने का कोई लाभ नहीं।

हल सहित ट्रेस 3: खाली और एक-नोड सीमाएँ

root = END हो तो हर खोज शून्य लूप पुनरावृत्ति के बाद END लौटाती है। root = 0 और नोड 0 = { -1, END, END } हो तो search(-1) एक नोड जाँचकर इंडेक्स 0 लौटाती है। search(0) दाएँ END पर जाकर END लौटाती है। search(-2) बाएँ END पर जाकर END लौटाती है। हर स्थिति में इंडेक्स से पढ़ने से पहले END जाँचा जाता है; -1 कुंजी को अनुपस्थिति नहीं माना जाता, क्योंकि मौजूद कुंजी का उत्तर उसका गैर-ऋणात्मक इंडेक्स है।

पूरा C11 प्रोग्राम

इस पूरे प्रोग्राम में केवल आरंभिक मानों वाला निश्चित आकार का भंडारण है; डायनैमिक मेमोरी आवंटन नहीं। ऊपर का अनुबंध आवश्यक पूर्वशर्त है, रनटाइम वैधता जाँच का दावा नहीं।

#include <stdio.h>

enum { CAP = 7, END = -1 };

typedef struct {
    int value;
    int left;
    int right;
} Node;

/* Caller supplies CAP initialized records and a valid unique-key BST.
   root is END or a valid index. Every reachable link is END or an
   index in [0, CAP). Reachable nodes form an acyclic tree (no sharing).
   At every node, all left-subtree keys are smaller and all right-
   subtree keys are larger. Unreachable slots are not tree members. */
int bst_search(const Node nodes[], int root, int key) {
    int current = root;
    while (current != END) {
        if (key == nodes[current].value) {
            return current;
        }
        if (key < nodes[current].value) {
            current = nodes[current].left;
        } else {
            current = nodes[current].right;
        }
    }
    return END;
}

int main(void) {
    const Node nodes[CAP] = {
        {30, 3, 4},
        {70, 5, 6},
        {50, 0, 1},
        {20, END, END},
        {40, END, END},
        {60, END, END},
        {80, END, END}
    };
    const int root = 2;
    const int keys[3] = {60, 65, 50};
    for (int i = 0; i < 3; i = i + 1) {
        int index = bst_search(nodes, root, keys[i]);
        if (index == END) {
            printf("%d: absent\n", keys[i]);
        } else {
            printf("%d: index %d, value %d\n",
                   keys[i], index, nodes[index].value);
        }
    }
    return 0;
}

सटीक आउटपुट:

60: index 5, value 60
65: absent
50: index 2, value 50

छोटा होने की शाखा से पहले बराबरी जाँची गई है, इसलिए अंतिम else का अर्थ सख्ती से बड़ा होना है। कोड संख्याओं को घटाने के बजाय सीधे तुलना करता है, इसलिए INT_MIN जितनी छोटी और INT_MAX जितनी बड़ी कुंजियाँ भी तुलना में ओवरफ़्लो नहीं करतीं। const इस पैरामीटर से लेखन रोकता है; अमान्य इनपुट को वैध नहीं बनाता।

लागत ऊँचाई से तय होती है, “बाइनरी” शब्द से नहीं

पिछले पाठ का ऊँचाई नियम रखें: गैर-खाली ट्री की ऊँचाई h, रूट से पत्ती के सबसे लंबे रास्ते के किनारों की संख्या है; एक नोड की ऊँचाई 0 है। खोज अधिकतम h + 1 नोड जाँचती है और खाली ट्री में कोई नोड नहीं। रूट पर सफलता में एक नोड जाँचते हैं। प्रत्येक नोड पर स्थिर मात्रा का काम होता है, इसलिए गैर-खाली ट्री में सबसे खराब खोज समय O(h + 1) है; लूप वाली खोज O(1) अतिरिक्त स्थान लेती है। CAP-रिकॉर्ड इनपुट ऐरे पहले से दिया भंडारण है, नई कार्यशील मेमोरी नहीं।

यहाँ O(...) बताता है कि पर्याप्त बड़े इनपुट पर स्थिर गुणकों को छोड़कर संसाधन की वृद्धि की ऊपरी सीमा क्या है। O(1) अतिरिक्त स्थान का अर्थ n से स्वतंत्र निश्चित मात्रा है। O(log n) लघुगणकीय वृद्धि है: n दुगुना करने पर इस वृद्धि के पैमाने में केवल सीमित मात्रा जुड़ती है। O(n), अर्थात रैखिक वृद्धि, नोड संख्या के अनुपात में काम की अनुमति देती है। सीमा का अर्थ यह नहीं कि हर खोज में अधिकतम काम ही होगा।

संतुलित BST के परिवार में नोड संख्या n बढ़ने पर ऊँचाई लघुगणकीय रूप से बढ़ती है, इसलिए सबसे खराब खोज समय भी लघुगणकीय होता है। केवल BST क्रम संतुलन की गारंटी नहीं देता। 10 ->दायाँ 20 ->दायाँ 30 ->दायाँ 40 एक वैध BST है, जिसकी ऊँचाई 3 है। 40 खोजने में चार नोड जाँचते हैं। बड़ी शृंखला में सभी n नोड जाँचने पड़ सकते हैं, इसलिए सबसे खराब BST खोज रैखिक भी हो सकती है। वृद्धि के ये कथन बड़ी क्षमताओं पर इसी एल्गोरिदम के बारे में हैं; यह प्रदर्शन स्वयं सात रिकॉर्ड तक सीमित है। कम्प्लीट, फुल और परफ़ेक्ट होना आकृति की विशेषताएँ हैं, BST क्रम से अलग।

सीमित उपमा

सात नंबर वाले कमरों की एक निर्देशिका सोचें। हर कमरे में खोजने योग्य एक अलग संख्या और दो दिशा-संकेत हैं। बायाँ संकेत केवल छोटी संख्याओं वाले भाग में ले जाता है; दायाँ संकेत केवल बड़ी संख्याओं वाले भाग में। आगे के हर कमरे को पहले के संकेतों से मिली सीमाएँ भी माननी हैं। कमरे का नंबर ऐरे इंडेक्स है; उसमें दिखाई संख्या उसकी कुंजी है। “कोई कमरा नहीं” संकेत पर दूसरा कमरा खोले बिना खोज रुकती है।

यह उपमा बताती है कि एक भाग क्यों छोड़ सकते हैं। इसमें सही संकेत, चक्र का न होना और पूरे सबट्री का बताया क्रम पहले से मानते हैं। यह बराबर आकार के भाग, लघुगणकीय यात्रा समय या खराब संकेतों पर सुरक्षा की गारंटी नहीं देती। वास्तविक BST को नंबर वाले ऐरे स्लॉट इस्तेमाल करना आवश्यक नहीं।

मुख्य बातें

• केवल बाइनरी-ट्री आकृति से खोज का क्रम नहीं मिलता।
• हर वंशज पर सभी संबंधित पूर्वजों की सीमाएँ लागू होती हैं, केवल parent की नहीं।
• अलग कुंजियों में बायाँ सबट्री सख्ती से छोटा और दायाँ सख्ती से बड़ा होता है।
• असमान कुंजी पर खोज एक शाखा लेती है; यह पूरे ट्री का ट्रैवर्सल नहीं है।
• सफलता पर इंडेक्स और अनुपस्थिति पर END लौटाएँ; -1 फिर भी डेटा की कुंजी हो सकती है।
• खाली ट्री में root = END है। खोज root या रिकॉर्ड नहीं बदलती।
• O(h + 1) काम से, ऊँचाई की गारंटी के बिना, O(log n) निष्कर्ष नहीं निकलता।
• वैध भंडारण, लिंक, संरचना और क्रम कॉलर देता है; यह खोज उनकी जाँच नहीं करती।

जाँच सहित दो अतिरिक्त अभ्यास

1. सात-नोड उदाहरण में search(40) और search(10) ट्रेस करें। जाँच: 40 के लिए इंडेक्स 2, 0, 4 पर जाकर 4 लौटाते हैं। 10 के लिए 2, 0, 3 और फिर बायाँ END मिलता है; END लौटाते हैं। दोनों में तीन नोड जाँचे गए, हालाँकि केवल एक खोज सफल है।
2. कागज़ पर इंडेक्स 4 का केवल डेटा 40 से 55 करें। कौन-सा नियम टूटता है और बदले रिकॉर्ड को वैध BST मानकर क्यों नहीं देना चाहिए? जाँच: 55 अपने parent 30 से बड़ा है लेकिन रूट 50 के बाएँ सबट्री में है, इसलिए पूर्वज की ऊपरी सीमा टूटती है। 55 खोजने पर रूट की दाईं शाखा में जाने से यह छूट जाएगा। यह तर्क का उदाहरण है, वैध-इनपुट प्रोग्राम परीक्षण नहीं।

छह मौलिक अभ्यास प्रश्न

ठीक एक विकल्प चुनें। ये मौलिक आधारभूत अभ्यास हैं, पिछले वर्ष के प्रश्न या पूरा मॉक पेपर नहीं।

1

रूट 50 का बायाँ बच्चा 30 है और उस 30 का दायाँ बच्चा 55 है; अन्य नोड नहीं हैं। कौन-सा कथन सही है?

A. यह वैध BST है क्योंकि हर बच्चा अपने parent से सही तुलना करता है। B. यह BST नहीं है क्योंकि 55 पूर्वज 50 की सीमा तोड़ता है। C. यह बाइनरी ट्री नहीं है क्योंकि 30 का दायाँ बच्चा है। D. केवल क्रमबद्ध ऐरे इंडेक्स पर रिकॉर्ड रखने से यह वैध BST हो जाएगा।

2

प्रोग्राम के सात-नोड ट्री में search(60) कौन-से इंडेक्स जाँचती है और क्या लौटाती है?

A. 2, 0, 4; 4 लौटाती है B. 50, 70, 60; 60 लौटाती है C. 2, 1, 5; 5 लौटाती है D. 2, 1, 6; END लौटाती है

3

वैध एक-नोड ट्री में root = 0 और nodes[0] = {-1, END, END} है। bst_search(nodes, root, -1) क्या लौटाता है?

A. 0 B. END, क्योंकि -1 कुंजी नहीं हो सकती C. 1, क्योंकि मिलान सत्य है D. nodes[-1] का डेटा

4

इस पाठ की नीति में bst_search के लिए कौन-सा इनपुट स्वीकार्य है?

A. चक्र वाली संरचना, यदि सभी इंडेक्स सीमा में हों B. कुंजियों के किसी भी क्रम वाला हर बाइनरी ट्री C. डुप्लिकेट कुंजियाँ मनमानी ओर रखने वाला ट्री D. वैध लिंक और सख्त अद्वितीय-कुंजी सबट्री क्रम वाला चक्र-रहित, बिना साझा नोड का ट्री

5

वैध BST शृंखला 10 ->दायाँ 20 ->दायाँ 30 ->दायाँ 40 है। 40 खोजते समय कितने नोड जाँचे जाते हैं?

A. एक, क्योंकि 40 सबसे बड़ी कुंजी है B. दो, क्योंकि हर BST खोज नोड संख्या आधी करती है C. चार, क्योंकि क्रम संतुलित आकृति की गारंटी नहीं देता D. तीन, क्योंकि ऊँचाई किनारों की संख्या है

6

प्रोग्राम के सात-नोड ट्री में 65 खोजते समय क्या होता है?

A. खोज इंडेक्स 5 लौटाती है क्योंकि 60 सबसे पास का जाँचा मान है। B. यह इंडेक्स 2, 1, 5, फिर END पर जाकर END लौटाती है। C. अनुपस्थिति जाँचने के लिए nodes[-1] पढ़ती है। D. दाईं खोज विफल होने पर पूरा बायाँ सबट्री देखना आवश्यक है।

व्याख्या सहित उत्तर

1. B

A गलत है: सीधे parent की तुलना से पूर्वजों की सीमाएँ छूट सकती हैं।

B सही है: 50 के बाएँ सबट्री में 55 सहित हर नोड का मान 50 से छोटा होना चाहिए।

C गलत है: बाइनरी-ट्री नोड का दायाँ बच्चा हो सकता है; यह आकृति स्वीकार्य है।

D गलत है: BST क्रम सबट्री संबंधों में डेटा का नियम है, ऐरे के भौतिक क्रम का नहीं।

2. C

A गलत है: 60 रूट की कुंजी 50 से बड़ा है, इसलिए पहली शाखा दाईं है, बाईं नहीं।

B गलत है: ये कुंजियाँ हैं, इंडेक्स नहीं; सफलता में इंडेक्स 5 मिलता है।

C सही है: इंडेक्स 2, 1, 5 पर क्रम से 50, 70, 60 की तुलना होती है।

D गलत है: कुंजी 70 पर छोटा लक्ष्य 60 बाएँ इंडेक्स 5 भेजता है, दाएँ 6 नहीं।

3. A

A सही है: इंडेक्स 0 पर बराबरी मिलने से 0 लौटता है; कुंजी और लौटे इंडेक्स के काम अलग हैं।

B गलत है: END लिंक और लौटे इंडेक्स का संकेत है, -1 कुंजी पर प्रतिबंध नहीं।

C गलत है: यह API इंडेक्स लौटाती है, बूलियन सफलता-संकेत नहीं।

D गलत है: बराबरी पर END इंडेक्स पढ़े बिना इंडेक्स 0 लौटता है।

4. D

A गलत है: सीमा के भीतर इंडेक्स होने से चक्र नहीं मिटता; चक्र-रहित संरचना कॉलर की आवश्यक ज़िम्मेदारी है।

B गलत है: खोज क्रम के आधार पर शाखाएँ छोड़ती है; सामान्य बाइनरी ट्री में वह क्रम आवश्यक नहीं।

C गलत है: डुप्लिकेट इस पाठ के अनुबंध से बाहर हैं; मनमानी डुप्लिकेट नीति स्वीकार्य नहीं।

D सही है: CAP आरंभिक रिकॉर्ड के भंडारण के साथ यही संरचना और क्रम की आवश्यकताएँ हैं।

5. C

A गलत है: अधिकतम की अलग पॉइंटर जानकारी नहीं है; यह खोज रूट 10 से लिंक पर चलती है।

B गलत है: चुने सबट्री में लगभग सभी बचे नोड हो सकते हैं; संतुलन अपने-आप नहीं मिलता।

C सही है: 10, 20, 30, 40 पर जाते हैं; ऊँचाई 3 लेकिन जाँचे नोड h + 1 = 4 हैं।

D गलत है: तीन किनारे चार जाँचे नोड जोड़ते हैं; किनारे और नोड की गिनती अलग है।

6. B

A गलत है: यह सटीक कुंजी की खोज है, सबसे पास का मान नहीं; 60 और 65 बराबर नहीं।

B सही है: तुलना 50 से दाएँ, 70 से बाएँ और 60 से दाएँ खाली सबट्री तक ले जाती है।

C गलत है: while की शर्त END से इंडेक्स करने से पहले रोकती है।

D गलत है: रूट 50 के बाएँ सबट्री की हर कुंजी 50 से छोटी है, इसलिए 65 नहीं हो सकती।

दायरा और अगला कदम

अब आप ट्री की आकृति और खोज के क्रम को अलग पहचानकर स्पष्ट अनुबंध में सटीक कुंजी की खोज ट्रेस कर सकते हैं। आगे BST क्रम और हीप क्रम की तुलना करें। जोड़ना, हटाना, संतुलन बनाना और औपचारिक शुद्धता-प्रमाण आगे के पाठों के विषय हैं। इस ऑफ़लाइन पाठ से पाठ्यक्रम का वर्ष, मूल्य या पहुँच सेटिंग नहीं बदलती। हिंदी सीखने में सहायक है; इससे आधिकारिक हिंदी GATE पेपर का दावा नहीं होता।