Factor में हैशटेबल एसोसिएटिव ऐरे होते हैं, यानी key/value जोड़ों का संग्रह, जिनमें O(1) लुकअप हो जाता है। ये बड़े assocs परिवार का हिस्सा हैं।
H{ { "coal" 1 } { "wood" 2 } } .
H{ } एक खाली हैशटेबल है। हैशटेबल परिवर्तनशील होते हैं: की जोड़ने और हटाने पर ये बढ़ते और घटते रहते हैं। अगर मूल हैशटेबल को वैसा ही छोड़ना हो, तो पहले clone कीजिए। हैशटेबल प्रिंट करने पर उसकी एंट्रियाँ दिखती हैं, लेकिन उनका क्रम डालने के क्रम से बँधा नहीं होता। हैशटेबल बिना किसी निश्चित क्रम के होते हैं।
at (assocs में) एक वैल्यू पढ़ता है, और अगर की मौजूद न हो तो f लौटाता है:
at ( key assoc -- value/f )
key? ( key assoc -- ? )
"coal" H{ { "coal" 1 } { "wood" 2 } } at . ! => 1
"gold" H{ { "coal" 1 } { "wood" 2 } } at . ! => f
set-at जोड़ता है या ऊपर लिख देता है; delete-at हटाता है; change-at मौजूदा वैल्यू पर एक कोटेशन चलाता है। ये तीनों हैशटेबल को बदल देते हैं:
set-at ( value key assoc -- )
delete-at ( key assoc -- )
change-at ( key assoc quot: ( old -- new ) -- )
H{ } clone 5 "coal" pick set-at .
! => H{ { "coal" 5 } }
inc-at: गिनती बढ़ाने का शॉर्टकटinc-at (यह भी assocs में) किसी की की मौजूदा वैल्यू में 1 जोड़ता है, और अगर की मौजूद न हो तो उसे 1 के रूप में डाल देता है। गिनती रखने के लिए बिल्कुल उपयुक्त:
inc-at ( key assoc -- )
H{ } clone "coal" over inc-at .
! => H{ { "coal" 1 } }
assoc-each हर ( key value -- ) जोड़े पर चलता है; cache किसी की की वैल्यू लौटाता है, और अगर की मौजूद न हो तो दिए गए कोटेशन से उसे एक बार गणना करके लौटाता है।
assoc-each ( assoc quot: ( key value -- ) -- )
cache ( key assoc quot: ( key -- value ) -- value )
cache एक ही शब्द में "देखो या बनाओ" वाला तरीका है। जब आप की की किसी धारा से हैशटेबल बना रहे हों और हर बार की गायब होने की स्थिति नहीं सँभालना चाहते हों, तब यह बहुत काम आता है।
जब इनपुट की का एक क्रम हो और आपको हर की के लिए हैशटेबल एक बार अपडेट करना हो, तो each से क्रम पर इटरेशन कीजिए और एक फ्राइड कोटेशन '[ _ … ] (fry से) इस्तेमाल कीजिए, जो हैशटेबल को लूप के अंदर के कोड में बाँध देता है। जैसे, की की एक सूची हटाना:
{ "wood" "iron" } H{ { "coal" 5 } { "wood" 3 } { "iron" 2 } } clone
[ '[ _ delete-at ] each ] keep .
! => H{ { "coal" 5 } }
'[ _ delete-at ] स्टैक पर अपने ऊपर रखे हैशटेबल को पकड़ लेता है, ताकि हर इटरेशन में each को सिर्फ की देनी पड़े। keep कोटेशन को चलाता है और साथ ही हैशटेबल को अंतिम . के लिए बचाए रखता है।
map>assoc (assocs में) एक क्रम पर कोटेशन लगाता है और ( elt -- key value ) के परिणामों को एग्ज़ेंप्लर के टाइप वाले assoc में इकट्ठा करता है:
map>assoc ( seq quot: ( elt -- key value ) exemplar -- assoc )
{ "wood" } [ dup length ] H{ } map>assoc .
! => H{ { "wood" 4 } }
keys और values (assocs में) सिर्फ की या सिर्फ वैल्यू लौटाते हैं; >alist { key value } जोड़े लौटाता है।
keys ( assoc -- keys )
values ( assoc -- values )
>alist ( assoc -- alist )
H{ { "wood" 11 } { "coal" 7 } } keys . ! the keys (order not guaranteed)
H{ { "wood" 11 } { "coal" 7 } } values . ! the matching values
keys और values एक-दूसरे से मेल खाते हैं: किसी जगह पर मौजूद वैल्यू उसी जगह वाली की की होती है।
sort-keys (sorting में) { key value } जोड़ों को की के अनुसार क्रम में लगाकर लौटाता है:
H{ { "wood" 11 } { "coal" 7 } } sort-keys .
! => { { "coal" 7 } { "wood" 11 } }
>hashtable (hashtables में) >alist का उल्टा है: यह किसी भी assoc को, जो अक्सर { key value } जोड़ों की एक alist होती है, O(1) लुकअप वाले हैशटेबल में बदल देता है।
>hashtable ( assoc -- hashtable )
{ { "coal" 7 } { "wood" 11 } } >hashtable .
! => H{ { "wood" 11 } { "coal" 7 } } (entry order not guaranteed)
यह तब काम आता है जब आपने जोड़ों की कोई सूची बनाई या बदली हो और आप उसे वापस हैशटेबल में डालकर की के ज़रिए एंट्रियाँ ढूँढना चाहते हों।
आप जहाज़ के पर्सर हैं और पेंट्री की इन्वेंटरी संभालते हैं। इन्वेंटरी एक हैशटेबल है। इसमें हर की एक चीज़ का नाम होती है और उसकी वैल्यू बताती है कि भंडार में उस चीज़ की कितनी मात्रा मौजूद है।
create-inventory बनाइए, जो चीज़ों के नामों का एक सीक्वेंस लेता है और एक हैशटेबल लौटाता है, जो हर अलग नाम को उसकी गिनती के साथ जोड़ता है।
{ "coal" "wood" "wood" "diamond" "diamond" "diamond" } create-inventory .
! => H{ { "coal" 1 } { "wood" 2 } { "diamond" 3 } }
add-items बनाइए, जो एक इन्वेंटरी और चीज़ों का एक सीक्वेंस लेता है और एक नई इन्वेंटरी लौटाता है, जिसमें सूची की हर चीज़ की गिनती बढ़ा दी गई हो। मूल इन्वेंटरी में कोई बदलाव नहीं होना चाहिए।
H{ { "coal" 1 } } { "wood" "iron" "coal" "wood" } add-items .
! => H{ { "coal" 2 } { "wood" 2 } { "iron" 1 } }
decrement-items बनाइए, जो एक इन्वेंटरी और चीज़ों का एक सीक्वेंस लेता है और एक नई इन्वेंटरी लौटाता है, जिसमें सूची की हर चीज़ की गिनती एक-एक कम कर दी गई हो। गिनती कभी भी शून्य से नीचे नहीं जानी चाहिए, और जो चीज़ें पहले से इन्वेंटरी में नहीं हैं उन्हें छोड़ देना चाहिए (ऋणात्मक प्रविष्टियाँ दर्ज नहीं की जाती हैं)।
H{ { "coal" 3 } { "diamond" 1 } { "iron" 5 } }
{ "diamond" "coal" "iron" "iron" } decrement-items .
! => H{ { "coal" 2 } { "diamond" 0 } { "iron" 3 } }
remove-item बनाइए, जो एक इन्वेंटरी और एक चीज़ लेता है और उस चीज़ को हटाकर एक नई इन्वेंटरी लौटाता है। अगर वह चीज़ मौजूद न हो, तो बिना बदली हुई एक प्रति लौटाइए।
H{ { "coal" 2 } { "wood" 1 } { "diamond" 2 } } "coal" remove-item .
! => H{ { "wood" 1 } { "diamond" 2 } }
list-inventory बनाइए, जो एक इन्वेंटरी लेता है और { name quantity } जोड़ों का एक ऐरे लौटाता है। उसमें सिर्फ़ वे चीज़ें होंगी जिनकी मात्रा शून्य से अधिक है, और उसे नाम के अक्षर-क्रम में लगाया गया होगा।
H{ { "coal" 7 } { "wood" 11 } { "diamond" 2 } { "iron" 7 } { "silver" 0 } }
list-inventory .
! => { { "coal" 7 } { "diamond" 2 } { "iron" 7 } { "wood" 11 } }
Exercism पर साइन अप कीजिए और Factor को 47 कॉन्सेप्ट163 अभ्यास तथा असली इंसानों से मिलने वाली मेंटरिंग के साथ सीखिए और उसमें महारत हासिल कीजिए, वह भी बिल्कुल मुफ्त।