वर्षों के माध्यम से प्रोग्रामिंग भाषाएँ


167

इस चुनौती में, उपयोगकर्ता प्रोग्रामिंग भाषाओं में तीन काफी सरल कोडिंग कार्यों को पूरा करेंगे, जिन्हें उत्तरोत्तर पुराने होने की अनुमति है।

पहला उत्तर एक प्रोग्रामिंग भाषा का उपयोग करना चाहिए जो वर्ष 2015 में बनाई गई थी। एक बार 2015 की भाषा में कम से कम एक उत्तर देने के बाद, उत्तर 2014 में बनाई गई प्रोग्रामिंग भाषाओं का उपयोग कर सकते हैं। इसी तरह, 2013 से भाषाओं का उपयोग करने वाले उत्तरों की अनुमति नहीं है। जब तक कम से कम एक 2014 का जवाब नहीं है।

सामान्य तौर पर, वर्ष Y से प्रोग्रामिंग भाषा के उपयोग की अनुमति तब तक नहीं दी जाती है जब तक कि वर्ष Y + 1 से किसी भाषा का उपयोग करने वाला उत्तर प्रस्तुत नहीं किया जाता है। एकमात्र अपवाद Y = 2015 है।

अपनी भाषा का वर्ष ढूँढना

इस प्रश्न का उत्तर देने के लिए, आपको पता होना चाहिए कि आपकी प्रोग्रामिंग भाषा किस वर्ष "इन" बनी थी। यह निश्चित रूप से, एक व्यक्तिपरक शब्द है; कुछ भाषाओं को कई वर्षों के दौरान विकसित किया गया था, और हर साल कई भाषाओं को अभी भी अपग्रेड किया जा रहा है। बता दें कि जिस साल एक भाषा को "बनाया गया" पहले साल में उस भाषा के लिए एक कार्यान्वयन आम जनता में दिखाई दिया।

उदाहरण के लिए, पायथन " 1991 में" बनाया गया था , हालांकि इसका विकास 1989 से प्रगति पर था, और संस्करण 1.0 को 1994 तक जारी नहीं किया गया था।

यदि यह वर्ष अभी भी व्यक्तिपरक है, तो सबसे उपयुक्त वर्ष चुनने के लिए अपने सामान्य ज्ञान का उपयोग करें। साल के विकल्पों के बारे में थोड़ी सी असहमति में मत उलझो। कृपया एक स्रोत का लिंक प्रदान करें जो कहता है कि आपकी भाषा कब बनाई गई थी।

एक प्रोग्रामिंग भाषा के विभिन्न संस्करणों या मानकों (जैसे पायथन 1, 2, 3) को उसी प्रारंभिक वर्ष के साथ एक ही भाषा के रूप में गिना जाता है।

इसलिए, जब तक आपकी भाषा का वर्ष 2015 नहीं है, तब तक आप केवल एक बार उत्तर प्रस्तुत करने के बाद अपना जवाब प्रस्तुत कर सकते हैं, जिसकी भाषा का वर्ष आपके समक्ष वर्ष है।

यदि आपके पास पहले से मौजूद एक ही वर्ष के साथ एक वैध उत्तर है, तो आप जवाब दे सकते हैं। इससे कोई फर्क नहीं पड़ता कि आपकी भाषा वर्ष में पहले या बाद में विकसित हुई थी।

कार्य

आपको टास्क 1 को 3 के माध्यम से पूरा करना होगा। टास्क 0 वैकल्पिक है।

इन कार्यों को प्रोग्रामिंग के तीन महत्वपूर्ण पहलुओं के अनुरूप करने के लिए चुना गया था: आउटपुट प्रदान करना (टास्क 1), लूपिंग (टास्क 2), और रिकर्सन (टास्क 3)।

टास्क 0 - भाषा इतिहास (वैकल्पिक)

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

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

टास्क 1 - "हैलो, वर्ल्ड!" प्रकार

एक प्रोग्राम लिखें जो प्रिंट करता है

[language name] was made in [year made]!

आपकी भाषा के मानक आउटपुट क्षेत्र में (सबसे हाल की भाषाओं के लिए स्टडआउट)।

उदाहरण के लिए, यदि भाषा पायथन थी, तो आउटपुट होगा:

Python was made in 1991!

टास्क 2 - एएससीआईआई कला एन

एक प्रोग्राम लिखें जो उपयोगकर्ता को एक अजीब सकारात्मक पूर्णांक में प्रवेश करने देता है (आप मान सकते हैं कि इनपुट हमेशा मान्य है), और चरित्र का उपयोग करके बनाया गया एक ASCII कला पत्र एन प्रिंट करता है N

यदि इनपुट 1 है, तो आउटपुट है:

N

यदि इनपुट 3 है, तो आउटपुट है:

N N
NNN
N N

यदि इनपुट 5 है, तो आउटपुट है:

N   N
NN  N
N N N
N  NN
N   N

यदि इनपुट 7 है, तो आउटपुट है:

N     N
NN    N
N N   N
N  N  N
N   N N
N    NN
N     N

इस तरह पैटर्न जारी है। आउटपुट में अनुगामी स्थान हो सकते हैं।

टास्क 3 - जीसीडी

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

उदाहरण:

8, 124
12, 84
3, 303
5689, 21
234, 8766

आप एक अंतर्निहित फ़ंक्शन का उपयोग कर सकते हैं, लेकिन यह पता लगाने की कोशिश करें कि क्या यह आपकी भाषा के पहले संस्करण में था। यदि नहीं, तो इसका उपयोग न करने का प्रयास करें।

नियम

  • आप कई बार उत्तर दे सकते हैं, लेकिन प्रत्येक नए उत्तर में आपके अंतिम उत्तर में भाषा से कम से कम 5 साल पहले की गई भाषा का उपयोग करना चाहिए। इसलिए यदि आपने २०१५ की भाषा में उत्तर दिया है, तो आप २०१० की भाषाओं की अनुमति नहीं दे सकते। यदि आप 2010 के उत्तर से शुरू करते हैं, तो आप 2015 के उत्तर को अपना दूसरा उत्तर नहीं बना सकते क्योंकि 2015 2010 से पहले नहीं है।
  • यदि संभव हो, तो अपना कोड लिखें ताकि यह आपकी भाषा के पहले संस्करण (या यथासंभव पुराने संस्करण) में काम किया हो। (यह कोई आवश्यकता नहीं है क्योंकि कुछ भाषाओं के लिए पुराने संकलक / दुभाषियों को खोजना मुश्किल हो सकता है।)
  • जब तक पोस्ट किए गए उत्तर में महत्वपूर्ण त्रुटियां नहीं होती हैं या आपके पास कार्यों को पूरा करने का एक बहुत अलग तरीका होता है, तब तक किसी भाषा को पोस्ट करने से बचना चाहिए।
  • अपने कोड को ठीक करना आवश्यक नहीं है।
  • किसी भी प्रोग्राम के आउटपुट में एक अनुगामी न्यूलाइन ठीक है।
  • कार्य 2 और 3 के लिए, कुछ उचित अधिकतम के नीचे सभी इनपुट मान जैसे 2 16 को काम करना चाहिए (बहुत कम से कम 256)।
  • इस प्रश्न को पोस्ट करने से पहले आपकी भाषा मौजूद होनी चाहिए।
  • बहुत पुरानी प्रोग्रामिंग भाषाओं में इनपुट और आउटपुट के विभिन्न रूप हो सकते हैं जो हम आज के बारे में सोचते हैं। यह ठीक है। अपनी भाषा के संदर्भ में अपनी क्षमता के अनुसार कार्यों को पूरा करें।

स्कोरिंग

आपके सबमिशन का स्कोर है:

upvotes - downvotes + (2015 - languageYear) / 2 

इस प्रकार, पुरानी भाषाओं का लाभ देते हुए, 2015 से पहले हर साल वोट संख्या में 0.5 जोड़ा जाता है। उच्चतम स्कोर जीत के साथ सबमिशन।

उत्तर सूची

नीचे दिए गए स्टैक स्निपेट उनकी भाषा वर्ष के अनुसार सभी मान्य उत्तरों को सूचीबद्ध करता है।

यह सही ढंग से सूचीबद्ध है यह सुनिश्चित करने के लिए आपको अपनी पोस्ट को इस मार्कडाउन लाइन से शुरू करना चाहिए :

#[year] - [language name]

उदाहरण के लिए:

#1991 - Python

भाषा का नाम एक लिंक में हो सकता है (यह उत्तर सूची में एक ही लिंक होगा):

#1991 - [Python](https://www.python.org/)

ऐसे उत्तर जो इस प्रारूप का पालन नहीं करते हैं, या एक वर्ष है जो अभी तक अनुमति नहीं है, या एक उपयोगकर्ता से आता है जो पहले से ही पिछले 5 वर्षों में उत्तर दिया गया है, को अमान्य के रूप में चिह्नित किया गया है।

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><script>$(function(){function e(e,r){var a="https://api.stackexchange.com/2.2/questions/48476/answers?page="+e.toString()+"&pagesize=100&order=asc&sort=creation&site=codegolf&filter=!YOKGPOBC5Yad160RQxGLP0r4rL";$.get(a,r)}function r(e){if(e.items.forEach(function(e){var r=e.link,a=e.owner.display_name,i=e.body.match(/<h1\b[^>]*>(\d{4}) - (.*?)<\/h1>/);if(i&&i.length>=3)var h=parseInt(i[1]),u=i[2];h&&u&&n>=h&&h>=t&&(!d.hasOwnProperty(e.owner.user_id)||d[e.owner.user_id]-h>=p)?(d[e.owner.user_id]=h,h==t&&--t,o.hasOwnProperty(h)||(o[h]=[]),o[h].push({language:u,user:a,link:r,score:e.score+(n-h)/2})):s.push(' <a href="'+r+'">'+a+"</a>")}),e.has_more)runQuery(++a,r);else{for(var i=n,h=[];o.hasOwnProperty(i);){for(var u=$("<tr>").append($("<td>").text(i.toString())),l=$("<td>"),c=$("<td>"),g=$("<td>"),f=0;f<o[i].length;f++){var v=o[i][f];l.append(v.language),c.append($("<a>").html(v.user).attr("href",v.link)),g.append(v.score),f+1<o[i].length&&(l.append("<br><br>"),c.append("<br><br>"),g.append("<br><br>"))}u.append(l).append(c).append(g),h.push(u),--i}$("#answers").find("tbody").append(h),s.length>0?$("#invalid").append(s):$("#invalid").remove()}}var a=1,n=2015,t=n-1,p=5,o={},s=[],d={};e(1,r)})</script><style>html *{font-family: Helvetica, Arial, sans-serif;}table{border: 4px solid #a4a; border-collapse: collapse;}th{background-color: #a4a; color: white; padding: 8px;}td{border: 1px solid #a4a; padding: 8px;}div{font-size: 75%;}</style><table id='answers'> <tr> <th>Year</th> <th>Language</th> <th>User (answer link)</th> <th>Score</th> </tr></table><div id='invalid'><br>Invalid Answers:</div>


2
यह मदद करनी चाहिए।
बेंत की मार

20
विकिपीडिया के पास हर चीज के लिए एक सूची है: यह गैर-गूढ़ भाषाओं के लिए एक वर्ष है।
सांचीस

2
क्या टास्क 3 को वास्तव में पुनरावृत्ति का उपयोग करना चाहिए या क्या यह पर्याप्त है कि यह सही परिणाम पैदा करता है? अगर मुझे अपना जीसीडी फ़ंक्शन लिखने की ज़रूरत है तो मैं आमतौर पर एक लूप का उपयोग करता हूं लेकिन मैंने इस चुनौती के लिए विशेष रूप से एक पुनरावर्ती लिखा है। कई प्रस्तुत जवाब हैं कि बस एक लूप का उपयोग करें।
सीजे डेनिस

5
मुझे ऐसा लग रहा है कि हमें 1971 में पा लेने के लिए दूसरा खाता बनाना होगा।
मैरिनस

5
अगर हम इसे 1952 में वापस पा सकते हैं, तो मेरे पास एक ऐतिहासिक मशीन है जो 1951 (पेगासस) के समाधानों को तैयार कर सकती है और उनका परीक्षण कर सकती है!
ब्रायन टॉम्पसेट -

जवाबों:


172

2013 - डॉगस्क्रिप्ट

डॉगस्क्रिप्ट 2013 में Zach Bruggeman द्वारा बनाई गई एक भाषा है। यह जावास्क्रिप्ट के लिए सिंटेक्स-रिप्लेसमेंट से ज्यादा कुछ नहीं है, इसे यादगार शिबा इनस के आंतरिक मोनोलॉग की तरह पढ़ा जा सकता है।

नमस्ते डोगे

console dose loge with "Dogescript was made in 2013!"

ASCII कला

such N much N
          much i as 0 next i smaller N next i more 1
              very doge is ("N" + " ".repeat(N-2) + "N").split('')
              s[i] is "N";
              console dose loge with doge.join('')
                              wow
                                      wow

GCD

such gcd_doge much doge, dooge
    rly dooge
              gcd_doge(dooge, doge % dooge)
  but
    rly doge smaller 0
           -doge
    but
          doge
  wow
        wow

112
वाह, ऐसे +1। बहुत जवाब। बहुत गुणवत्ता।
एलेक्स ए।

27
मैं कोडगॉल्फ में शामिल हो गया बस इस उत्तर को उभारने के लिए!
डेरेक टॉम्स

21
मैं GCD एक को सीधे चेहरे के साथ भी नहीं पढ़ सकता
कोल जॉनसन

16
मैं gcd_doge को good_dog के रूप में नहीं पढ़ सकता। सहायता
यन्न

बहुत खुबस। हालाँकि, LANGUAGE.md के अनुसार, दोहरे उद्धरण चिह्नों का समर्थन नहीं किया जाता है। s[i]बिट की एक व्याख्या भी पसंद करेंगे!
डॉक्टिरिटी

66

2015 - रेटिना

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

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

निम्नलिखित सबमिशन में, प्रत्येक लाइन एक अलग सोर्स फाइल में जाती है। (वैकल्पिक रूप से, आप नए -sविकल्प का उपयोग कर सकते हैं और सभी लाइनों को एक ही फाइल में डाल सकते हैं।) खाली फाइलों / लाइनों का प्रतिनिधित्व किया जाता है <empty>। एकल स्थान वाली फ़ाइलों / रेखाओं का प्रतिनिधित्व किया जाता है <space>

स्पष्टीकरण काफी लंबे हैं, इसलिए मैंने उन्हें पोस्ट के अंत में स्थानांतरित कर दिया है।

कार्यक्रमों

"नमस्ते दुनिया!" प्रकार

<empty>
Retina was made in 2015!

ASCII आर्ट एन

यह मानता है कि STDIN एक नई पंक्ति के साथ समाप्त हो गया है।

;`^
#
;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#
;`#
<empty>
;`\d
N
;`.(?<=(?=(.*\n)).*)|\n
$1
;`N(?=N\n.*\n.*\n`$)
<space>
;+`N(?=.?(.)+\n.* (?<-1>.)+(?(1)!)\n)
<space>
;`(?<=^.*\n.*\nN)N
S
;+`(?<=\n(?(1)!)(?<-1>.)+S.*\n(.)+N?)N
S
S
<space>

GCD

इसके लिए आवश्यक है कि STDIN एक नई पंक्ति के साथ समाप्त नहीं हुआ है।

;`\b(?=\d)
#
;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#
;`#
<empty>
;`\d
1
;`^(.+)\1* \1+$
$1
;`$
#:0123456789
;+`^(?=1)(1*)\1{9}(#(?=.*(0))|1#(?=.*(?<3>1))|11#(?=.*(?<3>2))|111#(?=.*(?<3>3))|1111#(?=.*(?<3>4))|11111#(?=.*(?<3>5))|111111#(?=.*(?<3>6))|1111111#(?=.*(?<3>7))|11111111#(?=.*(?<3>8))|111111111#(?=.*(?<3>9)))
$1#$3
#|:.*
<empty>

स्पष्टीकरण

"नमस्ते दुनिया!" प्रकार

यह काफी तुच्छ है। इसमें कोई इनपुट नहीं है (यानी एक खाली स्ट्रिंग), कुछ नहीं से मेल खाता है और इसके साथ बदलता है Retina was made in 2015![\s\S]*उदाहरण के लिए पैटर्न को बदलकर, यह मनमाने इनपुट के लिए भी काम कर सकता है । यह STDIN को थप्पड़ मार देगा और इसे आउटपुट के साथ बदल देगा।

ASCII आर्ट एन

इसके काफी चरण हैं। इस विचार को इनपुट को एकरी में बदलना है, s का N x N ब्लॉक Nबनाना है और फिर दो त्रिकोण बनाना है। आइए अलग-अलग चरणों से गुजरें। याद रखें कि ;केवल मध्यवर्ती आउटपुट को दबाता है, लेकिन +प्रतिस्थापन को लूप में लागू करने का कारण बनता है।

;`^
#

सरल: एक #इनपुट के लिए प्रस्तुत करना। इसे यूनीरी में रूपांतरण में एक मार्कर के रूप में उपयोग किया जाएगा।

;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#

यह एक अंक को एकता में परिवर्तित करता है। यह पहले से परिवर्तित अंकों को लेता है (\d*)और उन्हें 10 बार दोहराता है। और फिर यह अगला अंक लेता है और उचित संख्या में अंकों को जोड़ता है। इस स्तर पर अंकों का वास्तविक मूल्य अप्रासंगिक है। जब #संख्या के अंत तक पहुंच जाता है, तो रेगेक्स अब मेल नहीं खाता है, और रूपांतरण किया जाता है। एक उदाहरण के रूप में, संख्या के 127रूप में संसाधित किया जाएगा

#127
1#27
111111111122#7
1111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111227777777#

जहां अंतिम पंक्ति में 127 अंकों के अक्षर हैं।

;`#
<empty>
;`\d
N

दो सरल चरण जो इससे मुक्त हो जाते हैं #और फिर सभी अंकों को बदल देते हैं N। निम्नलिखित में मैं 7एक उदाहरण के रूप में इनपुट का उपयोग करूँगा । तो अब हमें मिल गया है

NNNNNNN

अगला चरण

;`.(?<=(?=(.*\n)).*)|\n
$1

Nपूरे स्ट्रिंग के साथ प्रत्येक को प्रतिस्थापित करता है (याद रखें कि इसमें एक अनुगामी न्यूलाइन शामिल है), और अनुगामी न्यूलाइन को भी हटाता है। इसलिए, यह एकल पंक्ति को वर्ग ग्रिड में बदल देता है:

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN

अब ऊपरी त्रिकोण। सबसे पहले, हम एन को निचले दाएं कोने में एक स्थान में बदलकर चीजों को शुरू करते हैं:

;`N(?=N\n.*\n.*\n`$)
<space>

लुकहेड सुनिश्चित करता है कि हम सही को संशोधित कर रहे हैं N। यह देता है

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNN N
NNNNNNN
NNNNNNN

और अब

;+`N(?=.?(.)+\n.* (?<-1>.)+(?(1)!)\n)
<space>

एक रेगेक्स है जो Nएक स्पेस कैरेक्टर के ऊपरी बाएं कोने पर या उसके ऊपर मेल खाता है , और इसे स्पेस के साथ बदल देता है। क्योंकि प्रतिस्थापन दोहराया जाता है, यह अनिवार्य रूप से एक बाढ़-भराव है, जो प्रारंभिक स्थान से तीसरे अष्टक को अधिक स्थानों में बदल देता है:

N     N
NN    N   
NNN   N
NNNN  N
NNNNN N
NNNNNNN
NNNNNNN

और अंत में, हम नीचे के त्रिकोण के साथ एक ही बात दोहराते हैं, लेकिन हम एक अलग चरित्र का उपयोग करते हैं, इसलिए पहले से मौजूद स्थान गलत बाढ़ का कारण नहीं बनते हैं:

;`(?<=^.*\n.*\nN)N
S

बीज सेट करता है:

N     N
NN    N   
NSN   N
NNNN  N
NNNNN N
NNNNNNN
NNNNNNN

फिर

;+`(?<=\n(?(1)!)(?<-1>.)+S.*\n(.)+N?)N
S

बाढ़ भरता है।

N     N
NN    N   
NSN   N
NSSN  N
NSSSN N
NSSSSNN
NSSSSSN

और अंत में

S
<space>

उन Sस्थानों में बदल जाता है और हम कर रहे हैं:

N     N
NN    N   
N N   N
N  N  N
N   N N
N    NN
N     N

GCD

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

;`\b(?=\d)
#
;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#
;`#
<empty>
;`\d
1

ये चरण अनिवार्य रूप से ऊपर के समान हैं, सिवाय इसके कि दोनों इनपुट नंबर परिवर्तित हैं, और परिणाम 1s के बजाय s का उपयोग करता है N(यह मायने नहीं रखता है)। तो अगर इनपुट 18 24होता, तो यह उत्पादन होता

111111111111111111 111111111111111111111111

अभी

;`^(.+)\1* \1+$
$1

संपूर्ण जीसीडी संगणना है। हम 1s के एक नंबर पर कब्जा करके एक सामान्य विभाजक से मेल खाते हैं , और फिर यह सुनिश्चित करने के लिए कि दोनों संख्याओं को उस स्ट्रिंग (और कुछ नहीं) को दोहराकर लिखा जा सकता है। रेगेक्स इंजन (यानी कि .+लालची है) में बैकट्रैकिंग कैसे काम करती है , इस वजह से यह हमेशा सबसे बड़ा कॉमन डिविज़र होगा। चूंकि मैच पूरे स्ट्रिंग को कवर करता है, इसलिए हम अपने जीसीडी को प्राप्त करने के लिए पहला कैप्चरिंग ग्रुप लिखते हैं।

अंत में, दशमलव रूपांतरण के लिए एकात्मक ...

;`$
#:0123456789

एक मार्कर #, एक सीमांकक :और सभी अंकों को स्ट्रिंग में जोड़ें। यह आवश्यक है, क्योंकि आप regex प्रतिस्थापन में सशर्त रूप से नए वर्णों का उत्पादन नहीं कर सकते हैं। यदि आप सशर्त प्रतिस्थापन चाहते हैं, तो आपको पात्रों को स्ट्रिंग से खींचने की आवश्यकता है, इसलिए हम उन्हें वहां डालते हैं।

;+`^(?=1)(1*)\1{9}(#(?=.*(0))|1#(?=.*(?<3>1))|11#(?=.*(?<3>2))|111#(?=.*(?<3>3))|1111#(?=.*(?<3>4))|11111#(?=.*(?<3>5))|111111#(?=.*(?<3>6))|1111111#(?=.*(?<3>7))|11111111#(?=.*(?<3>8))|111111111#(?=.*(?<3>9)))
$1#$3

यह पहले के असमान विस्तार का विलोम है। हम वर्तमान स्ट्रिंग में फिट होने वाले 10 का सबसे बड़ा गुण पाते हैं। फिर हम शेष के आधार पर अगला अंक चुनते हैं, और अंकों के माध्यम से मार्कर को आगे बढ़ाते हुए कई को 10 से विभाजित करते हैं।

#|:.*
<empty>

और अंत में मार्कर, सीमांकक और सहायक अंकों से छुटकारा पाने के लिए केवल एक सफाई कदम है।


मुझे लगता है कि आपको संख्यात्मक इनपुट को unary string में बदलने के लिए निर्देश जोड़ना चाहिए, और unary string को संख्यात्मक इनपुट में बदलने के लिए निर्देश देना चाहिए। शुद्ध रेगेक्स के साथ रूपांतरण शांत है, लेकिन बहुत दूर है।
n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

8
+1 मुझे पूरा यकीन था कि 2015 प्रस्तुत कोडगोल्फ उपयोग के लिए एक भाषा होगी।
शून्य फाइबर

@ n @h consideringa̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ मैं उस पर पहले विचार कर रहा था। मुझे लगता है कि अधिकांश कोड गोल्फ के लिए, मैं शायद केवल अनरी इनपुट ले सकता हूं (जब तक कि चुनौती स्पष्ट रूप से "दशमलव" या कुछ और ...) निर्दिष्ट नहीं करती है। मैंने इसके लिए समान करने के बारे में सोचा, लेकिन यह कोड गोल्फ नहीं है, और मैं यह दिखाना चाहता था कि मैं दशमलव इनपुट और आउटपुट को भी संभाल सकता हूं।
मार्टिन एंडर

6
उत्कृष्ट कार्य। रेटिना वास्तव में अच्छा है। और एक तरफ के रूप में, यह वास्तव में आपके नाम के आगे हीरे को देखकर भी अच्छा है! :)
एलेक्स ए।

मजेदार है कि हालांकि पुरानी भाषाओं को इस प्रतियोगिता में पसंद किया जाता है, यह सबसे युवा अभी भी जीत रहा है =)
क्लॉडिउ

60

2013 - स्नैप !

स्नैप ! स्क्रैच पर आधारित एक भाषा है , जिसे बर्कले विश्वविद्यालय में बनाया गया है। यह प्रथम श्रेणी के डेटा और कस्टम ब्लॉक (फ़ंक्शन) की विशेषता के लिए स्क्रैच का उन्नयन है। स्क्रैच की तरह, यह पाठ आधारित नहीं है, बल्कि दृश्य "ब्लॉक" द्वारा किया जाता है जो एक साथ स्नैप करते हैं।

स्नैप ! जावास्क्रिप्ट में लिखा, BYOB का उत्तराधिकारी है, जो स्क्वीक स्मॉलटॉक में लिखा गया था। स्नैप ! मार्च 2013 में सार्वजनिक खपत के लिए बीटा जारी किया गया था ।

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

मैंने परीक्षण और सामान के साथ मदद की।

"हैलो वर्ल्ड" संस्करण

ASCII कला "एन"

यहां छवि विवरण दर्ज करें

यह कुछ ब्लॉकों के लिए stdlib का उपयोग करता है।

यहां सुंदर बुनियादी लूपिंग। एक इनपुट लेता है। फिर हम इसे सभी को एक साथ जोड़ते हैं और कहते हैं कि (परिणाम के लिए n = 5):

यहां छवि विवरण दर्ज करें

मैं यहाँ 1 के बजाय 2 रिक्त स्थान का उपयोग करने के लिए स्वतंत्रता ले गया, क्योंकि Snap! मोनोस्पेस में सामान नहीं कहते हैं।

GCD

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

यहां छवि विवरण दर्ज करें

यह फ़ंक्शन परिभाषा तब इस ब्लॉक का उत्पादन करेगी:

यहां छवि विवरण दर्ज करें


3
यह एलिस में प्रोग्रामिंग की तरह एक बहुत कुछ दिखता है ...
mbomb007

4
यही आपको ब्लॉक आधारित भाषाओं के साथ मिलता है। इसकी बात पर आते हैं, बहुत सारी भाषाएं एक जैसी दिखती हैं। ;)
शिमोनस्टर

1
यहां तक ​​कि स्क्रैच का एक मॉड फंक्शन है, इसलिए मुझे लगता है कि आप GCM / GCD फंक्शन को ब्लॉक के साथ तेजी से बना सकते हैं, अगर (b == 0) पर आधारित है तो एक और GCM (b, एक% b)
अल्काइमर

55

2007 - LOLCODE

भाषा का इतिहास

LOLCODE को 2007 में Lancaster University के शोधकर्ता एडम लिंडसे ने बनाया था। इसका सिंटैक्स Cheezburger, Inc. द्वारा प्रचलित लोलक मेम पर आधारित है।

"नमस्ते दुनिया!" प्रकार

HAI
VISIBLE "LOLCODE wuz maed in 2007!"
KTHXBYE

ASCII आर्ट एन

HAI

BTW, read n from stdin
GIMMEH n

BTW, convert n from YARN to NUMBR
n R PRODUKT OF n AN 1

BOTH SAEM n AN 1, O RLY?
    YA RLY
        VISIBLE "N"
    NO WAI
        VISIBLE "N"!

        I HAS A butt ITZ 1
        IM IN YR toilet UPPIN YR butt TIL BOTH SAEM butt AN DIFF OF n AN 1
            VISIBLE " "!
        IM OUTTA YR toilet

        VISIBLE "N"

        I HAS A kat ITZ 2
        IM IN YR closet UPPIN YR kat TIL BOTH SAEM kat AN n
            VISIBLE "N"!
            BOTH SAEM kat AN 2, O RLY?
                YA RLY
                    VISIBLE "N"!
                NO WAI
                    I HAS A doge ITZ 1
                    IM IN YR l00p UPPIN YR doge TIL BOTH SAEM doge AN DIFF OF kat AN 1
                        VISIBLE " "!
                    IM OUTTA YR l00p
                    VISIBLE "N"!
            OIC

            I HAS A brd ITZ 1
            IM IN YR haus UPPIN YR brd TIL BOTH SAEM brd AN DIFF OF n AN kat
                VISIBLE " "!
            IM OUTTA YR haus

            VISIBLE "N"
        IM OUTTA YR closet

        VISIBLE "N"!

        I HAS A d00d ITZ 1
        IM IN YR lap UPPIN YR d00d TIL BOTH SAEM d00d AN DIFF OF n AN 1
            VISIBLE " "!
        IM OUTTA YR lap

        VISIBLE "N"
OIC

KTHXBYE

मानों का उपयोग स्टिंग से तार (YARN) के रूप में किया जाता है GIMMEH। उन्हें 1 से गुणा करके संख्यात्मक (NUMBRs) में परिवर्तित किया जा सकता है।

मूल्यों का उपयोग करने के लिए प्रिंट किया जाता है VISIBLE। डिफ़ॉल्ट रूप से एक नई पंक्ति जोड़ दी जाती है, लेकिन इसे विस्मयादिबोधक बिंदु जोड़कर दबाया जा सकता है।

GCD

HAI

GIMMEH a
a R PRODUKT OF a AN 1

GIMMEH b
b R PRODUKT OF b AN 1

I HAS A d00d ITZ 1
IM IN YR food UPPIN YR d00d TIL BOTH SAEM b AN 0
    I HAS A kitty ITZ a
    I HAS A doge ITZ b
    a R doge
    b R MOD OF kitty AN doge
IM OUTTA YR food

VISIBLE SMOOSH "gcd is " a

KTHXBYE

SMOOSH स्ट्रिंग संघनन करता है।


13
अंत में, एक भाषा हर कोई समझ सकता है।
ASCIIThenANSI

26
IM IN YR toilet UPPIN YR buttअच्छा चर नाम
कोल जॉन्सन

13
@ColeJohnson: मैं हमेशा के बजाय चर नाम उस स्थिति में समझ बनाने के चयन करने की कोशिश x1, x2आदि
एलेक्स ए

2
प्रफुल्लित। मुझे काम पर यह नहीं पढ़ना चाहिए।
एलन हूवर

@AlanHover: स्पष्ट रूप से तेह लोलज़ तेह जॉब से अधिक महत्वपूर्ण हैं।
एलेक्स ए।

43

1982 - पोस्टस्क्रिप्ट

पोस्टस्क्रिप्ट वेक्टर ग्राफिक्स और प्रिंटिंग बनाने के लिए एक भाषा है।

एडोब की स्थापना 1982 में हुई थी, और उनका पहला उत्पाद पोस्टस्क्रिप्ट था। भाषा का उपयोग प्रिंटर में किया गया था: आदेशों की व्याख्या प्रिंटर द्वारा रेखापुंज छवि बनाने के लिए की जाती है, जिसे तब पृष्ठ पर मुद्रित किया जाता है। यह 1990 के दशक में अच्छी तरह से लेजर प्रिंटर का एक बहुत ही सामान्य घटक था। लेकिन यह स्पष्ट रूप से प्रिंटर पर काफी सीपीयू गहन है, और जैसे-जैसे कंप्यूटर प्रोसेसर अधिक शक्तिशाली होते गए, यह प्रिंटर की तुलना में कंप्यूटर पर रेखांकन करने के लिए अधिक समझ में आता है। पोस्टस्क्रिप्ट काफी हद तक उपभोक्ता प्रिंटर पर चले गए हैं, हालांकि यह अभी भी बहुत अधिक हाई-एंड प्रिंटर पर मौजूद है।

पोस्टस्क्रिप्ट को प्रतिस्थापित करने वाला मानक पीडीएफ नामक एक अल्पज्ञात प्रारूप है।

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

चूंकि पोस्टस्क्रिप्ट एक मुद्रण भाषा है, इसलिए इसे कुछ प्रिंट करने के लिए उपयोग करने के लिए अधिक उपयुक्त लगता है फिर कंसोल में आउटपुट भेजें।

कार्य 1

/Courier findfont
12 scalefont
setfont
newpath

100 370 moveto
(PostScript was made in 1982!\n) show

पहली कुछ पंक्तियों में एक कैनवास स्थापित होता है। तब movetoकमांड PS को एक विशेष स्थिति में आकर्षित करने के लिए कहता है, और showस्ट्रिंग को पृष्ठ पर प्रिंट करता है। ध्यान दें कि कोष्ठक पोस्टस्क्रिप्ट में एक स्ट्रिंग को चिह्नित करते हैं, उद्धरण चिह्नों को नहीं।

टास्क २

/asciiartN {% stack: N row col
            % output: draws an "ASCII art" N

  % PostScript doesn't allow you to pass variables directly into a function;
  % instead, you have to pass variables via the global stack. Pop the variables
  % off the stack and define them locally.
  6 dict begin
  /row exch def
  /col exch def
  /N exch def

  % Define how much space will be between each individual "N"
  /spacing 15 def

  % Get the width of the "N". We need this to know where to draw the right-hand
  % vertical
  /endcol col spacing N 1 sub mul add def

  % One row is drawn at a time, with the bottom row drawn first, and working
  % upwards. This stack variable tracks which column the diagonal is in, and so
  % we start on the right and work leftward
  /diagcol endcol def

  % Repeat N times: draw one row at a time
  N {
    % Left-hand vertical of the "N"
    col row moveto
    (N) show

    % Right-hand vertical of the "N"
    endcol row moveto
    (N) show

    % Diagonal bar of the "N"
    diagcol row moveto
    (N) show

    % Advance to the next row. This means moving the row one space up, and the
    % diagonal position one place to the left.
    /row row spacing add def
    /diagcol diagcol spacing sub def

  } repeat

  end
} def

1 100 200 asciiartN
3 150 200 asciiartN
5 230 200 asciiartN

मैंने "ASCII कला" एन ड्राइंग के लिए एक फ़ंक्शन लिखा था, लेकिन एक तर्क लेने के लिए पोस्टस्क्रिप्ट फ़ंक्शन के लिए कोई रास्ता नहीं है। इसके बजाय, आप अपने तर्कों को स्टैक पर धकेलते हैं, फिर उन्हें वापस हटा दें। वह /x exch defरेखा है।

एक उदाहरण: मान लीजिए कि स्टैक है 8 9 2। पहले हम /xस्टैक को नाम धक्का देते हैं , इसलिए स्टैक है 8 9 2 /xexchऑपरेटर दो ढेर मूल्यों अदला-बदली, तो अब ढेर है 8 9 /x 2। फिर defशीर्ष दो स्टैक मानों को पॉप करता है, और मान रखने के /xलिए परिभाषित करता है 2। स्टैक अब है 8 9

जब मैंने पोस्टस्क्रिप्ट का उपयोग करना शुरू किया, तो मुझे यह थोड़ा भ्रमित लगा। मैं एक सैद्धांतिक अवधारणा के रूप में स्टैक के बारे में पढ़ूंगा, लेकिन यह पहली बार था जब मैं इसे अभ्यास में इस्तेमाल कर रहा था।

फ़ंक्शन का बाकी हिस्सा कुछ ड्राइंग कोड है: निचले दाएं हाथ के कोने पर शुरू करें, बाएं से दाएं-तिरछे एक समय में एक पंक्ति में भरना।

टास्क 3

/modulo {% stack: x y
         % output: returns (x mod y)
  3 dict begin
  /y exch def
  /x exch def

  % If x = y then (x mod y) == 0
  x y eq {0} {

    % If x < y then (x mod y) == x
    x y lt {x} {

      % If x > y then subtract floor(x/y) * y from x
      /ycount x y div truncate def
      /x x ycount y mul sub def

      /x x cvi def
      x

    } ifelse
  } ifelse
} def

/gcd {% stack: a b
      % returns the gcd of a and b
  2 dict begin
  /b exch def
  /a exch def

  % I'm using the recursive version of the Euclidean algorithm

  % If b = 0 then return a
  b 0 eq {a} {

    % Otherwise return gcd(b, a mod b)
    /a a b modulo def
    b a gcd
  } ifelse

} def

/displaygcd {% stack: a b xcoord ycoord
             % displays gcd(a,b) at position (xcoord, ycoord)
  5 dict begin
  /ycoord exch def
  /xcoord exch def
  /b exch def
  /a exch def
  /result a b gcd def

  xcoord ycoord moveto
  result 20 string cvs show

  % end
} def

8 12 100 80 displaygcd
12 8 150 80 displaygcd
3 30 200 80 displaygcd
5689 2 250 80 displaygcd
234 876 300 80 displaygcd

फिर से, मैंने यूक्लिड के एल्गोरिथ्म के एक रूप का उपयोग किया, लेकिन मैं भूल गया कि पोस्टस्क्रिप्ट में एक मॉड्यूल ऑपरेटर बनाया गया है, इसलिए मुझे अपना खुद का लिखना होगा। यह स्टैक-आधारित प्रोग्रामिंग की बाधाओं का एक उपयोगी अनुस्मारक निकला। मेरा पहला कार्यान्वयन moduloपुनरावृत्ति पर आधारित था:

modulo(x, y)
    if (x = y) return 0
    elif (x < y) return x
    else return module(x - y, y)

जो तब तक ठीक है जब तक आप इसे चलाने की कोशिश करते हैं जब xबड़ा होता है और yछोटा होता है (जैसे 5689 और 2)। स्टैक पर आपके पास केवल 250 तत्व हो सकते हैं, और इसलिए मैं स्टैक सीमा से अच्छी तरह से बह रहा था। उफ़। मुझे उस एक पर ड्राइंग बोर्ड पर वापस जाना पड़ा।

GCD कोड अपने आप में काफी सरल है। लेकिन जैसे ही फ़ंक्शन तर्क नहीं ले सकते हैं, इसलिए उनके पास रिटर्न मान नहीं हैं। इसके बजाय, आपको परिणाम को स्टैक पर धकेलना होगा जहां कोई और इसे बाद में बंद कर सकता है। यही वे aऔर b a gcdरेखाएँ हैं: जब उनका मूल्यांकन समाप्त हो जाता है, तो वे मूल्य को स्टैक पर धकेल देते हैं।

यदि आप एक दस्तावेज़ में सभी कोड डालते हैं और इसे प्रिंट करते हैं, तो यह वही है जो आउटपुट जैसा दिखता है:

यहां छवि विवरण दर्ज करें


8
हाहा मुझे कागज के छपे हुए टुकड़े की तस्वीर बहुत पसंद है। 1982 के लिए उपयुक्त लगता है।
एलेक्स ए।

1
इसके अलावा, आपके विवरण के लिए धन्यवाद कि आपको एक (शाब्दिक) स्टैक ओवरफ़्लो कैसे मिला - अब मैं अधिक सहजता से समझता हूं कि भाषाओं की अधिकतम पुनरावृत्ति गहराई क्यों है।
DLosc

2
@ एलेक्सा: हाँ, लेकिन एक डॉट-मैट्रिक्स प्रिंटआउट (कागज के किनारों पर छेद के साथ) और भी अधिक उपयुक्त होता । ;-)
एमोस कारपेंटर

@ AmosM.Carpenter: वास्तव में नहीं, मुझे नहीं लगता कि किसी भी डॉट-मैट्रिक्स प्रिंटर ने कभी पोस्टस्क्रिप्ट का समर्थन किया है। यह हमेशा लेज़र प्रिंटर से काफी जुड़ा होता है।
नवजाल

41

2009 - > <>

Befunge से प्रेरित,> <> (मछली) एक गूढ़ स्टैक-आधारित 2D भाषा है, अर्थात प्रोग्राम का प्रवाह ऊपर, नीचे, बाएं या दाएं हो सकता है। > <> के प्रारंभिक संस्करण में मल्टीथ्रेडिंग दिखाया गया है [और ]थ्रेड्स बनाए और समाप्त किए गए हैं, लेकिन सादगी कारणों से इन निर्देशों को क्रमशः नए स्टैक्स बनाने और हटाने के लिए बदल दिया गया।

> <> के लिए वर्तमान आधिकारिक दुभाषिया यहां पाया जा सकता है । दुर्भाग्य से, Esolang विकी पर पुराने दुभाषिया का लिंक टूट गया है।

"नमस्ते दुनिया!" प्रकार

"!9002 ni edam saw ><>"l?!;obb+0.

ध्यान दें कि स्ट्रिंग को पीछे की तरफ कैसे लिखा गया है -> <> तकनीकी रूप से तार नहीं है, एकमात्र डेटा प्रकार में चार, इंट और फ्लोट का एक अजीब मिश्रण है। "टॉगल स्ट्रिंग पार्सिंग, स्टैक पर प्रत्येक पात्र को धक्का देता है जब तक कि एक समापन नहीं मिलता "है।

कोड की दूसरी छमाही तब स्टैक की लंबाई को धक्का देती है l, जांचती है कि क्या यह शून्य है ?!और यदि प्रोग्राम समाप्त हो गया है ;। अन्यथा निर्देश सूचक जारी रहता है, oनिष्पादित करने से पहले स्टैक के शीर्ष को आउटपुट करता है bb+0., जो लूप बनाते समय, पॉइंटर को स्थिति से (22, 0)ठीक पहले lभेज देता है।

ASCII आर्ट एन

&0 > :&:&:*=?;  :&:&%  :0=?v  :&:&1-=?v  :{:{-&:&,{=?v   " " o   \

                           > ~"N"o                           v    
   +                                  > ~"N"oao              v    
   1                                                 >"N"o   v    

   \                                                         <   /

स्पष्टता के लिए रिक्ति के साथ। आप यहाँ नए ऑनलाइन दुभाषिया पर इसे आज़मा सकते हैं और निर्देश सूचक को इधर-उधर जाते देख सकते हैं - बस "इनिशियल स्टैक" टेक्स्टबॉक्स में एक संख्या दर्ज करना याद रखें। यदि आप पायथन इंटरप्रेटर के माध्यम से चल रहे हैं, -vतो स्टैक को इनिशियलाइज़ करने के लिए ध्वज का उपयोग करें , जैसे

py -3 fish.py ascii.fish -v 5

इस कार्यक्रम के लिए, हम इनपुट nको रजिस्टर में डालते हैं &और 0 दबाते हैं, जिसे हम i"पुनरावृत्तियों" के लिए कहेंगे । कार्यक्रम का बाकी हिस्सा एक विशाल लूप है जो इस प्रकार है:

:&:&:*=?;          If i == n*n, halt. Otherwise ...
:&:&%              Push i%n
:0=?v              If i%n == 0 ...
>~"N"o               Print "N"
:&:&1-=?v          Else if i%n == n-1 ...
>~"N"oao             Print "N" and a newline
:{:{-&:&,{=?v      Else if i%n == i//n, where // is integer division...
>~"N"o               Print "N"
" "o               Otherwise, print a space
1+                 Increment i

फिर हम शुरुआत से लूप दोहराते हैं।

तीर ^>v<प्रोग्राम फ्लो की दिशा बदलते हैं और दर्पण /\प्रोग्राम फ्लो की दिशा को दर्शाते हैं।

GCD

>:{:}%\
;n{v?:/
v~@/

यहां एक उदाहरण दिया गया है कि एक गोल्फ> <> कार्यक्रम कैसा दिख सकता है। एक बार फिर, आप इसे ऑनलाइन दुभाषिया में आज़मा सकते हैं ("प्रारंभिक स्टैक" बॉक्स में दो कॉमा-अलग किए गए मान दर्ज करें, जैसे 111, 87) या -vपायथन दुभाषिया के झंडे का उपयोग करके , जैसे

py -3 fish.py gcd.fish -v 111 87

यह कार्यक्रम यूक्लिडियन एल्गोरिथ्म का उपयोग करता है। यहाँ पहले से तैयार एक GIF है:

यहां छवि विवरण दर्ज करें

ध्यान दें कि> <> टॉरोइडल है, इसलिए जब नीचे बाएं vनिर्देश को निष्पादित किया जाता है तो निर्देश सूचक नीचे की ओर जाता है, चारों ओर लपेटता है, और शीर्ष पर फिर से दिखाई देता है।


संपादित करें: कोड को पूरी तरह से दाईं से बाईं ओर चलाकर, @randomra के साथ तीन बाइट्स दाढ़ी बनाने में कामयाब रहे

<~@v!?:%}:{:
;n{/

लगता है कि मैं इसे नीचे गोल्फ नहीं था :)


27
और इसी तरह मुझे पता चला कि नाम ><>एक पैलेंड्रोम है।
ज़ेव ईसेनबर्ग

33

2012 - तत्व

यह एक ऐसी भाषा है जिसका आविष्कार मैंने 2012 की शुरुआत में एक साधारण गोल्फिंग भाषा के रूप में किया था। इसके द्वारा, मेरा मतलब है कि कोई भी ऑपरेटर ओवरलोडिंग के लिए बहुत कम है। अधिकांश आधुनिक गोल्फिंग भाषाओं की तुलना में ऑपरेटर सरल और कम संख्या में हैं।

इस भाषा की सबसे दिलचस्प विशेषताएं इसकी डेटा संरचनाएं हैं। कर रहे हैं दो ढेर और एक हैश है कि जानकारी स्टोर करने के लिए उपयोग किया जाता है।

एम-स्टैक मुख्य स्टैक है, जहां अंकगणित और अधिकांश अन्य ऑपरेशन होते हैं। जब डेटा इनपुट या प्रिंट किया जाता है, तो यह वह जगह है जहां से इसे प्राप्त किया जाता है या फिर से प्राप्त किया जाता है।

सी-स्टैक नियंत्रण स्टैक है। यह वह जगह है जहाँ बूलियन अंकगणित होता है। सी-स्टैक के शीर्ष मानों का उपयोग अगर और जबकि स्थिति के रूप में करते हैं।

हैश वह जगह है जहां चर संग्रहीत किए जाते हैं। ;और ~स्टोर और क्रमश: हैश से डेटा पुनः प्राप्त।

तत्व एक बहुत ही कमजोर टाइप की भाषा है। यह पर्ल की क्षमता का उपयोग स्ट्रिंग्स और इसके विपरीत संख्याओं की स्वतंत्र रूप से व्याख्या करने के लिए करता है।

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

OP    the operator.  Each operator is a single character
STACK tells what stacks are affected and how many are popped or pushed
      "o" stands for "other effect"
HASH  tells if it involves the hash
x & y represent two values that are already on the stack, so the effect of
      the operator can be more easily described

OP     STACK  HASH   DESCRIPTION
text     ->m         --whenever a bare word appears, it pushes that string onto 
                       the main stack
_       o->m         --inputs a word and pushes onto main stack
`       m->o         --output.  pops from main stack and prints
xy;    mm->    yes   --variable assignment.  the top stack element y is assigned 
                       the value x
~       m->m   yes   --variable retrieval.  pops from main stack, pushes contents 
                       of the element with that name
x?      m->c         --test. pops x and pushes 0 onto control stack if x is '0' or 
                       an empty string, else pushes 1
><=     m->c         --comparison. pops two numbers off of stack and performs 
                       test, pushes 1 onto control stack if true and 0 if false
'       m->c         --pops from main stack and pushes onto control stack
"       c->m         --pops from control stack and pushes onto main stack
&|     cc->c         --AND/OR. pops two items from control stack, performs and/or 
                       respectively, and pushes result back onto control stack
!       c->c         --NOT. pops a number off of control stack, pushes 1 if 0 or 
                       empty string, 0 otherwise
[]       c           --FOR statement (view the top number number from control stack 
                       and eval those many times)
{}       c           --WHILE (loop until top number on control stack is 0, also 
                       does not pop)
#       m->          --discard. pops from main stack and destroys
(       m->mm        --pops from main stack, removes first character, pushes the 
                       remaining string onto stack, and pushes the removed character 
                       onto stack
)       m->mm        --pops from main stack, removes last character, pushes the 
                       remaining string onto stack, and pushes the removed character 
                       onto stack
+-*/%^ mm->m         --arithmetic. pops two most recent items, adds/negates
                       /multiplies/divides/modulates/exponentiates them, and places 
                       the result on the stack 
xy@    mm->o         --move. pops x and y and moves xth thing in stack to move to 
                       place y in stack
x$      m->m         --length. pops x and pushs length of x onto the stack
xy:    mm->o         --duplication. pops x and y and pushes x onto the stack y times
xy.    mm->m         --concatination. pops x and y and pushes x concatonated with y
\        o           --escapes out of next character, so it isn't an operator and can
                       be pushed onto the stack
,      m->mm         --character conversion. pops from main stack, coverts it to char
                       and pushes, and converts to num and pushes
Newlines and spaces separate different elements to be pushed 
onto the stack individually, but can pushed onto the stack using \

कार्य 1 - प्रिंट पाठ

Element\ was\ made\ in\ 2012\!`

भाषा के अधिक अजीब भागों में से एक स्ट्रिंग सीमांकक की कमी है, यही कारण है कि इस स्ट्रिंग में भागने के पात्रों की आवश्यकता होती है। `अंत में स्ट्रिंग प्रिंट करता है।

टास्क 2 - एएससीआईआई कला एन

_+'[y~1+y;0[1+4:"2:'=1=|y~=|\ [#N]`"#]\
`]

यहाँ, आप कुछ स्टैक हेरफेर देखेंगे। विवरण को प्रारूपित करने के लिए थोड़ा आसान बनाने के लिए, मैं न्यूलाइन को ए Lऔर स्पेस को ए के साथ बदलूंगा S

_+'[y~1+y;0[1+4:"2:'=1=|y~=|\S[#N]`"#]\L`]
_+'      input line, convert to #, move to c-stack
[        FOR loop
 y~1+y;  increment the y-pos
 0       set the x-pos (the top # on the stack) to zero
 [       FOR loop
  1+4:   increment x-pos and make 3 additional copies (4 is total #)
  "2:'   make a copy of the N size on the main stack
  =      if x-pos == size
  1=     or if x-pos == 1
  y~=|   of if x-pos == y-pos
  \S     (always) push a space
  [      the IF body (technically a FOR loop)
   #N    if true, remove the space and push an N
  ]      end IF
  `      output the pushed character
  "#     remove the result of the conditional
 ]       end x-pos FOR
 \L`     output a newline
]        end y-pos FOR

इस उत्तर के कुछ चरम गोल्फ करने के बाद, मुझे एक 39 बाइट समाधान मिला, हालांकि यह बहुत अधिक जटिल है।

_'1[y~+y;[#1+3:"2:'%2<y~=|\ [#N]`"]\
`]

टास्क 3 - जीसीडी

__'{"3:~2@%'}`

यह एक स्टैक-आधारित पद्धति है।

__                 input the two numbers
  '                use one of the number as a condition so the WHILE loop starts
   {        }      a WHILE loop. Repeats while the c-stack has a true value on top
    "              get the number back from the c-stack to do operations on it
     3:            make it so that there are threes copies on the stack
       ~           takes one of the copies from earlier and converts it to a zero
        2@         take the top item on the stack and move it behind the other two #s
          %        modulo operation
           '       use this number as the condition
             `     since one number is zero (and on the c-stack) print the 
                   other number, which is on m-stack

29

2012 - जूलिया

भाषा का इतिहास

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

"नमस्ते दुनिया!" प्रकार

println("Julia was made in 2012!")

जूलिया में STDOUT में मुद्रण काफी सरल है!

ASCII आर्ट एन

function asciin(n)
    # Create an nxn matrix of spaces
    m = fill(" ", (n, n))

    # Fill the first and last columns with "N"
    m[:,1] = m[:,n] = "N"

    # Fill the diagonal elements with "N"
    setindex!(m, "N", diagind(m))

    # Print each row of the matrix as a joined string
    for i = 1:n
        println(join(m[i,:]))
    end
end

कोड पठनीयता के लिए प्रेरित है, लेकिन जूलिया व्हाट्सएप पर कोई प्रतिबंध नहीं लगाती है।

GCD

function g(a, b)
    b == 0 ? a : g(b, a % b)
end

फ़ंक्शन में सूचीबद्ध अंतिम चीज़ को संक्षेप में वापस कर दिया जाता है।


27

1988 - गणितज्ञ

या मुझे इसे वुल्फराम भाषा कहना चाहिए ?

टास्क 0

मैथेमेटिका के निर्माता स्टीफन वोल्फ्राम हैं, जो वुल्फराम रिसर्च के संस्थापक और सीईओ हैं। गणितज्ञ के विकास से पहले, वह एक भौतिक विज्ञानी थे। भौतिक विज्ञान में बीजीय गणना की एक बड़ी मात्रा थी, इसलिए वह मैक्सीमैया का उपयोगकर्ता बन गया ।

वोल्फराम को 1979 में PHD मिला, जब वह 20 वर्ष के थे। उन्होंने सोचा कि उन्हें भौतिक विज्ञान करने के लिए Macsyma से बेहतर CAS की आवश्यकता है, इसलिए उन्होंने लिखना शुरू किया एसएमपी ("सिंबोलिक मैनिपुलेशन प्रोग्राम") । एसएमपी का पहला संस्करण 1981 में जारी किया गया था। एसएमपी गणितज्ञ का पूर्ववर्ती था। यद्यपि इसका गणितज्ञ पर गहरा प्रभाव था, लेकिन इसका कोई भी कोड कभी भी गणितज्ञ के लिए उपयोग नहीं किया गया था।

1986 में, वुल्फराम ने एक "परम कम्प्यूटेशन सिस्टम" लिखने का फैसला किया। उन्होंने 1986 में कोड लिखना शुरू किया और 1987 में वोल्फ्राम रिसर्च की स्थापना की। आखिरकार, मैथमेटिका 1.0 को 23 जून 1988 को रिलीज़ किया गया।

गणितज्ञ 1.0

मुझे Mathematica 1.0 नहीं मिला। वास्तव में, Mathematica 1.0 में न तो विंडोज था और न ही लिनक्स संस्करण। लेकिन मुझे एक चीनी वेबसाइट पर Mathematica 2.0 मिली। इसे अभी भी विंडोज एक्सपी पर चलाया जा सकता है।

गणितज्ञ २.०

कार्य 1

Print["Mathematica was made in 1988!"]

या केवल:

"Mathematica was made in 1988!"

टास्क २

आज के गणितज्ञ में, हम लिख सकते हैं:

asciiArtN[n_] := Print @@@ SparseArray[{i_, 1 | i_ | n} -> "N", {n, n}, " "]

जूलिया और आर की तरह , यह एक मैट्रिक्स समाधान है। Mathematica में, आप पैटर्न मिलान का उपयोग करके एक विरल मैट्रिक्स को परिभाषित कर सकते हैं।

हालाँकि, SparseArrayMathematica 5.0 में पेश किया गया था, इसलिए हम इसे Mathematica 1.0 में उपयोग नहीं कर सकते हैं।

यहाँ एक समाधान है जो गणित 1.0 में काम करता है:

asciiArtN[n_] := Block[{f},
  f[i_, 1]  = "N";
  f[i_, i_] = "N";
  f[i_, n]  = "N";
  f[__]     = " ";
  Apply[Print, Array[f, {n, n}], 1];
]

हम नहीं लिख सकते f[i_, 1 | i_ | n] = "N"क्योंकि AlternativesMathematica 2.0 में पेश किया गया था।

टास्क 3

हम केवल अंतर्निहित फ़ंक्शन का उपयोग कर सकते हैं:

gcd = GCD

या हम GCD की परिभाषा का उपयोग कर सकते हैं:

gcd = Max[Intersection @@ Divisors[{##}]] &;

या हम LCM का उपयोग कर सकते हैं , हालांकि अधिक सामान्यतः LCM की गणना GCD से की जाती है:

gcd = Times[##]/LCM[##] &;

या हम पैटर्न मिलान के साथ यूक्लिडियन एल्गोरिथ्म का उपयोग कर सकते हैं:

gcd[a_, 0] := a
gcd[a_, b_] := gcd[b, Mod[a, b]]

या एक अनाम फ़ंक्शन के रूप में:

gcd = If[#2 == 0, #1, #0[#2, Mod[##]]] &;

ऊपर दिए गए सभी कार्यों को गणितज्ञ 1.0 में पेश किया गया था।


3
यह मेरी तुलना में बहुत बेहतर उत्तर है। मैं मेरा डिलीट कर दूंगा।
मार्टिन एंडर

25

1999 - एक्सएसएलटी

वर्ल्ड वाइड वेब कंसोर्टियम (W3C) एचटीएमएल, पाठ, आदि में एक्सएमएल बदलने के लिए XSLT बनाई निम्न उदाहरण मान इनपुट में संलग्न है <input>..</input>टैग।

कार्य 1

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text" indent="no"/>
  <xsl:template match="/input">XSLT was made in 1999!</xsl:template>
</xsl:stylesheet>

यह एक सरल है। यह inputशीर्ष स्तर पर एक टैग से मेल खाता है और इसे वांछित आउटपुट से बदल देता है।

टास्क २

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text" indent="no"/>
  <xsl:template match="/input">
    <xsl:call-template name="loop">
      <xsl:with-param name="i">1</xsl:with-param>
      <xsl:with-param name="n">
        <xsl:value-of select="."/>
      </xsl:with-param>
    </xsl:call-template>
  </xsl:template>
  <xsl:template name="loop">
    <xsl:param name="i"/>
    <xsl:param name="n"/>
    <xsl:choose>
      <xsl:when test="$i = 1 or $i = $n">
        <xsl:text>N</xsl:text>
        <xsl:call-template name="spaces">
          <xsl:with-param name="n">
            <xsl:value-of select="$n - 2"/>
          </xsl:with-param>
        </xsl:call-template>
        <xsl:text>N&#13;&#10;</xsl:text>
      </xsl:when>
      <xsl:otherwise>
        <xsl:text>N</xsl:text>
        <xsl:call-template name="spaces">
          <xsl:with-param name="n">
            <xsl:value-of select="$i - 2"/>
          </xsl:with-param>
        </xsl:call-template>
        <xsl:text>N</xsl:text>
        <xsl:call-template name="spaces">
          <xsl:with-param name="n">
            <xsl:value-of select="$n - $i - 1"/>
          </xsl:with-param>
        </xsl:call-template>
        <xsl:text>N&#13;&#10;</xsl:text>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:if test="$i &lt; $n">
      <xsl:call-template name="loop">
        <xsl:with-param name="i">
          <xsl:value-of select="$i + 1"/>
        </xsl:with-param>
        <xsl:with-param name="n">
          <xsl:value-of select="$n"/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:if>
  </xsl:template>
      <xsl:template name="spaces">
    <xsl:param name="n"/>
    <xsl:if test="$n &gt; 0">
      <xsl:text> </xsl:text>
      <xsl:call-template name="spaces">
        <xsl:with-param name="n">
          <xsl:value-of select="$n - 1"/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:if>
  </xsl:template>
</xsl:stylesheet>

यह एक 2 पुनरावर्ती टेम्पलेट्स को परिभाषित करता है, loopऔर spacesloopमापदंडों के साथ iऔर स्थिति के nलिए वांछित आउटपुट उत्पन्न करेगा । पैरामीटर के साथ उत्पन्न होगाnispacesnn रिक्त स्थान ।

टास्क 3

इसके लिए इनपुट <input><num>..</num><num>..</num></input>टैग में होना चाहिए ।

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text" indent="no"/>
  <xsl:template match="/input">
    <xsl:call-template name="gcd">
      <xsl:with-param name="a"><xsl:value-of select="num[1]"/></xsl:with-param>
      <xsl:with-param name="b"><xsl:value-of select="num[2]"/></xsl:with-param>
    </xsl:call-template>
  </xsl:template>
  <xsl:template name="gcd">
    <xsl:param name="a"/>
    <xsl:param name="b"/>
    <xsl:choose>
      <xsl:when test="$b = 0"><xsl:value-of select="$a"/></xsl:when>
      <xsl:otherwise>
        <xsl:call-template name="gcd">
          <xsl:with-param name="a"><xsl:value-of select="$b"/></xsl:with-param>
          <xsl:with-param name="b"><xsl:value-of select="$a mod $b"/></xsl:with-param>
        </xsl:call-template>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
</xsl:stylesheet>

यह केवल एक पुनरावर्ती टेम्पलेट gcdहै जो यूक्लिडियन एल्गोरिथ्म का उपयोग करता है।


और वे कहते हैं कि INTERCAL अजीब है!
kirbyfan64sos

2
@ kirbyfan64sos निष्पक्ष होने के लिए, इस सामान के लिए इसका इस्तेमाल नहीं किया जाना चाहिए ...
LegionMammal978

24

2014 - सीजेएम

CJam को PPCG उपयोगकर्ता aditsu द्वारा बनाया गया था और अप्रैल 2014 के आसपास रिलीज़ किया गया था ।

"नमस्ते दुनिया!" प्रकार

"CJam was made in 2014!"

CJam प्रोग्राम के अंत में स्वचालित रूप से स्टैक की सामग्री को प्रिंट करता है

ASCII आर्ट एन

ri:R'#*a_R2-,{_)S*'#+\R((-zS*+}%+\+R<zN*

कोड स्पष्टीकरण:

ri:R                                       "Read the input as integer in R";
    '#*a                                   "Get a string of R # and wrap it in an array";
        _R2-,{                }%           "Copy that string and then run this loop R-2";
                                           "times for the diagonal";
              _)S*                         "Get iteration index + 1 spaces";
                  '#+                      "Append the hash";
                     \R((-zS*+             "Append remaining spaces";
                                +\+        "Append and prepend the initial # string";
                                   R<      "Take only R columns/rows. This is for";
                                           "tackling input 1";
                                     zN*   "Transpose and join with new lines";

STDIN के माध्यम से इनपुट के रूप में एन की ऊंचाई / चौड़ाई लेता है। इसे यहाँ ऑनलाइन आज़माएँ

GCD

l~{_@\%}h;

STDIN के माध्यम से इनपुट के रूप में दो नंबर लेता है। इसे यहाँ ऑनलाइन आज़माएँ


मुझे लगता है कि यह [कोड-गोल्फ] नहीं है, लेकिन आप ri_S*0'NtW'Nta1$*\,Sf*'Nf+..e>N*आधुनिक CJam में ASCII- कला एन कार्यक्रम को छोटा कर सकते हैं ।
फल

24

1990 - हास्केल

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

कार्य 1

main = putStrLn "Haskell was made in 1990!"

टास्क २

-- Infinite list of growing letters 'N'
bigNs :: [[[Char]]]
bigNs = ["N"]
      : ["NN","NN"]
      : [ ins (ins 'N' t) $ map (ins ' ') n | n@(t:_) <- tail bigNs ]

-- Insert a new element after the head (i.e. at the second position).
ins :: a -> [a] -> [a]
ins x (l:ls) = l:x:ls

डेमो, संपूर्ण अनंत सूची को प्रिंट करें (जब तक उपयोगकर्ता गर्भपात नहीं करता है, या दुनिया समाप्त हो जाती है ...)

GHCi> mapM_ (putStrLn . unlines) bigNs
N

NN
NN

N N
NNN
N N

N  N
NN N
N NN
N  N

N   N
NN  N
N N N
N  NN
N   N

N    N
NN   N
N N  N
N  N N
N   NN
N    N

...

बेशक, आप इनमें से किसी एक को आसानी से प्राप्त कर सकते हैं, अनंत सूची के केवल एक तत्व का उपयोग करके:

main :: IO ()
main = do
   i <- readLn
   putStrLn . unlines $ bigNs!!i

टास्क 3

gcd' :: Integer -> Integer -> Integer
gcd' a 0 = a
gcd' a b = gcd' b $ a`mod`b

23

1972 - आंतरिक

और आपने सोचा कि फोरट्रान और कोबोल अजीब थे। यह पागल है!

कार्य 1

DO ,1 <- #27
DO ,1SUB#1 <- #110
DO ,1SUB#2 <- #32
DO ,1SUB#3 <- #72
PLEASE DO ,1SUB#4 <- #136
DO ,1SUB#5 <- #88
DO ,1SUB#6 <- #136
PLEASE DO ,1SUB#7 <- #64
DO ,1SUB#8 <- #80
DO ,1SUB#9 <- #46
PLEASE DO ,1SUB#10 <- #22
DO ,1SUB#11 <- #104
DO ,1SUB#12 <- #184
PLEASE DO ,1SUB#13 <- #202
DO ,1SUB#14 <- #78
DO ,1SUB#15 <- #48
PLEASE DO ,1SUB#16 <- #96
DO ,1SUB#17 <- #128
DO ,1SUB#18 <- #162
PLEASE DO ,1SUB#19 <- #110
DO ,1SUB#20 <- #32
DO ,1SUB#21 <- #114
PLEASE DO ,1SUB#22 <- #120
DO ,1SUB#23 <- #240
DO ,1SUB#24 <- #128
PLEASE DO ,1SUB#25 <- #208
DO ,1SUB#26 <- #200
DO ,1SUB#27 <- #52
DO READ OUT ,1
DO GIVE UP

मैं INTERCAL की इनपुट और आउटपुट प्रणाली को समझाने की कोशिश नहीं करने जा रहा हूँ; अभी-अभी पढ़ा यह और आशा है कि आप नहीं मर जाते हैं।

टास्क २

DO WRITE IN 7
DO .1 <- .7
DO .2 <- #1
PLEASE DO (1010) NEXT
DO .8 <- .3
DO .5 <- .7
DO .6 <- .8
DO ,9 <- #2

DO (100) NEXT
DO (1) NEXT

(100) DO (99) NEXT
DO ,9SUB#1 <- #142
DO ,9SUB#2 <- #114
PLEASE DO READ OUT ,9
DO ,9SUB#1 <- #176
DO ,9SUB#2 <- #80
PLEASE DO READ OUT ,9
PLEASE GIVE UP

(99) DO .1 <- .7
DO .2 <- #1
PLEASE DO (1010) NEXT
DO .1 <- '.3~.3'~#1
PLEASE DO FORGET .1
DO RESUME #1

(1) PLEASE DO (3) NEXT
PLEASE DO FORGET #1
DO (1) NEXT

(3) DO (4) NEXT
PLEASE GIVE UP

(4) DO (8) NEXT
DO ,9SUB#1 <- #176
DO ,9SUB#2 <- #80
PLEASE DO READ OUT ,9
DO .6 <- .8
DO .1 <- .5
DO .2 <- #1
DO (1010) NEXT
DO .5 <- .3
DO .1 <- '.5~.5'~#1
PLEASE DO FORGET .1
DO RESUME #1

(8) DO (5) NEXT

(5) PLEASE DO (6) NEXT
PLEASE DO FORGET #1
DO (5) NEXT

(6) PLEASE DO (7) NEXT
DO RESUME #2

(7) DO (10) NEXT
DO .1 <- .6
DO .2 <- #1
PLEASE DO (1010) NEXT
DO .6 <- .3
DO .1 <- '.6~.6'~#1
PLEASE DO FORGET .1
DO RESUME #1

(10) DO (11) NEXT
DO (13) NEXT
DO (14) NEXT
DO (15) NEXT

(11) DO (111) NEXT
DO (112) NEXT

(13) DO (113) NEXT
DO (112) NEXT

(14) DO (114) NEXT
DO (112) NEXT

(111) DO .1 <- .6
DO .2 <- .8
DO (1010) NEXT
DO .1 <- '.3~.3'~#1
PLEASE DO FORGET .1
DO RESUME #1

(112) DO ,9SUB#1 <- #142
DO ,9SUB#2 <- #114
PLEASE DO READ OUT ,9
DO RESUME #3

(113) DO .1 <- .6
DO .2 <- #1
DO (1000) NEXT
DO .1 <- .5
DO .2 <- .3
DO (1010) NEXT
DO .1 <- '.3~.3'~#1
PLEASE DO FORGET .1
DO RESUME #1

(114) DO .1 <- '.6~.6'~#1
PLEASE DO FORGET .1
DO RESUME #1

(15) DO ,9SUB#1 <- #252
DO ,9SUB#2 <- #4
PLEASE DO READ OUT ,9
DO RESUME #2

विनीत अच्छाई। मुझे यह पता लगाने में थोड़ा समय लगा। लेबल नंबर एक गड़बड़ है और इसलिए यह दर्शाता है। जब तक कोई पूछता नहीं है मैं यह समझाने की कोशिश नहीं करने जा रहा हूं।

टास्क 3

DO WRITE IN .5
DO WRITE IN .6

DO (1) NEXT

(1) PLEASE DO (3) NEXT
DO FORGET #1
DO (1) NEXT

(3) DO (4) NEXT
DO READ OUT .5
PLEASE GIVE UP

(4) DO .1 <- .5
DO .2 <- .6
PLEASE DO (1040) NEXT
DO .1 <- .3
DO .2 <- .6
PLEASE DO (1039) NEXT
DO .2 <- .3
DO .1 <- .5
DO (1010) NEXT
DO .5 <- .6
DO .6 <- .3
DO .1 <- '.6~.6'~#1
PLEASE DO FORGET .1
DO RESUME #1

यह एक बालक सरल है। INTERCAL के ... विचित्रता के कारण, आपको इस तरह की संख्या दर्ज करनी होगी:

THREE FIVE

उदाहरण के लिए, 42 और 16 की GCD पाने के लिए, मैं दर्ज करूँगा:

FOUR TWO
ONE SIX

यह रोमन अंकों में संख्या को भी प्रिंट करता है ... क्योंकि यह आपके लिए अंतर है!


2
यह 19 7 2 नहीं होना चाहिए ? (यदि आप इसे लिखने के बाद थोड़ा चक्कर खा रहे हैं, तो मैं समझ सकता हूं: पी) इस गलती के कारण आपका उत्तर अमान्य माना जाता है, जो कि शर्म की बात होगी।
मेरिनस

@marinus धन्यवाद! फिक्स्ड!
kirbyfan64sos

5
कृपया समझाएं। (जब आपके पास समय हो, निश्चित रूप से;)
डीएलोस्क

1
INTERCAL मेरी पसंदीदा भाषा है जो मैंने कभी नहीं सीखी है!
सीजे डेनिस

1
PLEASE GIVE UP। मैंने पहले ही इसे कर दिया था ।-।
RedClover

23

1967 - एपीएल

1957 में, हार्वर्ड विश्वविद्यालय में, केन इवरसन ने सरणी हेरफेर के लिए एक गणितीय अंकन विकसित करना शुरू किया। 1960 के दशक के दौरान, उनके संकेतन को आईबीएम में एक प्रोग्रामिंग भाषा के रूप में विकसित किया गया था। पहला आंशिक कार्यान्वयन 1963 में बनाया गया था, और इसका उपयोग उच्च विद्यालय में छात्रों को पारलौकिक कार्यों के बारे में सिखाने के लिए भी किया गया था। एक पूर्ण, प्रयोग करने योग्य कार्यान्वयन के लिए 1965 तक इंतजार करना पड़ा। दो साल तक यह केवल आईबीएम द्वारा आंतरिक रूप से उपयोग किया गया था। 1967 में, आईबीएम ने सार्वजनिक रूप से एक एपीएल दुभाषिया जारी किया जो आईबीएम 1130 कंप्यूटर पर चलता था, जो 1966 में समाप्त हो गया था। आप समझ सकते हैं कि इसके लिए एक वर्ष चुनना कितना कठिन है, हालांकि, मुझे लगता है कि यह 1967 होना चाहिए। चूंकि यह पहला वर्ष है, इसलिए एक पूर्ण कार्यान्वयन जनता के लिए उपलब्ध कराया गया था। अगर कोई वास्तव में असहमत है, तो मैं इसे बदल सकता हूं।

APL \ 360 के लिए स्रोत कोड, ऑनलाइन है , जैसा कि एक एमुलेटर है। यही मैंने इन उदाहरणों का परीक्षण करने के लिए उपयोग किया है। यह 1967 से है, और एपीएल \ 1130 के साथ (उपरोक्त आईबीएम 1130 के लिए) यह कमोबेश सही मूल है। जैसा कि अपेक्षित था, यह बहुत ही आदिम है। यह इस तरह के ब्योरा छोटे अक्षरों के रूप में, किसी भी ऑपरेटरों के लिए समर्थन की कमी है केवल निर्मित कार्यों के साथ काम करते हैं, और निर्मित कार्यों का सेट बहुत विरल है (विशेष रूप से, है केवल or , और करता नहीं के रूप में दोगुनी हो gcd)। मूल, पूर्ण विवरण यहां उपलब्ध है , हालांकि, मैंने देखा कि मेरे पास जो संस्करण था, वह उस दस्तावेज़ के संबंध में भी पूरा नहीं था, जिसमें दूसरों की कमी थी ।

मैंने यूनिकोड प्रारूप (ताकि आप उन्हें पढ़ सकें) और मूल एन्कोडिंग में (ताकि आप उन्हें एमुलेटर की एपीएल विंडो में काट सकें और पेस्ट कर सकें) दोनों प्रोग्राम प्रदान किए हैं।

अविश्वसनीय रूप से, ये कार्यक्रम Dyalog, NARS2000 और GNU APL के आधुनिक संस्करणों में बिना किसी बदलाव (एन्कोडिंग के) को सही ढंग से चलाते हैं। इसलिए मुझे लगता है कि मुझे पोर्टेबल एपीएल लिखने का तरीका मिल गया है: बस यह दिखावा है कि यह 1967 है!

कार्य 1:

यूनिकोड:

⎕←'APL WAS MADE IN 1967!'

एपीएल \ 360:

L[Kapl was made in 1967ÝK

कार्य 2:

यूनिकोड:

⎕←' N'[1+((2⍴N)⍴(⍳N)∊1,N)∨(⍳N)∘.=⍳N←⎕]

एपीएल \ 360:

L[K nK;1-::2Rn"R:In"E1,n"(:In"J.%In[L'

कार्य 3:

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

यूनिकोड:

∇R←A GCD B
R←A
→(B=0)/0
R←B GCD B|A
∇

⎕←⎕ GCD ⎕

एपीएल \ 360:

Gr[a gcd b
r[a
{:b%0"/0
r[b gcd bMa
G

L[L gcd L

यह कमाल का है।
एलेक्स ए

22

1996 - Ocaml

किसी को 1996 भरने के लिए दिन से अधिक इंतजार था, इसलिए मैं रूबी में भर सकता था। तो फिर OCaml क्यों नहीं सीखते, हैसेल के समान लगता है ...

नमस्ते दुनिया

print_endline "OCaml was made in 1996!";;

ASCII

let ascii n =
  let rec ascii' = function
    | 0 -> ()
    | i ->
        let s = "N" ^ String.make (n-2) ' ' ^ "N" in
        String.fill s (n-i) 1 'N';
        print_endline s;
        ascii' (i-1)
  in ascii' n;;

म्यूटेबल स्ट्रिंग्स!

GCD

let rec gcd a b = if b = 0 then a else gcd b (a mod b);;

नहीं ==और infix mod, यह प्यारा है


मुझे क्षमा करें, मैंने रूबी :)
शून्य फाइबर

4
इस चुनौती का जवाब देने के लिए भाषा सीखने के लिए +1। :)
एलेक्स ए।

आपने अभी F # सीखा है! (यह CLR प्लस कुछ एक्स्ट्रा पर OCaml है)।
रॉबर्ट फ्रेजर

22

2005 - प्रस्तावना

प्रस्तावना एक बहुत ही मजेदार भाषा है, जिसके स्रोत कोड में कई "आवाज़ें" होती हैं, जिन्हें समानांतर में निष्पादित किया जाता है और जिन्हें मैं वास्तव में हल करने में आनंद लेता हूं । इसका मतलब अपनी बहन की भाषा फुगू का ASCII प्रतिनिधित्व है , जो वास्तव में .midi फाइलों को अपने स्रोत कोड के रूप में लेता है और प्रेड्यूले में पाए गए निर्देशों को स्वरों की धुनों में अंतराल के रूप में अंकित करता है।

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

0-9 ... Push the corresponding digit.
+   ... Add the top two numbers on the stack.
-   ... Subtract the top number from the one beneath.
#   ... Discard the top of the stack.
^   ... Copy the top value from the voice above.
v   ... Copy the top value from the voice below.
?   ... Read a number and push it onto the stack.
!   ... Print the top number (and pop it from the stack).
(   ... If the top of the stack is zero, jump past the matching ')'.
)   ... If the top of the stack is zero, jump to the column after the matching '('.

कुछ अतिरिक्त नोट:

  • आवाज चक्रीय हैं, इसलिए ^नीचे की आवाज (और इसके विपरीत) से शीर्ष आवाज प्रतियों पर।
  • एक ही कॉलम में कई ?और !ऊपर से नीचे तक निष्पादित किए जाते हैं।
  • भाषा विनिर्देश के अनुसार , ?और !संबंधित वर्ण कोड के साथ वर्ण पढ़ें और लिखें। हालांकि, पायथन दुभाषिया के पास स्वयं के बजाय संख्याओं को मुद्रित करने के लिए अपने कोड में एक स्विच भी है। परीक्षण प्रयोजनों के लिए मैं वास्तव में एक संशोधित संस्करण का उपयोग कर रहा हूं जो वर्णों के बजाय संख्याओं को भी पढ़ सकता है । लेकिन यहां चारों ओर आम सहमति यह है कि संख्यात्मक इनपुट / आउटपुट वास्तव में बाइट मान के रूप में दिए जा सकते हैं, इसलिए इन संशोधनों को संख्याओं से निपटने के लिए वैध कार्यक्रम बनाने के लिए आवश्यक नहीं है।
  • मिलान (और )एक ही आवाज पर होने की आवश्यकता नहीं है। स्थिति के लिए उपयोग की जाने वाली आवाज हमेशा वह होती है , जहां (दिखाई देती है। इसलिए, की ऊर्ध्वाधर स्थिति )पूरी तरह से अप्रासंगिक है।
  • प्रील्यूड के एक साथ निष्पादन की प्रकृति के कारण (, लूप शुरू होने से पहले केवल एक ही कॉलम में किसी भी निर्देश को निष्पादित किया जाता है, और चाहे लूप में प्रवेश किया गया हो। इसी तरह, एक ही कॉलम में किसी भी निर्देश )को प्रत्येक पुनरावृत्ति के अंत में निष्पादित किया जाता है, इस बात की परवाह किए बिना कि क्या इस पुनरावृत्ति के बाद लूप बाहर निकल जाएगा।

मैं सबसे पहले आपको बिना किसी टिप्पणी के तीन कार्यक्रम दिखाऊंगा। आप नीचे व्यापक स्पष्टीकरण पा सकते हैं।

कार्यक्रमों

"नमस्ते दुनिया!" प्रकार

9(1-)v98+^++!9v+!  v88++2+!^  ! ^9-3-! v      !    v2-!55+!
8 8+ !     7v+! 1v+!88+^+!^4-!^ v8-^ !!!9v+  !^9+9+!  v5+!
     ^98++4+! ^8-! ^4-   ^ #!^6-!    ^^  #5+! v    ^2-!1+!

यदि आप पायथन दुभाषिया का उपयोग कर रहे हैं, तो सुनिश्चित करें कि NUMERIC_OUTPUT = False

ASCII आर्ट एन

      v2-(1-)v         
9(1-)?1-( v!  (1-55+!      0     (0)#  ))55+!
4-4+                  v^-#
     v!      v! v1-v!(1- ^(#^!0)# v! )v!
6 8+           v#

उपयोग में आसानी के लिए, इस प्रोग्राम को इनपुट के रूप में रीडिंग से लाभ होता है, लेकिन आउटपुट संख्यात्मक नहीं होना चाहिए। इसलिए यदि आप संशोधित पायथन इंटरप्रेटर का उपयोग कर रहे हैं, तो सेट करें

NUMERIC_INPUT = True
NUMERIC_OUTPUT = False

GCD

?(                         v)
? (^-(0 # v   #       ^+0)#^ !
     ^^ (##v^v+)#  0 (0 )   
      1) ^ #  - 1+(#)#

यह सभी संख्यात्मक इनपुट / आउटपुट के साथ सबसे अच्छा उपयोग किया जाता है

NUMERIC_INPUT = True
NUMERIC_OUTPUT = True

स्पष्टीकरण

"नमस्ते दुनिया!" प्रकार

यह काफी सीधा-सीधा है। मैं सभी पात्रों के लिए वर्ण कोड को क्रमिक रूप से उत्पन्न करने के लिए 3 आवाज़ों का उपयोग कर रहा हूं Prelude was made in 2005!। मैं कंप्यूटिंग से शुरू करता हूं 8 + 9*8 = 80, जो Pनिम्न का वर्ण कोड है :

 9(1-)
 8 8+

उसके बाद मैं ज्यादातर पिछले चरित्र कोड को कॉपी करता हूं और अगले एक में अंतर जोड़ता या घटाता हूं। यहां कोड दिया गया है, लेकिन प्रत्येक के !साथ उस चरित्र को प्रतिस्थापित किया जाता है जिसे मुद्रित किया जा रहा है (और _रिक्त स्थान के %लिए और अंकों के लिए):

9(1-)v98+^++r9v+u  v88++2+w^  _ ^9-3-a v      _    v2-%55+!
8 8+ P     7v+l 1v+e88+^+_^4-s^ v8-^ de_9v+  n^9+9+%  v5+%
     ^98++4+e ^8-d ^4-   ^ #a^6-m    ^^  #5+i v    ^2-%1+!

अंतिम 55+!एक अनुगामी न्यूलाइन प्रिंट करता है, सिर्फ इसलिए कि यह अच्छा है।

एक साइड नोट के रूप में, इस कार्य के लिए आवाज़ों की संख्या बहुत ही मनमानी है, लेकिन 3 काफी सुविधाजनक है क्योंकि यह सबसे बड़ी संख्या है जिसमें हर आवाज़ सीधे एक दूसरे की आवाज़ तक पहुँच सकती है।

ASCII आर्ट एन

      v2-(1-)v         
9(1-)?1-( v!  (1-55+!      0     (0)#  ))55+!
4-4+                  v^-#
     v!      v! v1-v!(1- ^(#^!0)# v! )v!
6 8+           v#

5 आवाजों के साथ, यह निश्चित रूप से मेरे द्वारा लिखे गए सबसे जटिल कार्यक्रमों में से एक है। आवाज़ों के मोटे तौर पर निम्नलिखित उद्देश्य होते हैं:

  1. केवल एक सहायक आवाज जो N-1आंतरिक लूप में उपयोग के लिए संग्रहीत करता है।
  2. यह "मुख्य" आवाज की तरह है, जो इनपुट पढ़ता है, इसमें एक महत्वपूर्ण स्विच होता है और इसमें बाहरी लूप (यानी पंक्तियों पर एक) भी होता है।
  3. यह 32आसानी से प्रिंट स्थान के लिए स्टोर करता है।
  4. इसमें आंतरिक लूप (कॉलम के ऊपर एक) शामिल है।
  5. यह 78आसानी से प्रिंट करने के लिए स्टोर करता है N

कोड भाग के माध्यम से चलते हैं। सबसे पहले, मैं बना रहा हूं 32रूप में -4 + 9*4और 78के रूप में 6 + 9*8:

9(1-)
4-4+

6 8+

अब मैं Nइनपुट Nऔर स्टोरिंग पढ़ रहा हूं N-1और N-2पहले दो स्वरों में एकल (क्योंकि हमें हमेशा एक की आवश्यकता है) प्रिंट कर रहा हूं :

      v2-
     ?1-

     v!

अगला, एक "लूप" है जिस पर वातानुकूलित है N-1। लूप के अंत में, दूसरी आवाज़ हमेशा कम हो जाती है 0, और लूप पहले पुनरावृत्ति के बाद बाहर निकल जाता है। तो अनिवार्य रूप से, यह केवल if(N > 1){...}। लूप के बाद हम एक एकल अनुगामी न्यूलाइन प्रिंट करते हैं। पुनरावृत्ति करने के लिए, हमें अब निम्नलिखित रूपरेखा मिल गई है:

      v2-
9(1-)?1-(                               )55+!
4-4+
     v!
6 8+

इस सशर्त के अंदर, हम पहली पंक्ति को पूरा करने के लिए पहले N-2स्थान और एक एकल हैं N, और हम N-1भविष्य के उपयोग के लिए पहली आवाज पर भी स्टोर करते हैं:

         (1-)v         
          v!  

             v!

अब कोड का असली मांस। सबसे पहले, एक बाहरी लूप है, जो N-1पंक्तियों को प्रिंट करता है । प्रत्येक पंक्ति के लिए, हम पहली बार एक नई पंक्ति और एक प्रिंट करते हैं N। फिर हम लूप N-2समय, या तो रिक्त स्थान या Nएस (उस पर बाद में) को मुद्रित करते हैं । और अंत में हम एक और प्रिंट करते हैं N:

               1-55+!  

                v1-v!(               )v!
               v#

अंत में, मज़ेदार हिस्सा: प्रत्येक पंक्ति को प्रिंट करना (और Nदाईं ओर स्थिति प्राप्त करना )। वास्तव में Prelude में if / if नहीं है, इसलिए मुझे विभिन्न स्वरों पर दो लूप का उपयोग करके इसे स्वयं बनाना होगा। आंतरिक और बाहरी लूप चर को घटाकर आसानी से स्थिति प्राप्त की जा सकती है - 0यदि हम प्रिंट करना चाहते हैं Nऔर अगर हम किसी स्थान को प्रिंट करना चाहते हैं तो कुछ गैर-शून्य है।

Prelude में if / else का मूल विचार प्रासंगिक मान के बाद लूप लगाना है - "if" (या गैर-शून्य) कोड, और इसे धक्का देकर तुरंत बाहर निकलें 0। एक और आवाज पर, आप एक गैर-शून्य मान रखते हैं, और "अगर" लूप के बाद एक और लूप। "अगर" लूप के दौरान आप उस दूसरी आवाज़ के ऊपर एक शून्य लगाते हैं, ताकि "और" को निष्पादित होने से रोका जा सके। इसमें कुछ लचीलापन है कि क्या आप शून्य मान को गैर-शून्य मान के शीर्ष पर धकेलते हैं या शून्य-शून्य मान को त्याग देते हैं यदि कोई शून्य से नीचे है, लेकिन यह सामान्य विचार है। यदि आप प्रासंगिक आवाज़ का उपयोग करते रहना चाहते हैं, तो आपको बाद में कुछ सफाई भी करनी पड़ सकती है। यह कोड जैसा दिखता है:

                           0     (0)#
                      v^-#
                      1- ^(#^!0)# v! 

और बस!

GCD

यह यूक्लिडियन एल्गोरिथ्म का "सिर्फ" एक पुनरावृत्ति कार्यान्वयन है। लेकिन प्रस्तावना में मोडुलो थोड़ा परेशान करने वाला है, ज्यादातर क्योंकि आप आसानी से जांच नहीं कर सकते कि कोई संख्या सकारात्मक है या नकारात्मक। यह कोड एक सांकेतिक कार्यान्वयन का उपयोग करता है जिसे मैंने कुछ समय पहले लिखा था । यानी कोड का एक बड़ा हिस्सा सिर्फ एक संख्या को बदल देता है -1, 0या 1। फिर इसे आसानी से जोड़कर या घटाकर सकारात्मक या नकारात्मक संख्याओं के लिए एक स्थिति में बदल दिया जा सकता है 1

?(                         v)
? (^-(0 # v   #       ^+0)#^ !
     ^^ (##v^v+)#  0 (0 )   
      1) ^ #  - 1+(#)#

इसलिए हमें इस बार चार आवाजें मिली हैं। पहली आवाज़ में आसानी से नज़र रखी जाती है bऔर इसमें मुख्य समाप्ति की स्थिति होती है (यानी जब लूप बाहर निकलता bहै 0)। दूसरी आवाज़ में आवाज़ होती है aऔर a % bपिछली आवाज़ के परिणाम को स्वैप करने से पहले, तीन और चार गणनाओं की मदद से b। अंत में, जब !प्रिंट ।ab == 0

आइए पहले साइनम भाग को देखें:

     (0 # v   #
     ^^ (##v^v+)#
      1) ^ #  -

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

यदि nगैर-शून्य है, तो पहला छोटा लूप दर्ज किया जाता है। हम एक शून्य को तुरंत बाहर निकलने के लिए धक्का देते हैं, nमध्य की आवाज़ और 1नीचे की आवाज़ पर दो प्रतियाँ डालते हैं । अब मूल विचार यह है nकि nजब तक उनमें से कोई एक शून्य से हिट न हो जाए , तब तक दूसरी प्रति को घटाते हुए उसकी एक प्रति बढ़ाई जाए। ऐसा करते समय, 1नीचे की आवाज़ हर समय अपने संकेत को फ़्लिप करती है (जो 0स्टैक पर नीचे से इसे घटाकर आसानी से किया जाता है )। इसे ऐसे सेट किया जाता है कि जब कोई संख्या शून्य से टकराती है, तो नीचे की आवाज़ में सही चिह्न होगा।

अब मॉडुलो को घटाकर तब तक लागू किया जाता bहै aजब तक कि परिणाम नकारात्मक न हो जाए। जब ऐसा होता है, हम bफिर से एक जोड़ते हैं । यह बिट है:

  (^-  signum         ^+0)#
       signum      0 (0 )   
       signum   1+(#)#

नीचे दिए गए / यदि अन्य निर्माण पर ध्यान दें, जो कि मैंने टास्क 2 के लिए उपयोग किए गए के समान है।


2
यह वास्तव में एक प्रस्तावना ट्यूटोरियल का हिस्सा होना चाहिए।
एलेक्स ए

21

2007 - स्क्रैच

स्क्रैच MIT द्वारा शैक्षिक उद्देश्यों के लिए बनाई गई भाषा है। मैं इसके साथ 5 वर्षों से जुड़ा हुआ हूं; उस पर बाद में।

इन सभी को यहाँ देखा जा सकता है

मैं अभी बहुत जल्दी पहुँच गया हूँ और बाद में स्निपेट समझाऊँगा। उम्मीद है कि वे हालांकि स्वयं व्याख्यात्मक हैं।

कार्य 1

यहां छवि विवरण दर्ज करें

टास्क २

यहां छवि विवरण दर्ज करें

टास्क 3

यहां छवि विवरण दर्ज करें


क्या यह बाद में है?
फ़ौज

21

1972 - सी

हम सभी C के बारे में जानते हैं, क्या हम नहीं? C को यूनिक्स के साथ ही बेल लैब्स में बनाया गया था। यूनिक्स काफी हद तक सी में लिखा गया था। सभी आधुनिक यूनिक्स डेरिवेटिव्स अभी भी सी में लिखे गए हैं। सी। के वाक्य विन्यास ने कई, कई प्रोग्रामिंग भाषाओं को प्रभावित किया है। यह शायद सबसे पुरानी प्रोग्रामिंग भाषा है जो नए विकास के लिए अभी भी व्यापक उपयोग में है।

C स्वयं B का वंशज है, जो मुझे आशा है कि इस सूची में भी समाप्त होगा। कोई 'ए' प्रोग्रामिंग भाषा नहीं थी: बी बीसीपीएल का एक प्रकार है, जो बदले में सीपीएल से नीचे छीन लिया गया है। इनमें से कोई भी भाषा कभी बहुत लोकप्रिय नहीं थी। हालाँकि, BCPL वह भाषा थी जिसमें पहला "हैलो वर्ल्ड" प्रोग्राम लिखा गया था। एक और दिलचस्प तथ्य यह है कि बी में दोनों /* */और //टिप्पणियां थीं , लेकिन सी ने //टिप्पणियों को छोड़ दिया । बाद में उन्हें C99 मानक के साथ C में फिर से शामिल किया गया।

1974 के यूनिक्स V5 C संकलक के साथ यहाँ C कार्यक्रमों का परीक्षण किया गया था। यह सबसे पुराना C संकलक था जिसे मैं काम कर सकता था और प्राप्त कर सकता था, और ये कार्यक्रम एक आधुनिक C संकलक पर संकलित नहीं होंगे। (किए गए परिवर्तनों में से एक यह है कि म्यूटेशन ऑपरेटरों +=को लिखा जाता था =+।)

#include <... >अभी तक अस्तित्व में नहीं था। न ही मानक पुस्तकालय का बहुत कुछ किया। मुझे अपना लिखना था atoi। मैं वी 5 स्रोत कोड के माध्यम से कुछ जानने के लिए गया कि किन चीजों की अनुमति थी और जो नहीं थे। मैंने जिस संस्करण का उपयोग किया था struct, उसमें s शामिल करना सबसे पहले था , लेकिन जब से मैंने उन का उपयोग नहीं किया, और वाक्यविन्यास में V7 (K & R C) तक बहुत बदलाव नहीं हुआ है, यह पहले के संस्करणों के साथ भी काम कर सकता है।

मैंने अपने कोड को उसी शैली में लिखने की पूरी कोशिश की है जैसे वी 5 स्रोत कोड का उपयोग करता है। (ऐसा नहीं है कि यह बहुत सुसंगत है, हालांकि)

यूनिक्स वी 5 के लिंक के लिए यहां देखें , एक एमुलेटर, और इसे एक आधुनिक कंप्यूटर पर चलाने के निर्देश हैं।

कार्य 1

main()
{
   write(1, "C was made in 1972!\n", 20);
}

टास्क २

atoi(str)
char *str;
{
    register num, digit;
    while (digit = *str++) {
        num =* 10;
        num =+ digit - '0';

    }
    return num;
}

N(n)
{
    register x, y;
    for (y=1; y<=n; y++) {
        for (x=1; x<=n; x++) {
            write(1, " N"+(x==1||x==y||x==n), 1);
        }
        write(1, "\n", 1);
    }
}

main(argc, argv)
char *argv[];
{
    N(atoi(argv[1]));
}

टास्क 3

atoi(str)
char *str;
{
    register num, digit;
    while (digit = *str++) {
        num =* 10;
        num =+ digit - '0';
    }
    return num;
}

gcd(a, b)
{
    return b ? gcd(b, a%b) : a;
}

main(argc, argv)
char *argv[];
{
    printf("%d\n", gcd(atoi(argv[1]), atoi(argv[2])));
}

वाह, मुझे कभी एहसास नहीं हुआ कि सी कितना बदल गया है ... आपको वह कंपाइलर कहां से मिला?
kirbyfan64sos

1
संकलक वह है जो यूनिक्स वी 5 के साथ शामिल है। एक ब्लॉग पोस्ट के विवरण में एक लिंक है जो आपको दिखाता है कि फ़ाइलों को कहाँ प्राप्त करना है और इसे आधुनिक कंप्यूटर पर कैसे चलाना है। (यह यहाँ है )। एक बार आपके पास यह चल रहा है, तो आप इसका उपयोग करके कोड प्राप्त कर सकते हैं cat > file.c। (हमेशा की तरह, Ctrl-D के साथ समाप्त करें)। इसके अलावा, सी कम से कम आप सोच सकते हैं बदल गया है: अगर आप स्वैप =*और =+में atoiआधुनिक समकक्षों के लिए काम करता है *=और +=एक आधुनिक जीसीसी उन्हें ठीक संकलन होगा और वे चलाते हैं, तो भी। शायद ही कोई चेतावनी, यहां तक ​​कि।
मैरिनस

1
minnie.tuhs.org/cgi-bin/utree.pl?file=V2/c सबसे शुरुआती सी कंपाइलर है जो मुझे मिल सकता है (V2, दिनांक '72 से)।
ओबेरॉन

20

2009 - इदरीस

इदरीस एक भरोसेमंद रूप से टाइप की हुई, शुद्ध कार्यात्मक भाषा है जो वास्तव में वास्तविक अनुप्रयोगों के लिए व्यावहारिक रूप से प्रयोग करने पर जोर देती है, इसके अलावा अत्यंत कठोर प्रमाण संभावनाओं की पेशकश करने के अलावा जो निर्भर प्रकारों के साथ प्राप्त होती हैं।

कार्य 1

module Main

main : IO ()
main = putStrLn "Idris was made in 2009!"

टास्क २

module InN

import Data.Fin
import Data.Vect

genN : Vect n (Vect n Char)
genN = [[ if inN x y then 'N' else ' ' | x<-range ]| y<-range ]

||| Helper function, determines whether the char at coordinate (x,y)
||| is part of the letter:
inN : Fin n -> Fin n -> Bool
inN {n=S _} x y = x==0 || x==y || x==last

यह एक कार्यक्रम नहीं है, लेकिन केवल एक फ़ंक्शन (अधिक सटीक, निर्भर मूल्य ) है, वांछित पत्र एन को दो-आयामी सरणी के रूप में निर्मित करता है।

$ idris ascii-n.idr 
     ____    __     _                                          
    /  _/___/ /____(_)____                                     
    / // __  / ___/ / ___/     Version 0.9.17.1-
  _/ // /_/ / /  / (__  )      http://www.idris-lang.org/      
 /___/\__,_/_/  /_/____/       Type :? for help               

Idris is free software with ABSOLUTELY NO WARRANTY.            
For details type :warranty.
Type checking ./ascii-n.idr
*ascii-n> genN {n=4}
[['N', ' ', ' ', 'N'],
 ['N', 'N', ' ', 'N'],
 ['N', ' ', 'N', 'N'],
 ['N', ' ', ' ', 'N']] : Vect 4 (Vect 4 Char)

टास्क 3

module gcd

gcd' : Nat -> Nat -> Nat
gcd' a Z = a
gcd' a b = gcd' b $ a`mod`b

ध्यान दें कि मुझे नाम चुनना था gcd'क्योंकि चूंकि gcdयह पहले से ही इदरीस प्रस्तावना में परिभाषित है।

Type checking ./gcd.idr
*gcd> gcd' 8 12
4 : Nat
*gcd> gcd' 12 8
4 : Nat
*gcd> gcd' 234 876
6 : Nat

यही कारण है कि लगता है कि वे हास्केल ले लिया, बदली :और ::, और बदल _करने के लिए Z
21

@Chargin Zवास्तव में का निर्माता है 0 : Nat। अंडरस्कोर का उपयोग इदरिस में उसी तरह किया जाता है जैसे हास्केल में होता है।
counterclockwis चालू करने के लिए रह गए हैं

ओह, ठीक है, तुम वहाँ जाओ! :)
wchargin

19

2014 - पायथ

चूँकि हमारे पास CJam है, इसलिए हम पूर्णता के लिए भी Pyth कर सकते हैं :)

Pyth द्वारा एक गोल्फ भाषा है @isaacg जो अजगर करने के लिए नीचे संकलित करता है। यह प्रक्रियात्मक होने के लिए और उपसर्ग संकेतन का उपयोग करने के लिए उल्लेखनीय है। पायथ पहली बार जून 2014 के आसपास दिखाई दिया ।

"नमस्ते दुनिया!" प्रकार

"Pyth was made in 2014!

एक समापन उद्धरण की कमी पर ध्यान दें, जो वैकल्पिक है यदि एक स्ट्रिंग में एक पायथ कार्यक्रम समाप्त होता है।

ASCII आर्ट एन

VQ+\Nt+P++*Nd\N*t-QNd\N

इसे ऑनलाइन आज़माएं । बराबर पायथन है:

Q = eval(input())
for N in range(Q):
    print("N"+((" "*N+"N"+(Q-N-1)*" ")[:-1]+"N")[1:])

या विस्तारित (पहली और तीसरी लाइनें निहित हैं):

Q = eval(input())                                        # 
for N in range(Q):                                       #   VQ
    print(                                          )    # 
          "N"+                                           #     +\N
              (                                )[1:]     #        t
                                           +"N"          #         +              \N
               (                     )[:-1]              #          P
                         +(Q-N-1)*" "                    #           +      *t-QNd
                     +"N"                                #            +   \N
                " "*N                                    #             *Nd

GCD

=GvwWQAGQ,Q%GQ)G

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

Q = eval(input())     #
G = eval(input())     #    =Gvw
while Q != 0:         #        WQ
  G, Q = Q, G % Q     #          AGQ,Q%GQ)
print(G)              #                   G

i.uQअगर हम GCD के लिए बिलिन का उपयोग करते हैं तो और भी कम है। यह समतुल्य है print(gcd(*eval(input())))(इनपुट के रूप में दो अल्पविराम से अलग किए गए नंबर)


Drat - मैं Pyth xP
theonlygusti

@ आईआईएसएसीजी मैं मदद नहीं कर सकता, लेकिन आश्चर्य कर सकता हूं, और साथ ही यहां यह भी पूछ सकता हूं: किसी भी तरह, आकार या रूप में pyg से प्रेरित pyth था?
atı

@ YıGuʎs मैंने पायथ बनाने से पहले PYG देखा था, और यह 1 चरित्र - 1 अवधारणा दृष्टिकोण को प्रभावित कर सकता था। हालांकि, अगर कुछ भी पाइथ से प्रेरित था, तो यह शायद गोल्फस्क्रिप्ट था।
इसहाक

17

1964 - डार्टमाउथ बेसिक

BASIC सामान्य-प्रयोजन, उच्च-स्तरीय प्रोग्रामिंग भाषाओं का एक परिवार है, जिसका डिज़ाइन दर्शन उपयोग में आसानी पर जोर देता है। 1964 में, जॉन जी। कोमेनी और थॉमस ई। कर्ट्ज़ ने न्यू हैम्पशायर के डार्टमाउथ कॉलेज में मूल बुनियादी भाषा को डिज़ाइन किया। वे कंप्यूटर का उपयोग करने के लिए विज्ञान और गणित के अलावा अन्य क्षेत्रों में छात्रों को सक्षम करना चाहते थे।

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

कार्य 1

10 PRINT "BASIC WAS MADE IN 1964"
20 END

टास्क २

10 READ N
15 FOR Y = 1 TO N STEP 1
20 FOR X = 1 TO N STEP 1
25 IF X = 1 THEN 50
30 IF X = N THEN 50
35 IF X = Y THEN 50
40 PRINT " ",
45 GO TO 55
50 PRINT "N",
55 NEXT X
60 PRINT
65 NEXT Y
70 DATA 5
75 END

आउटपुट कुछ इस तरह है:

N                       N
N     N                 N
N           N           N
N                 N     N
N                       N

ध्यान दें कि प्रोग्राम के भाग के रूप में इनपुट कैसे टाइप किया जाता है ( 70 DATA 5); READशीर्ष पर अनुदेश तरह से वहाँ से डेटा को हासिल करेगा। कोई स्ट्रिंग संघनन नहीं है, लेकिन मैनुअल के अनुभाग 3.1 में वर्णन किया PRINTगया है कि आउटपुट पर "ज़ोन" को सारणीबद्ध कैसे किया जाता है।

टास्क 3

यूक्लिड के एल्गोरिथ्म का धीमा संस्करण:

10 READ A, B
20 IF A = B THEN 80
30 IF A < B THEN 60
40 LET A = A - B
50 GO TO 20
60 LET B = B - A
70 GO TO 20
80 PRINT A
85 DATA 144, 250
90 END

outputting:

2

अंत में, किसी ने BASIC किया।
मारिनस

16

2010 - WTFZOMFG

WTFZOMFG ब्रेनफक पर आधारित एक गूढ़ भाषा है। इसे 2010 में Jay Songdahl ने बनाया था। "WTFZOMFG", "व्हाट्सएप दैट फीनिक्स! ज़ेन ऑप्टिमाइज़्ड मैलीफिश फाइल गोफ़र्स" के लिए संक्षिप्त है। ।

यहाँ * निक्स सिस्टम के लिए एक कंपाइलर है

कार्य 1

'WTFZOMFG was made in 2010!\n"

टास्क २

/&(-.N%3 >&>s-{-(-. ).N}>{-(-. ).N}_0 '\n")

स्पष्टीकरण:

माफ़ करना। मैं स्पष्टीकरण लिखने में अच्छा नहीं हूँ।

/                                           # read the number and store it in cell 0
 &                                          # copy it to cell 1
  (                                         # loop while cell 0 isn't 0
   -                                        # decrease the value of cell 0
    .N                                      # print "N"
      %3                                    # copy cell 0 to cell 3
                                            # a space must be added after the number. I don't know if it's a bug of the compiler or a feature.
         >                                  # move to cell 1
          &                                 # copy cell 1 to cell 2
           >                                # move cell 2
            s                               # let cell 2 = cell 2 - cell 3
             -                              # decrease the value of cell 2
              {                             # if cell 2 isn't 0
               -                            # decrease the value of cell 2
                (-. )                       # while cell 2 isn't 0, decrease it and print " "
                     .N                     # print "N"
                       }                    # end if
                        >                   # move cell 3
                         {                  # if cell 3 isn't 0
                          -                 # decrease the value of cell 3
                           (-. )            # while cell 3 isn't 0, decrease it and print " "
                                .N          # print "N"
                                  }         # end if
                                   _0       # move to cell 0
                                      '\n"  # print a newline
                                          ) # 

टास्क 3

/>>/(<<&>dm<s&>>%0 <&>)<<\

यूक्लिडियन एल्गोरिथ्म। WTFZOMFG में मॉड के लिए कमांड नहीं है, इसलिए मुझे d(डिवाइड), m(गुणा) और s(घटाना) का उपयोग करना होगा।


16

2009 - जाओ

गो, Google द्वारा विकसित प्रोग्रामिंग भाषा है। विकास 2007 में शुरू हुआ था, लेकिन गो की घोषणा नवंबर 2009 में की गई थी।

गो, सी से प्रभावित एक वैचारिक रूप से टाइप की जाने वाली भाषा है जो संक्षिप्तता, सरलता और सुरक्षा पर जोर देती है।

कार्य 1:

package main
import "fmt"

func main(){
    fmt.Println("Go was made in 2009!")
}

पहली पंक्ति कोड के पैकेज की घोषणा करती है। यहां तक ​​कि एक लाइन को प्रिंट करने के लिए एक सरल उदाहरण एक पैकेज का हिस्सा होना चाहिए। और निष्पादन योग्य हमेशा कहा जाता है main

कार्य 2:

package main

import (
        "fmt"
        "strings"
)

func main(){
    var n int
    fmt.Scan(&n)

    for i := 0; i < n; i++ {
        a := make([]string, n, n)
        for j := 0; j < n; j++ { a[j] = " " }

        a[0] = "N"
        a[i] = "N"
        a[n-1] = "N"

        s := strings.Join(a, "")
        fmt.Println(s)
    }
}

गो के पास काफी संक्षिप्त चर घोषणा है ( i := 0जैसा है var i int = 0), और संकलक प्रकार निर्धारित करता है। यह आमतौर पर गतिशील भाषाओं में अधिक आम है। इस छोटी संकेतन का उपयोग करना भी चर ( f := func(x int) int {/* Code */}) और क्लोजर बनाने के लिए कार्यों को असाइन करना बहुत आसान है ।

कार्य 3:

package main

import "fmt"

func gcd(a, b int) int {
    for b != 0 {
        a, b = b, a%b
    }
    return a
}

func main(){
    var a, b int
    fmt.Scan(&a)
    fmt.Scan(&b)

    fmt.Println(gcd(a, b))
}

यहां आप a, b = b, a%bसिंटैक्स देख सकते हैं , जो वास्तव में अच्छा है। मैं सटीक नाम नहीं जानता, लेकिन पायथन में इसे टपल अनपैकिंग कहा जाता है। उसी तरह से आप एक फ़ंक्शन ( func f() (int, string) { return 42, "Hallo"}) से कई मान वापस कर सकते हैं ।

इस कोड में एक और बात लूप है। लूप के लिए गो में एकमात्र लूप है। जबकि-लूप या डू-ए-लूप मौजूद नहीं हैं। लेकिन आप आसानी से लूप for condition {}या अनंत लूप के लिए एक समान बना सकते हैं for {}


16

1991 - पायथन

भाषा का इतिहास

1980 के दशक के अंत में, गुइडो वैन रोसुम ने पायथन को एक शौक के रूप में तैयार करना शुरू किया। इसका नाम मोंटी पायथन के फ्लाइंग सर्कस से आया है, जो एक ब्रिटिश टेलीविजन शो है, जिसमें रोसुम एक प्रशंसक है। पहला पायथन कार्यान्वयन 1989 में शुरू हुआ था और 1991 में जारी किया गया था। यह वर्षों में लोकप्रियता में वृद्धि हुई है, कई परिचयात्मक कंप्यूटर विज्ञान पाठ्यक्रमों के लिए पसंद की भाषा बन गई है।

"नमस्ते दुनिया!" प्रकार

print("Python was made in 1991!")

कोष्ठक के चारों ओर इनपुट पर ध्यान दें print। हालाँकि यह वाक्यविन्यास पायथन 2 में काम करता है, आमतौर पर पायथन 2 में आप इन कोष्ठकों को छोड़ देंगे। हालाँकि, वे Python में आवश्यक हैं। 3. Zach Gates द्वारा सुझाए गए, कोष्ठक का उपयोग यह सुनिश्चित करने के लिए किया जाता है कि यहाँ प्रस्तुत कोड संस्करणों में काम करेगा।

ASCII आर्ट एन

def asciin(n):
    if n == 1:
        print("N")
    else:
        print("N" + " "*(n-2) + "N")

        for i in range(2, n):
            print("N" + " "*(i-2) + "N" + " "*(n-i-1) + "N")

        print("N" + " "*(n-2) + "N")

कार्यों का उपयोग करके परिभाषित किया गया है def। स्ट्रिंग संघनन का उपयोग +और स्ट्रिंग पुनरावृत्ति के साथ किया जाता है *

GCD

def gcd(a, b):
    if b == 0:
        return(a)
    else:
        return(gcd(b, a % b))

ध्यान दें कि अजगर को संरचित व्हाट्सएप की आवश्यकता होती है।


16

1968 - अल्गोल 68

Algol 68 को IFIP वर्किंग ग्रुप 2.1 द्वारा अल्गोल 60 के उत्तराधिकारी के रूप में परिभाषित किया गया था।

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

सभी नियंत्रण संरचनाओं में संक्षिप्त रूप के साथ-साथ भावों का उपयोग करने वाला एक लंबा रूप है। यह ऑपरेटरों की परिभाषा भी अनुमति देता है।

भाषा के लक्ष्यों का हवाला दिया जाता है:

ALGOL 68 के डिजाइन के मुख्य उद्देश्य और सिद्धांत:

  • वर्णन की पूर्णता और स्पष्टता
  • रूढ़िवादी डिजाइन,
  • सुरक्षा,
  • दक्षता
  • स्टेटिक मोड की जाँच
  • मोड-स्वतंत्र पार्सिंग
  • स्वतंत्र संकलन
  • लूप ऑप्टिमाइज़ेशन
  • प्रतिनिधित्व - न्यूनतम और बड़े वर्ण सेट में

इन कार्यक्रमों को अल्गोल 68 जिनी दुभाषिया के साथ परीक्षण किया गया है , जो भाषा का पूर्ण कार्यान्वयन है।

कुछ विशेषताएं जो आधुनिक प्रोग्रामर को अलग लग सकती हैं, वह यह है कि खाली स्टेटमेंट की अनुमति नहीं है। आप ;हर जगह नहीं जोड़ सकते । SKIPयदि आपको स्पष्ट रूप से कुछ नहीं करना है तो आपको कथन का उपयोग करना होगा। इसने समवर्ती कार्यक्रमों की कोडिंग को भी आसानी से अनुमति दी। अल्गोल 68 भी, विशेष रूप से, बैकवर्ड कीवर्ड्स को टर्मिनेटर के रूप में उपयोग करते हैं, जैसे कि एसैक , ओड , फाई आदि।

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

अगर मैं < 0 तो फाई छोड़ें

इसे प्राइम स्ट्रीपिंग मोड में एक कंपाइलर के लिए तैयार किया जा सकता है :

'IF' I 'LT' 0 'THEN' 'SKIP' 'FI'

में डॉट stropping मोड इस होगा:

.IF I .LT 0 .THEN .SKIP .FI

में मामला stropping मोड इस होगा:

IF i < 0 THEN SKIP FI

मुझे इस भाषा के लिए बहुत शौक है क्योंकि मैंने कंपाइलर कार्यान्वयन में से एक पर काम किया था, साथ ही साथ कई वर्षों तक इसमें विशेष रूप से प्रोग्रामिंग की गई थी।

कार्य 1

प्रिंट ("1968 में अल्गोल 68 बनाया गया था!", newline ))

यहां ध्यान देने वाली बात डबल कोष्ठक है। ऐसा इसलिए है क्योंकि प्रिंट एक फ़ंक्शन है जो एकल तर्क लेता है जो सभी प्रकार के संघ की एक चर लंबाई की सरणी है। आंतरिक कोष्ठक सरणी निर्माता हैं। इस तरह से इस जोरदार टाइप की भाषा में बहुरूपता को संभाला जाता है।

मामले में स्ट्रिपिंग मोड:

print (("Algol 68 was made in 1968!", newline))


C:\>a68g HelloWorld.a68
Algol 68 was made in 1968!

टास्क २

     इंट एन ;
     read ( n );
     के लिए मैं से 1 करने के लिए n करना
          के लिए जे से 1 करने के लिए n कर
               ¢ यहाँ हम एक संक्षिप्त का उपयोग करते हैं खंड ¢
               प्रिंट ((( j = 1 या j = मैं या j = n |
                    "एन"
               |
                    ""
               )))
          आयुध डिपो ;
     प्रिंट (( न्यू लाइन))
     आयुध डिपो

मामले में स्ट्रिपिंग मोड:

 INT n;
 read ((n));
 FOR i FROM 1 TO n DO
        FOR j FROM 1 TO n DO
            CO here we use an abbreviated IF clause CO
            print (( ( j = 1 OR j = i OR j = n |
                 "N"
            |
                 " "
            ) ))
        OD ;
        print ((newline))
    OD

C:\>a68g ASCIIart.a68
8
N      N
NN     N
N N    N
N  N   N
N   N  N
N    N N
N     NN
N      N

टास्क 3

     ¢ हम अल्गोल में 68 हमारे अपने ऑपरेटरों को परिभाषित कर सकते ¢
     सेशन % = ( int एक , ) int :
          (( = 0 |
               एक
          |
               % ( एक आधुनिक )
          ));
     int i , j ;
     read (( i , j ));
     प्रिंट (( i % j , newline ))

मामले में स्ट्रिपिंग मोड:

COMMENT we can define our own operators in Algol 68 COMMENT
OP % = ( INT a, b) INT:
    ((b = 0 |
        a
    |
       b % (a MOD b)
    ));
INT i,j;
read((i,j));
print(( i % j , newline))


C:\>a68g GCD.a68
4 12
         +4

7
ये संभवतः पहले अल्गोल 68 कार्यक्रम थे जो मैंने 30 वर्षों में लिखे और निष्पादित किए हैं। मैंने इसे इतना आगे बढ़ पाया, कि यह वास्तव में मुझे आँसू में ले आया। मुझे कभी भी "हैलो वर्ल्ड" का एहसास नहीं हुआ! कार्यक्रम इतना भावुक हो सकता है!
ब्रायन टॉम्पसेट -

1
मैं 60 के दशक की भाषाओं के लिए बहुत उत्सुक था और BCPL, Simula, CORAL66, Fortran 66, PL / 1, SNOBOL4, POP-1 और एक पूरी बेड़ा के साथ तैयार था, केवल यह जानने के लिए कि मेरे पास जो नियम हैं 5 साल की भाषाओं का इंतजार करने के लिए ... कम से कम किसी और के लिए हल चलाने के लिए एक अमीर है।
ब्रायन टॉम्पसेट - Tom Tom

यह वास्तव में Fortran66 (पंचकार्ड हिंसा की पूरी गड़बड़ी), APL (महाशक्ति-प्रतीकों का अजीब अव्यवस्था), और Algol68, जो वास्तव में बहुत सुंदर है, के बीच के अंतर को देखने के लिए अच्छा है। आज, आपको विभिन्न प्रकार के विभिन्न तरीकों को खोजने के लिए गूढ़ भाषाओं में देखने की आवश्यकता होगी ... फिर वापस, यह बल्कि मुख्यधारा थी, है न?
चालू करना बंद कर दिया

बेशक, संशोधित रिपोर्ट एह, 1976 तक प्रकाशित नहीं हुई थी? कम से कम वह कॉपीराइट वर्ष है जो स्प्रिंगर देता है। और स्कैन में मुझे 1978 का उल्लेख मिला।
Rhialto

[१] ए। वैन विंजयार्डन (एड।), ब्ल मैयूलक्स, १.ईएल पेक, सीबीए कोस्टर, एल्गोरिथम भाषा ALGOL ६,, न्यूमेर पर रिपोर्ट। गणित। 14 (1969) 79-218; किबिनिटिका 6 (1969) और 7 (1970) में भी। [२] ए। वैन विजेंगार्डन, ब्ल मैलोक्स, १.ईएल पेक, सीबीए कोस्टर, एम: सिंटजॉफ, सीबीएलंडसे, एलजीएलटी मेर्टेंस और आरजी फिस्कर, एल्गोरिथम भाषा ALGOL ६ 68, एक्टा इनफॉर्मेट पर संशोधित रिपोर्ट। 5 (1975) भागों 1-3 (स्प्रिंगर, बर्लिन, और गणितीय केंद्र ट्रैक्ट 50 के रूप में मैथमेटिश सेंट्रम, एम्स्टर्डम द्वारा प्रकाशित पुनर्मुद्रण); SIGPLAN नोटिस 12 (5) (1977) में
ब्रायन टॉम्प्सेट - 莱恩

16

1962 - SNOBOL

"स्ट्राइन्ग ओरिएंटेड एंड सिम्बोलिक लैंग्वेज"। पहले स्पष्ट रूप से सिंबोलिक एक्सप्रेशन इंटरप्रेटर, 'SEXI' कहा जाता था, जिसे तब बदल दिया गया था जब 1960 के दशक के नर्ड्स को अपनी नौकरी सौंपते समय ब्लश करने से रोका जा सके। सच्ची कहानी।

यह पहली भाषाओं में से एक थी जो मूल रूप से तार और पैटर्न से निपट सकती थी। दरअसल, SNOBOL के पहले संस्करण में इसके एकमात्र डेटाटाइप के रूप में स्ट्रिंग था । मठ तब पार्सिंग द्वारा किया गया था। प्रारंभिक कार्यान्वयन आईबीएम 7090 पर किया गया था। यह लंबे समय से चला गया लगता है, कम से कम, मुझे यह नहीं मिला। मुझे जो मिला वह मूल पेपर था और साथ ही जावा में एक SNOBOL3 दुभाषिया का वर्णन करता था , जो एक आधुनिक कंप्यूटर पर चल सकता है

पहले SNOBOL बहुत अधिक केवल था पैटर्न मिलान और बुनियादी अंकगणित था। SNOBOL 3 ने फ़ंक्शंस जोड़े और I / O को बदल दिया, लेकिन लगता है कि पीछे संगत बना हुआ है। SNOBOL 4 ने सिंटैक्स को बदल दिया, और वहां से यह Icon में विकसित हुआ , जो पैटर्न से मेल खाता रहता है, लेकिन लगभग "सामान्य" प्रोग्रामिंग की तरह दिखता है।

जिन कार्यक्रमों में मैंने लिखा है, केवल मूल पेपर में वर्णित कार्यक्षमता का उपयोग किया है, इसलिए I / O के अपवाद के साथ मूल SNOBOL के साथ काम करना चाहिए, जो मैंने SNOBOL3 शैली में किया था ताकि जावा दुभाषिया उन्हें चला सके। कागज से, ऐसा लगता है कि अंतर यह है कि SNOBOL1 एक विशेष के साथ पैटर्न मिलान का उपयोग करता हैSYS चर के , जबकि SNOBOL3 इनपुट और आउटपुट चर का उपयोग करता है:

  • इनपुट:
    • 1 SYS .READ *DATA*
    • 3 DATA = SYSPPT
  • आउटपुट:
    • 1 SYS .PRINT 'A STRING' AND VARIABLES
    • 3 SYSPOT = 'A STRING' AND VARIABLES

इन प्रतिस्थापनों को बनाते हुए आपको 'वास्तविक' SNOBOL 1. प्राप्त करना चाहिए, फिर आप इसे नहीं चला सकते।

कार्य 1

START   SYSPOT = 'SNOBOL WAS MADE IN 1962!'

टास्क २

यह गणित, स्ट्रिंग हैंडलिंग और प्रवाह नियंत्रण को दर्शाता है। SNOBOL3 में उपयोगी कार्य हैं, जैसे EQसमानता की जांच करना; मूल SNOBOL नहीं था, इसलिए मैंने उनका उपयोग नहीं किया।

* READ N FROM INPUT
START   SYSPOT = 'SIZE?'
        SZ = SYSPPT

* INITIALIZE
        CS = ''
        ROW = '0'

* OUTPUT PREVIOUS ROW AND START NEXT ONE
ROW     COL = '0'
        SYSPOT = CS
        CS = ''

COL     SUCC = 'N'
        EQ1 = COL
        FAIL = 'CHKE'
        EQ2 = '0'         /(EQUAL)
CHKE    FAIL = 'CHKR'
        EQ2 = SZ - '1'    /(EQUAL)
CHKR    FAIL = 'SPACE'
        EQ2 = ROW         /(EQUAL)

* CONCATENATE THE RIGHT CHARACTER TO THE CURRENT LINE         
SPACE   CS = CS ' '       /(NEXT)
N       CS = CS 'N'       /(NEXT)

* FOR NUMBERS, SUBSTRING MATCH IS ENOUGH IF IT IS KNOWN A<=B
NEXT    COL = COL + '1'
        COL SZ            /F(COL)
        ROW = ROW + '1'
        ROW SZ            /F(ROW)S(FIN)

* THERE SEEMS TO BE NO EQUALITY CHECK, JUST SUBSTRING MATCHING
* OF COURSE, EQ1 == EQ2 IFF EQ1 CONTAINS EQ2 AND VICE VERSA
* THIS ALSO ILLUSTRATES INDIRECTION
EQUAL   EQ1 EQ2           /F($FAIL)
        EQ2 EQ1           /S($SUCC)F($FAIL)

* OUTPUT THE LAST LINE
FIN     SYSPOT = CS     

टास्क 3

सबसे पहले, एक उबाऊ। ध्यान देने योग्य बात केवल छोटी-सी जाँच से है, यह दर्शाता है कि वास्तव में स्ट्रिंग-उन्मुख SNOBOL वास्तव में कैसे था: (B - A) '-'"बीए के परिणाम में एक ऋण होता है?"। SNOBOL3 भी कर सकते हैं LE(B,A), लेकिन SNOBOL 1 नहीं कर सकता (कम से कम पेपर में इसका उल्लेख नहीं है)।

* READ A AND B
START   SYSPOT = 'A?'
        A = SYSPPT
        SYSPOT = 'B?'
        B = SYSPPT

* GCD LOOP
STEP    '0' (A - B)          /S(DONE)
        (B - A) '-'          /S(AB)F(BA)
AB      A = A - B            /(STEP)
BA      B = B - A            /(STEP)
DONE    SYSPOT = 'GCD: ' A

बेशक, जब आपके पास स्ट्रिंग्स और पैटर्न मिलान के चारों ओर पूरी तरह से आधारित भाषा होती है, तो यह वास्तव में पैटर्न मिलान और प्रतिस्थापन का उपयोग करने के लिए नहीं शर्म की बात होगी। इस प्रकार, यहाँ उन यूनिरी-आधारित GCDs में से एक है, जिसमें यूनरी से और से परिवर्तित करने के लिए दिनचर्या शामिल है।

* READ A AND B
START   SYSPOT = 'A?'
        A = SYSPPT
        SYSPOT = 'B?'
        B = SYSPPT

* CONVERT TO UNARY
        UNA.IN = A
        UNA.FIN = 'ADONE'          /(UNA)
ADONE   A = UNA.R
        UNA.IN = B
        UNA.FIN = 'BDONE'          /(UNA)
BDONE   B = UNA.R


* USE STRING MATCHING TO FIND GCD
STEP    '' B                       /S(GDONE)
MATCH   A B =                      /S(MATCH)
        C = B
        B = A
        A = C                      /(STEP)

* CONVERT BACK TO DECIMAL
GDONE   DEC.IN = A
        DEC.FIN = 'DONE'           /(DEC)
DONE    SYSPOT = 'GCD: ' DEC.R     /(FIN)

***************************** 
* DECIMAL TO UNARY SUBROUTINE
UNA     UNA.R =
UNA.DGT UNA.IN *.DGT/'1'* =        /F($UNA.FIN)
        .X = UNA.R
        UNA.R =
UNA.MUL .X *.Y/'1'* =              /F(UNA.ADD)
        UNA.R = UNA.R '##########' /(UNA.MUL)
UNA.ADD '1' .DGT                   /S(UNA.1)
        '2' .DGT                   /S(UNA.2)
        '3' .DGT                   /S(UNA.3)
        '4' .DGT                   /S(UNA.4)
        '5' .DGT                   /S(UNA.5)
        '6' .DGT                   /S(UNA.6)
        '7' .DGT                   /S(UNA.7)
        '8' .DGT                   /S(UNA.8)
        '9' .DGT                   /S(UNA.9)
        '0' .DGT                   /S(UNA.DGT)
UNA.1   UNA.R = UNA.R '#'          /(UNA.DGT)
UNA.2   UNA.R = UNA.R '##'         /(UNA.DGT)
UNA.3   UNA.R = UNA.R '###'        /(UNA.DGT)
UNA.4   UNA.R = UNA.R '####'       /(UNA.DGT)
UNA.5   UNA.R = UNA.R '#####'      /(UNA.DGT)
UNA.6   UNA.R = UNA.R '######'     /(UNA.DGT)
UNA.7   UNA.R = UNA.R '#######'    /(UNA.DGT)
UNA.8   UNA.R = UNA.R '########'   /(UNA.DGT)
UNA.9   UNA.R = UNA.R '#########'  /(UNA.DGT)

*****************************
* UNARY TO DECIMAL SUBROUTINE
DEC     DEC.R =
DEC.DGT '' DEC.IN                  /S($DEC.FIN)
        .X = DEC.IN
        DEC.IN =
DEC.DIV .X '##########' =          /F(DEC.ADD)
        DEC.IN = DEC.IN '#'        /(DEC.DIV)
DEC.ADD '' .X                      /S(DEC.0)
        '#' .X                     /S(DEC.1)
        '##' .X                    /S(DEC.2)
        '###' .X                   /S(DEC.3)
        '####' .X                  /S(DEC.4)
        '#####' .X                 /S(DEC.5)
        '######' .X                /S(DEC.6)
        '#######' .X               /S(DEC.7)
        '########' .X              /S(DEC.8)
        '#########' .X             /S(DEC.9)
DEC.0   DEC.R = '0' DEC.R          /(DEC.DGT)
DEC.1   DEC.R = '1' DEC.R          /(DEC.DGT)
DEC.2   DEC.R = '2' DEC.R          /(DEC.DGT)
DEC.3   DEC.R = '3' DEC.R          /(DEC.DGT)
DEC.4   DEC.R = '4' DEC.R          /(DEC.DGT)
DEC.5   DEC.R = '5' DEC.R          /(DEC.DGT)
DEC.6   DEC.R = '6' DEC.R          /(DEC.DGT)
DEC.7   DEC.R = '7' DEC.R          /(DEC.DGT)
DEC.8   DEC.R = '8' DEC.R          /(DEC.DGT)
DEC.9   DEC.R = '9' DEC.R          /(DEC.DGT)

FIN     START

उत्कृष्ट पृष्ठभूमि का काम! 1961 के लिए ज्यादा नहीं - ऐसा लग रहा है कि COMIT हमारे पास है ....
ब्रायन टॉम्प्सेट -

15

2012 - टाइपस्क्रिप्ट

टाइपस्क्रिप्ट एक स्वतंत्र और खुला स्रोत प्रोग्रामिंग भाषा है जो माइक्रोसॉफ्ट द्वारा विकसित और रखरखाव की जाती है।

मुख्य लक्ष्य है: कोई भी ब्राउज़र। कोई होस्ट। कोई भी OS खुला स्त्रोत। यह अक्टूबर, 2012 को रिलीज़ हुई थी

हेलो टाइपस्क्रिप्ट

Task1(name:string,year:number) {
    return name + " was made in "+ year +"!";
}

ASCII कला

Task2(n:number,separator:string,space:string) {
    var result:string = "";
    for (var k = 0; k < n; k++)
    {
        for (var j = 0; j < n; j++)
        {
            var i = ((n * k) + j) % n;
            result+=(i == 0 || i == n - 1 || i == k) ? "N" : space;
        }
        result+=separator;
    }
    return result;
}

GCD

Task3(a:number,b:number) {
    while (a != 0 && b != 0)
        {
            if (a > b)
                a %= b;
            else
                b %= a;
        }

        if (a == 0)
            return b;
        else
            return a;
}

इसे ऑनलाइन आज़माएं , और इसका स्क्रेंकास्ट करें


4
आप एक बात का उल्लेख करना भूल गए: टाइपस्क्रिप्ट कुछ सिंटैक्स परिवर्तन और अनुमति (?) मजबूत-टाइप किए गए चर और तर्कों के साथ जावास्क्रिप्ट का एक सुपरसेट है।
इस्माइल मिगुएल

1
हे भगवान, एमएस द्वारा कुछ खुला स्रोत!
मेगा मैन

15

2011 - डार्ट

डार्ट Google द्वारा विकसित एक ओपन सोर्स प्रोग्रामिंग भाषा है जिसे जावास्क्रिप्ट के लिए एक प्रतिस्थापन के रूप में विकसित किया गया है (इसके अलावा यह जावास्क्रिप्ट के लिए संकलित है)। GOTO सम्मेलन के दौरान 2011 में Google द्वारा इसका अनावरण किया गया था।

"नमस्ते दुनिया!" संस्करण:

main() {
  print('Dart was made in 2011!');
}

ASCII कला एन:

Bruteforce विधि, 0 (n²) पर चलती है, लेकिन यह वास्तव में तब तक नहीं होनी चाहिए जब तक कि आप एक विशाल संख्या का उपयोग न करें।

asciiN(int number){
    if(number == 1){
        print('N');
    }else{
        for(var i = 1; i <= number; i++){
            String currentLine = "";
            for(var j = 1; j <= number; j++){
                if(j==1 || j == number || j == i){
                    currentLine = currentLine + "N";
                }else{
                    currentLine = currentLine + " ";
                }
            }
            print(currentLine);
        }
    }
}

GCD

सरल यूक्लिड विधि स्नैप से रखी गई! ऊपर का उदाहरण।

int gcd(int first, int second){
if(second > first){
   return gcd(second, first);
    }else{
        if(first == 0){
            return second;
        }else{
            if(second ==0){
                return first;
            }else{
                return gcd(second, first-second);
            }
        }
    }
}

5
मुझे नहीं लगता कि आप O (n।) से कम में × n ASCII कला का उत्पादन कर सकते हैं।
पाओलो एबरमन

@ Pa @loEbermann मैं बड़ी O संकेतन से परिचित नहीं हूं या जटिलता की गणना कैसे की जाती है, लेकिन जूलिया उदाहरण ऐसा लगता है कि यह O (n²) नहीं है।
नजल्ल

@AlexA। Println () फ़ंक्शन n वर्णों की एक स्ट्रिंग प्रिंट करता है। मुझे लगता है कि कार्य कॉल को निष्पादित करने के लिए कम से कम समय ओ (एन) की आवश्यकता है। लूप में, इसलिए पूरे कार्यक्रम के लिए O (n²)।
पाओलो एबरमन 20

@AlexA। मुझे लगता है कि एबरमन जो बात कर रहा है, वह यह है कि आपके प्रिंट फंक्शन में एन स्ट्रिंग कॉन्टेनेटेशन ऑपरेशन हैं। हम दोनों अपने कार्यों में n। स्ट्रिंग संघातन करते हैं। मैं उन्हें एक बार आंतरिक लूप पुनरावृत्ति के बाद करता हूं, आप उन्हें हर प्रिंटलाइन () के लिए करते हैं।
नजल्ल

1
यदि यह एससीआई कला नहीं थी, तो एन प्रदर्शित करने के लिए यह ओ (एन) होगा (स्क्रीन पर 3 रेखाएं खींचें, प्रत्येक लाइन ओ (एन) है इसलिए ओ (एन) जटिलता)। या, आप कह सकते हैं, प्रतिपादन एन है हे (एन) जटिलता ... hehe
rodolphito

15

2010 - जंग

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

कार्य 1

fn main()
{
    println!("Rust was made in 2010!");
}

Task2

fn main()
{
    // get commandline arguments
    // "test 3"
    let args : Vec<_> = std::env::args().collect();

    // convert 2nd argument to integer
    let n = u32::from_str_radix( args[1].as_ref(), 10 ).unwrap();
    print_n( n );
}

fn print_n( n: u32 )
{
    for y in range( 0, n )
    {
        for x in range( 0, n )
        {
            if x == 0 || x == y || x + 1 == n
            {
                print!("N");
            }
            else
            {
                print!(" ");
            }
        }
        println!("");
    }
}

स्पष्टीकरण:

if x == 0 || x == y || x + 1 == n

केवल ऊर्ध्वाधर (बाएं और दाएं |) और विकर्ण ( \) मुद्रण के लिए ध्यान रखता है

टास्क 3

यूक्लिडियन_ एल्गोरिथम का सरल कार्यान्वयन

fn main()
{
    // get commandline arguments
    // "test 453 3"
    let args : Vec<_> = std::env::args().collect();

    // convert 2nd and 3rd argument to integers
    let a = u32::from_str_radix( args[1].as_ref(), 10 ).unwrap();
    let b = u32::from_str_radix( args[2].as_ref(), 10 ).unwrap();
    let g = gcd( a, b );
    println!( "GCD of {} and {} is {}", a, b, g );
}

fn gcd( mut a: u32, mut b: u32 ) -> u32
{
    while b != 0
    {
        let c = a % b;
        a = b;
        b = c;
    }
    return a;
}

क्या आप एक स्निपेट दिखा सकते हैं कि स्टड से दो अंतरिक्ष-अलग पूर्णांक इनपुट कैसे करें?
जीरो फाइबर

3
क्या 2010 में "जंग" बनी थी? प्रोग्रामिंग भाषाओं की टाइमलाइन ऐसा कहती है, लेकिन वास्तविक लेख कहता है कि यह केवल 2010 में घोषित किया गया था (वास्तव में संदर्भ के अनुसार 2011 ) और उस संस्करण 0.2 को 2012 में जारी किया गया था।
EMBLEM

1
@SampritiPanda, hastebin.com/raw/lapekowogu पर नज़र डालें
isikuss

1
थोड़ा आधुनिक-ईश लगता है। क्या यह संकलनकर्ता के पहले <s> जारी किए गए कार्य संस्करण को प्रकाशित कर सकता है?
वि।

15

2015 - मफिन एम.सी.

टिकिया एमसी एक ट्यूरिंग-फुल, फनी (लेकिन गंभीर), फंक्शनल और मिनिमलिस्ट मैक्रो-लैंग्वेज है, जिसे फ्रेंक पोचर ( http://franckys.com ) ने फरवरी 2015 के मध्य में आवश्यकता से बाहर (क्विक) टूल के रूप में सशक्त किया था। स्प्रेडशीट को पायलट के लिए एकमात्र फ्रंट-एंड कंट्रोलर के रूप में इस्तेमाल किया जाना है और एक नए ताहिती फैशन ब्रांड के लिए Prestashop- आधारित मर्चेंट साइट से जुड़े सभी इन्वेंट्री से संबंधित ऑपरेशन को ड्राइव करना है: म्यूटिनी ताहिती ( http://mutinytahiti.com) - जल्द ही शुरू)।

मफिन एम सी के लिए एक संक्षिप्त है एमयू छोटे एफ unctional एफ lexible में लाइन एम एक्रो सी ommand भाषा।

हमारी आवश्यकताओं को पूरा करने के लिए, मफिन एमसी की मुख्य विशेषताओं को लचीले और कुशल प्रथम श्रेणी में निर्मित अर्थ-संबंधी निर्माण जैसे बनाया गया है पुनरावृत्तियों , आलसी-मूल्यांकन , मल्टी-फंक्शनलर्स , स्ट्रिंग-उत्पाद के रूप में तैयार किया गया है

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

Muffin MC सूची शब्दार्थ (प्रकार) पावर-सेट शब्दार्थ पर उधार लेता है , जो है:

  1. सभी मफिन एमसी ऑपरेशन एक सूची प्राप्त करते हैं, संभवतः खाली।
  2. किसी भी व्यक्तिगत सूची तत्व तक पहुंच हमेशा उस तत्व से बने एक-मूल्य-सूची की उपज होती है (इसे सिंगलटन के रूप में सोचो)।
  3. खाली सूची सूची संचालन पर तटस्थ तत्व है।

इसके साथ सामंजस्य स्थापित करने के लिए, निम्नलिखित मदद कर सकते हैं:

  • एक सूची की शक्ति-तत्व के तत्व के रूप में एक सूची की कल्पना कर सकता है जिसमें सबसे बड़ी कार्डिनैलिटी है।
  • किसी सूची के तत्व को सूची के शक्ति-सेट के तत्व के रूप में कल्पना करें जो उस तत्व से बना सिंगलटन है।
  • खाली सेट के रूप में एक खाली सूची की कल्पना करें; वह, खाली-सेट के पावर-सेट का एकमात्र तत्व है।

जैसे, एक खाली सूची तत्व तक पहुँचने से रिक्त सूची की पैदावार होती है, न कि कोई त्रुटि! वास्तव में, मफिन एमसी कई पारंपरिक ऑपरेशनों के शब्दार्थों को उस तरह से बढ़ाकर कुछ त्रुटियों को फेंकने की कोशिश करता है।

कार्य 1

#(say "MuffinMC was born in 2015 out of necessity !")

#(...)एक गैर-विकसित तर्क सूची पर एक फ़ंक्शन को लागू करने के लिए मफिन एमसी मैक्रो कमांड है, यहां अंतर्निहित फ़ंक्शन say, पर्ल से उधार लिया गया है।

#(say 1 2 3 ...) कार्यात्मक रूप से समान है map {say $_} (1,2,3,...)

टास्क २

फ़ंक्शन को परिभाषित करें ascii-art():

=(ascii-art
    '( =(*  x   #(2- $(_1))
        I   I( *($(x) " ") N)
            foo '( #(. #(I $(x))) ))
    #(say ?( #(== $(_1) 1) N "N#(map foo #(.. 1 $(_1)))N" ))
 ))

Ascii-art()सबसे छोटा कार्य प्रपत्र (88 बाइट्स):

=(f'(=(* x#(2-)I I(*($(x)" ")N)g'(#(.#(I$(x)))))#(say?(#(==$(_1)1)N"N#(map g#(..))N"))))
  • =(var val...)एक चर को परिभाषित करने के लिए मफिन एमसी मैक्रो कमांड है, या इसे फिर से असाइन करें।

  • $(var)वैरिएबल के मान तक पहुँचने के लिए मफिन MC मैक्रो कमांड है। यह स्वाभाविक रूप $(v1 v2 ...)से एक साथ कई चर का उपयोग करने के लिए प्रपत्र को स्वीकार करता है ।

  • =(* var1 val1 var2 val2 ...)समानांतर कार्यों से निपटने के लिए मफिन एमसी मैक्रो कमांड का विस्तार है =(...)

  • चर _1, _2, ... गतिशील रूप से स्कोप (उथले बाध्यकारी तंत्र) हैं और स्वचालित रूप से फ़ंक्शन के तर्कों को बांधने के लिए सेट होते हैं। Perl5 से उधार, सिस्टम चर #(तर्कों की संख्या) और @(तर्कों की सूची) भी स्वचालित रूप से सेट किए जाते हैं।

  • फ़ंक्शंस बस किसी भी संख्या में मफिन एमसी स्टेटमेंट के लिए बाध्य चर हैं ।

यह दिलचस्प समाधान दो प्राकृतिक मफिन एमसी अंतर्निहित सुविधाओं के संयोजन से आता है:

  1. मफिन एमसी I(...) मैक्रो कमांड, साइकिल चालन-पुनरावृत्तियों को परिभाषित करने के लिए, बाद में कार्यात्मक रूप के साथ प्रयोग किया जाता है #(my-iterator want-number-of-values),

  2. मफिन एमसी स्ट्रिंग-उत्पाद निर्माण, प्राकृतिक चर प्रक्षेप का विस्तार, जिसने किसी भी स्ट्रिंग को दिया "F1 F2 F3...", जहां एफ आई एस या तो मफिन एमसी स्ट्रिंग शाब्दिक या मफिन एमसी मैक्रो कमांड (उर्फ कार्यात्मक रूप) हैं, जो कई तारों का उत्पादन करेंगे। उत्पाद कार्डिनल (F1) x कार्डिनल (F2) x ... द्वारा दिया गया।

उदाहरण के लिए, दिया गया xa वैरिएबल जो 2 मान रखता है, a और b कहता है, और y एक अन्य वैरिएबल है जो 3 मान रखता है, कहता है, 1 2 3, तब स्ट्रिंग का मूल्यांकन "x=$(x) y=$(y))"6 अलग-अलग मान उत्पन्न करेगा, अर्थात् उस क्रम में:

  • "X = ay = 1"
  • "X = ay = 2"
  • "X = ay = 3"
  • "X = = 1 द्वारा"
  • "X = = 2 द्वारा"
  • "X = = 3 द्वारा"

यह MUTINY प्रोजेक्ट की अत्यधिक वांछनीय विशेषताओं में से एक है जिसे Muffin MC के लिए डिज़ाइन किया गया था।

चलाओ !

#(ascii-art 1)

N


#(ascii-art 3)

N N  
NNN  
N N 


#(map '( #(ascii-art $(_1))) 5 7 9)

N   N
NN  N
N N N
N  NN
N   N

N     N
NN    N
N N   N
N  N  N
N   N N
N    NN
N     N

N       N
NN      N
N N     N
N  N    N
N   N   N
N    N  N
N     N N
N      NN
N       N

यह कैसे काम करता है

हमारा एल्गोरिथ्म अनुसरण पर आधारित है:

Ascii- कला (n) के लिए एक कॉल दिया, {n = 2p + 1 | p पूर्णांक, p> = 0}, उत्पन्न करने की कला में n वर्णों के n तार शामिल हैं, जिनमें से, दो, सबसे बाईं और दाईं ओर, निश्चित और हमेशा समान हैं: 'N'। यह केवल मध्य तारों के उत्पादन में समस्या को कम करने की अनुमति देता है। उदाहरण के लिए, n = 5 को देखते हुए, हम निम्नलिखित 5 निम्न तारों का निर्माण करना चाहते हैं, जिनमें से प्रत्येक n-2 वर्णों से बना होता है (हमने बेहतर दृश्य के लिए '_' द्वारा स्थान बदल दिया है):

    The 5 strings :
        _ _ _
        N _ _ 
        _ N _
        _ _ N
        _ _ _

    can be seen as resulting from splitting in groups of 3 characters
    the following infinite sequence of 4 characters :


        /---- < _ _ _ N > ----\
       |                       |
        \---------------------/    


    which, once unfolded, yields the infinite ruban : 

        _ _ _ N _ _ _ N _ _ _ N _ _ _ N _ _ _ N _ _ _ N ...
              ^     ^     ^     ^     
        _ _ _ |     |     |     |
              N _ _ |     |     | 
                    _ N _ |     |
                          _ _ N |
                                _ _ _
  • ऐसे मध्य तार आसानी ('_' '_' '_' 'N')से 3 के 5 समूहों में 4 तत्वों के अनुक्रम में साइकिल चलाकर पैदा किए जा सकते हैं ; n को दिया गया, फ़ंक्शन का इनपुट, इस तरह का अनुक्रम n-2 वर्णों से बना है '_', उसके बाद वर्ण है 'N'। इस क्रम में साइकलिंग के अलावा मफिन एमसी I(sequence) बिल्ट-इन इटेरेटर (एक ऐसा इटरेटर जो अपने शुरूआती अनुक्रम के मूल्यों पर हमेशा के लिए साइकिल चलाता है) के सिवा और कुछ नहीं चाहिए ।

  • हम तब केवल अपने अगले n-2 मान (n - 2 वर्ण) देने के लिए अपने पुनरावृत्ति पूछकर, मध्ययुगीन तार का लंबाई n-2 का उत्पादन करते हैं, जो अपेक्षित मध्य स्ट्रिंग का उत्पादन करने के लिए एक साथ समवर्ती होते हैं।

  • N मध्य तार उपरोक्त प्रक्रिया को n परिणाम (n-2 वर्णों के n तार) एकत्र करने के लिए मानचित्र का उपयोग करते हुए, उपरोक्त प्रक्रिया को दोहराते हुए निर्मित होते हैं।

  • हम एक और शक्तिशाली मफिन एमसी बिल्ट-इन निर्माण का उपयोग करते हैं, अर्थात् स्ट्रिंग उत्पाद , एन अंतिम स्ट्रिंग्स का उत्पादन करने के लिए "N#(map...)N":।

  • और बस !

    Commented script  
    
    =(ascii-art                    Define the 'ascii-art' variable to hold
                                   the function's definition.
                                   When called, its argument, the actual
                                   value of n, will be bound to the system
                                   variable _1, accessed as $( _1 ).
    
        '(                         '(...) quote macro-command -- protects 
                                   its arguments, here the function 
                                   definition, from being evaluated.
                                   We want to keep it literally for further evaluation.
    
           =(*                     =(*...) // assignment macro-command.
                                   Similar to the Lisp (let (...)...),
                                   not the let* !
    
               x #(2- $(_1))       Define the variable x to hold the value 
                                   n-2.   
    
               I I(                Define I to be an iterator over the 
                                   the x+1 characters sequence :
                    *( $(x) " ")   . x white-space characters
                    N              . 1 'N' character (here the atom N)
                 )
    
               foo '(              Define the variable foo as a function 
                      #(.          to catenate ( #(. s1...) )
                         #(I $(x)) the iterator's next x elements.
                       )            
               )
           )                       End of =(*...
    
        #(say                      Print each element of:
           ?(                      If
              #(== $(_1) 1)        n equals 1
      N                    the atom N,
      "N#(map foo #(.. 1 $(_1)))N" else the n strings as a string-product 
                                   resulting from foo-computing the  
           )                       n middle-strings.
         )
     ))
    

टास्क 3

फ़ंक्शन को परिभाषित करें gcd():

=(gcd '( ?( #(== $(_2) 0)
        $(_1)
            #(self $(_2) #(mod $(_1) $(_2)))) ))

gcd()के असली कम से कम प्रपत्र (37 बाइट्स - 2bytes Rodolvertice करने के लिए धन्यवाद प्राप्त करता है)

=(g'(?(#(z$(_2))$(_1)#(g$(_2)#(mod)))))

चलाओ !

#(gcd 225 81)

पैदावार ९।

बस।

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

चियर्स

फ़्रैंक


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


बहुत अच्छे! एससीआई-कला के सबसे छोटे रूप में एक छोटा नाम है, लेकिन जीसीडी सबसे छोटा नहीं है। क्या यह जानबूझकर है, क्योंकि अगर यह नहीं है तो आप एक और 2 बाइट्स से किनारा कर सकते हैं। +1
रॉडॉल्फिटो

यकीन है, और यह जानबूझकर है। क्या मैं ? हाँ, चलो इसे करते हैं;) पोस्ट के लिए धन्यवाद, और आपकी प्रशंसा।
फ्रेंक पोश्चर

1
चूँकि आप अतिरिक्त वर्णों से छुटकारा पाने की कोशिश कर रहे हैं (और क्योंकि मैं एक अचूक व्याकरण-गंदा हो सकता हूं), आप पहले कार्य के लिए विस्मयादिबोधक चिह्न के सामने की जगह को हटा सकते हैं। वह जगह फ्रेंच एफैक में सही है, लेकिन अंग्रेजी में नहीं।
एमोस एम। बढ़ई
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.