एक शांत कचरे से अपने घुटने पर और भी अधिक ठंडा कचरा या कार्यात्मक भाषा कैसे बनाएं

“पानी में कंकड़ फेंकते हुए, उनके बनाए हुए घेरे को देखो; अन्यथा, ऐसा फेंक खाली मज़ा होगा। ”
K.Prutkov

एक बार, जब इंटरनेट सर्फिंग का उपयोग करते हुए काम के समय और नियोक्ता के पैसे खर्च करते हैं, तो मुझे जब भी भाषा का वर्णन आया और कुछ समय के लिए मैं मोहित हो गया। भाषा अपनी पागल सादगी में हड़ताली है। इसके सिद्धांत इस प्रकार हैं:

1) कार्यक्रम कोड की पंक्तियों को निश्चित रूप से किसी दिन निष्पादित किया जाएगा, हालांकि, उनके निष्पादन का क्रम किसी भी तरह से उस क्रम से जुड़ा नहीं है जिसमें वे लिखे गए हैं।
2) चर? हमारे पास निष्पादन आदेश पर भी नियंत्रण नहीं है, हमें किसी भी चर की आवश्यकता नहीं है।
3) डेटा संरचनाएं? हाँ आप मजाक कर रहे हैं!

यही है, कार्यक्रम को निष्पादन के लिए लाइनों के एक सेट (पूल) के रूप में व्याख्या की जाती है, और दुभाषिया यादृच्छिक पर वहां से एक लाइन का चयन करता है, अपने आदेशों को निष्पादित करता है और इसे पूल से बाहर फेंकता है। और इसलिए जब तक पूल में कुछ भी नहीं रहता है। मुझे यह स्वीकार करना चाहिए कि इस पागलपन के लेखक ने अवधारणा को लगभग खड़ा कर दिया। लगभग, क्योंकि फिर भी कार्यक्रम में निष्पादन आदेश को व्यवस्थित करना संभव है, जैसे आप निष्पादन योग्य पूल में लाइनों को जोड़ने की क्षमता का उपयोग करके चर जोड़ सकते हैं।

तो, भाषा में निम्नलिखित निर्माण हैं:

कोड स्ट्रिंग देखें

line-number statement;

एक्सपट्र्स में कमांड्स होते हैं, जो कॉमा से अलग होते हैं। उनमें से हैं:
पंक्ति संख्या

line-number#number-of-times-to-add/remove

उदाहरण के लिए, लाइन 1 पर कमांड

1 4,5#3,-6;

निष्पादन पूल में नंबर 4 के साथ 1 लाइन, 5 नंबर के साथ 3 लाइनें और पूल से लाइन 6 को हटा दें।

ध्यान दें कि एक अनंत लूप के साथ एक कार्यक्रम संक्षिप्त और इसलिए शानदार दिखाई देगा

1 1;

दुभाषिया पूल से पहली पंक्ति का चयन करेगा (अब कोई अन्य नहीं है) और इसे वापस पूल में जोड़ें। संयोग से, एक बहुत ही उपयोगी डिजाइन, जैसा कि बाद में देखा जाएगा।

स्क्रीन आउटपुट

बस एक प्रिंट कमांड जो प्रिंट करता है कि स्क्रीन पर कोष्ठक में क्या है।

इन आदेशों के अतिरिक्त, निम्नलिखित डिज़ाइन हैं:

आस्थगित करें
यदि कोष्ठक में अभिव्यक्ति "सही" है, तो कमांड निष्पादित नहीं की जाएगी, और लाइन पूल में वापस आ जाएगी। उदाहरण के लिए

1 defer (2) 3;

जब तक लाइन 2 पूल में मौजूद है, तब तक पूल में लाइन 3 को जोड़ने की कमांड निष्पादित नहीं की जाएगी।

फिर
यदि कोष्ठक में अभिव्यक्ति "सही" है, तो कमांड निष्पादित की जाएगी, लेकिन लाइन पूल में वापस आ जाएगी। उदाहरण के लिए:

1 again (2) 3;

लाइन 3 को हमेशा पूल में जोड़ा जाएगा, लेकिन अगर पूल में लाइन 2 है, तो उसके बाद लाइन 1 को पूल से हटाया नहीं जाएगा।

मैं ध्यान देता हूं कि अभिव्यक्ति (2) (एन (2)> 0) के बराबर है, जहां एन () एक फ़ंक्शन है जो एक पूल में एक संख्या की पंक्तियों की संख्या लौटाता है।

भूलना
यदि कोष्ठक में अभिव्यक्ति "सही" है, तो कमांड निष्पादित नहीं होगी और लाइन पूल से हटा दी जाएगी। उदाहरण के लिए:

1 forget(2) 3;

भाषा के लेखक ने इस अभिव्यक्ति को भाषा से बाहर फेंक दिया, लेकिन मुझे इसे वापस करना पड़ा, जैसा कि नीचे वर्णित है।

फिर से, डिफर और भूल को संयुक्त किया जा सकता है, लेकिन प्रत्येक संशोधक को केवल एक बार लाइन में दिखाई देना चाहिए।

असल में सब कुछ, पूरी भाषा। भाषा के विवरण वाली साइट में दो कार्यक्रम हैं:

99 बोतल बीयर

 1 defer (4 || N(1)<N(2) && N(2)<N(3)) print(N(1)+" bottles of beer on the wall, "+N(1)+" bottles of beer,"); 2 defer (4 || N(1)==N(2)) print("Take one down and pass it around,"); 3 defer (4 || N(2)==N(3)) print(N(1)+" bottles of beer on the wall."); 4 1#98,2#98,3#98; 

और फाइबोनैचि संख्या (1 से 100 वें तत्व तक फाइबोनैचि श्रृंखला की गणना करता है ... अच्छी तरह से ... यदि आप प्रतीक्षा करते हैं):

 1 again (1) defer (3 || N(1)<=N(2) || N(7)>99) 2#N(1),3,7; 2 again (2) defer (3 || N(2)<=N(1) || N(7)>99) 1#N(2),3,7; 3 defer (5) print(N(1)+N(2)); 4 defer (5) print("1"); 5 4,-3,7; 6 defer (4) 3; 7 7; 8 defer (N(7)<100) -1#N(1),-2#N(2),-7#100,-3; 9 defer (3 || 6) 1,3; 

यदि पहला कार्यक्रम शुद्ध शरारत है, तो दूसरा कुछ सार्थक करता है और यह आश्चर्यजनक है। ऐसा लगता है - परिभाषा के अनुसार, इस तरह की शरारत से कुछ भी सार्थक नहीं निकल सकता है। लेकिन यहाँ यह है।

और इसलिए मैं इस सब के साथ कुछ करना चाहता था। परिणाम कुछ अप्रत्याशित था, लेकिन पहली चीजें पहले।

यह तुरंत स्पष्ट है कि इन कार्यक्रमों में यह असुविधाजनक है: फिबोनाची श्रृंखला की गणना करने के लिए सौवें तक नहीं, लेकिन, कहते हैं, 20 वें तत्व तक, आपको कार्यक्रम में चार स्थानों पर पाठ को बदलने की आवश्यकता है। यह किसी तरह कष्टप्रद है। हम इसे बनाते हैं ताकि कार्यक्रम इनपुट मापदंडों को स्वीकार कर सके। उदाहरण के लिए, इस तरह:

 1 again (1) defer (3 || N(1)<=N(2) || N(7)>( @1 - 1 )) 2#N(1),3,7; 2 again (2) defer (3 || N(2)<=N(1) || N(7)>( @1 - 1 )) 1#N(2),3,7; 3 defer (5) print(N(1)+N(2)); 4 defer (5) print("1"); 5 4,-3,7; 6 defer (4) 3; 7 7; 8 defer (N(7)<@1) -1#N(1),-2#N(2),-7#100,-3; 9 defer (3 || 6) 1,3; 

फ़ाइल fib.src में प्रोग्राम के टेक्स्ट को सेव करें। प्रोग्राम कॉल इस तरह दिखेगा:
java -cp Whenever.jar Whenever fib.src 20

पहले से ही अच्छा है। सफलता को मजबूत करने के लिए, मैंने दो प्राकृतिक संख्याओं के सबसे बड़े सामान्य भाजक को खोजने के लिए एक कार्यक्रम लिखा, यह है:

 1 defer(2) again(N(3) - (N(3)/N(4))*N(4) != 0) 6#N(3),-3#N(3),3#N(4),-4#N(4),4#(N(6) - (N(6)/N(3))*N(3)),-6#N(6); 2 3#( @1 - 1 ),4#( @2 - 1 ),-6; 3 3; 4 4; 5 defer(1) print("NOD of " + @1 + " and " + @2 + " is " + N(4)),-3#N(3),-4#N(4); 6 6; 

जब आप प्रोग्राम को कॉल करते हैं, तो आपको दो नंबर निर्दिष्ट करने होंगे, पहले अधिक, फिर कम। हम इस कार्यक्रम का विश्लेषण करेंगे;

लाइन्स 3 और 4 को दो संख्याओं के भंडारण के लिए मेमोरी सेल के रूप में उपयोग किया जाता है। अधिक सटीक रूप से, संबंधित पंक्तियों के पूल में प्रविष्टियों की संख्या का उपयोग चर के रूप में किया जाता है। लाइन 6 का उपयोग उसी विकृत तरीके से एक मध्यवर्ती चर के रूप में किया जाता है (भाषा दूसरे को नहीं छोड़ती है)।
लाइन 2 पूरी प्रक्रिया शुरू करती है। यह पूल में N लाइनों 3 और M लाइनों 4 को जोड़ता है और पूल से लाइन 6 को हटाता है। फिर इसे स्थायी रूप से पूल से हटा दिया जाता है।
लाइन 1 वास्तव में सभी काम करता है। लाइन 1 के निष्पादन में देरी हो रही है जब तक कि पूल में लाइन 2 (defer (2)) नहीं है। इसके अलावा, स्ट्रिंग को पूल से बाहर नहीं फेंका जाता है जब तक कि जीसीडी नहीं मिला (फिर से)। कोष्ठक में अभिव्यक्ति लाइनों की संख्या को 4 की संख्या से विभाजित करने के शेष को 4 की संख्या देगा (पूर्णांक गणित का उपयोग किया जाता है)। दरअसल, लाइन 1 में क्रियाएं बाएं से दाएं की जाती हैं:

1. वहाँ के रूप में कई पंक्तियाँ 6 हैं पूल में पंक्ति 3 पूल में इस कदम के रूप में
2. सभी लाइनों 3 को पूल से हटा दिया जाता है
3. जैसे ही कई लाइनें जोड़ी जाती हैं, एक निश्चित समय पर 4 लाइनें होती हैं (इन दोनों कमांडों को एक -3 # (एन (3) - एन (4) में ढहाया जा सकता है)
4. हम सभी लाइनों को हटा देते हैं 4
5. राशि में 4 पंक्तियों को जोड़ें == एक बड़ी संख्या को एक छोटे से विभाजित करने के शेष। फिर से, ये दोनों टीमें आपस में टकरा सकती हैं।
6. हम पूल से सभी लाइनों को हटाते हैं 6 (वायलिन वादक की आवश्यकता नहीं है)

लाइन 5 स्क्रीन पर परिणाम प्रदर्शित करता है और पूल से छोड़ी गई सभी चीज़ों को हटाते हुए खुद को साफ़ करता है। जब तक पंक्ति 1 पूल में मौजूद नहीं होती है, तब तक इसके निष्पादन में देरी होती है, और यह तब तक रहेगा जब तक जीसीडी नहीं मिल जाता। मैं ध्यान देता हूं कि भाषा के मूल संस्करण में प्रिंट को अन्य कमांड के साथ नहीं जोड़ा जा सकता है, इसे वहां लिखना होगा

 5 defer(1) print("NOD of " + @1 + " and " + @2 + " is " + N(4)); .... 7 defer(5) -3#N(3),-4#N(4); 

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

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

तब मेरे पास अचानक एक और आयाम था, दूसरा चर - वर्तमान लाइन संख्या। इसका उपयोग करने में सक्षम होने के लिए, मैंने एक और कीवर्ड दर्ज किया - स्व।

हुर्रे! अब आप कुछ उपयोगी कर सकते हैं। उदाहरण के लिए, उसी फिबोनाची श्रृंखला को फिर से लिखें:

 1 forget(self>@3) print("iter: " + self + " value: " + @1 ),1[@1+@2%@1%@3]; 

कार्यक्रम के लिए तीन पैरामीटर पारित किए जाते हैं - 1, 0 और वह संख्या जिस पर गणना करना आवश्यक है। अच्छे के लिए, केवल तीसरा पैरामीटर महत्वपूर्ण है और कार्यक्रम को फिर से लिखा जा सकता है ताकि यह केवल इसे स्वीकार करे। फिर, वैसे, स्वयं से छुटकारा पाना संभव होगा, लेकिन कार्यक्रम दो पूरी लाइनों के लिए बहुत बढ़ जाएगा, जो बहुत सुंदर नहीं है।

नोट: मुझे 1) राइट राइट्स बहाल करना था और 2) कई अन्य कमांड्स में प्रिंट रन बनाना (मूल में, केवल एक प्रिंट या अन्य कमांड हो सकता है)।

और यहाँ जीसीडी है:

 1 forget( @2 == 0 ) 1[@2%(@1 - (@1 / @2) * @2)],2[@2%(@1 - (@1 / @2) * @2)]; 2 forget( @2 > 0 ) print("Nod is: " + @1 ); 

फिर, आप यह सुनिश्चित कर सकते हैं कि निष्पादन इस बात पर निर्भर नहीं करता है कि बड़ा पैरामीटर किस नंबर पर है, लेकिन मैं बहुत आलसी हूं।

और शुरुआत के लिए, जाँच की जा रही है कि संख्या प्रमुख है:

 1 defer(5) forget( @2 == 0 || @2 == 1 ) 4[@1%(@2 - 1)],2[@1%(@2 - 1)],3[@1%(@2 - 1)]; 2 defer(5) forget( @2 == 0 || @1 != (@1 / @2) * @2 || @1 == @2 || @2 == 1 ) print( "Number " + @1 + " is not prime"); 3 defer(5) forget( @2 != 1 ) print( "Number " + @1 + " is prime"); 4 defer(5) forget( @2 == 0 || @1 == (@1 / @2) * @2 ) 1[@1%@2]; 5 1[@1%@1]; 

यहां मैं एक और चाल का उपयोग करता हूं: यदि पैरामीटर निर्दिष्ट नहीं है, तो यह शून्य के बराबर हो जाता है।

ये बिल्ली के बच्चे हैं। कुछ मुझे बताता है कि आप इस कचरे के साथ जुडी समस्याओं को हल करने का प्रयास कर सकते हैं। लेकिन यह समाधान के साथ आने के लिए बहुत आलसी है। हालांकि ...