निर्देश
किसी खेल के खिलाड़ी की हाई स्कोर ऐरे संभालिए।
आपको क्लासिक Frogger खेल का हाई स्कोर कंपोनेंट बनाना है। Frogger अब तक के सबसे अधिक बिकने वाले और सबसे लत लगाने वाले खेलों में से एक है, और आर्केड युग का एक क्लासिक भी।
आपको ऐसे मेथड लिखने हैं जो ऐरे से सबसे अधिक स्कोर, सबसे बाद में जोड़ा गया स्कोर और सबसे अधिक वाले तीन स्कोर लौटाते हैं।
AWK में सॉर्टिंग
इस अभ्यास में आउटपुट को एक खास क्रम में सॉर्ट करना ज़रूरी है।
बहुत सी प्रोग्रामिंग भाषाओं की तरह, ऐरे पर एक-एक करके चलने का क्रम इस बात पर निर्भर करता है कि भाषा को कैसे लागू किया गया है, और वह देखने में बेतरतीब लगता है।
आम तौर पर इंसान यह क्रम देखना नहीं चाहते।
GNU awk में सॉर्ट करने की कुछ सुविधाएँ हैं।
-
asort, संख्यात्मक इंडेक्स वाले ऐरे को उसकी वैल्यू के आधार पर सॉर्ट करता है।
#!gawk
BEGIN {
for (i = 1; i <= 5; i++)
nums[i] = int(100 * rand())
# returns the array size
n = asort(nums, sorted)
for (i = 1; i <= n; i++)
print i, nums[i], sorted[i]
}
जिसका आउटपुट यह होता है
1 92 30
2 59 57
3 30 59
4 57 74
5 74 92
n = asort(array) रूप दिए गए ऐरे को उसी जगह पर सॉर्ट कर देता है।
यह संख्यात्मक इंडेक्स वाले ऐरे के लिए सबसे उपयोगी है।
sorted ऐरे को भरने वाली प्रक्रिया मूल ऐरे के इंडेक्स हटा देती है:
sorted ऐरे का इंडेक्स 1 से n तक होता है।
-
asorti, ऐरे को उसके इंडेक्स के आधार पर सॉर्ट करता है।
asorti फंक्शन एक "गंतव्य" ऐरे भरता है, जिसमें "स्रोत" ऐरे के इंडेक्स सॉर्ट होकर आते हैं।
#!gawk
BEGIN {
nums["foo"] = int(100 * rand())
nums["bar"] = int(100 * rand())
nums["qux"] = int(100 * rand())
print "unordered"
for (i in nums)
print i, nums[i]
print "ordered by index"
n = asorti(nums, sorted)
for (i = 1; i <= n; i++)
print sorted[i], nums[sorted[i]]
}
जिसका आउटपुट यह होता है
unordered
foo 92
qux 30
bar 59
ordered by index
bar 59
foo 92
qux 30
-
PROCINFO["sorted_in"], ऐरे को एक तय क्रम में ट्रैवर्स करता है।
बिल्ट-इन PROCINFO ऐरे में चल रही awk प्रक्रिया के बारे में बहुत सारी जानकारी होती है
इस ऐरे का एक दिलचस्प एलिमेंट sorted_in है
इस ऐरे की की की वैल्यू उस फंक्शन का नाम होती है, जो तय करती है कि for (indx in array) लूप ऐरे के इंडेक्स को किस क्रम में प्रोसेस करेंगे।
यह फंक्शन किसी यूज़र-डिफाइंड फंक्शन का नाम हो सकता है, या फिर कुछ काम के पहले से बने सॉर्टिंग फंक्शन भी हैं, जिनमें शामिल हैं:
-
"@ind_str_asc", "@ind_str_desc", ऐरे को इंडेक्स के आधार पर सॉर्ट करते हैं; वर्णानुक्रम में; बढ़ते या घटते क्रम में।
-
"@ind_num_asc", "@ind_num_desc", ऐरे को इंडेक्स के आधार पर सॉर्ट करते हैं; संख्यात्मक क्रम में; बढ़ते या घटते क्रम में।
-
"@val_str_asc", "@val_str_desc", ऐरे को वैल्यू के आधार पर सॉर्ट करते हैं; वर्णानुक्रम में; बढ़ते या घटते क्रम में।
-
"@val_num_asc", "@val_num_desc", ऐरे को वैल्यू के आधार पर सॉर्ट करते हैं; संख्यात्मक क्रम में; बढ़ते या घटते क्रम में।
ऊपर दिया गया asort वाला उदाहरण इस तरह लागू किया जा सकता है:
PROCINFO["sorted_in"] = "@val_num_asc"
for (idx in nums)
print idx, nums[idx]
3 30
4 57
2 59
5 74
1 92
asorti वाला उदाहरण इस तरह लिखा जा सकता है:
PROCINFO["sorted_in"] = "@ind_str_asc"
for (idx in nums)
print idx, nums[idx]
bar 59
foo 92
qux 30
इस तरीके से हम अस्थायी sorted ऐरे और n रिटर्न वैल्यू से बच जाते हैं।
साफ और सुथरा।
यूज़र-डिफाइंड सॉर्टिंग फंक्शन
यूज़र-डिफाइंड सॉर्टिंग फंक्शन 4 पैरामीटर लेता है:
एक ऐरे एलिमेंट का इंडेक्स और वैल्यू, और दूसरे ऐरे एलिमेंट का इंडेक्स और वैल्यू:
function compare(idx1, val1, idx2, val2) {...}
रिटर्न वैल्यू यह बताती है:
- शून्य से कम:
idx1, idx2 से पहले आता है
- शून्य से अधिक:
idx1, idx2 के बाद आता है
- शून्य: दोनों इंडेक्स का सॉर्टिंग क्रम समान होता है, लेकिन उनका आपसी क्रम तय नहीं होता।
for (idx in array) का क्रम तय करने वाले PROCINFO["sorted_in"] के अलावा, asort और asorti दोनों एक तुलना फंक्शन का नाम तीसरे पैरामीटर के रूप में ले सकते हैं।
संदर्भ
स्रोत
अस्सी के दशक के आर्केड गेम Frogger को श्रद्धांजलि
