ट्रैक
/
Factor
Factor
/
अभ्यास
/
निर्देशांकों की कोरियोग्राफी
निर्देशांकों की कोरियोग्राफी

निर्देशांकों की कोरियोग्राफी

सीखने का अभ्यास

परिचय

जब किसी क्वोटेशन को अपने आसपास से वैल्यू याद रखनी होती हैं, तो दूसरी भाषाएँ इसे क्लोज़र कहती हैं। ऐसी स्थिति में Factor दो टूल इस्तेमाल करता है: curry शब्द और '[ ] फ्राई सिंटैक्स।

curry: एक वैल्यू कैप्चर करना

curry (kernel में) एक वैल्यू और एक क्वोटेशन लेता है और उस वैल्यू को अंदर रखकर एक नया क्वोटेशन लौटाता है:

curry ( value quot -- newquot )
3 [ + ] curry .
! => [ 3 + ]

10 3 [ + ] curry call .
! => 13

दो वैल्यू कैप्चर करने के लिए curry को दो बार लगाइए:

2 3 [ + + ] curry curry .
! => [ 2 3 + + ]

compose: दो क्वोटेशन जोड़ना

compose (kernel में) दो क्वोटेशनों को आपस में जोड़ता है:

compose ( quot1 quot2 -- quot )
[ 1 + ] [ 2 * ] compose .
! => [ 1 + 2 * ]

5 [ 1 + ] [ 2 * ] compose call .
! => 12

फ्राई क्वोटेशन: कई वैल्यू कैप्चर करना

एक या दो से अधिक कैप्चर के लिए, curry को बार-बार लगाना पढ़ने में कठिन हो जाता है। फ्राई '[ … ] का उपयोग एक या अधिक _ प्लेसहोल्डर के साथ करता है; हर _ को डेटा स्टैक से निकाली गई वैल्यू से क्रम में बदल दिया जाता है:

2 3 '[ _ _ + + ] .
! => [ 2 3 + + ]

curry और फ्राई दोनों क्लोज़र बनते ही अपनी वैल्यू स्टैक से ले लेते हैं। ऊपर की लाइन स्टैक पर कुछ नहीं छोड़ती और [ + + ] curry curry का सीधा विकल्प है।

प्लेसहोल्डर बाएँ से दाएँ स्टैक की वैल्यू से नीचे से ऊपर तक भरे जाते हैं: 2 3 '[ _ _ ] का मतलब [ 2 3 ] है, [ 3 2 ] नहीं।

फ्राई नेस्टेड क्वोटेशन के अंदर तक भी पहुँचता है, जिससे आप कैप्चर की गई वैल्यू को ठीक वहीं रख सकते हैं जहाँ आप उन्हें चाहते हैं:

2 '[ [ _ > ] filter ] { 1 2 3 4 5 } swap call( s -- s ) .
! => { 3 4 5 }

_ अंदर वाले [ … ] के भीतर बैठता है, फिर भी फ्राई उसे भर देता है।

घोषित इफेक्ट के साथ call

जब आप अंत में संग्रहीत क्वोटेशन चलाते हैं, तो call पर उसका स्टैक इफेक्ट घोषित कीजिए ताकि कंपाइलर उसका टाइप-चेक कर सके:

{ 3 4 5 } [ first2 + ] call( p -- n ) .
! => 7

{ 3 4 5 } [ first ] call( p -- n ) .
! => 3

वेक्टर अंकगणित

math.vectors वोकैबुलरी समान लंबाई की दो सीक्वेंस को एलिमेंट के हिसाब से मिलाती है। v+ और v* उन्हें जोड़ते या गुणा करते हैं; vmax और vmin हर कंपोनेंट में से बड़ा या छोटा रखते हैं। हर एक दो एलिमेंट वाला ऐरे लौटाता है:

{ 1 1 } { 3 4 } v+ .    ! => { 4 5 }
{ 2 5 } { 3 -1 } v* .   ! => { 6 -5 }
{ 1 9 } { 4 4 } vmax .  ! => { 4 9 }
{ 1 9 } { 4 4 } vmin .  ! => { 1 4 }

निर्देश

आपकी डिज़ाइन टीम अपने कुछ लेआउट कामों के लिए CSS ट्रांसफॉर्म से हटकर अब Factor पर जा रही है। बाकी टीम को खुश रखने के लिए आप छोटे-छोटे, दोबारा इस्तेमाल में आने वाले रूपांतरण क्वोटेशन के रूप में बनाएँगे। ऐसा क्वोटेशन एक 2D पॉइंट लेता है और एक 2D पॉइंट लौटाता है।

एक पॉइंट दो एलिमेंट वाला ऐरे होता है, जैसे { x y }।

1. निर्देशांकों का स्थानांतरण कीजिए

translate-2d को ऐसा बनाइए जो स्टैक से दो वैल्यू, dx और dy, ले और एक क्वोटेशन लौटाए। यह क्वोटेशन किसी पॉइंट को (dx, dy) से स्थानांतरित करता है।

{ 4 8 } 2 0 translate-2d call( p -- p' ) .
! => { 6 8 }

2. निर्देशांकों को स्केल कीजिए

scale-2d को भी इसी तरह बनाइए। यह एक ऐसा क्वोटेशन लौटाता है जो किसी पॉइंट को (sx, sy) से स्केल करता है।

{ 6 -3 } 2 2 scale-2d call( p -- p' ) .
! => { 12 -6 }

3. दो रूपांतरणों को मिलाइए

compose-transformations को ऐसा बनाइए जो दो रूपांतरण क्वोटेशन, f और g, ले और एक ही क्वोटेशन लौटाए। यह नया क्वोटेशन पहले f लागू करता है और उसके बाद g।

{ 0 1 } 2 0 translate-2d 2 2 scale-2d compose-transformations
call( p -- p' ) .
! => { 4 2 }

4. एक रूपांतरण लागू कीजिए

apply-transformation को ऐसा बनाइए जो स्टैक से एक पॉइंट और एक रूपांतरण क्वोटेशन ले और रूपांतरित पॉइंट लौटाए।

{ 4 8 } 2 0 translate-2d apply-transformation .
! => { 6 8 }

5. एक साथ कई पॉइंट का रूपांतरण कीजिए

transform-points को ऐसा बनाइए जो पॉइंट का एक ऐरे और एक रूपांतरण क्वोटेशन ले, और रूपांतरित पॉइंट का ऐरे लौटाए।

{ { 0 0 } { 1 1 } { 2 2 } } 1 0 translate-2d transform-points .
! => { { 1 0 } { 2 1 } { 3 2 } }
GitHub के ज़रिए संपादित करें यह लिंक एक नई विंडो या टैब में खुलता है
Factor Exercism

निर्देशांकों की कोरियोग्राफी शुरू करने के लिए तैयार हैं?

Exercism पर साइन अप कीजिए और Factor को 47 कॉन्सेप्ट163 अभ्यास तथा असली इंसानों से मिलने वाली मेंटरिंग के साथ सीखिए और उसमें महारत हासिल कीजिए, वह भी बिल्कुल मुफ्त।