भाषाओं का प्रदर्शन


507

टिप्पणियाँ

  • यह धागा केवल इसलिए खुला और खुला हुआ है क्योंकि समुदाय ने अपवाद बनाने का फैसला किया है । कृपया इस प्रश्न को सबूत के रूप में उपयोग करें कि आप यहां इसी तरह के प्रश्न पूछ सकते हैं। कृपया अतिरिक्त प्रश्न बनाएं ।

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

यह धागा दिलचस्प, उपयोगी, अस्पष्ट, और / या अनूठी विशेषताओं को दिखाने के लिए समर्पित है, जो आपकी पसंदीदा प्रोग्रामिंग भाषाओं को प्रस्तुत करना है। यह न तो एक चुनौती है और न ही एक प्रतियोगिता है, लेकिन जितनी संभव हो उतनी प्रोग्रामिंग भाषाओं को प्रदर्शित करने के लिए एक सहयोग प्रयास है।

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

  • सभी उत्तरों में पोस्ट के शीर्ष पर प्रोग्रामिंग भाषा का नाम शामिल होना चाहिए, उपसर्ग a #

  • उत्तर में एक (और केवल एक) फैक्टॉइड हो सकता है, अर्थात, कोड के बिना कुछ वाक्य जो भाषा का वर्णन करते हैं।

  • फैक्टॉइड के अलावा, उत्तरों में कोड के स्निपेट्स शामिल होने चाहिए, जो प्रोग्राम (या कार्य) नहीं कर सकते।

  • स्निपेट्स को संबंधित होने की आवश्यकता नहीं है। वास्तव में, स्निपेट जो बहुत अधिक संबंधित हैं, निरर्थक हो सकते हैं।

  • चूंकि यह एक प्रतियोगिता नहीं है, सभी प्रोग्रामिंग भाषाओं का स्वागत है, जब भी वे बनाए गए थे।

  • उत्तर जो कि एक से अधिक कोड स्निपेट में होते हैं, उन्हें फैक्टॉयड और स्निपेट में से एक को छोड़कर सब कुछ समेटने के लिए स्टैक स्निपेट का उपयोग करना चाहिए ।

  • जब भी संभव हो, प्रति प्रोग्रामिंग भाषा में केवल एक ही उत्तर होना चाहिए। यह एक सामुदायिक विकी है, इसलिए किसी भी उत्तर के लिए स्निपेट को जोड़ने के लिए स्वतंत्र महसूस करें, भले ही आपने इसे स्वयं नहीं बनाया हो। संपीड़ित पदों के लिए एक स्टैक स्निपेट है , जिसे 30,000 वर्ण सीमा के प्रभाव को कम करना चाहिए।

उत्तर है कि इन दिशानिर्देशों को पूर्व निर्धारित किया जाना चाहिए। कृपया उन्हें आवश्यकतानुसार अपडेट करने में सहायता करें।

वर्तमान उत्तर, भाषा के नाम से वर्णानुक्रम में छांटे गए

$.ajax({type:"GET",url:"https://api.stackexchange.com/2.2/questions/44680/answers?site=codegolf&filter=withbody",success:function(data){for(var i=0;i<data.items.length;i++){var temp=document.createElement('p');temp.innerHTML = data.items[i].body.split("\n")[0];$('#list').append('<li><a href="/a/' + data.items[i].answer_id + '">' + temp.innerText || temp.textContent + '</a>');}}})
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><base href="http://codegolf.stackexchange.com"><ul id="list"></ul>

जवाबों:


414

मेथेमेटिका

आप इस बॉटम-टू-टॉप को पढ़ना चाहते हैं क्योंकि यह जिस क्रम में लिखा गया था, और कुछ स्पष्टीकरण पिछले स्निपेट को संदर्भित करेंगे या आगे से नीचे स्पष्टीकरण मानेंगे।

सूची काफी लंबी हो रही है। मैंने कम दिलचस्प स्निपेट निकालना शुरू कर दिया है, और मैं अब स्निपेट्स छोड़ना शुरू कर दूंगा। 41 तक स्निपेट्स की पूरी सूची के लिए संशोधन इतिहास देखें। कुछ असली रत्नों के लिए, स्निपेट्स 81 , 64 , 44 , 23 , 19 , 12 और 8 को देखें

लंबाई 143 और 144 स्निपेट

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

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

यह काफी अपठनीय है, क्योंकि मुझे इसे बहुत कम करना था:

d@t@t;NDSolve[{#''@t==-#4#2''[t]Cos@d-##3#2'@t^2Sin@d-Sin@#@t&@@@{{θ,φ,1,.5},{φ,θ,-1,1}},θ@0==2,φ@0==1,θ'@t==φ'@t==0/.t->0},{θ,φ},{t,0,60}]

क्या साफ है कि गणितज्ञ तुरंत एक लघु कथानक प्रदर्शित करता है कि समाधान क्या दिखता है:

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

ठीक है, लेकिन यह थोड़ा लंगड़ा है। हम जानना चाहते हैं कि पेंडुला की गति वास्तव में कैसी दिखती है। तो यहाँ एक 144-चरित्र वाला स्निपेट है, जो निचले पेंडुम के प्रक्षेपवक्र का पता लगाते हुए पेन्डुला को एनिमेट करता है:

Graphics@{Line@{{0,0},p=θ~(h={Sin@#@#2,-Cos@#@#2}&)~t,p+φ~h~t},White,{0,0}~Circle~2.2}~Show~ParametricPlot[θ~h~u+φ~h~u,{u,0,t}]~Animate~{t,0,60}

परिणामी एनीमेशन इस तरह दिखता है:

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

मुझे थोड़ा धोखा देना पड़ा: यदि आप परे साजिश करते हैं t = 30, तो ParametricPlotडिफ़ॉल्ट रूप से बहुत कम साजिश बिंदुओं का उपयोग करता है और लाइन काफी दांतेदार हो जाती है। लेकिन उस समय के बाद अधिकांश दिलचस्प गतिकी होती है, इसलिए मैंने PlotPoints -> 200एनीमेशन के दूसरे छमाही को चिकना बनाने के लिए विकल्प का उपयोग किया । यह काफी हद तक अलग नहीं है, और पहली छमाही वैसे भी अप्रभेद्य दिखेगी।

मुझे लगता है कि यह मेरा आखिरी स्निपेट होगा, जब तक कि मैं कुछ सच में माइंडब्लोइंग के साथ नहीं आता। आशा है आपको यह पसंद आया होगा!

लंबाई 100 स्निपेट

GeoGraphics[{GeoStyling[Opacity[0.5]], NightHemisphere[]}, GeoBackground -> GeoStyling["ReliefMap"]]

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

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

लंबाई 81 स्निपेट

CellularAutomaton[{{0,2,3,If[0<Count[#,1,2]<3,1,3]}[[#[[2,2]]+1]]&,{},{1,1}},i,n]

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

वैसे भी, मैंने विकिपीडिया से i(सिग्नल उत्पन्न करने वाली दो घड़ियाँ, और एक XOR गेट) का उदाहरण स्थापित किया है और इसे कुछ 50 चरणों के लिए चलने दिया है:

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

यदि आप रुचि रखते हैं, तो वास्तविक प्लॉटिंग और एनीमेशन स्निपेट 77 हो सकते हैं:

ListAnimate[ArrayPlot[#,ColorRules->{0->Black,1->Blue,2->Red,3->Yellow}]&/@w]

लंबाई 69 स्निपेट

DSolve[r^2*R''[r]+2r*R'[r]-R[r]==0&&(R[r]==1&&R'[r]==2/.r->1),R[r],r]

कुछ उपयोगी करने के लिए वापस। समीकरणों की सामान्य प्रणालियों के अलावा, Mathematica विभेदक समीकरणों की प्रणालियों को भी हल कर सकता है। उपरोक्त तकनीकी रूप से सीमा स्थितियों के साथ केवल एक अंतर समीकरण है, लेकिन आप इसे तीन समीकरणों की प्रणाली के रूप में भी आपूर्ति कर सकते हैं। एकीकृत कार्यों के समान DSolveसटीक समाधानों के लिए है जबकि NDSolveसिस्टम को संख्यात्मक रूप से हल करेगा। उपरोक्त एक एकल समाधान देता है

{{R[r] -> 1/2 r^(-(1/2) - Sqrt[5]/2) (1 - Sqrt[5] + r^Sqrt[5] + Sqrt[5] r^Sqrt[5])}}

जिसे अब आगे की गणना या प्लॉट के लिए आसानी से उपयोग किया जा सकता है।

लंबाई 64 स्निपेट

CellularAutomaton[{224,{2,{{2,2,2},{2,1,2},{2,2,2}}},{1,1}},i,n]

मैंने तुमसे और CellularAutomatonजादू का वादा किया था ! यह स्निपेट कॉनव्स गेम ऑफ लाइफ को चरणों के iलिए प्रारंभिक स्थिति के साथ गणना करता है nऔर आपको सभी मध्यवर्ती टाइमस्टेप्स के लिए परिणाम देता है।

मापदंडों के बारे में कुछ शब्द: 2सेल राज्यों की संख्या है। {{2,2,2},{2,1,2},{2,2,2}}3x3 पड़ोस में 9 कोशिकाओं के लिए वजन देता है। यह सुनिश्चित करता है कि सेल स्वयं 8 पड़ोसियों के योग से अलग है। {1,1}कहते हैं कि सीए नियम किसी भी दिशा में 1 कदम दूर कोशिकाओं पर निर्भर करता है। अंत में, 224एकल संख्या में एन्कोडेड वास्तविक अद्यतन नियम है। इस संख्या का पता लगाना थोड़ा मुश्किल हो सकता है, लेकिन प्रलेखन में काफी उपयोगी ट्यूटोरियल है । अधिक जटिल ऑटोमेटा के लिए, एक भी संख्या में कटौती नहीं होगी (क्योंकि संख्या बहुत बड़ी होगी)। शायद हम कल वहाँ पहुँच जाएँगे! ;)

वैसे भी, अगर मैं एक यादृच्छिक ग्रिड में iऔर 200 में फ़ीड n, और एक एनिमेटेड के माध्यम से परिणाम भेजें ArrayPlot, हम देख सकते हैं कि यह वास्तव में काम कर रहा है:

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

लंबाई 59 स्निपेट

SphericalPlot3D[Re[Sin[θ]Cos[θ]Exp[2I*φ]],{θ,0,π},{φ,0,2π}]

स्निपेट 26 से ध्रुवीय भूखंड याद है? हम 3 डी में एक ही काम कर सकते हैं! (वास्तव में, दो कार्य हैं: RevolutionPlot3Dबेलनाकार खंभे के लिए और SphericalPlot3Dगोलाकार खंभे के लिए।) ठीक वैसे ही जैसे कि Graphics3Dसभी तीन आयामी प्लॉट स्वचालित रूप से मैथेमेटिका में घूर्णन योग्य हैं, इसलिए आपको एक अच्छे कैमरा कोण अपफ्रंट के बारे में चिंता करने की ज़रूरत नहीं है। उपरोक्त भूखंड एक गोलाकार हार्मोनिक की तरह कुछ (हालांकि काफी नहीं) और जैसा दिखता है:

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

लंबाई 52 स्निपेट

Manipulate[Plot[x^2a+x*b,{x,-3,3}],{a,.1,3},{b,0,3}]

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

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

लंबाई 48 स्निपेट

Import["http://www.google.com/doodles","Images"]

Importएक बहुत शक्तिशाली कमांड है। यह डिस्क और वेब से फ़ाइलों को लोड करने के लिए उपयोग किया जाता है। यह काफी भिन्न फ़ाइल स्वरूपों को जानता है, और उनमें से कुछ (जैसे HTML पृष्ठ) यह वास्तव में डेटा को तुरंत निकाल सकता है। उपरोक्त सभी चित्र Google के डूडल पेज से डाउनलोड किए गए हैं।

लंबाई 45 स्निपेट

EdgeDetect@ExampleData@{"TestImage","Splash"}

कुछ इमेज प्रोसेसिंग के लिए समय। Mathematica उदाहरण डेटा के एक पूरे समूह के साथ आता है, जिसमें छवियां (जैसे Lena), बनावट, 3D मॉडल और ऑडियो स्निपेट शामिल हैं। सबसे पहले, हम उनमें से एक को लोड करते हैं:

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

किनारों का पता लगाना चाहते हैं? यह एक एकल फ़ंक्शन कॉल है:

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

लंबाई 44 स्निपेट

ArrayPlot@CellularAutomaton[110,{{1},0},100]

अंत में, मुझे उपयोग करने के लिए पर्याप्त वर्ण मिले हैं CellularAutomatonऔर परिणाम भी प्रस्तुत करना है। :) जहाँ तक मेरी जानकारी है, CellularAutomatonसीए से संबंधित गणितज्ञ का एकमात्र कार्य है। लेकिन स्टीफन वोल्फ्राम जब सेल्युलर ऑटोमेटा की बात करते हैं तो वह खुद को नंबर-वन का लड़का मानते हैं, इसलिए यह फंक्शन अविश्वसनीय रूप से शक्तिशाली है। उपरोक्त बहुत सरलतम उपयोग को दर्शाता है। यह 100 कदम के लिए 1 डी सेलुलर ऑटोमेटन का अनुकरण करता है - और यह वास्तव में उन प्रत्येक चरणों में ऑटोमेटन की स्थिति को वापस कर देगा, इसलिए परिणाम दो आयामी है। नियम पहला पैरामीटर है, जिसे या तो सूचियों के माध्यम से विस्तार से निर्दिष्ट किया जा सकता है, या केवल एक ही संख्या में एन्कोड किया जा सकता है। इस उदाहरण के लिए, मैंने बल्कि प्रसिद्ध, ट्यूरिंग पूर्ण, नियम 110 को चुना है{{1},0}प्रारंभिक स्थिति को परिभाषित करता है: एक एकल1शून्य की पृष्ठभूमि के सामने। हो सकता है कि मुझे CellularAutomatonभविष्य में कुछ और विशेषताएं दिखाई दें , जब मुझे अधिक वर्ण उपलब्ध हों: यह बड़े आयामों का उपयोग करके और दो से अधिक राज्यों के साथ सीए को उच्च आयामों में अनुकरण कर सकता है।

ArrayPlotएक और अच्छी साजिश रचने वाली उपयोगिता है जो सिर्फ ठोस मूल्य के ग्रिड के रूप में एक 2 डी सूची का प्लॉट करती है जो उनके मूल्य को दर्शाता है। सरलतम मामले में, 0सफेद और 1काले रंग के लिए हल्का होता है । स्निपेट का परिणाम है:

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

लंबाई 43 स्निपेट

HighlightGraph[graph,FindVertexCover@graph]

जब से मैंने रेखांकन का उल्लेख किया है, यह एक समय है। बहुत सारे सामान्य ग्राफ सैद्धांतिक समस्याओं का निर्माण किया गया है, जिसमें अच्छे दृश्य उपकरण के साथ-साथ गणितज्ञ भी शामिल हैं। ऊपर, दिए गए के लिए graph, ग्राफ़ का एक न्यूनतम शीर्ष कवर मिलेगा, और फिर उन हाइलाइट्स के साथ ग्राफ़ को प्रस्तुत करना होगा। उदाहरण के लिए अगर graphहै PetersenGraph[7,2]टुकड़ा 18 से वापस, हम पाते हैं:

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

लंबाई 42 स्निपेट

Animate[Plot[Sin[t-x],{x,0,10}], {t,0,10}]

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

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

लंबाई 40 स्निपेट

SortBy[PlanetData[#, "EscapeVelocity"]&]

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

और हाँ, एक और अच्छा *Dataकार्य है - ऊपर ग्रहों के पलायन वेगों द्वारा ग्रह नामों को क्रमबद्ध किया जाएगा ।

लंबाई 39 स्निपेट

f[1]=1
f[2]=1
f[n_]:=f[n]=f[n-1]+f[n-2]

मैंने फिबोनाची फ़ंक्शन को अधिक कुशल बनाने का वादा किया। इस स्निपेट से पता चलता है कि मैथेमेटिका में कितनी तुच्छ याद है। ध्यान दें कि सभी को बदल दिया f[n]=गया तीसरी पंक्ति में एक अतिरिक्त है। इसलिए जब fएक नए मूल्य (कहते हैं f[3]) के लिए बुलाया जाता है , तो f[3]=f[3-1]+f[3-2]मूल्यांकन किया जाएगा। यह गणना करता है f[2]+f[1], फिर इसे f[3](साथ =, नहीं :=!) को असाइन करता है , और अंत में हमारे शुरुआती कॉल के लिए मान लौटाता है। इसलिए इस फ़ंक्शन को कॉल करना इस मान के लिए एक नई परिभाषा जोड़ता है, जो स्पष्ट रूप से सामान्य नियम की तुलना में अधिक विशिष्ट है - और इसलिए fउस मूल्य के साथ भविष्य के सभी कॉल के लिए उपयोग किया जाएगा ।

याद रखें कि अन्य फाइबोनैचि फ़ंक्शन ने 30 मानों के लिए 4 सेकंड का समय लिया था? यह 300,000 मूल्यों के लिए 3 सेकंड की जरूरत है।

लंबाई 37 स्निपेट

l//.{a___,x_,b___,x_,c___}:>{a,x,b,c}

आखिरी स्निपेट में मैंने पैटर्न का उल्लेख किया। ये अक्सर नियमों में उपयोग किए जाते हैं , जो (अन्य चीजों के अलावा) उन संरचनाओं को संशोधित करने के लिए उपयोग किया जा सकता है जो एक निश्चित पैटर्न से मेल खाते हैं। तो आइए इस स्निपेट को देखें।

{a___,x_,b___,x_,c___}:>{a,x,b,c}एक नियम है। x_एक एकल अंडरस्कोर के साथ एक पैटर्न है जो एक एकल मनमाना मूल्य (जो खुद एक सूची या समान हो सकता है) को संदर्भित करता है। a___एक अनुक्रम पैटर्न है (स्निपेट 15 भी देखें), जो 0 या अधिक मानों के अनुक्रम को संदर्भित करता है। ध्यान दें कि मैं x_दो बार उपयोग कर रहा हूं , जिसका अर्थ है कि सूची के उन दो हिस्सों का समान मूल्य होना चाहिए। तो यह पैटर्न किसी भी सूची से मेल खाता है जिसमें दो बार एक मान होता है, उस तत्व xको कॉल करता है और उन दो तत्वों के आसपास तीन अनुक्रमों को कॉल करता है a, bऔर c। इसके द्वारा प्रतिस्थापित किया जाता है {a,x,b,c}- वह दूसरा xगिरा दिया जाता है।

अब //.एक नियम लागू करेगा जब तक कि पैटर्न किसी भी अधिक मेल नहीं खाता। तो उपरोक्त स्निपेट एक सूची से सभी डुप्लिकेट को हटा देता है l। हालाँकि, यह उससे थोड़ा अधिक शक्तिशाली है: //.सभी स्तरों पर नियम लागू करता है। इसलिए यदि lस्वयं सूची (किसी भी गहराई तक) में है, तो उन उप-सूची से डुप्लिकेट भी हटा दिए जाएंगे।

लंबाई 36 स्निपेट

f[1]=1
f[2]=1
f[n_]:=f[n-1] + f[n-2]

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

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

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

लंबाई 35 स्निपेट

StreamPlot[{x^2,y},{x,0,3},{y,0,3}]

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

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

लंबाई 34 स्निपेट

Solve[a*x^4+b*x^3+c*x^2+d*x==0, x]

गणितज्ञ भी समीकरणों (या समीकरणों के सिस्टम) को हल कर सकते हैं, लेकिन हमें केवल अभी बहुत सारे वर्ण मिले हैं)। परिणाम, हमेशा की तरह, प्रतीकात्मक होगा।

{
  {x -> 0}, 
  {x -> -(b/(3 a)) - (2^(1/3) (-b^2 + 3 a c))/(3 a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) + (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)/(3 2^(1/3) a)}, 
  {x -> -(b/(3 a)) + ((1 + I Sqrt[3]) (-b^2 + 3 a c))/(3 2^(2/3) a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) - ((1 - I Sqrt[3]) (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3))/(6 2^(1/3) a)}, 
  {x -> -(b/(3 a)) + ((1 - I Sqrt[3]) (-b^2 + 3 a c))/(3 2^(2/3) a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) - ((1 + I Sqrt[3]) (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3))/( 6 2^(1/3) a)}
}

ध्यान दें कि समाधान नियमों के रूप में दिए गए हैं , जिन्हें मैं शायद भविष्य के स्निपेट में अधिक विस्तार से दिखाऊंगा।

लंबाई 33 स्निपेट

Dynamic@EdgeDetect@CurrentImage[]

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

लंबाई 32 स्निपेट

NumberLinePlot[x^2<2^x,{x,-2,5}]

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

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

तीर इंगित करता है कि क्षेत्र अनंत तक जारी है। सफेद वृत्त संकेत देते हैं कि वे खुले अंतराल हैं (अंत बिंदु अंतराल का हिस्सा नहीं हैं)। बंद छोरों के लिए, मंडलियां भर जाएंगी।

लंबाई 28 स्निपेट

Graphics3D@{Sphere[],Cone[]}

कुछ 3 डी ग्राफिक्स के लिए समय। उपरोक्त एक सुपर-थोपा हुआ क्षेत्र प्रदान करता है और डिफ़ॉल्ट मापदंडों के साथ शंकु बनाता है, जो क्रिस्टल बॉल की तरह दिखता है:

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

Mathematica में, आप वास्तव में क्लिक कर सकते हैं और इसे घुमाने के लिए इस छोटे विजेट को खींच सकते हैं।

लंबाई 27 स्निपेट

CountryData["ITA", "Shape"]

अधिक *Data! CountryDataबहुत पागल है। किसी देश का आकार प्राप्त करना हिमशैल का टिप भी नहीं है। देशों के बारे में बहुत डेटा है, आप शायद इस फ़ंक्शन के बारे में पूरी पुस्तक लिख सकते हैं। जैसे ... वहाँ है FemaleLiteracyFraction। आप उस डेटा को अलग-अलग समय के लिए क्वेरी कर सकते हैं। पूरी सूची के लिए, संदर्भ देखें।

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

लंबाई 26 स्निपेट

PolarPlot[Sin[5θ],{θ,0,π}]

अधिक रोचक कथानक के लिए समय। PolarPlotबस ध्रुवीय निर्देशांक में एक भूखंड है। किसी दिए गए x के लिए y निर्दिष्ट करने के बजाय, आप किसी दिए गए कोण के लिए त्रिज्या r निर्दिष्ट करते हैं for:

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

लंबाई 25 स्निपेट

{{1,5},{2,3},{7,4}}.{8,9}

हमने आखिरकार कुछ वेक्टर गणित के लिए पर्याप्त वर्ण प्राप्त कर लिए हैं। उपरोक्त 2x3 मैट्रिक्स और पंक्ति 2-वेक्टर के मैट्रिक्स गुणन की गणना करता है:

{53, 43, 92}

लंबाई 23 स्निपेट

Rotate[Rectangle, Pi/2]

हे। हेहे। आपको लगता है कि आप जानते हैं कि यह क्या करता है। लेकिन तुम नहीं। Rectangleअपने आप में केवल एक नामित कार्य है। वास्तव में एक आयत का प्रतिनिधित्व करने वाली एक वस्तु प्राप्त करने के लिए, आपको उस फ़ंक्शन को कुछ मापदंडों के साथ कॉल करना होगा। तो आपको क्या लगता है, जब आप घुमाने की कोशिश करते हैं Rectangle? इस:

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

लंबाई 22 स्निपेट

30~ElementData~"Color"

निर्मित *Dataकार्यों का एक और । हां, रासायनिक तत्वों के लिए, आपको उनके परमाणु संख्या, गलनांक और नाम जैसी चीजें नहीं मिलती हैं ... आप वास्तव में कमरे के तापमान पर अपना रंग प्राप्त कर सकते हैं। उपरोक्त जस्ता का रंग देता है:

SlateGray

लंबाई 21 स्निपेट

Integrate[E^(-x^2),x]

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

1/2 Sqrt[π] Erf[x]

लंबाई 20 स्निपेट

"Sun"~StarData~"Age"

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

अरे हाँ, और क्या मैंने उल्लेख किया है कि गणितज्ञ (9 के बाद से) इकाइयों के साथ मात्रा का समर्थन करता है? (उस पर बाद में और अधिक।) उपरोक्त का मूल्यांकन:

Quantity[4.57*10^9, "Years"]

जो के रूप में प्रदर्शित है

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

लंबाई 19 स्निपेट

MandelbrotSetPlot[]

हाँ ... बहुत उपयोगी कार्य ... मैं इसे हर समय उपयोग करता हूं । (कभी-कभी, कुछ भी समर्थन करने की उनकी इच्छा, जो संभवतः कम्प्यूटेशनल है, थोड़ी दूर जा सकती है ...)

गणितज्ञ ग्राफिक्स

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

लंबाई 18 स्निपेट

PetersenGraph[7,2]

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

गणितज्ञ ग्राफिक्स

लंबाई 17 स्निपेट

Plot[x^x,{x,0,2}]

अंत में कुछ प्लॉटिंग करने के लिए पर्याप्त वर्ण। उपरोक्त वास्तव में एक आयामी कथानक का सबसे सरल उदाहरण है। मैं बाद में कूलर भूखंड दिखाने का वादा करता हूं

गणितज्ञ ग्राफिक्स

लंबाई 15 स्निपेट

{##4,#,#2,#3}&

यह दो और अधिक शक्तिशाली विशेषताओं (और गोल्फ के लिए भी उपयोगी) को दर्शाता है। पूरी बात एक अनाम शुद्ध कार्य है , जो lambdaपायथन में s के साथ तुलनीय है , या Ruby में Procs है। शुद्ध कार्य केवल एक द्वारा समाप्त किया जाता है &। इस ऑपरेटर की बहुत कम पूर्ववर्तीता है, ताकि इसमें आमतौर पर इसमें बची लगभग सभी चीजें शामिल हों। एक शुद्ध कार्य के तर्कों को #कभी-कभी अन्य चीजों के साथ संदर्भित किया जाता है। पहला तर्क है #या #1, दूसरा है #2, और इसी तरह।

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

f[1,2,3,4,5]

हमें मिलेगा

{4,5,1,2,3}

इसलिए फ़ंक्शन इनपुट तर्कों को बाईं ओर 3 तत्वों को घुमाता है। ध्यान दें कि ##4जिसे संदर्भित किया 4,5गया था उसे सूची में समतल कर दिया गया था।

लंबाई 12 स्निपेट

D[x^y^x,x,y]

आंशिक भेदभाव। Dपरिणाम के रूप में एक प्रतीकात्मक अभिव्यक्ति देते हुए, इसके अन्य तर्कों के संबंध में क्रमिक रूप से पहली अभिव्यक्ति को अलग करेगा। तो ऊपर d the है (x ^ y ^ x) / dxdy (जहाँ d आंशिक हैं), जो गणितज्ञ होने की रिपोर्ट करते हैं

x^y^x (y^(-1 + x) + y^(-1 + x) Log[x] + x y^(-1 + x) Log[x] Log[y]) + 
  x^(1 + y^x) y^(-1 + x) Log[x] (y^x/x + y^x Log[x] Log[y])

लंबाई 9 स्निपेट

Exp[I*Pi]

हमने अभी तक कोई जटिल अंकगणित नहीं किया है! जैसा कि आप देख सकते हैं, πवास्तव में सिर्फ एक उपनाम था Pi। वैसे भी, उपरोक्त वास्तव में पूर्णांक को सही ढंग से लौटाएगा -1

लंबाई 8 स्निपेट

Sunset[]

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

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

लंबाई 7 स्निपेट

9!/43!!

यह स्निपेट कुछ शांत चीजों को दिखाता है।

मैथेमेटिका में केवल एक बिल्ट-इन फैक्टोरियल ऑपरेटर नहीं होता है !, इसमें एक डबल फैक्टरियल भी होता है !!(जो nनीचे से हर दूसरे नंबर को गुणा करता है 1)। इसके अलावा, यह मनमाना-सटीक पूर्णांक का समर्थन करता है। 43!!वास्तव में मूल्यांकन किया जाएगा, पिछले अंक के लिए नीचे। इसके अलावा, तर्कसंगत संख्याओं का भी सटीक मूल्यांकन किया जाएगा। इसलिए, जब से अंश और हर दोनों पूर्णांक होते हैं, तो गणितज्ञ जहाँ तक संभव हो सके अंशों को कम कर देगा और फिर आपके साथ उपस्थित होगा

128/198893132162463319205625

बेशक, आप जब चाहें फ्लोट्स का उपयोग कर सकते हैं, लेकिन सामान्य तौर पर, यदि आपके इनपुट में फ्लोट्स नहीं हैं, तो आपका परिणाम सटीक होगा।

लंबाई 4 स्निपेट

Here

यह उस समय की बात है जब हमने मैथेमेटिका की क्रेजी बिल्ट-इन की शुरुआत की थी। ऊपर वह करता है जो यह टिन पर कहता है और (मेरे लिए) मूल्यांकन करता है GeoPosition[{51.51, -0.09}]

लंबाई 3 स्निपेट

x-x

बस मूल फैक्टॉइड को दिखाने के लिए : उपरोक्त कार्य भले ही xअभी तक परिभाषित नहीं किए गए हैं और वास्तव 0में उस मामले में परिणाम होंगे ।

लंबाई 2 स्निपेट

3x

Juxtaposition के माध्यम से गुणा! यदि यह स्पष्ट है कि एक पहचानकर्ता समाप्त हो जाता है और दूसरा शुरू होता है, तो आपको *उन्हें एक साथ गुणा करने के लिए व्हाट्सएप की भी आवश्यकता नहीं है । यह बहुत अधिक सब कुछ के साथ काम करता है, जिसमें तार और चर शामिल हैं जिनके मूल्य अभी तक नहीं हैं। गोल्फ के लिए बहुत सुविधाजनक है। ;)

लंबाई 1 स्निपेट

π

लगता है क्या, यह पाई है। और वास्तव में, यह कुछ अनुमानित फ्लोटिंग-पॉइंट प्रतिनिधित्व नहीं है, यह बिल्कुल पीआई है - इसलिए सभी प्रकार के जटिल और त्रिकोणमितीय कार्यों का उपयोग किया जाता है, यदि वे ज्ञात हैं तो सटीक परिणाम प्राप्त करेंगे।

factoid

गणितज्ञ प्रतीकात्मक हेरफेर कर सकते हैं, इसलिए चर को उनके साथ काम करने के लिए मूल्यों की आवश्यकता नहीं है।


19
स्निपेट 23 काफी उत्सुक है। यदि आपने किया Translate[Scale[Rectangle, 80], {0, 0, 100}]तो Rectangleआपके मॉनिटर के सामने विशाल शब्द तैरता हुआ दिखाई देगा?
केल्विन के

53
@ केल्विन हॉबीज ने इसे आजमाया ... एक दुर्भाग्यपूर्ण zऑफसेट उठाया ... मुझे सही चेहरे पर स्मैक दी।
मार्टिन एंडर

45
आधिकारिक गणितज्ञ वेबसाइट को इस से बिल्कुल लिंक होना चाहिए।
कारिडोरक

7
@ durron597 इसे एक प्रतीक के रूप में रखकर और अपने सभी त्रिकोणमितीय और जटिल कार्यों को एक By के साथ क्या करना है, इसके बारे में जागरूक करना।
मार्टिन एंडर

16
एक बार जब मैंने देखा कि महान मार्टिन बंटनर ने एक गणितज्ञ उत्तर पोस्ट किया है, तो मुझे पता था कि मेरे पास लोकप्रियता प्रतियोगिता जीतने का कोई मौका नहीं था। आप सर एक सच्चे जादूगर हैं।
एलेक्स ए।

187

बदनाम शेक्सपियर प्रोग्रामिंग भाषा

शेक्सपियर प्रोग्रामिंग लैंग्वेज को 2001 में दो स्वीडिश छात्रों, कार्ल हैसेलस्ट्रॉम और जॉन itslund द्वारा बनाया गया था, और इसे जोड़ती है, जैसा कि लेखक घोषणा करते हैं ,

विधानसभा भाषा के उपयोगकर्ता-मित्रता के साथ BASIC की अभिव्यक्ति।

उत्तर ऊपर से नीचे की ओर जाते हैं। इसके अलावा, यह मुझे पुराने या पिछले स्निपेट के संदर्भ में देखने के लिए सामान्य है।

( खुद के लिए लिंक: संपादित करें )

factoid:

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

लंबाई 1 स्निपेट:

I

शेक्सपियर के कोड को अधिनियमों में विभाजित किया गया है, और कृत्यों को "जंप-टू" कारण के लिए दृश्यों में विभाजित किया गया है। एक अधिनियम को परिभाषित करने का Act Iअर्थ है कि यह चलने वाला कोड का पहला भाग होगा, प्रति उदाहरण - लेकिन न केवल।

लंबाई 2 स्निपेट:

as

दो "वर्णों" के बीच तुलनात्मक रूप से प्रयुक्त।

लंबाई 3 स्निपेट:

day

अब तक, आप महसूस कर रहे होंगे कि एसपीएल बहुत ही क्रियात्मक है। और अजीब है। और आपने अभी तक कुछ भी नहीं देखा है। day, SPL में, 1. सभी "सकारात्मक" और "तटस्थ" संज्ञाओं को माना जाता है 1, साथ ही साथ सभी "नकारात्मक" वाले होते हैं -1

लंबाई 4 स्निपेट:

rich

क्या है rich? एक विशेषण। एसपीएल में, विशेषण उन संज्ञाओं का मूल्य बनाते हैं जिन्हें वे दो से गुणा करते हैं। स्निपेट 14 पर कार्यान्वयन देखें।

लंबाई 5 स्निपेट:

Act I

पहले स्निपेट का कार्यान्वयन। सभी कार्यों को एक शीर्षक दिया जा सकता है, जैसे Act I: Hamlet must die!कि रोमन अंक के बाद सब कुछ पार्सर द्वारा अनदेखा किया जाता है।

लंबाई 6 स्निपेट:

better

हर भाषा में स्थितियां होती हैं, और SPL कोई अपवाद नहीं है। सिवाय, चूंकि यह एक लंबी वाक्य रचना वाली भाषा है (और क्या मैंने इसे अजीब होने का उल्लेख किया है?), इसके सशर्त बयान लंबे होने वाले हैं। बीत रहा है ओफेलिया जूलियट पूछना Am I better than you?होने की तरह है if (Ophelia > Juliet)सबसे "सामान्य" भाषाओं पर। और, ज़ाहिर है, आप दूसरे तरीके से पूछ सकते हैं: Am I not better than you?के बराबर है if (Ophelia < Juliet)। और आप पहले से ही अनुमान लगा सकते हैं कि =एसपीएल का अनुवाद कैसे किया जाता है: as good as- कोड स्निपेट 2 का उपयोग।

हालांकि, good/betterइस शेक्सपियरियन भाषा में तुलना करने का एकमात्र तरीका नहीं है, आप किसी भी विशेषण का उपयोग कर सकते हैं। स्निपेट 3 का एक ही सिद्धांत यहां भी लागू होता है, जिसमें "सकारात्मक" विशेषण का मूल्य होता है >, जबकि "नकारात्मक" का अर्थ होता है <

लंबाई 7 स्निपेट:

Juliet:

यह एक चर का आह्वान है; इसके बाद, उसकी / उसके निर्देशों / घोषणाओं / जो भी पालन करेंगे।

एसपीएल की एक सीमा यह है कि इसमें सीमित संख्या में चर होते हैं: रोमियो, जूलियट, हेमलेट, ओफेलिया, मैकबेथ और इसी तरह "वर्ण" के कुछ उदाहरण हैं जो शेक्सपियरियन कार्यक्रम पर दिखाई देंगे।

लंबाई 8 स्निपेट:

[Exeunt]

[Exeunt]रखा जाता है जब सभी "वर्ण" "चरण" छोड़ देते हैं। उम्मीद है कि मैं पात्रों के बीच बातचीत के बारे में थोड़ा और विस्तार से बता सकता हूं। आम तौर पर किसी भी एसपीएल कार्यक्रम का अंतिम निर्देश होता है, हालांकि[Exeunt] विशेष रूप से भाषा का टर्मिनल "चरित्र" नहीं है। एक अन्य उदाहरण के लिए, स्निपेट 27 देखें।

लंबाई 9 स्निपेट:

as bad as

सिर्फ एक चरित्र का प्रतिनिधित्व करने के लिए नौ वर्ण = - स्निपेट का उपयोग हुए 2. क्या मैंने उल्लेख किया है कि एसपीएल अजीब है? उदाहरण के लिए स्निपेट 30 देखें। (और हाँ, इसका उत्पादन करने का एक से अधिक तरीका है)

लंबाई 10 स्निपेट:

difference

प्रतिनिधित्व करने का एक फैंसी तरीका -, एक घटाव। SPL पर आपके पास गणित का संचालन हो सकता है, भले ही आपको इसे सही करने के लिए पूरे दिन की आवश्यकता होगी।

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

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

SPL कोड चलाने के लिए एक और साइट यह है Oracle PL / SQL: कि आंतरिक रूप से एक और गूढ़ भाषा को एसपीएल कोड का अनुवाद कार्य करती है।

लंबाई 11 स्निपेट:

[Exit Romeo]

हाँ! अंत में मैं पात्रों के बीच बातचीत के बारे में बात कर सकता हूं! अपने मूल्य को बदलने या दूसरों के साथ बातचीत करने के लिए, एक "चरित्र" मंच पर होना चाहिए - साथ प्रवेश करना [Enter Romeo]। यदि एक चरित्र को संबोधित किया गया है, लेकिन मौजूद नहीं है, तो एक रनटाइम त्रुटि है और प्रोग्राम बंद हो जाता है। क्योंकि, SPL में, चर का मान उन नामों की मात्रा द्वारा निर्धारित किया जाता है जिनकी वे मंच पर अन्य वर्णों के साथ - या - के साथ प्रशंसा करते हैं। मुझे लगता है कि मुझे कुछ भ्रम को दूर करने के लिए एक उदाहरण रखना चाहिए जिससे मेरा लंगड़ा स्पष्टीकरण हो सकता है, लेकिन शायद यह सबसे अच्छा है कि कुछ स्निपेट में देरी हो।

लंबाई 12 स्निपेट:

Remember me.

एसपीएल सुंदर "बुनियादी" है, ठीक है - लेकिन इसमें ढेर हैं! जब उदाहरण के लिए, रोमियो जूलियट को "उसे याद रखना" बताता है, तो वह वास्तव में अपने प्रियजन को रोमियो के मूल्य को उसके ढेर में धकेलने के लिए कह रहा है। मान को रोकना Recall your happy childhood!या Recall your love for me, या मूल रूप से किसी भी वाक्य से शुरू होता हैRecall - बाकी सिर्फ कलात्मक ड्राइवल है, जैसे स्निपेट 22।

लंबाई 13 स्निपेट

Let us return

शेक्सपियरियन रास्ता होने का एक goto। और यह वह जगह है जहाँ अधिनियम और दृश्य काम आते हैं। अगर रोमियो जूलियट को बताता हैwe shall return to Act II (हां, फिर से, इसे लिखने के कई तरीके हैं), तो प्रोग्राम कोड के उस विशिष्ट हिस्से पर कूद जाएगा। इसे सशर्त बयानों के साथ भी देखा जाता है।

लंबाई 14 स्निपेट

my little pony

हां, यह 80 के दशक में एक श्रृंखला थी। यहाँ, यह है 2*1। क्यों? क्योंकि एक pony(कुछ) सकारात्मक संज्ञा है और littleएक विशेषण है। इसलिए, स्निपेट्स 3 और 4 को याद करते हुए, हमारे पास little = "2 *"और हैpony = "1"

लंबाई 15 स्निपेट

Speak thy mind!

SPL प्रोग्राम में, आप इसे (या Speak your mind!, जो समान है) बहुत कुछ देखेंगे । यह मूल रूप से आपके कंप्यूटर द्वारा उपयोग किए जा रहे चरित्र सेट के आधार पर, अंक, पत्र या किसी अन्य चीज़ में प्रत्येक "वर्ण" के मूल्य को आउटपुट करता है। वहाँ भी है Open your mind.कि लगभग एक ही काम करता है, यद्यपि केवल संख्यात्मक रूप में outputting।

लंबाई 16 स्निपेट

You are nothing!

जब कोई आपको वास्तविक जीवन में यह बताता है, तो आप उदास महसूस करेंगे। जब ओफेलिया इसे शेक्सपियरियन प्रोग्रामिंग में हेमलेट को बताता है, तो हेमलेट बेकार महसूस करता है। इसका क्या मतलब है? वह Hamlet = 0

लंबाई 17 स्निपेट

Ophelia, a wench.

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

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

लंबाई 18 स्निपेट

lying sorry coward

-4सभी सांसारिक जीवों के लिए। क्यों? क्योंकि 2*2*(-1) = -4

लंबाई 19 स्निपेट

Romeo:
 Remember me.

अंत में!!! मैं अंत में एक पूर्ण सही वाक्यविन्यास निर्देश का उत्पादन कर सकता हूं (भले ही संक्षिप्त रूप से)! इस तरह से आप स्निपेट 12 का उपयोग करते हैं: सबसे पहले आप घोषणा करते हैं कि कौन किसकी बात कर रहा है, फिर अगली पंक्ति में आप "संवाद" लिखते हैं। आम तौर पर, केवल दो "पात्र" मंच पर होते हैं, ताकि पार्सर को दुखी और भ्रमित न किया जा सके। जब आपको एक और "चरित्र" की आवश्यकता होती है, तो आप मंच से एक लेते हैं और उसे नए द्वारा प्रतिस्थापित करते हैं।

लंबाई 20 स्निपेट

cube of thy codpiece

मैं इस एक के लिए थोड़ा और विस्तृत करना चाहता था, लेकिन, सच कहा जाए, तो मैं जिन चीजों के साथ आता हूं, वे अभी भी इस स्निपेट की लंबाई के लिए बहुत कम हैं। और, इसलिए, मैं आपको यह लाता हूं, जो समाप्त हो रहा है -1- क्योंकि (-1) 3 = -1 (और codpiece"नकारात्मक" संज्ञा है, क्योंकि वे असहज और सभी हैं)। एसपीएल कुछ अधिक विस्तृत अंकगणित संचालन को कुछ घातांक और वर्गमूल के रूप में समझता है ।

फैक्टॉइड (अभी तक एक और एक, क्योंकि हम एक और मील के पत्थर तक पहुँच चुके हैं)

शेक्सपियरियन में "हैलो वर्ल्ड प्रोग्राम" में 89 लाइनें और 2400 से अधिक वर्ण हैं, जैसा कि यहां देखा गया है

लंबाई 21 स्निपेट

Listen to your heart.

स्निपेट 15 में आपने कुछ आउटपुट किया; यहां, आप प्रोग्राम के लिए एक नंबर इनपुट करते हैं। यदि आप एक वर्ण इनपुट करना चाहते हैं, तो आप Open your mind.इसके बजाय उपयोग करेंगे । और, कहने की जरूरत नहीं है, यह मूल्य "चरित्र" में बोला जा रहा है।

लंबाई 22 स्निपेट

Recall your childhood!

स्टैक से पूर्णांक को रोकना इसके साथ किया जाता है, जैसा कि स्निपेट 12 पर समझाया गया है। उदाहरण के अनुसार, ओफेलिया हेमलेट को उपरोक्त वाक्य बताता है, यह हेमलेट को अपने स्टैक से पूर्णांक लेने और उस मान को मानने का कारण बनता है।

बेशक, जब तक यह शब्द recallवाक्य शुरू कर रहा है, तब तक आप अपने रचनात्मक शेक्सपियर की इच्छाओं को पूरा करने के लिए बहुत कुछ कर सकते हैं।

लंबाई 23 स्निपेट

Are you better than me?

स्निपेट का कार्यान्वयन 6. जब एक "चरित्र" दूसरे से इस तरह का सवाल करता है, तो वह जो कर रहा है वह if (x > y)अधिक सामान्य प्रोग्रामिंग भाषाओं के बराबर है । इस निर्देश के पालन में विलंब होना चाहिए, जब तक कि मेरे पास अधिक पात्र उपलब्ध न हों।

लंबाई 24 स्निपेट

[Enter Romeo and Juliet]

हां, "वर्ण" जोड़े में प्रवेश कर सकते हैं। एक "चरित्र" के लिए मंच में प्रवेश करना आवश्यक नहीं है, दूसरे द्वारा पीछा किया जा रहा है।

लंबाई 25 स्निपेट

remainder of the quotient

25 अक्षर सिर्फ लिखने के लिए %। एक विभाजन के शेष 25 वर्ण। और इसका उपयोग करने के लिए? खैर, यह और भी बड़ा है - स्निपेट 75 देखें।

लंबाई 26 स्निपेट

Let us return to scene II.

यहाँ यह gotoएसपीएल में है, जो एक प्रोग्रामिंग भाषा में अपेक्षा के अनुसार काम करता है। एक बात यह है: आप एक ही अधिनियम में दृश्यों के बीच, और कृत्यों के बीच कूद सकते हैं; लेकिन आप अलग-अलग कामों में दृश्यों के बीच नहीं कूद सकते।

लंबाई 27 स्निपेट

[Exeunt Ophelia and Hamlet]

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

लंबाई 28 स्निपेट

Scene I: Ophelia's flattery.

एक घोषणा की। जैसा कि आप पहले से ही उम्मीद कर सकते हैं कि आप मेरे साथ मुकाबला कर रहे हैं, महत्वपूर्ण बिट हैScene I , बाकी कलात्मक फुलाना है।

कुछ संकलक बनाए गए हैं (जैसे कि यह SPL से C तक संकलित है, जो पायथन में लिखा गया है ) जो इसके बजाय अधिनियम / दृश्य की संख्या के बाद पाठ को संदर्भित करता है। जबकि अधिक तार्किक (सब के बाद, एक नाटक के दौरान, पात्रों को यह कहते हुए लाइनें "जैसे हम एक्ट आई पर लौटते हैं" को मूर्खतापूर्ण समझा जा सकता है), मैं मूल तरीके से चिपका रहा हूं।

लंबाई 29 स्निपेट

You pretty little warm thing!

हां, अभी तक एक और स्थिर (चूंकि हमें अंकगणित संचालन के लिए अधिक पात्रों की आवश्यकता है )। यह एक के बराबर है 8, क्योंकि 2*2*2*1 = 8

लंबाई 30 स्निपेट

You are as cowardly as Hamlet!

उदाहरण के लिए, रोमियो का कहना है कि इसका मतलब है Romeo = Hamlet। जैसे स्निपेट 9।

फैक्टॉइड (हाँ, एक और मील का पत्थर पहुंच गया!)

यह भाषा एक सिंटैक्स विश्लेषण पाठ्यक्रम में असाइनमेंट के लिए बनाई गई थी - इस प्रकार, लेखकों द्वारा कोई एसपीएल संकलक नहीं बनाया गया था। अधिक: ऐसा लगता है कि एसपीएल के लेखकों ने अपनी रचना के साथ अपने संबंधों को तोड़ दिया है, क्योंकि 2001 के बाद से भाषा में कुछ भी संशोधित नहीं हुआ है ...

लंबाई 31 स्निपेट

Am I as horrid as a flirt-gill?

हां, मुझे पता है, यह कुछ हद तक स्निपेट 23 को दोहरा रहा है, हालांकि, यहां, हम "चरित्र" की तुलना कर रहे हैं जो "इश्कबाज-गिल" (यदि आप चाहें, तो if (Ophelia == -1)) के साथ बोलते हैं । बात है...

लंबाई 32 स्निपेट

If so, let us return to scene I.

... अब मैं thenSPL, और सशर्त कूदने के लिए और छोरों को लागू करने का शेक्सपियरियन तरीका पेश कर सकता हूं । उदाहरण के लिए, आप रोमियो को मान दे सकते हैं, 0किसी अन्य कार्य को करते समय उसके मूल्य में वृद्धि कर सकते हैं और जब वह 10 तक पहुँचता है तो रुक जाता है, बाद में कार्यक्रम के साथ आगे बढ़ता है।

लंबाई 33 स्निपेट

If not, let us return to scene I.

बस एक चेतावनी है कि, इसके बजाय, हम एक और दृश्य के लिए आगे बढ़ सकते हैं यदि हम जिस स्थिति के लिए परीक्षण करते हैं वह गलत है

लंबाई 34 स्निपेट

Open your mind! Remember yourself.

एक पंक्ति में दो निर्देश, यिप्पी! पहला एक पात्र पढ़ता है, दूसरा उसे दूसरे पात्र की मेमोरी स्टैक में धकेल देता है।

लंबाई 35 स्निपेट

Act I: Death!

Scene I: Oh, shit.

अधिनियम और दृश्य घोषित करने का उचित तरीका। स्वाद से कलात्मक फल जोड़ें।

लंबाई 36 स्निपेट

Thou art as sweet as a summer's day!

यह कहने का एक और तरीका है कि "चरित्र" जिस पर बात की जा रही है वह मूल्य प्राप्त करेगा 1- क्योंकि गर्मी के दिन अच्छे और सुखद होते हैं।

लंबाई 37 स्निपेट

Art thou more cunning than the Ghost?

ओफेलिया ने हेमलेट से यह सवाल पूछा, इसका मतलब यह है कि इसे कम पठनीय प्रोग्रामिंग भाषा में अनुवाद किया जाए if (Hamlet > the Ghost)। यह 23 से अधिक बार स्निपेट है, हाँ - लेकिन यह आपको यह दिखाने के लिए जाता है कि "वर्ण" पूछने की आवश्यकता नहीं है यदि वे एक-दूसरे से बेहतर हैं: कोई अन्य प्रश्न भी काम करेगा।

लंबाई 38 स्निपेट

[Enter the Ghost, Romeo and the Ghost]

हां, मैं दो बार एक "चरित्र" कह रहा हूं - क्योंकि मैं चाहता था कि कार्यक्रम मुझे एक त्रुटि दे। एक "चरित्र" को कॉल करना जो पहले से ही मंच पर है, या एक को बताने के लिए जो बाहर निकलने के लिए अनुपस्थित है, पार्सर / कंपाइलर के लिए बहुत दुख का कारण होगा।

लंबाई 39 स्निपेट

the sum of a fat lazy pig and yourself!

पूर्ण निर्देश अधिक बेहतर है कि यह देखकर, मैं आपको वह देता हूं, लेकिन ... यहां हमारा पहला अंकगणितीय ऑपरेशन है! वास्तव में इसका क्या मतलब है? खैर, pigएक गंदा जानवर है (यद्यपि स्वादिष्ट), इसलिए यह इसके बराबर है -1, इसमें दो विशेषण हैं, जिसका अर्थ है fat lazy pigसमान 2*2*(-1) = -4। लेकिन इससे क्या yourself? यह एक रिफ्लेक्टिव सर्वनाम है, न नाम और न ही विशेषण। खैर, याद रखें कि एसपीएल "पात्रों" के बीच संवाद पर आधारित है; इस प्रकार, yourselfमंच पर अन्य "चरित्र" को संदर्भित करता है। तो, हम अंत में पहुंचते हैं और हमें पता चलता है कि "एक मोटा आलसी सुअर और खुद का योग" वास्तव में है -4 + x

लंबाई 40 स्निपेट

the sum of a squirrel and a white horse.

हां, एक और राशि, लेकिन यह एक स्निपेट 39 की तुलना में सरल है। यह केवल है 1 + 2- 3अगर मेरा गणित सही है।

फैक्टॉइड (कलात्मक फुलाने के इन चालीस स्निपेट के बाद भी मेरे साथ? आप एक पुरस्कार के पात्र हैं।)

SPL, इसके संस्करण 1.2.1 में, यहाँ डाउनलोड किया जा सकता है

लंबाई 41 स्निपेट

Juliet:
 Speak thy mind!

[Exit Romeo]

कभी-कभी, "वर्णों" को केवल मंच पर बुलाया जाता है ताकि उनका मूल्य बदल जाए - जो कि एक वास्तविक नाटक पर, कुछ विचित्र होगा। वैसे भी, यहाँ, जूलियट अपने प्रिय रोमियो को अपने संग्रहीत मूल्य का प्रिंट देता है, जिसके बाद वह मंच से बाहर निकलता है।

लंबाई 42 स्निपेट

Speak YOUR mind! You are as bad as Hamlet!

एक लाइन में फिर से दो निर्देश (हम कई हो सकते हैं, लेकिन स्निपेट लंबाई इसे अभी तक अनुमति नहीं देती है); यहां हमारे पास एक "चरित्र" है जो दूसरे को उसके मूल्य को आउटपुट करने के लिए कह रहा है और मान लें कि हैमलेट का मूल्य क्या है। भ्रामक? Mayhap।

लंबाई 43 स्निपेट

Am I as horrid as a half-witted flirt-gill?

जूलियट ने पूछा कि इसका मतलब यह नहीं है कि उसके पास कम-सम्मान है (हालांकि यह वास्तविक जीवन में हो सकता है); यह if23 और 37 स्निपेट की तरह बस एक और है। ओह, मैं लगभग भूल गया: यह करने के लिए अनुवाद if (Juliet == -2)

लंबाई 44 स्निपेट

You are as evil as the square root of Romeo!

हाँ, वर्गमूल बुराई हैं, क्या आप नहीं जानते? वैसे भी, यह निर्देश सीधा समझने के लिए पर्याप्त है कि यह क्या करता है: रोमियो में संग्रहीत मूल्य के वर्गमूल के मूल्य के लिए बोले जा रहे "चरित्र" को विशेषता देता है।

लंबाई 45 स्निपेट

Hamlet:
 Art thou more cunning than the Ghost?

स्निपेट 37 ठीक से चरित्र के साथ लिखा गया है जो लाइन बोल रहा है।

लंबाई 46 स्निपेट

the product of a rural town and my rich purse.

ठीक है ... वैसे भी, एसपीएल दुनिया की एकमात्र भाषा हो सकती है जो आपको पर्स के साथ शहरों को गुणा करने की अनुमति देती है। इसका मतलब यह है (2*1)*(2*1)कि, अगर मैं बहुत गलत नहीं हूं, तो इसके बराबर है 4

लंबाई 47 स्निपेट

Romeo:
 Speak your mind.

Juliet:
 Speak YOUR mind!

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

लंबाई 48 स्निपेट

You lying fatherless useless half-witted coward!

यह सीधे अनुवाद कर रहा है, 2*2*2*2*(-1)-16, सही?

लंबाई 49 स्निपेट

Scene V: Closure.

Hamlet:
 Speak your mind!

[Exeunt]

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

लंबाई 50 स्निपेट

Othello, a young squire.
Lady Macbeth, an old fart.

अधिक "चरित्र" प्रस्तुति, उचित निर्देशों से पहले। हमेशा की तरह, केवल एक चीज जो संकलक के लिए मायने रखती है Othelloऔर हैLady Macbeth , इसलिए बाकी की लाइन कब्रों के लिए है ...

एक और बात: एसपीएल कार्यक्रम में प्रदर्शित होने के लिए "वर्णों" को एक-दूसरे से संबंधित नहीं होना पड़ता है - इसलिए आपके पास एक ही नाटक में रोमियो, ओथेलो और हेमलेट हो सकते हैं।

फैक्टॉइड (इन चीजों की आधी सदी? काहे! इसके बाद मुझे लगता है कि मैं विलियम शेक्सपियर से घृणा करने जा रहा हूं ...)

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

लंबाई 51 स्निपेट

Othello:
 Recall your great dreams. Speak your mind!

(रोमियो, जूलियट और हेमलेट के बीमार ... चलो एक बदलाव के लिए ओथेलो में ले आओ!)

Recall, जैसा कि आप अनुमान लगा सकते हैं, यहाँ कुंजी है। "चरित्र" ओथेलो संबोधित कर रहा है, उसके / उसके ढेर से एक मूल्य लेगा, मान और उसके बाद, इसे आउटपुट करेगा।

लंबाई 52 स्निपेट

Thou art as pretty as the sum of thyself and my dog!

एक और राशि। जम्हाई। यह मानकर कि हेमलेट को संबोधित किया जाता है, इसका मतलब है कि Hamlet = Hamlet + 1। या Hamlet += 1। या Hamlet++

लंबाई 53 स्निपेट

Romeo:
 You are as vile as the sum of me and yourself!

आह, हाँ, कुछ जिसे मैं पहले उल्लेख करना भूल गया था: बोलने वाले "वर्ण" खुद की तर्ज पर खुद का उल्लेख कर सकते हैं।

लंबाई 54 स्निपेट

Juliet:
 Is the sum of Romeo and me as good as nothing?

एक स्थिति में शामिल पिछली स्निपेट का एक और उदाहरण। तो हमारे पास यहां क्या है if (Romeo + Juliet == 0)

लंबाई 55 स्निपेट

Juliet:
 You are as lovely as the sweetest reddest rose.

तो, यहाँ, जूलियट "शेक्सपियर की खातिर (यह मान लें कि यह रोमियो है, मान लें) की प्रशंसा कर रहा है, यह घोषणा करते हुए कि वह 4. वह है। हां, मूल्यों का एक और काम है।

लंबाई 56 स्निपेट

Othello:
 You lying fatherless useless half-witted coward!

स्निपेट 48 ठीक से, एक "चरित्र" के साथ। यदि आप स्क्रॉल करने के लिए बहुत आलसी हैं (जैसे मैं होगा), इसका मतलब है कि अपमान किया जा रहा मूल्य -16 प्राप्त कर रहा है।

लंबाई 57 स्निपेट

Romeo:
 If not, let us return to Act I. Recall thy riches!

मैं पहले ही बता चुका हूं कि एसपीएल सामान्य स्थिति में कैसे काम करता है; हालाँकि, अधिक इनलाइन विश्लेषण की आवश्यकता है। हमारे पास यहां नहीं है else: प्रति उदाहरण, इस उदाहरण में, यदि स्थिति विफल हो जाती है, तो कार्यक्रम अधिनियम I में वापस आ जाएगा; लेकिन अगर यह सच था, तो यह अगले निर्देश तक जारी रहेगा, जो कि एक है Recall- स्टैक से एक पॉप, अर्थात्।

लंबाई 58 स्निपेट

Romeo:
 You are as disgusting as the square root of Juliet!

स्निपेट 44 को हथियाने और निर्देश को कैसे प्रस्तुत किया जाना चाहिए। यदि यह रोमियो और ओथेलो के बीच एक संवाद था, तो हम इसे जावा में अनुवाद कर सकते हैं Othello = Math.sqrt(Juliet)

लंबाई 59 स्निपेट

Othello:
 You are as vile as the sum of yourself and a toad!

ठीक है, अगर ओथेलो रोमियो से बात कर रहा है, तो यह इसके बराबर होगा Romeo+(-1); Romeo--, छोटे के लिए। सुंदर बुनियादी, सही? वह आपके लिए एसपीएल है।

लंबाई 60 स्निपेट

Is the quotient between the Ghost and me as good as nothing?

संक्षेप में, if (The Ghost/Hamlet == 0)"मुझे" मान लेना हेमलेट का है।

लंबाई 61 स्निपेट

Thou art as handsome as the sum of yourself and my chihuahua!

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

लंबाई 62 स्निपेट

twice the difference between a mistletoe and a oozing blister!

हां, हां, अधिक अंकगणितीय ऑपरेशन। मोटे तौर पर, एसपीएल के इन 62 बाइट्स का अनुवाद किया जा सकता है2*(1-2*(-1)) । यह एक बहुत बढ़िया गोल्फ भाषा होगी, है ना? सही।

लंबाई 63 स्निपेट

You lying stupid fatherless rotten stinking half-witted coward!

स्निपेट 48 आउटपुट -16, यह एक -64 के बराबर है: 2*2*2*2*2*2*(-1) :।

लंबाई 64 स्निपेट

your coward sorry little stuffed misused dusty oozing rotten sky

एसपीएल के बारे में मुझे जो समझ है, वह पूरी तरह से वैध है। आपके पास अपमानजनक विशेषणों की एक पूरी बहुत कुछ है जो "सकारात्मक" संज्ञा को आगे बढ़ाते हैं। चूंकि विशेषणों में कोई विशेष अंतर नहीं है कि वे नकारात्मक हैं या नहीं (उनका एकमात्र मूल्य उनके दाईं ओर संख्या को दो से गुणा कर रहा है), हम इस तरह पूरी तरह से मूर्खतापूर्ण वाक्य रख सकते हैं। जो 256 के बराबर है 2*2*2*2*2*2*2*2*1=256। क्योंकि ।

लंबाई 65 स्निपेट

You are nothing! You are as vile as the sum of thyself and a pig.

हम्म, इतनी नफरत है, है ना? तो, हमारे यहाँ जो है वह बराबर है y=0; y=y+(-1);शायद "गोल्फ" हो सकता है You are a pig!, लेकिन हे।

लंबाई 66 स्निपेट

You are as beautiful as the difference between Juliet and thyself.

तो, अपने आप से जूलियट घटाना, हे? यह समझने के लिए बहुत सरल है:, Romeo=Juliet-Romeo;यह मानते हुए कि यह रोमियो है जो उससे बात कर रहा है।

लंबाई 67 स्निपेट

Juliet:
 Am I better than you?

Romeo:
 If so, let us proceed to Act V.

एसपीएल पर अधिकांश स्थितियां कैसे काम करती हैं। आप अभिव्यक्ति का परीक्षण करते हैं और, अगर यह सच है (या नहीं: स्निपेट 33 देखें), तो आप कार्यक्रम के दूसरे भाग में जाते हैं; अन्यथा, आप अगले वाक्य पर जारी रखेंगे।

लंबाई 68 स्निपेट

The Ghost:
 You are as small as the sum of yourself and a stone wall!

हां, हां, मैं थोड़ा नीरस हो रहा हूं। लेकिन एसपीएल ऐसा ही है। जैसा कि मैंने पहले कहा था, इसके भाव अंकगणितीय संचालन के मिश्रण हैं। इस प्रकार, यह अभी तक एक और वृद्धि है - तब सेstone wall एक तटस्थ "संज्ञा" है।

लंबाई 69 स्निपेट

Thou art as disgusting as the difference between Othello and thyself!

एक राशि के बजाय, हमारे पास दो पात्रों, ओथेलो और जो कोई भी बोला जा रहा है, के बीच घटाव है।

लंबाई 70 स्निपेट

You are as handsome as the sum of Romeo and his black lazy squirrel!

हम परिवर्धन पर लौटते हैं, हां - मुझे सूत्र कहते हैं, हे। हम इसका अनुवाद करते हैंRomeo + 2*2*1

लंबाई 71 स्निपेट

Scene I: Dialogues.

[Enter Juliet]

Othello:
 Speak your mind!

[Exit Juliet]

एक दृश्य इसके जितना छोटा हो सकता है। Julietमंच में प्रवेश करती है, ओथेलो उसे अपने संग्रहीत मूल्य का उत्पादन करने के लिए कहती है, फिर वह फिर से मंच पर पहुंच जाती है।

लंबाई 72 स्निपेट

twice the difference between a mistletoe and an oozing infected blister!

एक और अंकगणितीय ऑपरेशन - क्योंकि एसपीएल उनके साथ भरा हुआ है। हम इसका अनुवाद कर सकते हैं 2*(1-2*2*(-1))

लंबाई 73 स्निपेट

You are nothing! Remember me. Recall your unhappy story! Speak your mind!

एक पंक्ति में चार निर्देश ?! मुझे वास्तव में खुद पर काफी गर्व है। वैसे भी, मान लें कि यह रोमियो और जूलियट के बीच एक संवाद है (और वह बोल रहा है): इसका मतलब है कि जूलियट का मूल्य 0 से शुरू होता है; फिर, जूलियट रोमियो के मूल्य को उसकी मेमोरी के ढेर में धकेल देगा, इसे पॉप करेगा और इसे उसके प्रवेशित रूप में आउटपुट करेगा। सरल, सही?

लंबाई 74 स्निपेट

You are as sweet as the sum of the sum of Romeo and his horse and his cat!

हाँ, हाँ, उबाऊ उदाहरण, मुझे पता है। लेकिन यह है X = (Romeo + 1) + 1

लंबाई 75 स्निपेट

Is the remainder of the quotient between Othello and me as good as nothing?

खैर, यह बहुत सीधा है। यदि आपके डिकोडिंग कौशल में खराबी है, तो यह अनुवाद करता है if (Othello % X == 0)

लंबाई 76 स्निपेट

Thou art as rich as the sum of thyself and my dog! Let us return to scene I.

इससे पहले एक अभिव्यक्ति के साथ स्निपेट 26 से कूद। एक gotoएसपीएल पर हमेशा एक शर्त के पास पाया नहीं है, यह इस तरह से हो सकता है - और, जाहिर है, इस प्रकार की gotoहमेशा की तरह, एक अधिनियम या दृश्य के अंत में पाया जाएगा उसके बाद निर्देश के बाद से संकलित कभी नहीं की जाएगी / प्रदर्शन किया। पहला निर्देश बहुत सरल है x=x+1:।

लंबाई 77 स्निपेट

[Exit Hamlet]

[Enter Romeo]

Juliet:
 Open your heart.

[Exit Juliet]

[Enter Hamlet]

तो, हमारे पास जूलियट और हेमलेट मंच पर हैं; लेकिन हमें रोमियो से मूल्य की आवश्यकता है। इस प्रकार, कंपाइलर को बहुत बुरा सिरदर्द से दूर करने के लिए, सबसे पहले हम हैमलेट को स्टेज से हटाते हैं (हालाँकि यह जूलियट द गो टू गो हो सकता है), हम रोमियो को मंच पर लाने के लिए कहते हैं, जूलियट उसे आउटपुट देने का निर्देश देती है। संख्या (स्निपेट 21 की व्याख्या देखें), तब रोमियो मंच से बाहर निकलता है और हेमलेट लौट आता है। बहुत सीधा और सरल।

लंबाई 78 स्निपेट

The Ghost:
 Speak thy mind.

Lady Macbeth:
 Listen to thy heart! Remember thyself.

तो, द घोस्ट (हेमलेट के मृतक पिता) लेडी मैकबेथ को उसके मूल्य का उत्पादन करने के लिए कह रहे हैं, जबकि वह द घोस्ट को एक नंबर पढ़ने और उसे अपने ढेर में धकेलने का आदेश देती है।


32
यह अविश्वसनीय रूप से दिलचस्प है और आपकी प्रोफ़ाइल तस्वीर एकदम सही है, वह ठीक वैसी ही दिखती है जैसा मैं कल्पना करता हूं कि एक एसपीएल प्रोग्रामर कैसा दिखेगा।
ओवरएक्टर

3
@overactor मुझे पता नहीं है कि अपमान किया जा सकता है या एक Gumby की तरह गर्व किया जा सकता है। ^ _ ^
रोडोल्फो डायस

9
विचित्र रूप से यह उदाहरण पढ़ने के लिए सबसे अस्पष्ट नहीं है ... और "कम से कम व्यावहारिक" के लिए बंधा हुआ लगता है।
HRRambler

6
ROFL यहां +1 आपको रास्ते में मदद करने के लिए है - एक बार ब्रीच रोडोल्फो के लिए!
HRRambler

3
@RodolfoDias आप शुरू कर सकते हैं। मैं उन्हें देखने के लिए इंतजार कर रहा हूं। आपके पास 120 अप-वोट हैं।
भूत_न_थे_कोड

176

पीट

factoid

Piet एक प्रोग्रामिंग भाषा है जहाँ स्रोत कोड में चित्र होते हैं। कार्यक्रम का प्रवाह शीर्ष-बाएँ पिक्सेल से शुरू होता है और पिक्सेल और पिक्सेल समूहों के बीच छवि के चारों ओर चलता है जब तक कि यह समाप्त नहीं हो जाता।

पठनीयता के लिए, पीइट कार्यक्रम आमतौर पर एक बढ़े हुए संस्करण में प्रदर्शित होते हैं। ऐसी स्थिति में पदcodel का उपयोग समान-रंगीन पिक्सेल के समूह का वर्णन करने के लिए किया जाता है जो स्रोत छवि में एक व्यक्तिगत पिक्सेल के अनुरूप होता है।

इस चुनौती के लिए, चूंकि पीट पात्रों का उपयोग नहीं करता है, इसलिए नमूना कार्यक्रमों के लिए प्रति वोट एक कोडेल का उपयोग किया जाएगा।

1 कोडेल

1 कोडेल

यह एक वैध कार्यक्रम है, यह कुछ नहीं करता है और समाप्त करता है। नियंत्रण प्रवाह शीर्ष-बाएं (केवल) पिक्सेल में शुरू होता है और इसका कोई रास्ता नहीं है, जो कार्यक्रम को समाप्त करता है।

इस मामले में पिक्सेल सटीक समान प्रभाव के लिए कोई भी रंग हो सकता है।

2 कोडेल

2 कोडेल

यह स्टडिन के पात्रों को लगातार पढ़ेगा और उनके यूनिकोड मानों को चालू रखेगा (हालांकि इस कुल के साथ कुछ भी नहीं किया गया है और यह प्रदर्शित नहीं होता है)।

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

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

3 कोडेल

3 कोडेल

यह एक बुनियादी गूंज प्रकार का कार्यक्रम है, यह एक समय पर एक चरित्र को स्टड से पढ़ेगा और इसे प्रिंटआउट करेगा।

फिर से यह एक अनंत लूप है। कार्यक्रम बाएं से दाएं की यात्रा करके शुरू होता है, जो inputतब होता है output। जब भी यह कार्यक्रम एक ही दिशा में प्रवाहित होता रहेगा। हल्के हरे रंग के कोडेल में एकमात्र निकास दूसरे तरीके से आगे बढ़ना शुरू करना है। दाएं-बाएं घूमने पर यह प्रदर्शन करने का प्रयास करता है subtractऔरadd आज्ञा , लेकिन स्टैक खाली होता है, इसलिए ये नो-ऑप बन जाते हैं।

4 कोडेल

4 कोडेल

अनिश्चितकाल के लिए स्टैडआउट करने के लिए 2 प्रिंट करता है।

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

5 कोडेल

5 कोडेल

बार-बार स्टड से एक बार में एक चरित्र को पढ़ता है और उनके यूनिकोड मानों के योग को ट्रैक करता है।

यह अनिवार्य रूप से 2-कोडेल संस्करण के समान कार्यक्षमता है, लेकिन यह चुनौती भाषा को दिखाने के बारे में है, और पीट के बारे में ठंडी चीजों में से एक यह है कि आपके पास अलग-अलग दिखने वाली तस्वीरें कैसे हो सकती हैं जो एक ही काम करती हैं।

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

6 कोडेल

6 कोडेल

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

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

7 कोडेल

7 कोडेल

फिर भी एक अलग नज़र के साथ एक और गूंज कार्यक्रम।

यहाँ हम अपने पहले कोडेल ब्लॉक को आकार की तुलना में बड़ा देखते हैं। 1 पीट में, एक ही रंग के कोडेल के किसी भी सन्निहित ब्लॉक को एकल ब्लॉक माना जाता है। pushनिर्देश को निष्पादित करते समय ब्लॉक का आकार कोई फर्क नहीं पड़ता है , इसलिए इस कार्यक्रम को बिल्कुल अलग-अलग रंगों को छोड़कर 3-कोडेल संस्करण की तरह माना जाता है।

8 कोडेल

8 कोडेल

स्टड से एक संख्या पढ़ता है और बार-बार, स्टडआउट के लिए वर्ग को आउटपुट करता है।

नियंत्रण प्रवाह 4-कोडेल कार्यक्रम की तरह ही एक बुनियादी घड़ी का पैटर्न है। ऊपरी-बाएं से शुरू, क्रम में संचालन कर रहे हैं input, duplicate(ढेर के शीर्ष मूल्य की एक अतिरिक्त प्रति ढेर पर धक्का), multiply, output। तब यह pushस्टैक पर मान 1 popसे बच जाता है , सफेद पर स्लाइड करता है ताकि कोई कमांड निष्पादित न हो, और फिर स्टैक के 1 बंद को निचले-बाएं से ऊपरी-बाएं कोडेल में ले जाए। यह एक खाली स्टैक के साथ कार्यक्रम की शुरुआत में इसे वापस करता है, और यह दोहराता है।

9 कोडेल

9 कोडेल

1 + 2 = 3 जोड़ता है, और फिर समाप्त करता है।

अब जब हमारे पास दोनों आयामों में 2 से अधिक कोडल के साथ एक कार्यक्रम है, तो हम अंत में एक क्षेत्र स्थापित कर सकते हैं जो प्रोग्राम को फंसा देगा और इसे हमेशा के लिए समाप्त कर देगा। लाल कोडेल से गहरे लाल क्षेत्र में जाने वाला पहला ऑपरेशन push1 में से एक है, फिर प्रोग्राम घूमता है और बीच में हल्के लाल कोडेल में नीचे बहता है और push2 के मान से निकलता है । हल्के लाल से हल्के पीले रंग में बहता है एक addऑपरेशन। नीचे की हल्की पीली पट्टी से कार्यक्रम समाप्त हो जाता है क्योंकि इसके बाहर निकलने का कोई रास्ता नहीं है क्योंकि सभी कोने बंद हैं।


1- और 2-उच्च कार्यक्रम जल्दी से बदसूरत और निर्बाध होते जा रहे हैं इसलिए इस बिंदु से मैं उन संख्याओं पर ध्यान केंद्रित करने जा रहा हूं जो प्रत्येक दिशा में कम से कम कुछ कोडल्स की अनुमति देते हैं।

12 कोडेल

12 कोडेल

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

कार्यक्रम बहती दाएं 4 रंगीन सलाखों के पार-दाएं 2 परमानेंट कमांड inputsद्वारा पीछा करता है add। यह फिर निचले-दाएं कोडल में outputजाता है और एक प्रदर्शन करता है , और फिर शुरू में वापस सफेद क्षेत्र में छोड़ दिया जाता है।

यह 8 कोडल्स में किया जा सकता था, लेकिन चूंकि हमारे पास अतिरिक्त जगह है इसलिए हम कुछ ऐसा बना सकते हैं जो पुराने नो-सिग्नल टीवी डिस्प्ले से प्रेरित हो।

15 कोडेल

15 कोडेल

स्टड से एक नंबर पढ़ता है और अपने 'वर्ग' को आउटपुट करता है।

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

गहरे लाल कोडेल, मध्य स्तंभ के ऊपर और नीचे मध्यम हरे रंग के कोडल्स के साथ, सजावटी हैं और कार्यक्रम कभी भी उनके साथ नहीं होगा।

20 कोडेल

20 कोडेल

स्टड से संख्याओं को 0 तक पढ़ा जाता है, जिस बिंदु पर यह सभी दर्ज संख्याओं के योग को आउटपुट करता है और बाहर निकलता है।

हमारे पास अंत में pointerऑपरेशन के रूप में नियंत्रण प्रवाह करने के लिए पर्याप्त जगह है । शीर्ष के साथ 4 codels प्रदर्शन input, duplicateऔर notसंचालन, और फिर एक और notऑपरेशन 2-codel इसके नीचे पीले करने के लिए ऊपरी दाएं भाग में मैजेंटा से घूम रहा है। notआपरेशन ढेर के बंद शीर्ष मूल्य पॉप और एक 1 धक्का अगर शीर्ष मूल्य एक 0 था, और एक 1 अन्यथा। इसलिए एक डबल के notसाथ किसी भी गैर-मूल्य को दोहराता है 1. पीली पट्टी से नीचे गहरे नीले रंग में जाने पर एpointer ऑपरेशन होता है, जो स्टैक के शीर्ष मूल्य को पॉप करता है और कई बार दिशा सूचक को दक्षिणावर्त घुमाता है।

यदि शीर्ष मान 1 है (यानी हमने एक शून्य दर्ज नहीं किया है) दिशा सूचक बायीं ओर जाएगा, एक के लिए मैजेंटा कोडल पर जा रहा है add ऑपरेशन के (जो स्टैक पर केवल एक मूल्य के कारण पहली बार अनदेखा किया जाएगा) और फिर कार्यक्रम की शुरुआत में वापस सफेद के माध्यम से।

यदि पॉइंटर के शीर्ष मान पॉइंटर ऑपरेशन में एक शून्य है, तो दिशा सूचक नहीं बदलेगा और प्रोग्राम नीचे की ओर जारी रहेगा। हल्के नीले रंग की पट्टी में जाने से popवह 0 होगा जो स्टैक से प्रवेश किया गया था, केवल संचित संख्याओं का योग छोड़कर। तल पर सियान बार में जाने से outputवह योग होगा , और फिर कार्यक्रम प्रवाह के फंसने के बाद समाप्त होगा।

25 कोडेल

25 कोडेल

उलटी गिनती! स्टड से एक नंबर पढ़ता है, और फिर एक बार में एक नंबर को स्टडआउट करने के लिए एक उलटी गिनती को प्रिंट करता है। उदाहरण के लिए, यदि 5 पढ़ा जाता है, तो 54321 प्रिंट होगा।

सियान से पीले रंग का पहला ऑपरेशन है input। फिर पीला वह जगह है जहां कार्यक्रम "लूप" शुरू होता है। पीला> मैजेंटा> ब्लू एक है duplicateतो एक output, तो यह ढेर पर शीर्ष मूल्य प्रिंट लेकिन एक प्रति रहता है। दाईं ओर नीचे चलती है, हम pushढेर पर मान 1 फिर एक प्रदर्शन subtraction, 1. द्वारा हमारे दर्ज किया गया मान कम हो रही है अगला duplicate, not, और एक अन्य notइसके बगल में गहरे पीले के लिए नीचे दाएं में हल्का मैजेंटा से घूम रहा है। यह पिछले कार्यक्रम के समान ही शून्य / नॉनजेरो जांच है। हल्के नीले रंग के कोडेल में बाएं घूमने से एक pointerऑपरेशन होता है, जो या तो हमे पूरा करने के लिए अंधेरे सियान में छोड़ दिया जाएगा, अगर हम काम कर रहे हैं, या पीले रंग के लिए प्रारंभिक इनपुट के बिना हमारे लूप को फिर से शुरू कर सकते हैं, लेकिन मूल मूल्य कम हो गया है 1 से।

लाल कोडल के सभी 3 सजावटी हैं और कोई भी रंग हो सकता है।

30 कोडेल

30 कोडेल

फाइबोनैचि जनरेटर। बाहर निकलने के लिए फाइबोनैचि अनुक्रम की शर्तों को प्रिंट करता है और बंद नहीं करता है।

यह rollऑपरेटर का पहला परिचय है , साथ ही पहली बार 1 से बड़ा क्षेत्र आकार का उपयोग pushऑपरेटर के साथ स्टैक पर एक विशिष्ट मूल्य प्राप्त करने के लिए किया जाता है ।

जैसा कि हमेशा शीर्ष-बाएं चलती दाएं में होता है। pushस्टैक पर पहले 2 ऑपरेशन 1 और उसके outputबाद से यह फिबोनाची अनुक्रम दो 1 एस के साथ शुरू होता है, लेकिन मुख्य प्रोग्राम लूप केवल 1 बार प्रिंट होगा। फिर pushमुख्य कार्यक्रम लूप शुरू करने के लिए शीर्ष-दाएं में डार्क मैजेंटा में समाप्त होने के लिए स्टैक पर 2 और 1 एस।

दाईं ओर नीचे बढ़ते हुए हम duplicateऔर outputअनुक्रम के अगले शब्द को प्रिंट करते हैं, फिर duplicateवर्तमान अनुक्रम मान की एक प्रति प्राप्त करने के लिए। नीचे की ओर बाएं घूमने से 2 pushऑपरेशन निष्पादित होते हैं । चूंकि नीचे-दाएं में हल्का लाल क्षेत्र आकार में 3 कोडेल है, इसलिए पहले push1 के बजाय स्टैक पर 3 को धक्का देगा।

हल्के नीले रंग में ऊपर जाना एक rollऑपरेशन है। यह स्टैक के शीर्ष 2 मानों को पॉप करता है और पहले मूल्य पॉपप के बराबर कई रोल करता है, दूसरे मूल्य पॉपप के बराबर गहराई तक। इस स्थिति में, यह 3 की गहराई पर 1 रोल करेगा। एक रोल टू डेप्थ nस्टैक के शीर्ष मान (हमारे डुप्लिकेट किए गए वर्तमान मूल्य) को लेता है और इसे nगहरी जगह देता है। हमारा स्टैक अभी केवल 3 गहरा है, इसलिए यह नीचे के शीर्ष मूल्य को दफन कर देगा।

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

बीच में पीले पैटर्न का उपयोग कभी नहीं किया जाता है।

54 कोडेल

54 कोडेल

प्रिंट "हाय!" टालमटोल करना

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

कार्यक्रम pushबाईं ओर के सियान क्षेत्र से 5 से शुरू होता है । यहां से, यह duplicate5 एस के एक गुच्छा के साथ स्टैक को प्राइम करने के लिए 6 ऑपरेशनों के साथ सबसे ऊपर बहती है । अगला push1 है, subtractस्टैक के शीर्ष पर 4 लगाने के लिए, फिर स्टैक के शीर्ष पर multiply4 * 5 * 5 = 100 डालने के लिए 2 ऑपरेशन। फिर duplicate2 100 के लिए।

अब यह कार्यक्रम काले रंग से उछलता है और नीचे की ओर बाईं ओर काम करना शुरू करता है। Push3 और 2 के संचालन और फिर roll2 100 को 5 के नीचे दफनाने के लिए 5. अगला push1 है, घटाना और स्टैक के शीर्ष पर 100 + 5-1 = 104 प्राप्त करने के लिए जोड़ें, जो यूनिकोड "एच" है। अगले 2 ऑपरेशन push1 हैं और pointerकोने के चारों ओर जाने के लिए और बीच में दाईं ओर बढ़ना शुरू करें, और फिर output"एच" प्रिंट करें।

अगला addस्टैक के शीर्ष पर 100 + 5 = 105 है, और output"i" प्रिंट करने के लिए। स्टैक में अब दो 5 एस शामिल हैं। Push1, add, multiply(1 + 5) * 5 = 30 देता है। अंत में push3 और add33 के लिए, और outputअनुगामी के लिए "!"। कार्यक्रम फिर दाईं ओर हरे रंग में समाप्त होने के लिए शेष सफेद स्थान से होकर जाता है।


5
हाँ हाँ, इस के लिए इंतजार कर रहा था :)
Sp3000

यह कैसे एक 2 डी चरित्र भाषा से अलग है? यह आप सेल वैल्यूज को व्यक्त करने का तरीका है।
JDługosz

25
@jdlugosz कई गूढ़ प्रोग्रामिंग भाषाएं, जब आप इसके लिए नीचे उतरते हैं, तो कमांडों को एन्कोडिंग करने का एक अनूठा तरीका के साथ बस कुछ बुनियादी स्टैक हेरफेर कमांड हैं। मैं व्यक्तिगत रूप से उन्हें एक छवि में एन्कोडिंग एक साफ विचार है।
स्पेंसर

13
यदि हम कार्यात्मक तुल्यता की बात कर रहे हैं, तो आप पूछ सकते हैं "ट्यूरिंग मशीन से कैसे अलग है?" लेकिन तब आप एक बिल्ली, या ग्रह बृहस्पति, या अन्य भाषाओं में से किसी पर भी यही सवाल कर सकते हैं ...
ट्राइकोप्लाक्स

3
9 कोडेल का उदाहरण मिनी पोकेबल की तरह दिखता है। अच्छा लगा।
The_Basset_Hound

155

> <> (मछली)

(ध्यान दें: कुछ स्निपेट्स पिछले स्निपेट पर बनते हैं, इसलिए अधिकांश उत्तरों के विपरीत मैंने उन्हें जल्द से जल्द नवीनतम बनाने का फैसला किया है।)

factoid:

Befunge की तरह,> <> स्टैक-आधारित 2D भाषा है। इसका मतलब यह है कि निर्देशों को अधिकांश पारंपरिक भाषाओं की तरह रैखिक रूप से निष्पादित नहीं किया जाता है - कार्यक्रम प्रवाह ऊपर, नीचे, बाएं या दाएं हो सकता है!

लंबाई 1 स्निपेट:

X

X> <> में एक अमान्य कमांड है, इसलिए त्रुटि संदेश something smells fishy...मुद्रित होता है। वास्तव में, यह एकमात्र त्रुटि संदेश है> <>, चाहे कारण शून्य से विभाजन हो या खाली स्टैक को पॉप करने की कोशिश करना।

लंबाई 2 स्निपेट:

1n

> <> में कार्यक्रम प्रवाह ऊपर बाईं ओर से शुरू होता है और शुरू में दाईं ओर होता है। 1स्टैक पर 1 दबाता है, फिर nइसे एक संख्या के रूप में प्रिंट करता है (जैसा कि ASCII चार के रूप में विरोध किया जाता है)। लेकिन> <> प्रोग्राम टॉरॉयडल हैं, जिसका अर्थ है कि निर्देश सूचक जब एक पंक्ति के अंत तक पहुंचता है तो उसके चारों ओर लपेटता है। इसलिए जब nहम शुरुआत करने के लिए लपेटते हैं, तो 1 को धक्का दें, प्रिंट करें, शुरुआत से लपेटें, 1 को धक्का दें, प्रिंट करें ... और हम 1हमेशा के लिए मुद्रण को समाप्त करते हैं !

लंबाई 3 स्निपेट:

"o;

यहाँ "स्ट्रिंग पार्सिंग है, oASCII चार के रूप में आउटपुट और ;प्रोग्राम को समाप्त करता है। लेकिन कार्यक्रम वास्तव में समग्र रूप से क्या करता है?

अच्छी तरह से पहले हम स्ट्रिंग पार्सिंग शुरू करते हैं, जब तक हम एक समापन नहीं पाते तब तक हम हर एक स्टैक को देखते हैं "। हम एक धक्का देते हैं o, फिर एक ;... और निर्देश सूचक को शुरू में वापस लपेटते हैं। लेकिन अब हम एक पर हैं" इतने कि हम स्ट्रिंग पार्स करना बंद कर दें , और अंत में हम स्टैक ( )) के शीर्ष को प्रिंट करने और समाप्त करने के लिए oऔर ;सामान्य रूप से निष्पादित करते हैं ;

हां, हमने एक स्ट्रिंग शुरू करने और समाप्त करने के लिए बस एक ही उद्धरण चार का उपयोग किया है!

लंबाई 4 स्निपेट:

42n;

अब तक हमने जो देखा है, उसके आधार पर, आप यह उम्मीद कर सकते हैं कि 42 को धक्का दे, एक संख्या के रूप में आउटपुट फिर समाप्त करें। लेकिन> <> में सभी निर्देश एकल वर्ण हैं, इसलिए यह वास्तव में धक्का देता है एक 4 और 2 को है , फिर स्टैक के शीर्ष को एक संख्या (केवल 2) के रूप में आउटपुट करता है और समाप्त करता है।

लंबाई 5 स्निपेट:

<v
;>

याद रखें,> <> एक 2D भाषा है। इसका मतलब है कि कार्यक्रम के प्रवाह की दिशा को बदलने के तरीके हो सकते हैं!

Befunge की तरह, एक तरीका यह है कि आप इसे तीर के माध्यम से कर सकते हैं >^v<। यह समझने के लिए कि वे कैसे काम करते हैं, आइए उपरोक्त कार्यक्रम को देखें:

  • कार्यक्रम प्रवाह शुरू में सही है
  • < कार्यक्रम को बाएं ओर प्रवाहित करता है - हम बाईं ओर जाते हैं और चारों ओर लपेटते हैं v
  • v कार्यक्रम को नीचे की ओर प्रवाहित करता है - हम नीचे जाते हैं >
  • > कार्यक्रम प्रवाह को सही बनाता है - हम दाईं ओर जाते हैं और चारों ओर लपेटते हैं ;
  • अंत में, हम समाप्त करते हैं।

लंबाई 6 स्निपेट:

";"00p

> <> की एक और अच्छी विशेषता यह है कि यह रिफ्लेक्टिव है - कार्यक्रम मक्खी पर अपने स्वयं के स्रोत कोड को संशोधित कर सकता है!

यहां हम एक धक्का देते हैं ;, उसके बाद दो शून्य। pफिर शीर्ष तीन तत्वों पॉप y, x, v( yढेर के शीर्ष जा रहा है) और स्थानों vकी स्थिति में x,y। दूसरे शब्दों में, pइस कार्यक्रम में एक अर्धविराम को स्थिति में रखा जाता है 0,0, जिससे कोड बदल जाता है;;"00p । यह तब प्रोग्राम को समाप्त करने की अनुमति देता है, क्योंकि निर्देश सूचक अब चारों ओर घूमता है और नए-नवेले को निष्पादित करता है ;

लंबाई 7 स्निपेट:

\7*n;
6

संयुक्त राष्ट्र Befunge की तरह,> <> भी दर्पण (है \/|_#), जो कार्यक्रम के प्रवाह की दिशा को दर्शाते हैं। तो यहाँ हम:

  • सही शुरुआत करें, लेकिन \ हमें नीचे की ओर दर्शाता है
  • एक 6 धक्का और लपेटो
  • के पीछे की तरफ मारो \ ओर और सही पर वापस प्रतिबिंबित करें
  • एक धक्का 7
  • स्टैक के शीर्ष दो को गुणा करें
  • आउटपुट और समाप्त

एक _दर्पण के माध्यम से या एक दर्पण के माध्यम से क्षैतिज रूप से क्षैतिज रूप से आगे बढ़ना |एक नो-ऑप है।

लंबाई 8 स्निपेट:

"r00g>o<

यदि किसी त्रुटि को फेंकने की अनुमति दी जाती है, तो संभवतः सबसे सरल> <> quine। यहाँ दो नए निर्देश हैं:

  • r: स्टैक को उल्टा करें
  • g: प्राप्त करें - पॉप y, xऔर x,yस्टैक पर चरित्र को धक्का दें (प्रतिपक्ष p)

पहले से स्ट्रिंग रैपिंग ट्रिक का उपयोग करते हुए, प्रोग्राम शुरू में धक्का देता है r00g>o<फिर पहले उद्धरण को हिट करता है। स्टैक तो उलटा, दे रहा है <o>g00r। उसके बाद हम पर चार धक्का 0,0, "देने के लिए, <o>g00r"। अंत में, हम oदो तीरों के बीच फंसते हैं, स्टैक के शीर्ष को आउटपुट करते हैं जब तक कि कुछ भी नहीं बचा है और हमें एक त्रुटि मिलती है।

लंबाई 9 स्निपेट:

x0\>
\1n>

x(लोअर केस) निर्देश सूचक को यादृच्छिक दिशा में ले जाता है, और प्रोग्राम इस कार्यक्षमता को यादृच्छिक बिट्स को हमेशा के लिए प्रिंट करके दिखाता है। यह कैसे काम करता है यह पता लगाने के लिए तीर और दर्पण का अनुसरण करने की कोशिश करें! (सभी चार दिशाओं की जाँच करना न भूलें, जिसमें ऊपर और बाएँ शामिल हैं)

लंबाई 10 स्निपेट:

;a comment

> <> में कोई टिप्पणी वाक्यविन्यास नहीं है - इसकी आवश्यकता नहीं है। बस जो आप चाहते हैं उसे कहीं भी लिखें और सुनिश्चित करें कि यह कोड के रूप में निष्पादित नहीं होता है!

लंबाई 11 स्निपेट:

1!X2!X+!Xn;

!एक ट्रम्पोलिन है जो निर्देशों पर छोड़ देता है। यह विशेष रूप से उपयोगी है जब ?एक सशर्त के साथ प्रयोग किया जाता है ट्रैम्पोलिन जो स्टैक के शीर्ष को चबूतरे पर रखता है और अगले निर्देश को निष्पादित करता है यदि पॉपप्ड तत्व नॉनजरो है। हम देखेंगे कि यह बाद में कैसे काम करता है।

उपर्युक्त कोड Xएस पर लंघन द्वारा 3 प्रिंट करता है , केवल निष्पादन1! 2! +! n;

लंबाई 12 स्निपेट:

01v
ao>:@+:n

1प्रत्येक पंक्ति में एक से दूसरे से शुरू होने वाले फाइबोनैचि संख्याओं को हमेशा के लिए प्रिंट करता है । नए आदेश हैं:

  • a: पुश 10, जो हमें न्यूलाइन के लिए चाहिए। a-fक्रमशः 10 से 15 धक्का।
  • :: स्टैक के ऊपर डुप्लिकेट
  • @: स्टैक के शीर्ष तीन तत्वों को घुमाएं, जैसे [5 4 3 2 1] -> [5 4 1 3 2]

पहले कुछ पुनरावृत्तियों के लिए ट्रेस:

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

लंबाई 13 स्निपेट:

i:d=?v
l?!;o>

एक "टैक" प्रोग्राम जो इनपुट की एक पंक्ति में पढ़ता है और आउटपुट इसे उलट देता है। स्निपेट के लिए @tomsmeding का धन्यवाद।

=शीर्ष दो तत्वों को पॉप करता है और 1 को धक्का देता है यदि वे समान हैं, 0 अन्यथा। पहली पंक्ति इनपुट में पढ़ती रहती है जब तक ASCII char 13 (गाड़ी वापसी) नहीं मिल जाती है, जिस बिंदु पर वह दूसरी पंक्ति में जाती है।

l?!;oपाश> <> में एक महत्वपूर्ण निर्माण जो पूरे ढेर आउटपुट है। इसके विपरीत >o<, यह किसी भी त्रुटि का कारण नहीं बनता है। यह इस तरह काम करता है:

  • l स्टैक की लंबाई को बढ़ाता है
  • हम लंबाई की जाँच करते हैं ?:
    • यदि लंबाई नोनजरो थी, तो अगले निर्देश !को निष्पादित किया जाता है;
    • अगर लंबाई था शून्य है, तो हम पर अमल नहीं करते !और की वजह से समाप्त;

ध्यान दें कि कोई भी आउटपुट वास्तव में तब तक नहीं होता है जब तक आप कैरिज रिटर्न नहीं मारते हैं।

लंबाई 14 स्निपेट:

32.

   X67*n;

प्रोग्राम फ्लो की दिशा बदलने के अलावा, आप वास्तव में आप की तरह कहीं भी निर्देश सूचक को स्थानांतरित कर सकते हैं!

.पॉप y, xऔर करने के लिए अनुदेश सूचक teleports x,y, दिशा को बनाए रखने। ध्यान दें, हालांकि, आपको एक वर्ग में जाने से पहले जहां आप जाना चाहते हैं - निर्देश सूचक को अगला निर्देश निष्पादित होने से पहले अद्यतन किया जाता है। तो यहाँ अनुदेश सूचक अवैध पर भूमि X, लेकिन सब ठीक है क्योंकि सूचक 6निरंतर निष्पादन से पहले चलता है ।

.अधिकांश> <> कार्यक्रमों को एक-लाइनर में बदलना संभव बनाता है, लेकिन आप 2 डी का मज़ा क्यों खोना चाहेंगे? :)

लंबाई 15 स्निपेट:

01+:aa*=?;:nao!

प्रत्येक लाइन पर एक, संख्या 0को प्रिंट करता है 99। इस कार्यक्रम के एक स्वच्छ उपयोग प्रदर्शित करता है! trampoline के - यह सुनिश्चित करने के लिए कि प्रारंभिक 0 केवल एक बार धकेल दिया जाता है।

लंबाई 16 स्निपेट:

"r00g!;oooooooo|

एक उचित क्वीन जो त्रुटियों को नहीं फेंकती है, एलांग पृष्ठ पर क्वीन द्वारा प्रेरित है

आप कैसे पिछले Quine संशोधित करने के लिए (स्निपेट # 8) इतना है कि यह एक त्रुटि का कारण नहीं हैं के बारे में सोचा और सोचा कि अगर "क्यों मैं सिर्फ एक टन का नहीं जोड़ते oनिर्देश?", तो आप हर के लिए है कि एहसास हो सकता है oआप जोड़ना , आपको दूसरा उत्पादन करने की आवश्यकता है o! यह क्वीन |अंत में दर्पण लगाकर समस्या को हल करता है , जो प्रत्येक oको दो बार उपयोग करने की अनुमति देता है ।

यदि हम सिंगल कोट्स (जो कि स्ट्रिंग पार्सिंग के लिए भी हैं) पर स्विच करते हैं, तो एक वैकल्पिक क्वीन जो उपयोग नहीं करता gहै

'r3d*!;oooooooo|

लंबाई 17 स्निपेट:

b2,63,.

   17,n;

हमारे पास जोड़ ( +), घटाव ( -), गुणा ( *), मोडुलो ( %) ... लेकिन विभाजन के बारे में क्या है? यह वहाँ है, लेकिन चूंकि /पहले से ही एक दर्पण है, इसलिए विभाजन को ,इसके बजाय प्रतीक सौंपा गया है । दिलचस्प है, विभाजन फ्लोट है डिवीजन है, पूर्णांक विभाजन नहीं!

उपरोक्त कार्यक्रम में कूदने की कोशिश करके कुछ अपरिभाषित व्यवहार की पड़ताल 11/2, 6/3अजगर intepreter ठीक लग रहा है, तो पहले समन्वय एक पूर्णांक नहीं है (हालांकि यह गलत जगह पर कूदता है), लेकिन अगर दूसरा नहीं है chokes।

लंबाई 18 स्निपेट:

123456${{$}nnnnnn;

हमने देखा है rजो स्टैक को उलट देता है और @जो शीर्ष तीन तत्वों को घुमाता है। यहां कुछ और कमांड दिए गए हैं जो स्टैक पर तत्वों को स्थानांतरित करते हैं:

  • $: शीर्ष दो तत्वों को स्वैप करें
  • {: बचे हुए पूरे स्टैक को शिफ्ट करें
  • }: पूरे स्टैक को दाईं ओर शिफ्ट करें

यह दिखाने के लिए कि यह कैसे काम करता है, यहाँ कार्यक्रम ट्रेस है:

123456 ------> 123465 ------> 234651 ------> 346512 ------> 346521 ------> 134652
       $ Swap        { L shift      { L shift       $ Swap        } R shift

फिर हम आउटपुट देते हैं 256431

लंबाई 19 स्निपेट:

"reward"4[roooo]oo;

अब तक मैं "स्टैक", "स्टैक" कह रहा हूं ...

यद्यपि अधिकांश कार्यक्रम केवल एक स्टैक का उपयोग करते हैं,> <> वास्तव में कई स्टैक हो सकते हैं! यहां प्रासंगिक निर्देश दिए गए हैं:

  • [: चबूतरे xऔर ऊपर ले जाता हैx तत्वों को एक नए स्टैक में
  • ]: वर्तमान स्टैक को हटाता है, और इसके मानों को अंतर्निहित स्टैक में ले जाता है।

यहाँ उपरोक्त कार्यक्रम के लिए ट्रेस है:

       [r e w a r d]       Push "reward"
4[     [r e] [w a r d]     Move four elements to a new stack
r      [r e] [d r a w]     Reverse the current stack
oooo   [r e] []            Output "ward"
]      [r e]               Remove the current stack, no values to move
oo     []                  Output "er", giving "warder" altogether

ध्यान दें कि बस धक्का rewardऔर फिर से इसे फिर से ooooooप्रिंट करने के साथ outputtingdrawer स्टैक के "पहले, आखिरी बाहर" प्रकृति के कारण, ।

लंबाई 20 स्निपेट:

aa*5+\
7a*2+\
oo;  \

> <> की एक छोटी ज्ञात विशेषता यह है कि, पायथन की तरह, बैकस्लैश का उपयोग कई मामलों में लाइन निरंतरता के लिए किया जा सकता है। *

उपरोक्त कोड कार्यात्मक रूप से समान है

aa*5+7a*2+oo;

* अस्वीकरण: यह काम करता है या नहीं, इसका कारण पूरी तरह से अलग कारण हो सकता है

लंबाई 22 स्निपेट:

1&fv ;n&<
&1->:0=?^:&*

स्टैक के अलावा,> <> में रजिस्टर्स (प्रत्येक स्टैक के लिए एक) भी है जिसका उपयोग मूल्यों को संग्रहीत करने के लिए किया जा सकता है। &पहली बार कॉल करना स्टैक के शीर्ष मान को रजिस्टर में &ले जाता है , और फिर से निष्पादित करने से मान वापस आ जाता है। यह बहुत उपयोगी हो सकता है जब एक मूल्य जमा करते हैं, उदाहरण के लिए रकम और factorials।

कार्यक्रम ऊपर की भाज्य की गणना करता है f, (15) मुद्रण 1307674368000. यहाँ के लिए ट्रेस है fके साथ बदल दिया 4:

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

लंबाई 24 स्निपेट:

"Hello, World!"rl?!;of0.

हम सभी के पसंदीदा कार्यक्रम के लिए पर्याप्त आकर्षण हैं! यहां हम उपयोग करते हैं. आउटपुट लूप के लिए टेलीपोर्टर का हैं।

लंबाई 25 स्निपेट:

0i:0(?v$a*$"0"-+!
   ;n~<

दुर्भाग्य से> <> केवल एक समय में STDIN एक चार से पढ़ने की अनुमति देता है, जिससे संख्याओं में पढ़ना थोड़ा मुश्किल हो जाता है। 0-9 अंकों वाले इनपुट के लिए, यह प्रोग्राम अनिवार्य रूप से एटोई है, STDIN से अंकों की एक स्ट्रिंग को स्टैक पर एक संख्या में परिवर्तित करना (जो तब मुद्रित होता है)।

एक और नोट ईओएफ iपर, स्टैक पर -1 को धक्का देता है। यह 0 का उपयोग करके (, या "इससे कम" की तुलना करके ईओएफ के लिए जाँच करना आसान बनाता है ।

यह स्निपेट भी उपयोग करता है ~, जो स्टैक के शीर्ष तत्व को पॉप और डिस्क्राइब करता है।

लंबाई 33 स्निपेट:

i>:nao:1=?;\
 ^  ,2v?%2:/
 ^+1*3<

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

कार्यक्रम एक एकल ASCII चरित्र में पढ़ता है और 3x+1इसके कोड बिंदु पर एल्गोरिथ्म चलाता है (In> <>, अक्षर मूल रूप से पूर्णांक हैं)। एल्गोरिथ्म के प्रत्येक चरण को तब तक छापा जाता है जब तक हम 1 हिट नहीं कर देते।

यहाँ इनपुट के साथ पहले पुनरावृत्तियों के लिए एक निशान है a(कोड बिंदु 97):

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

लंबाई 44 स्निपेट:

a&>i:0(?v"+"$\
/&^?=0l< "a*"/
\:1+&2p/\0
n
;

मुझे ऐसा नहीं लगता है कि मैंने pकमांड न्याय किया है, केवल स्निपेट # 6 में एक बार वापस आने के लिए इसका इस्तेमाल किया है, इसलिए यहां एक अलग अटोई फ़ंक्शन है। इस बारे में क्या अच्छा है? कार्यक्रम संख्या की गणना करने के लिए आवश्यक अभिव्यक्ति लिखता है क्योंकि यह इनपुट पढ़ता है!

इसलिए इनपुट के लिए 573, जैसे कि सभी वर्णों को पढ़ने के बाद तीसरी पंक्ति का अंत दिखाई देगा \0a*5+a*7+a*3+, जिसका मूल्यांकन 573 है!

एक बार फिर, इनपुट केवल अंकों के होने की उम्मीद है। यहाँ GIF का पता लगाएं

लंबाई 74 स्निपेट:

>i:'A'(?v:'N'(?v:'['(?v\
  :'a'(?v:'n'(?v:'{'(?v\
^      o<    +d<  -d-d<o

यदि आप यहां तक ​​पहुंचने में कामयाब रहे हैं, तो आप मेरे साथ सहमत हो सकते हैं जब मैं कहता हूं कि यह एक बहुत ही पठनीय ROT13 कार्यक्रम है। एक चार को देखते हुए c1, हम पहले चार c2को पाते हैं AN[an{, जैसे कि c1 < c2, फिर जोड़कर / घटाकर d(13) उपयुक्त ऑफसेट लागू करें । ध्यान दें कि [और {वर्ण के बाद सीधे हैं Zऔरz क्रमशः।

कंसोल में इसे आज़माएं, और आपके द्वारा लिखे गए अक्षरों को रूपांतरित करते हुए देखें!

(आप इनपुट में भी पाइप कर सकते हैं, लेकिन जैसा कि मुझे EOF की याद आ रही है, :0(?;यह एक त्रुटि के साथ बंद हो जाएगा जब यह 1-चार्ट प्रिंट करने की कोशिश करता है)


13 स्निपेट के लिए एक विचार: i:d=?v NEWLINE o;!?l<- इनपुट लाइन को पीछे की ओर
tomsmeding

12
काश, मैं इसे और अधिक वोट दे पाता, अब मैं सीखना शुरू करने के लिए प्रेरित हूं> <> ...
Robobenklein

6
शीर्ष पर शुरू करने और नीचे जाने के लिए +1 (और सिर्फ इसलिए कि यह पढ़ने में मजेदार है)।
mbomb007

5
@ mbomb007 यह एक शर्म की बात है, हालांकि, यह आदेश बाएं / दाएं नहीं जा सकता है और पृष्ठ के निचले भाग में लपेट सकता है: P
krs013

यदि आप something smells fishy...अगली पंक्ति में लिखते हैं तो आपकी लंबाई 8 स्निपेट एक सच्ची क्वीन होगी ।
wizzwizz4

148

सी - संपादित करें

वोट के लिए धन्यवाद! जब अन्य भाषाओं की तुलना में और वे सीमित बाइट्स में क्या कर सकते हैं, सी अप्रचलित, उधम मचाते हुए और डेवलपर पर निर्भर दिखता है। कई मायनों में यह है: स्वचालित मेमोरी प्रबंधन वाली स्क्रिप्टेड और उच्च स्तरीय भाषाएं बहुत अधिक अभिव्यंजक हैं और सी की तुलना में उत्पादन के लिए तेज हैं।

तो सी की सुविधा क्यों?

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

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

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

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

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

मैंने यह भी सुनिश्चित करने की कोशिश की कि प्रत्येक कोड स्निपेट जितना संभव हो उतना छोटा था ताकि मैं एक निश्चित लंबाई तक पैड को अतिरिक्त स्थान न दे पाऊं। ऐसे मामलों में जहां कोड इंडेंट किया जाता है, इंडेंट लंबाई में शामिल नहीं होते हैं, प्रत्येक नई लाइन के लिए सिर्फ एक चरित्र।

factoid

C चट्टानों।

लंबाई 0 स्निपेट

दुनिया का सबसे छोटा स्व-प्रजनन कार्यक्रम http://www.ioccc.org/1994/smr.hint

लंबाई 1 स्निपेट

;

C संकलन और लिंकिंग के बीच अंतर करता है। सी में कई इकाइयां सिर्फ बाद में संकलित और जुड़ी हुई हैं - एक उदाहरण सभी स्थिर और गतिशील पुस्तकालय हैं।

अन्य इकाइयाँ केवल शामिल हैं और स्वयं के द्वारा कोई कोड उत्पन्न नहीं करती हैं।

उपरोक्त सेमी-कॉलन निश्चित रूप से ऑब्जेक्ट कोड में संकलित करेंगे, और कुछ भी नहीं करेंगे!

लंबाई 2 स्निपेट

x;

C, एक पुरानी प्रोग्रामिंग भाषा होने के नाते, कई पुनरावृत्तियों से गुज़री है। व्यापक रूप से उपयोग में सबसे पहले कर्निघन और रिची द्वारा विकसित किया गया था और K & R को संक्षिप्त किया गया था। यदि आप स्पष्ट रूप से उन्हें प्रदान नहीं करते हैं तो आपके कोड के बारे में बहुत सी धारणाएँ बनाने के लिए K & R C उल्लेखनीय है।

विशेष रूप से, K & R C में, ऊपर दिए गए कोड xको 0. के लिए एक वैश्विक पूर्णांक माना जाता है, इसे K & R मोड में संकलित करने से एक ऑब्जेक्ट फ़ाइल उत्पन्न होगी जो इसके उपयोग के लिए इस चर को जोड़ने वाला कोई भी प्रोग्राम प्रदान करती है।

लंबाई 3 स्निपेट

??/

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

C में एक सामान्य संस्कृति संकलन चेतावनियों को अनदेखा करना है, और कई बड़े कोड बेस अनिवार्य रूप से कुछ या अधिक चेतावनियाँ हैं जब उनका निर्माण किया जाता है।

लंबाई 4 स्निपेट

f();

K & R के साथ फिर से, ऊपर "भरा हुआ है" का मतलब संकलन पर है कि "मौजूद है, वैश्विक संबंध के साथ, एक फ़ंक्शन f, जिसे बाद में प्रदान किया जाना है, जो एक निश्चित लेकिन अनिर्दिष्ट संख्या में तर्क लेता है और एक पूर्णांक देता है।"

इस और के बीच मूलभूत अंतरों पर ध्यान दें f;

लंबाई 5 स्निपेट

s="";

वास्तव में क्षमा करने के लिए K & R C उल्लेखनीय है। संकलन करने पर, यह कोड sवैश्विक लिंकेज के लिए पूर्णांक प्रदान करेगा जो कि एक खाली स्ट्रिंग के शुरुआती पते (मुझे लगता है) के लिए प्रारंभ है। यदि कोई पूर्णांक बड़े पते पर रखने के लिए पर्याप्त नहीं है, तो K & R चुपचाप सभी क्यूरेशनों को संभालता है, जिसमें छंटनी भी शामिल है।

यह इस तरह का निर्माण है जिसने कई कठिन-से-खोज कीड़े उत्पन्न किए हैं और IOCCC प्रतियोगिताओं में बहुत प्रेरणा प्रदान की है।

लंबाई 6 स्निपेट

o=042;

यहां तक ​​कि पुराने टाइमर का एक गोच, एक शाब्दिक संख्या में एक अग्रणी 0 का मतलब है कि निम्नलिखित अंक अष्टक आधार में हैं। उपरोक्त कोड, संकलन पर, oदशमलव 34 के लिए इनिशियलाइज़ किए गए वैश्विक लिंकेज के लिए पूर्णांक प्रदान करेगा ।

C की इस विशेषता ने कई डेवलपर्स को अपनी संख्या को पैड करने का प्रयास करने के लिए काट लिया है ताकि उन्हें अच्छा और समान बनाया जा सके!

लंबाई 7 स्निपेट

f(){f;}

उपरोक्त कोड एक निकाय के साथ एक फ़ंक्शन है। लेकिन यह क्या करता है? यह फ़ंक्शन का पता पुनर्प्राप्त करता है, और इसके साथ कुछ भी नहीं करता है! आमतौर पर क्या फ़ंक्शन वापस आएगा अपरिभाषित है। इस तरह के निरर्थक कोड अक्सर चेतावनी के बिना संकलन कर सकते हैं।

लंबाई 8 स्निपेट

main(){}

यह सी में सबसे कम संकलन योग्य और लिंक करने योग्य कोड का प्रतिनिधित्व करता है। सी के आधुनिक संस्करणों में, आमतौर पर फ़ंक्शन को स्पष्ट रूप से परिभाषित नहीं किया जा सकता है, ऐतिहासिक कारणों से इस प्रतिबंध के लिए आराम है main

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

लंबाई 9 स्निपेट

#define Z

C हेडर फ़ाइलों का एक मुख्य आधार #defineप्रीप्रोसेसर निर्देश है। सी कार्यक्रम विभिन्न चरणों में संकलित होते हैं, और इनमें से एक चरण में इन परिभाषाओं को उनके वास्तविक मूल्यों के साथ प्रतिस्थापित किया जाता है।

जब कोई तर्क गायब होता है 1, तो सी का अर्थ होगा , इसलिए स्रोत कोड में 1जहां भी Zउपयोग किया जाता है , ऊपर दिया गया विकल्प होगा ।

ऊपर आम तौर पर एक हेडर फ़ाइल में डाल दिया जाएगा और #includeआवश्यक के रूप में घ।

लंबाई 10 स्निपेट

enum{P,Q};

enumकीवर्ड स्थिरांक की एक श्रृंखला को परिभाषित करने के लिए एक कभी कभी प्रकार सुरक्षित तरीका प्रदान करता है। परिभाषित की तरह, वे अक्सर हेडर फ़ाइलों में उपयोग किए जाते हैं। जब उपरोक्त कोड Pको 0 और Q1 के पूर्णांक के रूप में परिभाषित किया जाएगा ।

लंबाई 11 स्निपेट

volatile v;

volatileकीवर्ड जाने के लिए संकलक जानते हैं कि एक चर अन्य एजेंटों द्वारा बदला जा सकता और मान्यताओं कि यह पहुंच के बीच स्थिर रहेंगे बनाने के लिए नहीं है।

लंबाई 12 स्निपेट

#pragma once

#pragma once एक गैर-मानक लेकिन व्यापक रूप से समर्थित प्रीप्रोसेसर निर्देश है जो यह दर्शाता है कि वर्तमान स्रोत फ़ाइल को केवल एक बार एक संकलन में शामिल किया गया है।

पारंपरिक और पूरी तरह से समर्थित तकनीक #includeगार्ड को अतिरिक्त कोड और संभावित नाम की गड़बड़ी के नुकसान के साथ उपयोग करना है ।

लंबाई 13 स्निपेट

w(){for(;;);}

सी में कई सम्मेलन हैं, और इनमें से एक यह है कि अनंत छोरों का प्रतिनिधित्व कैसे करें। इस मामले में, for(;;)कोई आरंभीकरण इंगित नहीं करता है, कोई निकास जांच नहीं है जो 1 अर्थ को चूकता है - यानी ब्रेक न करें, और कोई लूपिंग कोड नहीं।

कभी-कभी यह अंदर और सब कुछ करने के लिए संभव है ()लूप खुद को शरीर की आवश्यकता नहीं है। इस मामले में एक डमी अर्धविराम अंत में जोड़ा जाता है।

ऊपर दिए गए कोड में, जब संकलित किया जाता है, तो यह एक फ़ंक्शन प्रदान करेगा जो एक तंग व्यस्त लूप में प्रवेश करेगा - सॉफ़्टवेयर डिज़ाइन में नंबर-नो में से एक - और कभी वापस नहीं।

लंबाई 14 स्निपेट

int a[]={1,2};

C में एरर्स को निर्दिष्ट लंबाई की आवश्यकता नहीं है। खाली वर्ग कोष्ठक []संकलक को "यह पता लगाने के लिए अपने आप को" बताता है। सी में हालांकि, अन्य भाषाओं के विपरीत, इन सीमाओं के बाहर एक सरणी तक पहुंचने से रोकने के लिए एक अंतर्निहित तरीका नहीं है, जिससे "पैर में अपने आप को गोली मारना" रूपक के लिए जाना जाता है कि सी के लिए जाना जाता है।

ऊपर दिया गया कोड, जब संकलित किया जाता है, तो a1 और 2 के साथ आरंभ किए गए दो पूर्णांकों का एक वैश्विक परिवर्तनशील सरणी प्रदान करेगा ।

लंबाई 15 स्निपेट

const long k=7;

constSpecifer सेल्सियस के लिए एक बाद इसके अलावा सी ++ से उधार लिया है। एक सामान्य साक्षात्कार का सवाल है "क्या यह एक चर को परिभाषित करने के लिए समझ में आता है volatile const?"। constके साथ enumऔर जिस प्रकार की सुरक्षा के साथ समस्या है उस inlineपर निर्भरता को कम करने का इरादा है #define

लंबाई 16 स्निपेट

extern void **q;

externयह दर्शाने के लिए प्रयोग किया जाता है कि एक चर अन्यत्र घोषित किया गया है। void *प्रकार जिसका अर्थ यह स्पष्ट रूप से काम करने के लिए बयान में डाली या डाली जा करने के लिए से की जरूरत नहीं है, सी में मानक सामान्य प्रकार है। **ऑपरेटर अनुक्रम एक सूचक है, जो अक्सर newbies के मन चल रही है करने के लिए सूचक का मतलब है, लेकिन पूरी तरह से वैध और अक्सर इस्तेमाल किया सी है

लंबाई 17 स्निपेट

double d=4/3-1/3;

यदि आप ऊपर मुद्रित करने के लिए थे, तो परिणाम एक होगा, और आप सोचेंगे, सुपर! बदलें double d=4/3-2/3;और उत्तर क्या है? यह अभी भी एक है! C पूर्णांक अंकगणितीय का उपयोग 4/3 → 1 और 2/3 → 0, और 1 - 0 → 1 की गणना के लिए कर रहा है!

लंबाई 18 स्निपेट

main(){puts("!");}

अंत में हमें कुछ कोड मिलते हैं जो वास्तव में कुछ करते हैं! putsसी गोल्फर्स का पसंदीदा है क्योंकि इसे उपयोग करने के लिए हेडर फ़ाइल की आवश्यकता नहीं है।

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

लंबाई 19 स्निपेट

#include <stdlib.h>

हेडर फ़ाइलों का समावेश अक्सर डेवलपर्स का एक व्यक्तिगत हस्ताक्षर होता है। कई में शामिल हैं libऔर ioयदि आवश्यक हो तो भी। कुछ हेडर फ़ाइलों का आदेश देते हैं ताकि लंबाई बढ़ रही है या घट रही है। सबसे <>पहले रखा ""। व्यक्तिगत रूप से मैंने अपने टीए दिनों में इस हस्ताक्षर का उपयोग छात्रों के बीच धोखाधड़ी की जांच करने के लिए किया है: एक ही हेडर हस्ताक्षर? करीब से देखो!

लंबाई 20 स्निपेट

char*p=(char*)0x300;

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

एक पोर्ट के पते के ऊपर कोड में हेक्साडेसिमल 300 के रूप में परिभाषित किया गया है। आप सभी बिट्स को चालू करने के लिए या वर्तमान मूल्य को पुनः प्राप्त करने के लिए पोर्ट के मूल्य का उपयोग *pकरेंगे ।*p=0xff;v=*p;

लंबाई 21 स्निपेट

int w=sizeof(double);

sizeofऑपरेटर एक प्रकार की बाइट में आकार प्रदान करता है। चर नामों के साथ कोष्ठक आवश्यक नहीं हैं double d;int w=sizeof d;

लंबाई 22 स्निपेट

asm("xorl %ecx,%ecx");

उपयोग कैसे asmकिया जाता है यह कंपाइलर द्वारा परिभाषित किया गया है। उपरोक्त इंटेल प्लेटफॉर्म पर लिनक्स gcc इन-लाइन कोड का एक उदाहरण है।

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

संगत प्रणालियों पर, ऊपर दिया गया कोड संकलित होगा, और यह शाब्दिक रूप से एक अलग विधानसभा निर्देश होगा जिसमें इसे एक्सेस करने का कोई पारंपरिक साधन नहीं होगा! xor R,Rकिसी रजिस्टर को जल्दी क्लियर करने के लिए BTW एक आम असेंबली भाषा का मुहावरा है।

लंबाई 23 स्निपेट

union u{char c;int i;};

unionसबसे बड़े तत्व के लिए कम से कम पर्याप्त स्थान प्रदान करेगा। आप इसे void *कुछ पुस्तकालयों में एक आम "अपारदर्शी" प्रकार प्रदान करने के लिए संयोजन के रूप में उपयोग कर सकते हैं । इस मामले में, संघ आमतौर पर बड़ी संरचना का हिस्सा होगा, संरचना के साथ संघ प्रकार की पहचान करने के लिए एक क्षेत्र होगा।

लंबाई 24 स्निपेट

/*INTS*/int i,j,k;//INTS

मूल C टिप्पणी को सीमांकित किया गया था /* comment */, और // comment to end of lineC ++ से प्रारूप उधार लिया था ।

लंबाई 25 स्निपेट

int main(void){return 1;}

यह ऊपर की लंबाई 8 स्निपेट का अधिक आज्ञाकारी संस्करण है। वापसी प्रकार और फ़ंक्शन प्रकार निर्दिष्ट हैं, और इसका स्पष्ट रूप से लौटाया गया मान है।

सी में कन्वेंशन 0सफलता के लिए और 1विफलता के लिए, या यदि आप कड़ाई से अनुरूप होना चाहते हैं EXIT_SUCCESSऔर EXIT_FAILUREजैसा कि परिभाषित किया गया है , रिटर्न रिटर्न का उपयोग करना है stdlib.h

लंबाई 26 स्निपेट

typedef struct{int x,y;}P;

typedefविशेष रूप से, अत्यंत उपयोगी है typedef struct। आधुनिक शब्दों में आप इसे "ऑब्जेक्ट-ओरिएंटेशन-लाइट" कह सकते हैं।

उपरोक्त शामिल करने के बाद, कोड Pपूर्ण प्रकार की जाँच के साथ, घोषणाओं और कार्यों में एक नियमित प्रकार के रूप में उपयोग कर सकता है । C ++ के विपरीत, हालांकि, आप +, *, या << जैसे ऑपरेटरों को परिभाषित नहीं कर सकते हैं, इसलिए "ऑब्जेक्ट-ओरिएंटेशन-लाइट"।

लंबाई 27 स्निपेट

#define C(x,y)(((x)+1)*(y))

सी में एक सुविधाजनक मैक्रो #defineसिंटैक्स है।

एक सामान्य नौसिखिया त्रुटि आंतरिक और / या बाहरी कोष्ठक को छोड़ना है, जिसके परिणामस्वरूप हार्ड-टू-ऑपरेट ऑपरेटर पूर्ववर्ती त्रुटियां हैं।

लंबाई 28 स्निपेट

struct f{int s:1,e:8,m:23;};

C स्पष्ट रूप से बिट-फ़ील्ड्स को परिभाषित कर सकता है जिसे किसी भी पूर्णांक की तरह सौंपा और पढ़ा और हेरफेर किया जा सकता है।

ऊपर एक IEEE एकल-चौड़ाई फ़्लोटिंग पॉइंट डेटा संरचना का एक अनुमान है।

लंबाई 36 स्निपेट

f(unsigned x){return!!x&!(x&(x-1));}

कई भाषाओं में, आपको इस बात की परवाह करने की ज़रूरत नहीं है कि संख्याओं का प्रतिनिधित्व कैसे किया जाता है। सी में, आपको आंतरिक रूप से उनके आंतरिक प्रतिनिधित्व के बारे में पता होना चाहिए।

इसका सबसे अच्छा उदाहरण मैं सोच सकता हूं कि अगर पूर्णांक दो {1, 2, 4, 8, ...} की शक्ति है। C से परिचित न होने वाले लोग लूप और शिफ्ट्स करेंगे और O (log (n)) रन-टाइम के लिए सभी तरह के सामान खराब नहीं होंगे, लेकिन ऊपर एक फ़ंक्शन है जो O (1) रन-टाइम में भी ऐसा ही करेगा। मैं इसे पढ़ने के लिए एक अभ्यास के रूप में छोड़ता हूँ कि यह पुष्टि करता है कि यह काम करता है, लेकिन यह वास्तव में करता है ...

!!सम्मेलन अक्सर क्रमशः 1 और 0 के लिए गैर-शून्य और शून्य से एक पूर्णांक मजबूर करने के लिए प्रयोग किया जाता है। कई सी डेवलपर्स इस प्रकार के ट्रिक्स का उपयोग करना पसंद करते हैं (अक्सर कोड स्पष्टता को महत्व देने वालों की कठिनाई पर)।

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

लंबाई 48 स्निपेट

#include<complex.h>
double complex c=3.0+I*4.0;

C99 में जटिल संख्याओं के लिए समर्थन शामिल है। जैसा कि आप कोड से देख सकते हैं, यह एक वास्तविक प्रकार के लिए एक संशोधक का रूप लेता है। आप इसका उपयोग भी कर सकते हैं, int complex c=3+I*4;लेकिन आंतरिक रूप से यह एक फ्लोटिंग पॉइंट प्रकार के लिए करता है। उपरोक्त कोड gcc का उपयोग करके संकलित करेगा gcc -std=c99 -c length-48.c

यदि आप अधिक इंटर्नल देखना चाहते हैं, तो -ई स्विच के साथ प्रयास करें। जीसीसी के मेरे संस्करण के लिए, ऊपर घोषणा बन जाती है double _Complex c=3.0+(__extension__ 1.0iF)*4.0;। ध्यान दें कि जटिल प्रकार भाषा का एक महत्वपूर्ण जोड़ है, न कि केवल कुछ सस्ते मैक्रोज़।

यह सिर्फ एक टीज़र है, जब हम 125 से अधिक पात्रों को प्राप्त करते हैं, तो हम जटिल संख्याओं के साथ कुछ वास्तविक मज़ा लेना शुरू कर सकते हैं!

लंबाई 51 स्निपेट

#include <math.h>
main(){double d=sqrt(sin(3.2));}

विभिन्न कारणों से, C स्वचालित रूप से मानक गणितीय कार्यों जैसे पाप, कॉस, टैन, sqrt इत्यादि से लिंक नहीं करता है, इसलिए यदि उनका उपयोग किया जाता है, लेकिन लिंक नहीं किया जाता है, तो डेवलपर को लिंकर त्रुटि अपरिभाषित संदर्भ के साथ प्रस्तुत किया जाएगा। 'sqrt' , या कुछ अन्य त्रुटि।

Gcc में, ऊपर दिया गया कोड उपयोग करके संकलन और लिंक करेगा gcc length-51.c -lm

नोट sin(3.2)एक नकारात्मक संख्या लौटाएगा, जिसमें से वास्तविक डोमेन में वर्गमूल कानूनी नहीं है। सी में, NaNइस त्रुटि को इंगित करने के लिए एक विशेष मान लौटाया जाता है, जिसे प्रोग्राम अनदेखा करने के लिए स्वतंत्र है!

C99 में, इस प्रकार की गणित त्रुटियों के बहुत ही सुरक्षित और बारीक नियंत्रण प्रदान करने के लिए बहुत सारे नए अपवाद हैंडलिंग कार्य हैं, जो कि किसी के उपयोग के बारे में नहीं है!

लंबाई 63 स्निपेट

static int w;static int X(int x){static int s=0;s^=x;return s;}

या अधिक पवित्र स्वरूपित:

static int w;
static int X(int x)
{
    static int s=7;
    s^=x;
    return s;
}

जैसा कि आपने अनुमान लगाया होगा, यह सब उस कीवर्ड के बारे में है staticजिसका C में एक से अधिक अर्थ है।

पहले दो मामलों में, staticसंकलक को बता रहा है कि पूर्णांक wऔर फ़ंक्शन Xइस फ़ाइल या संकलन इकाई के बाहर दिखाई नहीं दे रहे हैं, अर्थात वे आंतरिक हैं।

इन कार्यों को बाहरी रूप से कहने का इरादा नहीं है, इसलिए वे वैधता के लिए तर्कों की जांच नहीं कर सकते हैं, और अन्य कोनों को काट सकते हैं। क्योंकि वे आंतरिक गुंजाइश है, तो आप को फिर से परिभाषित कर सकते हैं wऔर Xअन्य फ़ाइलों में, और वे आमतौर पर अलग हो जाएगा।

अंतिम स्थिति में, staticइंगित करता है कि पूर्णांक sफ़ंक्शन कॉल के बीच अपने मूल्य को बरकरार रखता है। पहली बार Xकहा जाता है, sइसका प्रारंभिक मूल्य होगा 7, जब यह अनन्य-ओरेड के साथ होगा x, तो नया मूल्य बनाए रखा जाएगा।

आंतरिक रूप से, हालांकि यह कार्यान्वयन पर निर्भर है, सामान्य मेमोरी संगठन वह sहै जो ढेर पर रहता है, विशेष रूप से प्रारंभिक स्मृति, जबकि तर्क xस्टैक पर रहता है। उदाहरण के लिए, यदि आप पुनरावर्ती एल्गोरिदम को लागू करना चाहते हैं तो चर महत्वपूर्ण हैं।

C में एक गोच वैश्विक वैरिएबल के साथ टकराव है। इस समय तक wऔर Xवास्तव में के रूप में परिभाषित कर रहे हैं staticअगर वे परिभाषित कर रहे हैं दुनिया भर में कहीं न कहीं, तो, wऔर Xबजाय वैश्विक संस्थाओं के पास भेजेगा।

यहाँ qऔर wएक ही मूल्य के लिए इनिशियलाइज़ नहीं किया जा सकता है, क्योंकि एक ग्लोबल wसेट करने के लिए इस्तेमाल किया जा रहा है q:

static int q = w;
static int w;

यदि कोई वैश्विक wमौजूद नहीं है, तो संकलन विफल हो जाना चाहिए।

यहाँ qऔर wएक ही मूल्य के लिए इनिशियलाइज़ किया जाएगा:

static int w;
static int q = w;

आमतौर पर, डिजाइनर अपने वैश्विक चर और कार्यों में एक विशिष्ट उपसर्ग या प्रत्यय जोड़कर नाम की कमी को कम करेंगे।

C99 में, staticएक और उपयोग प्राप्त किया है, उदाहरण के लिए int Y(int a[static 10]);जिसका अर्थ है कि एक फ़ंक्शन है Yजो कम से कम 10 पूर्णांकों की एक सरणी लेता है ।

लंबाई 74 स्निपेट

void f(register int*p,register int*q,register int l){while(l--)*p++=*q++;}

या अच्छी तरह से बाहर रखा:

void f(register int *p, register int *q, register int l)
{
    while (l--)
        *p++ = *q++;
}

कीवर्ड registerकंपाइलर को संकेत देता है कि हार्डवेयर रजिस्टरों का उपयोग करना यहाँ लाभदायक होगा। ऊपर समारोह की प्रतिलिपि बनाएगा lसे पूर्णांकों qके लिए p, यदि संभव हो तो हार्डवेयर रजिस्टरों का उपयोग कर।

कभी-कभी स्पीडअप महत्वपूर्ण हो सकता है। उदाहरण के लिए, 68K माइक्रोप्रोसेसर परिवार में, लाइन *p++ = *q++को एक ही निर्देश MOVE.W (Ap)+,(Aq)+बनाम छह या आठ में अनुवाद किया जा सकता है यदि आपने उपयोग नहीं किया है register। 68K माइक्रोप्रोसेसर, स्पष्ट के बाद वेतन वृद्धि और पूर्व घटती मोड, तो समझ रखने वाले डेवलपर था कि क्या वह मंच जानता था, का उपयोग करके कोड से तैयार हैं x++और --yबनाम ++xऔर y--

इन दिनों कंपाइलर ज्यादातर अनदेखा कर देते हैं register, इसके अलावा, पते लेने की अनुमति नहीं दी जाती (उदाहरण के लिए ऊपर &lकंपाइलर त्रुटि का कारण होगा)।

लंबाई 88 स्निपेट

#include<stdio.h>
int f(int x){return(x>1)?x*f(x-1):1;}int main(){printf("%d\n",f(12));}

या एक सैनर लेआउट के साथ:

#include <stdio.h>

int f(int x)
{
    return (x > 1)? x * f(x - 1): 1;
}

int main()
{
    printf("%d\n", f(12));
}

आह, पुनरावृत्ति! स्निपेट संकलन, लिंक और रन करने का एक पूरा कार्यक्रम है। फ़ंक्शन पुनरावर्ती सूत्र f (x) = x * f (x - 1) का उपयोग करके fअपने तर्क के भाज्य की गणना करता है x। Factorials वास्तव में जल्दी से बड़े हो जाते हैं, इसलिए उदाहरण के लिए f(12)आप एक हस्ताक्षरित 32-बिट पूर्णांक में प्राप्त कर सकते हैं सबसे बड़ा मूल्य है।

वास्तव में पुनरावर्ती कोड के उदाहरण के लिए , एकरमैन फ़ंक्शन के भोले कार्यान्वयन में देखें ।

स्मार्ट कंपाइलर फ़ंक्शन को ऑप्टिमाइज़ कर सकते हैं, संकेत का उपयोग करके inlineऔर फ़ंक्शन को "अनियंत्रित" करते हैं जब स्थिरांक को तर्क के रूप में प्रदान किया जाता है:

f(12)

हो जाता है:

12 * 11 * 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1

बिना किसी फ़ंक्शन कॉल की आवश्यकता है!

अन्य संकलक कार्य को पुनर्गठित कर सकते हैं:

int f(int x)
{
    return (x < 2)? 1: f(x - 1);
}

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

असेंबली भाषा में, इस प्रकार के अनुकूलन के अवसर वास्तव में आसान होते हैं और इसे "कीहोल ऑप्टिमाइज़र" नामक किसी चीज़ द्वारा कार्यान्वित किया जा सकता है, जो मूल रूप से छोटे पैटर्न की तलाश करता है और उन्हें कुछ तेज़ और / या छोटे से बदल देता है।

लंबाई 117 स्निपेट

#include<stdio.h>
int main(int c,char**v){int a,b;sscanf(v[1],"%d%*[\t ,]%d",&a,&b);printf("%d\t%d\n",a,b);return 0;}

या:

#include <stdio.h>

int main(int c, char **v)
{
    int a, b;

    sscanf(v[1], "%d%*[\t ,]%d", &a, &b);
    printf("%d\t%d\n", a, b);

    return 0;
}

C उस समय समकालीन भाषाओं से उधार लिया गया था, एक सार्वभौमिक I / O की अवधारणा जो किसी भी उपकरण, चाहे कंसोल, पंच कार्ड, टेप, डिस्क या प्रिंटर पर लगातार लागू हो सकती है, लेकिन सही C रूप में, इसने डेवलपर को बनाने की अनुमति दी बहुत ही आकर्षक लेकिन शक्तिशाली कथन।

उपरोक्त स्निपेट में, यह कमांड लाइन इनपुट लेगा, दो पूर्णांकों को रिक्त स्थान, टैब या कॉमा से अलग कर देगा और उन्हें आउटपुट करेगा। यह एक नए scanfविनिर्देशक का लाभ उठाता है %*[\t ,]जो: [\t ,]सभी टैब, रिक्त स्थान और अल्पविराम को बाहर निकालता है, और: *उन्हें अनदेखा करता है।

मैं कुछ सी ++ कोड में संशोधन जहां डेवलपर सब कुछ "शुद्ध" सी ++ तरीके के साथ कर रहा था याद <<और इस तरह के तरीकों में से एक शस्त्रागार findऔर substr। यह कम से कम एक दर्जन रेखाएँ थीं और यह अभी भी अल्पविरामों को सीमांकक के रूप में नहीं संभाल सका। मैंने sscanfऊपर की तरह एक पंक्ति के साथ उस सभी क्लूनी कोड को बदल दिया !

लंबाई 132 स्निपेट

#include<stdio.h>
int main(int c,char**v){while(--c){++v;printf("|%s|\n|%5s|\n|%-5s|\n|%.5s|\n|%5.5s|\n",*v,*v,*v,*v,*v);}return 0;}

या:

#include <stdio.h>

int main(int c, char **v)
{
    while (--c)
    {
        ++v;
        printf("|%s|\n|%5s|\n|%-5s|\n|%.5s|\n|%5.5s|\n", *v, *v, *v, *v, *v);
    }

    return 0;
}

कार्यों printf, sprintf, fprintfआदि उपयोग प्रारूप विनिर्देशक चौड़ाई और उत्पादन के गद्दी परिभाषित करने के लिए।

विभिन्न आउटपुट देखने के लिए कमांड लाइन तर्कों का उपयोग करके ऊपर संकलन करें और चलाएं:

> main xyz 123456
|xyz|                                                                                                                                                
|  xyz|                                                                                                                                              
|xyz  |                                                                                                                                              
|xyz|                                                                                                                                                
|  xyz|                                                                                                                                 
|123456|                                                                                                                                             
|123456|                                                                                                                                             
|123456|                                                                                                                                             
|12345|                                                                                                                                              
|12345| 

अधिकतम पांच वर्णों के .5लिए विनिर्देशक के लिए आउटपुट की सीमा को नोट करें , जबकि प्रमुख यह सुनिश्चित करता है कि आउटपुट कम से कम पांच वर्ण है, जो संरेखण को इंगित करता है। उनका संयोजन आउटपुट को ठीक पांच वर्णों पर सेट करता है।5-


4
मुझे नहीं लगता कि प्रत्येक upvote के लिए एक नया फैक्टॉइड जोड़ने की आवश्यकता थी :)
ऑप्टिमाइज़र

28
C में एक सामान्य संस्कृति संकलन चेतावनी को अनदेखा करना है , मुझे नहीं लगता कि यह कहीं भी सच्चाई के पास है!
शाहबाज

4
यदि आपके पास एक बड़ी परियोजना है और कई संकलक मानते हैं, तो सभी चेतावनियों को खत्म करने की कोशिश करना काफी व्यर्थ हो सकता है।
फ़ेरसम

5
यह उत्कृष्ट है
किक

4
मैं एक सी प्रोग्रामर हूं, और मैं हास्केल से डरता नहीं हूं।
शाहबाज

138

x86 मशीन कोड

factoid:

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

लंबाई 1:

अब पहले कार्यक्रम के लिए:

0xC3

एक हेक्स संपादक खोलें, उस बाइट को दर्ज करें, और इसे test.com के रूप में सहेजें।

अब आपके पास मान्य MS-DOS प्रोग्राम है जो बिना कुछ किए तुरंत वापस आ जाता है, क्योंकि 0xC3 इंस्ट्रक्शन 'RET' है। हालांकि यह x86 के साथ गोल्फ के लिए एक और दिलचस्प पहलू दिखाता है: .com फ़ाइल प्रारूप। इस निष्पादन योग्य प्रारूप में बिल्कुल कोई हेडर नहीं है - फ़ाइल को केवल 0x100 पते पर शुरू होने वाली मेमोरी में लोड किया गया है, और फिर निष्पादन 0x100 पर शुरू किया गया है। इसका मतलब है कि मेटाडेटा पर कोई बाइट बर्बाद नहीं हुई है!

लंबाई 2:

हमारा अगला कार्यक्रम:

0x4D 0x5A

या ASCII में 'MZ'।

ठीक है, मैंने थोड़ा धोखा दिया, यह वास्तव में एक उपयोगी कार्यक्रम नहीं है, क्योंकि यह निर्देशों से मेल खाती है

DEC     BP
POP     DX

जो वास्तव में .com प्रोग्राम शुरू करने के लिए उपयोगी नहीं हैं। वास्तव में, यह उन दो मूल्यों का पूरा बिंदु है - कोई उचित .com फ़ाइल उनके साथ शुरू नहीं होनी चाहिए! .com फाइलें आकार में 65280 बाइट्स (64KiB - 0x100) तक सीमित थीं, इसलिए जब बड़े कार्यक्रमों की आवश्यकता होने लगी, तो एक नया प्रारूप विकसित करना पड़ा। यह .exe फ़ाइल स्वरूप था, जिसमें हेडर होता है। हालाँकि, MS-DOS को बैकवर्ड संगतता के लिए कुछ घटकों पर .com एक्सटेंशन को रखने की आवश्यकता थी, इसलिए यह पता लगाने के लिए एक तरीका आवश्यक था कि .com फ़ाइल वास्तव में .exe है या नहीं। उन्होंने स्टिंग 'MZ' को इस मैजिक नंबर के रूप में चुना, और आज तक, यदि आप एक हेक्स एडिटर में एक .exe (या .dll) फ़ाइल खोलते हैं, तो आप देखेंगे कि वे उन दो बाइट्स से शुरू होते हैं। यह मुझे खुशी देता है कि यहां तक ​​कि सबसे आधुनिक विंडोज प्रोग्राम 70 के दशक से संगतता बाधा के साथ शुरू होता है।

लंबाई 3:

अब एक अनंत लूप के लिए:

41 E2 FD

जिसका अनुवाद है

start:
inc cx
loop start 

यह प्रोग्राम सीएक्स के मूल्य को बढ़ाता है (जो कि 0 से शुरू होगा), फिर लूप इंस्ट्रक्शन को निष्पादित करता है। लूप एक CISC इंस्ट्रक्शन का एक उत्कृष्ट उदाहरण है क्योंकि यह 3 सरल ऑपरेशनों को एक विशेष-उद्देश्य ऑपरेशन में जोड़ता है: यह CX के मान को घटाता है, अगर यह 0 है, और यदि नहीं तो लक्ष्य लेबल पर कूदता है। लूप के ऐसे रूप भी हैं जो सीएक्स 0. होने के अलावा अन्य झंडे की जांच करते हैं। हम 2 बाइट अनंत लूप के लिए सिर्फ 'जंप स्टार्ट' कर सकते थे, लेकिन यह अधिक दिलचस्प था।

लंबाई 4:

एक कार्यक्रम जो न्यूनतम उपयोगी है:

40 CD 10 C3

विधानसभा में अनुवादित:

inc ax    ; 1 byte
int 10h   ; 2 bytes
ret       ; 1 byte

यह प्रोग्राम 40x25 अक्षरों के कंसोल को सेट करता है, स्क्रीन को साफ करता है, फिर कमांड लाइन पर लौटता है। AX हम चाहते हैं (1) वीडियो मोड पर सेट किया गया है, तो BIOS व्यवधान 10 h को वास्तव में वीडियो मोड सेट करने और विंडो को खाली करने, लौटने से पहले बुलाया जाता है। भविष्य में इनमें से अधिक BIOS बाधित होने की उम्मीद है।

लंबाई 5:

अब हम एक ठहराव कार्यक्रम लागू कर सकते हैं:

B4 01 CD 21 C3

विधानसभा में अनुवादित:

mov ah,1  ; 2 bytes
int 21h   ; 2 bytes
ret       ; 1 byte

यह प्रोग्राम BIOS को दबाए जाने के लिए कुंजी की प्रतीक्षा करने के लिए कहता है और लौटने से पहले इसे स्क्रीन पर इकोस करता है। यह यह भी दर्शाता है कि x86 पर, कुछ रजिस्टरों को आंशिक रूप से पढ़ा या लिखा जा सकता है। इस स्थिति में, हम AX (AH) के शीर्ष बाइट को 1. 32 बिट प्रोसेसर पर सेट करते हैं, आप शीर्ष 16 बिट्स को प्रभावित किए बिना निम्न 16 बिट्स पर भी काम कर सकते हैं। आंशिक रजिस्टरों को संशोधित करने की यह क्षमता असेंबली प्रोग्रामर के लिए आसान हो सकती है, लेकिन आधुनिक प्रोसेसर के लिए कमियां हैं जो आउट-ऑफ-ऑर्डर निष्पादन करने की कोशिश कर रहे हैं , क्योंकि वे गलत डेटा निर्भरताएं पेश कर सकते हैं।

लंबाई 9:

अब वास्तव में आउटपुट प्रदर्शित करने के लिए:

68 00 B7 07 AB 40 79 FC C3

विधानसभा में अनुवादित:

; These two instructions set up ES, the 'extra segment'
push 0xb700 ; 3 bytes
pop  es     ; 1 byte
label:
stosw       ; 1 byte, Store Word - Copy AX to [ES:DI] then add 2 to DI
inc  ax     ; 1 byte
jns  label  ; 2 bytes, Jump Not Signed - Jump unless the sign flag is set (when inc AX yields 0x8000
ret         ; 1 byte

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

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

लंबाई 20:

चलो कुछ पहचानने योग्य बनाते हैं - हम Sierpinski त्रिकोण बनाने के लिए 'नियम 90' का उपयोग करेंगे।

B0 13 CD 10 68 0F A0 1F AC 31 C2 88 94 3E 01 87 D3 93 EB F4

विधानसभा में:

mov al,13h      ; 2b
int 10h         ; 2b - Set the video mode to 13h

push    0xA00F  ; 3b
pop     ds      ; 1b - Set the data segment to video memory

start:          ; This loop runs 'Rule 90' to draw Sierpinski triangles
lodsb           ; 1b - load al with [ds:si] then increment si

xor     dx,ax   ; 2b - xor the left and right values of the previous row of pixels
mov     [si+318],dl ;4b - store result to memory

xchg    dx,bx   ; 2b - swap register values
xchg    ax,bx   ; 1b - swapping with ax is 1 byte shorter

jmp     start   ; 2b - infinite loop

नमूना उत्पादन: Sierpinski त्रिकोण

इस कार्यक्रम के लिए, हम कुछ प्रसिद्ध 'मोड 13' का उपयोग करते हैं - एक ग्राफिक्स मोड जिसमें 256 रंगों के साथ 320x200 का संकल्प है। इसका उपयोग कई लोकप्रिय डॉस गेम्स , जैसे कि डूम के द्वारा किया गया था ।

लंबाई २१

आइए देखें कि हम जिस सीपीयू का निर्माण कर रहे हैं, वह किस पर चल रहा है।

0F A2 66 60 BB EE FF B9 0C 00 8A 17 43 B4 02 CD 21 E2 F7 FF E1

विधानसभा में अनुवादित:

cpuid         ; 2b  CPU ID - retrieve processor information based on the value in AX. For AX=0,
              ;     the 12 bytes in EBX, ECX, and EDX are loaded with a vendor identification string
pushad        ; 2b  Push all registers on the stack (32 bit version)
mov  bx,0xffee; 3b  Start of the vendor identification string on the stack
mov  cx,12    ; 3b  12 characters to print
print:    
mov  dl,[bx]  ; 2b  Character to print
inc  bx       ; 1b  Advance string position
mov  ah,2     ; 2b  Set AH to the 'Print character to STDOUT' value
int  21h      ; 2b  Call the bios interrupt to print
loop print    ; 2b  Decrement CX and jump if it is not zero
jmp  cx       ; 2b  Instead of restoring the stack, just jump right to the exit point

नमूना उत्पादन:

c:\misc>cpuid.com
GenuineIntel

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

लंबाई 26

अब हम दिलचस्प एनिमेशन कर सकते हैं

B0 13 CD 10 C4 07 BB 40 01 59 99 89 F8 F7 F3 31 D0 AA E2 F6 26 FE 05 47 EB FA

विधानसभा में

mov al,13h     ;2b
int 10h        ;2b Enter Video Mode 13h

les ax,[bx]    ;2b Set ES to (roughtly) video memory
mov     bx,320 ;3b Set up  BX asdivisor
pop     cx     ;1b Zeroize CX

start:
cwd            ;1b Sign extend AX to DX, AX will never have the sign bit set so this zeroizes DX in 1 byte
mov     ax,di  ;2b Copy video memory pointer
div     bx     ;2b Divide by width to get AX = Y pos, DX = X pos
xor     ax,dx  ;2b X pos ^ Y pos
stosb          ;1b Store and increment video pointer
loop    start  ;2b CX starts at 0, so this will loop until it wraps around

cycle:
inc     byte [es:di];3b Increment value in video memory to animate
inc     di     ;1b Increment video memory pointer
jmp     cycle  ;2b Infinite loop 

और आउटपुट इस तरह दिखेगा:

मार्चिंग XOR

समारोह एक्स पॉस ^ वाई पॉस एक दिलचस्प भग्न पैदा करता है, खासकर जब एनिमेटेड

लंबाई 27

न केवल आप एक छोटे से x86 .com कार्यक्रम में पाठ और ग्राफिक्स उत्पन्न कर सकते हैं, आप ध्वनि और संगीत भी उत्पन्न कर सकते हैं:

BA 31 03 B0 3F EE BA 30 03 B0 93 EE B4 01 CD 21 3C 1B EE 3C 1B B0 7F EE 75 EC C3

विधानसभा में:

    mov dx,0x331            ; value for the midi control port
    mov al,0x3F             ; command value to set midi mode to UART
    out dx,al               ; output the command to the midi control port
play_loop:
    mov dx,0x330            ; value for the midi data port
    mov al,0x93             ; midi instrument value (piano)
    out dx,al               ; output to midi data port
    mov ah,1
    int 0x21                ; read character from stdin, with echo
    cmp al,27               ; test if it is escape
    out dx,al               ; output the ascii value as the midi note to play
    mov al,0x7F             ; note duration
    out dx,al               ; output note duration
    jne play_loop           ; loop if escape was not pressed
    ret  

यह प्रोग्राम कीबोर्ड को पियानो में बदलने के लिए मिडी कार्ड का उपयोग करता है। ऐसा करने के लिए, मिडी कार्ड को UART मोड पर सेट किया जाता है, जो प्राप्त होते ही मिडी नोट खेलता है। इसके बाद, प्रोग्राम एक चरित्र को दबाए जाने की प्रतीक्षा करता है, और मिडी कार्ड के नोट के रूप में ASCII मूल्य को आउटपुट करता है। भागने तक दबाया जाता है कार्यक्रम चलता है।

लंबाई 29

आइए ड्रैगन वक्र भग्न बनाने के लिए एक पुनरावृत्त फ़ंक्शन सिस्टम का उपयोग करें :

B0 13 CD 10 89 D0 01 CA 29 C1 D1 FA D1 F9 73 03 83 E9 7A B4 01 CD 16 B8 02 0C 74 E6 C3

विधानसभा में अनुवादित:

mov  al,13h
start:
int  0x10    ; This does double duty, setting the video mode to 13h at program start,
             ; and calling the 'draw pixel at coordinates' interrupt when looping
mov  ax,dx   ; The next couple instructions are our IFS, the algorithm is aproximately
add  dx,cx   ; f(y) = 0.5x + 0.5y
sub  cx,ax   ; f(x) = 0.5x - 0.5y OR f(x) = 0.5x - 0.5y - 1
sar  dx,1    ;
sar  cx,1    ;
jnc  skip    ; This jump handles pseudo-randomly switching between the two functions for x,
             ; based on if the previous value of x was odd or not.
sub  cx,122  ; Magic number, chosen since it provides sufficent 'randomness' for a filled in
             ; fractal and a good scale to the fractal. 102 and 130 also work.
skip:
mov  ah,1
int  0x16    ; Get keyboard state, zero flag will be set if no key has been pressed
mov  ax,0xC02; Set up AH for the draw pixel function when int 0x10 is executed,
             ; AL = color, CX = column, DX = row
jz   start   ; Loop if a key hasn't been pressed
ret  

आउटपुट:

ड्रैगन कर्व

एक गैर-नियंत्रण कुंजी दबाने से प्रोग्राम बाहर निकल जाएगा। यह Pouet.net पर Desire द्वारा फायर कोरल पर आधारित है।

लंबाई 52

यह कार्यक्रम एक दोहरी विशेषता का एक सा है, यह x87 फ्लोटिंग-पॉइंट सह-प्रोसेसर और आत्म-संशोधित कोड का एक सा दिखाता है।

B3 07 D9 E8 B1 11 DE 0E 32 01 E2 FA BE 0A 24 56 B1 09 DF 34 AC D4 10 
86 E0 05 30 30 50 E2 F5 44 B4 2E 50 89 E2 B4 09 CD 21 FE 06 03 01 4B
75 D2 CD 20 0A 00

जब चलाया जाता है, तो प्रोग्राम कई गणितीय स्थिरांक का उत्पादन करेगा:

1.00000000000000000
3.32192809488736235
1.44269504088896341
3.14159265358979324
0.30102999566398120
0.69314718055994531
0.00000000000000000

ये हैं वन, लॉग 2 (10), लॉग 2 (ई), पाई, लॉग 10 (2), लॉग ई (2) और जीरो।

विधानसभा में:

org 100 ह

mov     bl,7         ;Counter for the total number of constants to print
start:
fld1                 ;Floating point constant to load on the FP stack,
                     ;start with 1 since it's op-code is the lowest

mov     cl,17        ;Multiply the constant by 10, 17 times to get the
mult:                ;printing part as an integer
fimul   word[ten]
loop    mult

mov     si,10+'$'*256;ASCII new line (10) and the end-of-string ($)
                     ;characters. These are used both as
push    si           ;a constant memory location, and stored to the
                     ;stack to format and printing

mov     cl,9         ;print 18 digits (9 pairs)
fbstp   [si]         ;store the integer part of the floating point
                     ;number on top of the FP stack as a packed
                     ;binary-coded decimal number (1 digit/nibble),
                     ;and then pop the number off the FP stack

convert:
lodsb                ;load a pair of packed digits

db 0xd4,16 ; AAM 16  ;ASCII Adjust For Multiply instruction using
                     ;non-standard base 16. This puts AL/16 in AH,
                     ;and AL%16 in AL, unpacking the digit pair.

xchg    ah,al        ;Swap the digit order
add     ax,'00'      ;Convert the digits to ASCII values
push    ax           ;Store digits on the stack
loop    convert

inc     sp           ;AX now holds the 1st 2 digits to print,
mov     ah,'.'       ;so to insert a decimal point, the 2nd digit
push    ax           ;is replaced with a '.', the stack pointer
                     ;is adjusted to overwrite 1 byte, and then
                     ;AX is pushed on the stack

mov     dx,sp        ;Load DX with the start of the print string
mov     ah,9         ;Load AH with the 'Print String' constant
int     21h          ;Call the 'Print String' interrupt to display
                     ;the constant

inc     byte[start+1];Self-modifying code - increment the load
                     ;floating point constant op-code to iterate
                     ;through all of them

dec     bx
jnz     start        ;Exit when all 7 constants have been printed
int     20h


ten: dw  10

X86 सिस्टम पर फ्लोटिंग पॉइंट गणित को मूल रूप से वैकल्पिक x87 सह-प्रोसेसर द्वारा नियंत्रित किया गया था, यह 486 तक नहीं था कि इसे उसी चिप पर स्थानांतरित किया गया था। X87 में भी एक अलग वास्तुकला थी, यह स्टैक-आधारित थी, जिसमें 8 80bit रजिस्टर उपलब्ध थे। इसमें कई प्रकार के राउंडिंग मोड, सटीक और नकाबपोश अपवाद भी निर्धारित किए जा सकते हैं।

यह प्रोग्राम प्रोसेसर में पके हुए सात स्थिरांक के मानों को प्रिंट करता है। यह अजीब लग सकता है कि निर्देश स्थान 0 और 1 जैसे सरल स्थिरांक पर बर्बाद हो जाएगा, लेकिन ध्यान रखें कि निर्देश सेट मेमोरी के छोटे होने पर बनाया गया था, और ये निर्देश आम तौर पर समकक्ष कार्यों की तुलना में 2 बाइट्स छोटे होते हैं। कार्यक्रम में एक अस्पष्ट निर्देश, FBSTP -'Store BCD Integer and Pop 'का भी उपयोग किया गया है। जब x86 विकसित किया गया था, तो वापस BCD नंबरों पर संचालन अधिक सामान्य था, और x86 / x87 में विशेष रूप से BCD गणित को सरल बनाने के लिए कई निर्देश हैं, जैसे कि AAM 'ASCII एडजस्ट फॉर मल्टीपल' निर्देश भी कार्यक्रम में उपयोग किया जाता है।

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

लंबाई 64

मैंडलब्रॉट चैलेंज के लिए मेरी प्रविष्टि को क्रॉस-पोस्ट करना , एक प्रोग्राम लिखा जा सकता है जो केवल 64 बाइट्स में 320x200 रंग मेंडेलब्रोट फ्रैक्टल प्रदर्शित करता है।

B0 13 CD 10 C4 07 99 89 F8 B9 40 01 F7 F1 83 E8 64 FE CE 31 DB 31 F6 
89 F5 0F AF F3 01 F6 0F AF DB 70 19 0F AF ED 70 14 01 EB 70 10 29 EB
29 EB C1 FB 06 01 D3 C1 FE 06 01 C6 E2 DB 91 AA EB C6

विधानसभा में:

mov al,13h ; set up graphics mode 13
int 10h

les ax,[bx]; trick to set video memory

FillLoop:
cwd
mov ax,di  ; di is the current position on screen
mov cx,320 ; convert di int x,y screen coordinates
div cx     ; CX is the iteration counter, exit the loop if it hits
           ; zero before the value escapes.
sub ax,100 ; center the fractal vertically
dec dh     ; center the fractal horizontally

xor bx,bx
xor si,si

MandelLoop: ; Fairly standard Mandelbrot routine,
mov bp,si   ; exits if the values overflow
imul si,bx
add si,si
imul bx,bx
jo MandelBreak
imul bp,bp
jo MandelBreak
add bx,bp
jo MandelBreak
sub bx,bp
sub bx,bp

sar bx,6   ; We use fixed point math with the lowest 6
add bx,dx  ; bits being the fractional portion, so this
sar si,6   ; rescales the values after multiplication
add si,ax

loop MandelLoop

MandelBreak:
xchg ax,cx ; Write the escape itteraction as the color
stosb
jmp FillLoop

अंतिम परिणाम यह छवि है:

मैंडलब्रोट फ्रैक्टल

यह कार्यक्रम फ्रैक्टल उत्पन्न करने के लिए फिक्स्ड-पॉइंट गणित का उपयोग करता है, क्योंकि यह कम बाइट लेता है। 16 बिट रजिस्टरों में से सबसे कम 6 बिट्स को अंश का आंशिक भाग माना जाता है, और मान गुणा किए जाने के बाद फिर से बढ़ जाते हैं।


7
पीपीसीजी पर देखने के लिए सभी भाषाओं में से, मुझे इसकी उम्मीद नहीं थी।
एलेक्स ए।

23
वाह। प्लस अन्य पात्रों यह एक टिप्पणी करने के लिए। परन्तु गंभीरता से। वाह।
krs013

2
@ माइकल एडेनफील्ड यही DOSBox है!
सर_जगलोट

1
20 बाइट Sierpinski बहुत प्रभावशाली है।
qwr

1
मैं खुद को एक अच्छा प्रोग्रामर मानता हूं, लेकिन जब मैं इसे देखता हूं तो मुझे हार माननी चाहिए।
Stephan Bijzitter

121

हास्केल

आप नीचे से ऊपर पढ़ने के लिए चाहते हो सकता है। कभी-कभी मैं निचले स्निपेट का उल्लेख करता हूं, लेकिन कभी भी उच्चतर लोगों को नहीं, इसलिए यह समझने में मदद कर सकता है।

पाठक जो हास्केल को नहीं जानते हैं: क्या मैं स्पष्ट हूं? जब मैं स्पष्ट नहीं हूँ? मैं बता नहीं सकता।

लंबाई 86 स्निपेट

हमारे पेड़ डेटा संरचना (स्निपेट 23) के लिए एक तह उदाहरण। फोल्डेबल एक प्रकार का वर्ग है - जैसा कि, प्रकारों का एक वर्ग (/ समूह)। ये जावा में इंटरफेस के समानांतर हैं। वे अनिवार्य रूप से प्रकारों को सामान्य करते हैं, उन प्रकारों को एकजुट करते हैं जिनमें सामान्य विशेषताएं होती हैं; उदाहरण के लिए, उन्हें एक साथ जोड़ा जा सकता है ( Monoid), कंटेनर ( Functor), पाठ के रूप में मुद्रित किया जा सकता है ( Show, जिसे हम पहले ही मिल चुके हैं, showफ़ंक्शन में), और इसी तरह। यह उन डेटा प्रकारों को एकीकृत करता है जो सूची-जैसे होते हैं कि वे सूची से अधिक प्रसारित या चपटा हो सकते हैं।

इस स्निपेट में, हम परिभाषित करके परिभाषित करते हैं foldr, जो अनिवार्य रूप से दाएं से बाएं से डेटा प्रकार पर पुनरावृत्ति करता है। अब, हम सामान्य पूर्व-लिखित कोड का एक गुच्छा उपयोग कर सकते हैं। सबसे पहले, हम एक सहायक समारोह एक सिंगलटन पेड़ प्राप्त करने के लिए, सभी अव्यवस्था से बचने के लिए निर्धारित किए हैं: s a = N E a E। अभी:

sum (N (s 3) 7 (N E 5 (s 8))     === 23
product (N (s 3) 7 (N E 5 (s 8)) === 840
toList (N (s 3) 7 (N E 5 (s 8))  === [3,7,5,8]

और इसी तरह।

यहाँ हमारे पेड़ की एक तस्वीर है:

7
| \
3  5
    \
     8

लंबाई 70 स्निपेट

primes=sieve[2..] where
 sieve(p:xs)=p:sieve(filter(\x->x`mod`p/=0)xs)

यह एक प्रमुख छलनी है!

(नोट: अन्य भाषाओं में /=क्या !=है)

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

फिर, हम यहां अनंत सूचियों के साथ काम कर रहे हैं - लेकिन गणना समय में रुक जाएगी जब तक आपको गणना करने के लिए अनंत राशि की आवश्यकता नहीं होती है।

take 4 primes === [2,3,5,7]

लंबाई 68 स्निपेट

अंत में, एक रानी!

main=do putStr s;print s where s="main=do putStr s;print s where s="

इसे पढ़ते हुए, आप पहली बार सोच सकते हैं कि इस क्वीन के आउटपुट में उद्धरण चिह्नों की कमी है, और आप एक बार putStrऔर एक बार क्यों लिखेंगे print? यह एक ही लगता है।

हास्केल में, putStrएक ऐसा कार्य है जो स्ट्रिंग की सामग्री को प्रिंट करता है जो इसे स्टडआउट को प्राप्त करता है; printहालाँकि, चीजों को स्टडआउट करने के लिए प्रिंट करता है। तो, print 4के बराबर है putStr "4\n", लेकिन putStr 4निरर्थक है - 4एक स्ट्रिंग नहीं है! इसलिए, जब printकोई मान मिलता है, तो यह पहले इसे एक स्ट्रिंग में परिवर्तित करता है, और फिर उस स्ट्रिंग को प्रिंट करता है। आमतौर पर चीजों को स्ट्रिंग्स में बदलने का तरीका यह है कि जिस तरह से आप इसे कोड में लिखेंगे उसे ढूंढना होगा। तो, जिस तरह से आप स्ट्रिंग abcको एक स्ट्रिंग में हास्केल कोड में लिखेंगे "abc", वह print "abc"वास्तव में प्रिंट है "abc", नहीं abc

मेरे पास अभी कितने सौभाग्यशाली वोट हैं, मुझे इन चीजों को नहीं करना पड़ेगा

लंबाई 33 स्निपेट:

main=go 0
go n=do print n;go(n+1)

ध्यान देने वाली महत्वपूर्ण बात यह है कि हमने लूप का उपयोग नहीं किया है। हास्केल लूप नहीं करता है। हास्केल पुनरावर्ती करता है। हास्केल में लूप नहीं होते हैं। यह उससे कहीं अधिक गहरा है: हास्केल में नियंत्रण प्रवाह भी नहीं है । कैसे, आप पूछ सकते हैं? खैर, इसकी कोई जरूरत नहीं है।

विवरण के साथ। यह प्रोग्राम पूर्णांक के एक अनंत बढ़ते क्रम को प्रिंट करता है, जो 0. से शुरू होता है, goउन्हें इसके इनपुट से शुरू करते हुए प्रिंट करता है, फिर mainइसे कॉल करता है 0

doहास्केल की एक विशेष वाक्यात्मक शक्ति है। इस परिदृश्य में, यह सिर्फ I / O क्रियाओं को जोड़ता है, ठीक उसी तरह जैसे >>(स्निपेट 22 देखें)।

लंबाई 26 स्निपेट:

map f=foldr(\x y->f x:y)[]

यह mapफ़ंक्शन को परिभाषित करता है , शायद सभी के लिए परिचित है, का उपयोग करके foldr। ध्यान दें कि हालांकि, हमने mapकिसी प्रकार की घोषणा नहीं की है , लेकिन कंप्यूटर किसी भी तरह से जानता है कि इसका प्रकार क्या है , और इसमें से एक सूची (a -> b) -> [a] -> [b]दी गई है , और एस की एक सूची, एस की सूची लौटाएं ।abab

यह कैसे पता चला ?? ;-)

लंबाई 25 स्निपेट:

main=putStr"Hello World"

मानक नमस्ते विश्व। नोटों के प्रकार: mainका प्रकार होता है IO ()और putStrइसमें प्रकार होता है String -> IO ()(स्ट्रिंग्स से आई / ओ कार्यों के लिए एक फ़ंक्शन जो कुछ भी नहीं लौटाता है)।

लंबाई 23 स्निपेट:

data T a=E|N(T a)a(T a)

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

(स्निपेट 10 देखें)

चलो इसे तोड़ दो:

data- यह घोषणा डेटा प्रकार की घोषणा करती है। T a- एक पेड़ जिसमें प्रकार के तत्व होते हैं a। यह वह प्रकार है जिसे हम परिभाषित कर रहे हैं। =- प्रत्येक मूल्य में T aसे कोई एक पाइप द्वारा अलग किया जाएगा |E- T sखाली पेड़ के संभावित मूल्यों में से एक। N (T a) a (T a)- एक पेड़ का दूसरा संभावित मूल्य - एक नोड। प्रत्येक नोड में बाएं बच्चे ( (T a)) तत्व ( a) और दाएं बच्चे ( (T a)) होते हैं।

लंबाई 22 स्निपेट:

main=putStrLn"y">>main

एक हास्केल yesफ़ंक्शन। >>एक ऑपरेटर है जो दो I / O क्रियाओं को जोड़ता है और अनुक्रम करता है। इसका प्रकार है >> :: IO a -> IO b -> IO b

mainस्वयं द्वारा पुनरावर्ती रूप से परिभाषित किया गया है, जैसे कि I / O क्रिया जो पहले प्रिंट "y"करता है और फिर वही करता है जो mainस्वयं करता है।

लंबाई 18 स्निपेट:

fix f=r where r=f r

के लिए एक बेहतर परिभाषा fix। (स्निपेट 14. देखें) पहली परिभाषा के साथ समस्या यह fix f = f(fix f)है कि हर बार जब हम कॉल fix f fixकरते हैं fix f, जो याद करते हैं fix f, उसी गणना की अंतहीन प्रतियां उत्पन्न करते हैं । यह संस्करण rपरिणाम (परिणाम) को परिभाषित करने के लिए इसे ठीक करता है ; जैसे, f r = r। तो, चलो परिभाषित करते हैं r = f r। अब हम लौटते हैं r

लंबाई 17 स्निपेट:

f n=product[1..n]

यह भाज्य को परिभाषित करने का कार्यात्मक तरीका है।

लंबाई 16 स्निपेट:

f n=(\x->x+x+x)n

(\x -> x + x + x)एक लैम्ब्डा है (किसी ने सोचा था \कि यह अक्षर जैसा है।)।

(\x -> x + x + x) nपर लागू लैम्ब्डा n(यह बिल्कुल वैसा ही है n + n + n)।

fगुणा-तीन कार्य है (भी f = (*3))

लंबाई 15 स्निपेट:

sum=foldl (+) 0

यह sumएक गुना का उपयोग करके फ़ंक्शन को परिभाषित करता है । एक तह मूल रूप से एक संचयकर्ता के साथ सूची के तत्वों पर एक लूप है।
foldlतर्क के रूप में कुछ फ़ंक्शन fऔर xसंचायक और एक सूची के लिए कुछ प्रारंभिक मूल्य लेता है xs। फ़ंक्शन fको इनपुट को पिछले संचायक मान और सूची के वर्तमान मूल्य के रूप में प्राप्त करना चाहिए, और यह अगला संचायक लौटाता है।
फिर गुना सूची मानों पर पुनरावृत्ति करता है, fपिछले संचायक पर लागू होता है, और फिर अंतिम संचायक को वापस करता है।

सिलवटों के बारे में सोचने का एक और तरीका fसूची मूल्यों के बीच गुना 'आवेषण' की तरह है और एक पक्ष में प्रारंभिक संचायक के साथ है। उदाहरण के लिए, का foldl (*) 1 [4,2,5]मूल्यांकन करता है 1 * 4 * 2 * 5

लंबाई 14 स्निपेट:

fix f=f(fix f)

कंघी yकरनेवाला। इसे आमतौर पर नाम दिया गया है fixक्योंकि यह समीकरण का निर्धारण करता है f x = x। ध्यान दें कि x = infinite loopकभी-कभी एक समाधान भी हो सकता है, इसलिए fix (\x -> x^2 + 5*x + 7)समीकरण हल नहीं करेगा , x^2 + 4*x + 7 = 0बल्कि एक अनंत लूप लौटाएगा।

आप यह भी ध्यान रख सकते हैं कि x = infinite loopहास्केल के आलस्य के कारण हमेशा समाधान नहीं होता है।

यह संस्करण एक समय और अंतरिक्ष रिसाव है; हम इसे लंबे समय तक स्निपेट में फिर से परिभाषित करेंगे।

लंबाई 13 स्निपेट:

f=sum.map(^2)

यह उस फ़ंक्शन को परिभाषित करता है जो fएक सूची दी गई है, इसके वर्गों का योग देता है। यह है समारोह की संरचना समारोह sum और समारोहmap(^2) , जो बारी में है समारोह map के लिए आवेदन किया समारोह (^2) ( वर्ग समारोह ), जो बारी में का एक वर्ग है समारोह ^ (वर्गों टुकड़ा 2 में शुरू किए गए थे, और टुकड़ा 3 पर रचना )।

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

वैसे, तकनीकी रूप से, प्रत्येक दो या अधिक तर्क फ़ंक्शन एक फ़ंक्शन है जो आउटपुट के रूप में कार्य करता है (इसे क्यूरिंग कहा जाता है)।

लंबाई 10 स्निपेट:

data B=T|F

यह विभिन्न नामों के साथ हास्केल बूलियन की परिभाषा है। बूलियन प्रकार का नाम दिया गया है B
यह परिभाषा दो निर्माणकर्ताओं का परिचय देती है: सत्य ( T) और असत्य ( F)।
यह कोड स्निपेट मूल रूप से संकलक है कि हर बूलियन (बताता है B) या तो सही (है T) या गलत ( F,), या दूसरे शब्दों में B=T|F

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

लंबाई 9 स्निपेट:

main=main

यह निरर्थक कार्यक्रम mainमुख्य रूप से परिभाषित होगा । क्योंकि हास्केल आलसी है, जिन मूल्यों का मूल्यांकन करने के लिए एक अनंत लूप की आवश्यकता होती है, यदि हम उनके वास्तविक मूल्य का उपयोग नहीं करते हैं तो स्वतंत्र रूप से उपयोग किया जा सकता है। ऐसे मूल्य जिनमें अनंत लूप होते हैं, जैसे हमारे main, "बॉटम्स" कहलाते हैं।

एक मजेदार तथ्य यह है कि जीएचसी हास्केल कंपाइलर इन प्रकार के अनंत छोरों का पता लगा सकता है और जब इसे चलाया जाता है तो एक कैटलेबल (!) अपवाद को फेंक सकता है।

लंबाई 8 स्निपेट:

f(x:_)=x

यह फ़ंक्शन को परिभाषित करता है, fजो एक गैर-रिक्त सूची दी गई है, वह अपना सिर वापस कर देगा।

हास्केल में पैटर्न पायथन के अनुक्रम को अनपैक करने जैसा है, लेकिन सभी प्रकारों के लिए सामान्यीकृत है। पैटर्न या तो मान को अस्वीकार या मैच कर सकते हैं, और यदि यह मेल खाता है, तो चर को मानों से बाँध सकता है।

इस स्निपेट में पैटर्न हैं:

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

पैटर्न मिलान अत्यधिक सामान्यीकृत है। वास्तव में, नए डेटा प्रकारों को परिभाषित करने से स्वचालित रूप से उनके साथ काम करने के लिए पैटर्न शुरू हो जाएंगे।

लंबाई 5 स्निपेट:

x=2:x

वाह, इस पर समझाने के लिए बहुत कुछ है।

सबसे पहले, हास्केल आलसी है। इसका मतलब यह है कि सबएक्सप्रेस का मूल्यांकन केवल तभी किया जाएगा जब कड़ाई से आवश्यक हो।

नोट: यह कोड स्निपेट असाइनमेंट नहीं दिखाता है, लेकिन परिभाषा है। हास्केल के पास असाइनमेंट नहीं है।

यह कोड स्निपेट परिभाषित किया गया है x, एक अनंत सूची पूरी तरह से बनी है 2। आमतौर पर अन्य भाषाओं xमें मूल्यांकन किया जाना चाहिए पहले 2:xकभी भी मूल्यांकन किया जा सकता है, लेकिन हास्केल में हम ऐसा कर सकते हैं।

हास्केल अनंत सूचियां पुनरावृत्तियों और नियमित रूप से जुड़ी सूचियों के मिश्रण की तरह हैं: वे दोनों की तरह कार्य करते हैं (एक सीमा पर एक पुनरावृत्ति निरंतर स्मृति का उपयोग करेगी, उदाहरण के लिए)।

लंबाई 4 स्निपेट:

2:[]

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

लंबाई 3 स्निपेट:

f.g

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

लंबाई 2 स्निपेट:

1-

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

लंबाई 1 स्निपेट:

1

हास्केल में, 1हो सकता है दोनों एक Int, Float, Double, Wordऔर इसके आगे। वास्तव में, आप 1किसी भी प्रकार के संस्करण को परिभाषित करने के लिए कोड लिख सकते हैं और इसे स्वतंत्र रूप से उपयोग कर सकते हैं।
यह जावास्क्रिप्ट, पाइथन और इसके आगे भी किया जाता है, लेकिन इसके विपरीत, यह पूर्ण प्रकार की सुरक्षा के साथ किया जाता है।

factoid:

मूल रूप से, हास्केल समिति ने हास्केल बी करी के नाम के बाद "करी" भाषा को कॉल करने का इरादा किया, लेकिन नाम को हास्केल में बदलने का फैसला किया क्योंकि कुछ दंड उत्पन्न हो सकते हैं। केवल बाद में उन्होंने हास्केल की समानता "पास्कल" और "हास्ले" पर देखी!


मुझे नहीं पता कि क्या मुझे इस तथ्य के साथ तथ्य को प्रतिस्थापित करना चाहिए कि हास्केल के पास मानक पुस्तकालय में सबसे अधिक फ़ंक्शन / ऑपरेटर हैं जो अन्य कार्यों से कार्य उत्पन्न करते हैं (और तकनीकी रूप से हर दो या अधिक पैरामीटर फ़ंक्शन ऐसा है)। क्या मैं?
गर्वित हैकेलर

स्निपेट में दिखावा करें और स्पष्टीकरण में जोड़ें।
मार्टिन एंडर

f=0:1:zipWith(+)f(tail f) -- 25 chars, एक फ़ंक्शन जो फाइबोनैचि संख्याओं की एक आलसी-परिकलित सूची देता है।
chamini2

ugh मैंने स्निपेट्स का एक गुच्छा जोड़ा और फिर मेरा कंप्यूटर बंद हो गया
गर्वित हेकलर

@proudhaskeller सेविंग ऑप। मैंने इसे व्यक्तिगत रूप से कभी नहीं किया है, लेकिन यदि आपके पास एक बार में करने के लिए एक बड़ा संपादन है, तो आप संपादन को सहेजने के साथ एक बाहरी दस्तावेज़ में कर सकते हैं, फिर इसे पूरा होने पर पेस्ट करें।
mbomb007

99

सी#

सी # जावा, सी, हास्केल, एसक्यूएल और अन्य भाषाओं की एक टन का एक मजेदार, पागल मिश्रण है, और यह वास्तव में बहुत अच्छी सुविधाएं और एपीआई प्रदान करता है। यह भी सुंदर क्रिया होने के लिए यहाँ के आसपास जाना जाता है, लेकिन हम देखेंगे कि हम क्या कर सकते हैं!

मैं सामान्य आवश्यक बॉयलरप्लेट को अनदेखा करूँगा:

class Program { public static void Main(string[] args) { ... } }

लंबाई 1:

;

कमांड # C में अर्धविराम के साथ समाप्त हो गए हैं! एक खाली रेखा पूरी तरह से वैध सिंटैक्स है।

लंबाई 5:

x=5f;

जब आप C # में शाब्दिक संख्याएँ निर्दिष्ट करते हैं, तो संकलक यह मान लेगा कि वे ints या युगल हैं (इस आधार पर कि उनके पास कोई दशमलव है)। यदि आप एक शाब्दिक फ्लोट का उपयोग करना चाहते हैं, तो आपको यह निर्दिष्ट करना चाहिए कि संख्या में 'एफ' जोड़कर, या इसे रनटाइम पर डाला जाएगा, एक मामूली लागत।

लंबाई 7 (बाइट्स):

s=@"
";

यदि आप @ चिन्ह के साथ एक स्ट्रिंग शाब्दिक उपसर्ग करते हैं, तो यह एक "शब्दशः" स्ट्रिंग शाब्दिक बन जाता है। सामान्य स्ट्रिंग शाब्दिक भाग विशेष वर्णों में '\ n' की तरह अनुक्रम से बचते हैं, लेकिन शब्दशः शाब्दिक नहीं है, जिससे आप बिना पीछे भागे वर्ण का उपयोग कर सकते हैं। वे लाइन रिटर्न भी शामिल कर सकते हैं, जैसा कि दिखाया गया है। यह आपको गोल्फ में कुछ बाइट्स बचा सकता है, या आपके मल्टी-लाइन स्ट्रिंग शाब्दिक को अधिक पठनीय बना सकता है। बस इंडेंटेशन को स्ट्रिंग में शामिल करने के लिए देखें।

लंबाई 8:

()=>x=y;

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

लंबाई 9:

(a)=>a.p;

यहां एक और अनाम फ़ंक्शन है जो एक पैरामीटर और रिटर्न मान का उपयोग करता है। अभिव्यक्ति प्रकार की एक वस्तु लौटाती है Func(फंक स्वयं के प्रकार लौटाता है a.p। आप उपयोग करेंगेFunc Linq के साथ इंटरफेस करने के लिए बहुत ।

लंबाई 10:

enm.Any();

यह लिनक से हमारा पहला परिचय है! लाइनक विस्तार विधियों का एक सेट है जिसे किसी भी ऑब्जेक्ट पर कहा जा सकता है जो कि असंख्य है (IEnumerable इंटरफ़ेस को लागू करना) - जैसे ArrayऔरList । IEnumerable आलसी मूल्यांकन को नियोजित करता है: यह एक समय में एक आइटम के संग्रह के माध्यम से जाता है, संग्रह के बारे में पूरी जानकारी के बिना - यह अनंत भी हो सकता है!

यही वह जगह है जहां Any- यह वापस आता है trueयदि Enumerable में कम से कम 1 आइटम होता है। पूरी लंबाई की गणना करने से बेहतर है।

लंबाई 11:

var a=1.5f;

varकीवर्ड संकलक स्वतः के प्रकार का निर्धारण करने के लिए निर्देश देता है aaइस मामले में टाइप किया जाएगाSingle । कोड गोल्फ के लिए बहुत आसान है, क्योंकि यह लगभग किसी भी प्रकार के नाम से कम है, हालांकि कई इसे उत्पादन कोड में उपयोग करना पसंद नहीं करते हैं।

लंबाई 15:

yield return 0;

यहाँ एक पागल कथन है जिससे आप कम परिचित हो सकते हैं। आप जानते हैं कि वस्तुओं को IEnumerable विरासत में प्राप्त किया जा सकता है, लेकिन क्या आप जानते हैं कि फ़ंक्शन गणना योग्य हो सकते हैं? एक प्रकार की वापसी के साथ एक फ़ंक्शन की घोषणा करें IEnumerable, और इसे yield returnजितनी बार चाहें उतनी बार करें। जब आप फ़ंक्शन के लिए एक एन्यूमरेटर प्राप्त करते हैं, तो प्रत्येक कॉल GetNextमें प्रोग्राम को अगले तक सभी कोड निष्पादित करेगा yield return, उस मान को लौटाएगा, और तब तक रोकें जब तक आप इसे फिर से आगे नहीं बढ़ाते। आप yield breakपुनरावृत्ति को समाप्त करने के लिए उपयोग करते हैं ।

लंबाई 16:

[Obsolete]int a;

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

लंबाई १ 17

c.Count(t=>t==3);

यहाँ एक आसान गोल्फ विधि है। यह Funcबताने के cलिए कि एन्यूमरबल के एक तत्व को मैप करता है bool, यह उन तत्वों की संख्या देता है cजिनके लिए वह Funcरिटर्न करता है true। एक पाश लिखने की तुलना में बहुत अच्छा है।

लंबाई 18:

foreach(T t in c);

यह प्रत्येक लूप के लिए है। इन सभी चीजों के बारे में बात करने के साथ, यह एक बहुत जरूरी संरचना है। एक समय में एक तत्व के माध्यम से इसके foreachलिए एक एन्यूमरेटर c(जो कि पर्याप्त होना चाहिए) और इट्रेट को सेट करने के लिए सिंटैक्टिक शुगर है t। आप प्रत्येक व्यक्तिगत तत्व को बदल सकते हैं या उसकी जांच कर सकते हैं, लेकिन संग्रह को बदलना ही गणनाकर्ता को अमान्य कर देगा।

लंबाई १ ९

c.Select(t=>t.a/2);

कार्यात्मक प्रोग्रामिंग प्रशंसकों के लिए यह आपका 'मानचित्र' कार्य है। चयन करें एक अच्छा संक्षिप्त तरीका है एक मनमाने रूपांतरण के Funcप्रत्येक तत्व पर कुछ मनमाना रूपांतरण (एक पारित द्वारा परिभाषित ) करने के लिए। यह एक IEnumerable देता है जो "तत्संबंधी" तत्वों को थूक देगा जब आप इसे पुनरावृत्त करेंगे।

लंबाई २१

Console.Write("Hi!");

यह पंक्ति कुछ पाठ लिखती है, और संभवतः मुख्य कारणों में से एक है C # का उपयोग गोल्फिंग के लिए ज्यादा नहीं किया जाता है!

लंबाई २३

typeof(T).GetMethods();

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

लंबाई 25

from t in c select t.a/2;

क्या वह एसक्यूएल है? C # कोड में? बहुत करीब। यह अभिव्यक्ति लंबाई 19 पर एक ही काम करता है।

लंबाई 27

for(var l;;l=new object());

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

लंबाई 29

var e=Enumerable.Range(0,99);

Enumerable.Rangeसंभावित रूप से आसान गोल्फ फ़ंक्शन है। यह एक संरचना देता है जिसे गणना की जा सकती है और क्रम में प्रत्येक संख्या को निर्दिष्ट सीमा में प्राप्त करेगी। दूसरा पैरामीटर एक गिनती है, न कि एक सूचकांक।

लंबाई ३१

public int pr{get;private set;}

यहां, हम एक साधारण 'प्रॉपर्टी', एक OOP सुविधा और C # का एक और हॉलमार्क दिखा सकते हैं। यदि आपने कभी जावा का उपयोग किया है, तो आपने अपनी पहुंच को अलग करने या कोड बदलने के लिए किसी फ़ील्ड के लिए संभवतः 'गेट' और 'सेट' तरीके बनाए हैं। खैर, C # आपको उस कोड को क्षेत्र के शीर्ष पर घोषित करने देता है, और प्राप्त करने और स्थापित करने के लिए अलग-अलग एक्सेस संशोधक भी सेट करता है। यह विशेष स्निपेट स्वचालित रूप से एक डिफ़ॉल्ट गेट्टर और सेटर बनाता है, लेकिन सेटर को निजी बनाता है।

लंबाई 32

public static void m(this T o){}

यह स्निपेट सी # सुविधा दिखाता है जो एपीआई डिजाइन के लिए अच्छा है। thisएक स्थिर विधि के पहले पैरामीटर में संशोधक को लागू करने से , वह विधि एक "विस्तार" विधि बन जाती है। एक बार यह घोषित हो जाने के बाद, T.mअब टाइप टी के किसी भी ऑब्जेक्ट पर कॉल किया जा सकता है , क्योंकि यह वास्तव में टी की एक विधि थी। इसका उपयोग किसी भी मौजूदा वर्ग में नई कार्यक्षमता जोड़ने के लिए किया जा सकता है, बिना संशोधित किए या यहां तक ​​कि अपने स्रोत कोड तक पहुंच के बिना।

लंबाई 38

int f(int a,ref int b,out int c){c=0;}

यह विधि विभिन्न प्रकार के पैरामीटर को दिखाती है जिससे आप C # में पास हो सकते हैं। अनमॉडिफाइड पैरामीटर मान द्वारा पारित किए जाते हैं । उपसर्गों को उपसर्ग द्वारा refसंदर्भ द्वारा पारित किया जाता है: आप उन्हें पूरी तरह से एक नई वस्तु सौंप सकते हैं और वे इसे विधि से वापस ले जाएंगे। द्वारा उपसर्ग किए गए पैरामीटर outअतिरिक्त रिटर्न मानों की तरह हैं: आपको उन्हें विधि में एक मान निर्दिष्ट करने की आवश्यकता होती है, और उन्हें रेफ मापदंडों की तरह ही वापस ले जाया जाता है।

लंबाई 42

Console.Write("It is \{DateTime.Now()}.");

नया C # 6 मानक आपको कुछ वर्णों को बचा सकता है जब आपको स्ट्रिंग इंटरपोलेशन का उपयोग करके असेंबलिंग स्ट्रिंग्स को आउटपुट करना होगा। यह सुविधा आपको एक स्ट्रिंग शाब्दिक के अंदर घुंघराले ब्रेसिज़ में किसी भी अभिव्यक्ति को लिखने की अनुमति देती है, और स्ट्रिंग स्वचालित रूप से रनटाइम पर उन अभिव्यक्तियों के मूल्यों के साथ इकट्ठा हो जाएगी।

लंबाई 48

IEnumerable f(){for(int a=0;;)yield return a++;}

बस एक वास्तविक उद्देश्य के साथ कुछ करने के लिए अभी पर्याप्त वर्ण हैं! यह विधि उन विचारों में से कुछ का उपयोग करती है, जिन्हें हमने एक अनंत Enumerable बनाने के लिए ऊपर खोजा है, जो केवल एक-एक करके पूर्णांक लौटाएगा। 0. याद रखें कि C # Enumerables के साथ आलसी मूल्यांकन को नियोजित करता है, इसलिए एक अनंत अनुक्रम पूरी तरह से मान्य है - आप कर सकते हैं अनुक्रम के रूप में आप चाहते हैं के रूप में ज्यादा, और किसी भी समय बाहर तोड़।

लंबाई 56

int p{get{return mP;}set{mP=Math.Max(value,0);}};int mP;

यहाँ एक 'संपत्ति' का एक और उदाहरण है (स्निपेट 31 देखें)। यहाँ, मैं वास्तव में के लिए अलग कोड के टुकड़े को परिभाषित किया है getऔर setनहीं बल्कि पहले की तरह स्वत: लोगों का उपयोग करने से। यह उदाहरण दर्शाता है कि आप किसी चर को दिए गए मान को मान्य करने के लिए किसी संपत्ति का उपयोग कैसे कर सकते हैं - यहां, मान को 0. से कम नहीं होने दिया जाता है। गुणों के अन्य अच्छे उपयोगों में एक घटना को अधिसूचित करना शामिल है जब एक मूल्य बदल जाता है, या कैश्ड मानों का पुनर्निर्माण होता है यह इस पर आधारित हो सकता है।

लंबाई ६५

int v;public static implicit operator int(Program o){return o.v;}

इस सुविधा को एक निहित कलाकार कहा जाता है। यह एक विस्तार विधि की तरह है कि यह स्थिर कोड है जो एक विशिष्ट वर्ग पर काम करता है (देखें स्निपेट 32)। हालाँकि, निहित कलाकारों का उपयोग इसे कॉल करके नहीं किया जाता है - इसका उपयोग किसी Programऑब्जेक्ट को पूर्णांक (उदाहरण int i=new Program()) के रूप में करके किया जाता है । जब आप ऐसा करते हैं, तो ऑब्जेक्ट चुपचाप उस प्रकार में परिवर्तित हो जाएगा जैसा आप इसका उपयोग कर रहे हैं, जैसा कि निहित कलाकारों में कोड के आधार पर किया गया है। सर्वोत्तम प्रथा केवल यह करने के लिए कहती है जब रूपांतरण के परिणामस्वरूप कोई जानकारी नहीं खो जाती है।


1
आइए देखें कि आप इन पात्रों के साथ क्या कर पाएंगे ... ;-)
गर्वित हैकेलर

9
मैं कहूंगा कि यह सी से जावा के करीब है, वास्तव में
गर्वित हैकेलर

का उल्लेख किया। मुझे लगता है कि हम लगभग कुछ Linq करने के लिए पर्याप्त है - आज रात आ रहा है!
बीएमएसी

सार्वजनिक स्थैतिक अंतर्निहित ऑपरेटर int (MyClass o) {वापसी o.objVal;} // 65। इस कोड के साथ, यह पंक्ति मान्य है: MyClass o1 = new MyClass (10); int o2 = o1; // o2 अब 10 है। msdn.microsoft.com/en-us/library/85w54y0a.aspx
Zukki

अधिक स्निपेट कृपया
5

98

जावा


लंबाई 44 स्निपेट

Object a=System.out.append("Hello, World!");

प्रिंटों Hello, World! करने के लिए ।

लंबाई 43 स्निपेट

float[][][][][]a=new float[5][3][7][2][10];

a10 सरणियाँ होती हैं, जिनमें प्रत्येक में 2 सरणियाँ होती हैं, जिनमें से प्रत्येक में 7 सरणियाँ होती हैं, जिनमें से प्रत्येक में 3 सरणियाँ होती हैं, जिनमें से प्रत्येक में 5 होते हैं float

लंबाई 42 स्निपेट

interface A{static void main(String[]a){}}

एक पूरा कार्यक्रम। चूँकि सब कुछ interfaceस्वाभाविक रूप से है public, हम publicमुख्य विधि से शब्द को छोड़ सकते हैं ।

लंबाई 36 स्निपेट

class A{class B extends A{B.B.B b;}}

Aएक आंतरिक वर्ग है B। इसका मतलब है कि हम एक प्रकार का चर घोषित कर सकते हैं A.B

लेकिन Bइसका एक उपवर्ग है A, जिसका अर्थ है कि इसमें सभी तरीके, क्षेत्र और आंतरिक वर्ग हैं A। इस प्रकार, हम प्रकार B.Bको भी संदर्भित कर सकते हैं ।

इस कोड में, हम इसे एक कदम आगे ले जाते हैं, और Bएक प्रकार का उदाहरण चर देते हैं B.B.B

नैतिक: एसओ पर गर्म सवालों का पालन करना आपको बहुत दिलचस्प सिखा सकता है, अगर व्यर्थ, तकनीक।

लंबाई 35 स्निपेट

l.stream().map("a"::equals).count()

यदि lस्ट्रिंग्स की सूची है, तो यह हमें बताता है कि उनमें से कितने बराबर हैं "a"

लंबाई 34 स्निपेट

public static void main(String[]a)

एक कार्यक्रम की मुख्य विधि का विधि हस्ताक्षर। सिर्फ 11 और पात्र और हम एक संपूर्ण कार्यक्रम बना सकते हैं!

लंबाई 33 स्निपेट

enum D {NORTH, EAST, SOUTH, WEST}

NORTH, EAST, SOUTH, और WESTप्रकार के सभी स्थिरांक हैं D

लंबाई 32 स्निपेट

Files.readAllBytes("hello.txt");

एक संपूर्ण फ़ाइल पढ़ता है, byte[]सामग्री की एक वापसी ।

लंबाई 31 स्निपेट

new String(new char[]{'h','i'})

के बराबर है "hi""कुंजी टूट गई है तो उपयोगी है।

लंबाई 30 स्निपेट

new JFrame().setVisible(true);

एक नया दृश्यमान फ्रेम बनाता है, जिसे आप अन्य घटकों में रख सकते हैं।

लंबाई 29 स्निपेट

throws ClassNotFoundException

प्रत्येक विधि को मजबूर करता है जो इसे कॉल करने के लिए उपयोग करता है try- catchब्लॉक, या फिर स्टैक अप त्रुटि को पास करने के लिए। चेक किए गए अपवाद जावा डिजाइनरों के सबसे विवादास्पद निर्णयों में से एक हैं।

लंबाई 28 स्निपेट

int f(int x){return f(x-1);}

यह फ़ंक्शन हमेशा के लिए नहीं चलता है; वास्तव में, एक विशिष्ट कंप्यूटर पर यह एक सेकंड से भी कम समय लेता है। धन्यवाद, ढेर अतिप्रवाह।

लंबाई 27 स्निपेट

Object a=new String[]{"a"};

तार की एक नई सरणी बनाता है।

लंबाई 26 स्निपेट

Object.class.newInstance()

नया बनाता है Object

लंबाई 25 स्निपेट

((Supplier)()->-~0).get()

हार्ड-कोडिंग स्थिरांक से बचना सबसे अच्छा है। यह 1बिना किसी स्थिरांक का उपयोग किए बिना मान प्राप्त करने का एक वस्तु-उन्मुख तरीका है 0

लंबाई 24 स्निपेट

(Function<Long,?>)x->x+1

उत्तराधिकारी समारोह।

लंबाई 23 स्निपेट

l.removeIf(x->x%10==0);

यदि lपूर्णांकों की सूची है, तो यह 10 से विभाज्य सभी मानों को हटा देता है।

लंबाई 22 स्निपेट

int i=(new int[7])[5];

सात पूर्णांक का एक नया सरणी बनाता है, और पांचवां तत्व प्राप्त करता है।

लंबाई 21 स्निपेट

Arrays.asList(2L,"a")

इन तत्वों के साथ एक ArrayList बनाता है।

लंबाई 20 स्निपेट

System.out.print(s);

प्रिंट करता है s

लंबाई 19 स्निपेट

import java.util.*;

की अनुमति देता है जैसे वर्गों के संक्षिप्त उपयोग List, Map, Scanner, Timer, औरRandom

लंबाई 18 स्निपेट

Math.addExact(x,y)

दो पूर्णांक जोड़ता है xऔर y। यदि अतिप्रवाह होता है, तो विधि एक गलत उत्तर देने के बजाय एक अपवाद को फेंक देती है।

लंबाई 17 स्निपेट

Double.MIN_NORMAL

प्रकार का सबसे छोटा सकारात्मक मूल्य double, जहां महत्व का अग्रणी बिट 0 है।

लंबाई 16 स्निपेट

System.in.read()

कंसोल से एक एकल वर्ण पढ़ता है।

लंबाई 15 स्निपेट

Long.reverse(x)

के द्विआधारी प्रतिनिधित्व में बिट्स को उलट देता है x

लंबाई 14 स्निपेट

int x=050+120;

xअब 160 है, क्योंकि किसी भी चीज की शुरुआत 0ऑक्टल के रूप में की जाती है।

लंबाई 13 स्निपेट

private C(){}

एक निजी कंस्ट्रक्टर अन्य वर्गों को इसे तत्काल करने से रोकता है। इस पैटर्न का उपयोग Systemऔर के द्वारा किया जाता हैMath अन्य लोगों के बीच कक्षाओं । सिंगलटन पैटर्न को लागू करने के लिए एक निजी कंस्ट्रक्टर का भी उपयोग किया जा सकता है।

लंबाई 12 स्निपेट

static class

कई बाहरी प्रोग्रामर द्वारा सामना की जाने वाली समस्या का समाधान - एक बाहरी बाहरी वर्ग के बिना आंतरिक कक्षाओं के निर्माण की अनुमति देता है ।

लंबाई 11 स्निपेट

throw null;

इसे फेंकना अक्सर आवश्यक होता है NullPointerException, लेकिन यह काफी चिंताजनक भी है। यह बहुत सरल विकल्प है।

लंबाई 10 स्निपेट

int[]a,b[]

दो चर को परिभाषित करता है: aऔर baप्रकार int[]का bहै और प्रकार का है int[][]

लंबाई 9 स्निपेट

switch(x)

के मान के आधार पर किसी स्थान पर जाता है x

लंबाई 8 स्निपेट

break a;

ब्लॉक किए गए लेबल से ब्रेक a

लंबाई 7 स्निपेट

goto x;

gotoकीवर्ड सी, सी ++, जावा में आरक्षित है। यदि xएक लेबल है, तो यह कोड प्रोग्राम को उपयुक्त लेबल पर भेजता है - सी और सी ++ में। लेकिन यह जावा, यह एक रहस्यमय चलाता है RuntimeException। वास्तव में, gotoजावा में कीवर्ड का उपयोग करने का कोई तरीका नहीं है ।

लंबाई 6 स्निपेट

\u003b

एक कथन समाप्त करता है। जावा अजीब है

लंबाई 5 स्निपेट

a-=-a

aइसकी उपेक्षा को घटाकर युगल ।

लंबाई 4 स्निपेट

a&=b

का मान सेट करता है aबिटवाइज़ करने के लिए और की aऔर b

लंबाई 3 स्निपेट

...

किसी भी संख्या में तर्क, एक सरणी में समेकित।

लंबाई 2 स्निपेट

<>

संकलक को यह पता लगाने देता है कि आप किस सामान्य प्रकार का मतलब रखते हैं। बहुत अन-जावा-जैसा।

लंबाई 1 स्निपेट

@

तरीकों और कक्षाओं के बारे में अतिरिक्त जानकारी दिखाने की अनुमति देने के लिए एक एनोटेशन इंगित करता है।

factoid

जावा में, अनंत लूप कभी-कभी कंपाइलर त्रुटियों का कारण बनते हैं। उदाहरण के लिए, while(true);विधि से बाहर निकलने के बिना लूप को समाप्त नहीं किया जा सकता है, इसलिए उसके बाद कोई भी कोड "अगम्य कथन" त्रुटि को ट्रिगर करेगा। जैसा कि @Optimizer ने बताया, केवल कुछ अनंत लूप इस तरह पकड़े जाएंगे।


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

4
आप अभी नीचे मतदान कर रहे हैं, मुझे लगता है कि इसका मतलब आपको एक स्निपेट निकालना होगा! ;) (डाउनवोट "जावा अजीब है" के लिए था)
साइमन फोर्सबर्ग

1
ऐसा लगता है कि स्निपेट # 36 पुनरावर्ती है और इसे अनिश्चित काल तक बढ़ाया जा सकता है: class A{class B extends A{B.B.B.B.B.B.B b;}}अभी भी संकलित है।
Natix

3
पूरा कार्यक्रम बनाने में आपकी मदद करने के लिए तैयार;)
डुर्रोन 597

1
But it Java, [goto] triggers a mysterious RuntimeExceptionगलत। gotoसंकलन भी नहीं करता।
डोरुकायहन

93

अजगर

अब अपनी सुविधा के लिए नवीनतम के साथ शुरू! 30 की लंबाई के माध्यम से पढ़ने के लिए सबसे पहले सबसे पहले, संशोधन इतिहास पर जाएं।

अगर किसी के पास कोई सुझाव है, तो टिप्पणी करने के लिए स्वतंत्र महसूस करें।

लंबाई 52:

i=0
while s[i-n:]:print(' '*n+s)[i:n+i];i+=1;i**7**7

फेक मार्की टेक्स्ट चैलेंज में मेरी एंट्री से लिया गया । sऔर nसमय से पहले एक स्ट्रिंग और पूर्णांक पर सेट होने की आवश्यकता है। यह वास्तव में मुक्त पायथन 2 दुभाषिया में अच्छा काम नहीं करता है, इसलिए मैंने कोष्ठक को चारों ओर जोड़ा (' '*n+s)[i:n+i], और आप इसे पायथन 3 दुभाषिया में यहां देख सकते हैं ।

लंबाई 43:

#-*-coding:rot13-*-
cevag h"Una fubg svefg"

पायथन में आप एक विशेष कोडेक के साथ स्रोत को एनकोड करने में सक्षम हैं। यह दिखाता है कि स्रोत को Rot13 में कैसे लिखा जा सकता है। सामान्य वाक्यविन्यास यह है # -*- coding: <codec-name-goes-here> -*-:।

यहाँ इसका अनुवाद किया गया है:

#-*-coding:rot13-*-
print u"Han shot first"

uनिर्दिष्ट करता है कि स्ट्रिंग शाब्दिक निम्नलिखित एक यूनिकोड स्ट्रिंग है। यह आवश्यक है यदि आप चाहते हैं कि आपके तार भी रोट 13 में हों, अन्यथा एन्क्रिप्शन के बावजूद स्रोत का प्रत्येक स्ट्रिंग आसानी से पढ़ा जा सकता है। वैकल्पिक रूप से, आप .encode("Rot13")प्रत्येक स्ट्रिंग के बाद उपयोग कर सकते हैं (इस पर भी रोट 13 का उपयोग करना न भूलें।) इस लेख के अनुसार , कुछ वैकल्पिक एनकोडिंग "बेस 64 ″," यूएनकोड "," ज़्लीब ", या" बी 2 "हैं।

लंबाई 33:

import cmath
print cmath.sqrt(-1)

यह जटिल (काल्पनिक) संख्याओं के लिए पायथन का मॉड्यूल है । यह प्रिंट 1j, के बाद से अजगर इंजीनियरिंग मानकों के अनुरूप है और का उपयोग करता है jहालांकि मैं पसंद करते हैं, काल्पनिक इकाई के रूप में iहै, जो और अधिक सामान्यतः गणित के क्षेत्र में प्रयोग किया जाता है, और का उपयोग कर jऔर kके अलावा iके लिए quaternions , लेकिन मैं पीछे हटना। बग / परिवर्तन आदेश यहां पढ़ें (इसे बदला नहीं जाएगा)।

लंबाई 30:

f=lambda n:n*f(n-1)if n else 1

अब हम अपने स्वयं के फैक्टरियल फ़ंक्शन को पुनरावृत्ति और टर्नरी का उपयोग करके परिभाषित करते हैं यदि-और! जहां तक ​​मुझे पता है, यह उतना ही गोल्फ है जितना यह पायथन में मिलता है। इसे इस तरह भी लिखा जा सकता है: f=lambda n:n and f(n-1)*n or 1एक युगल पायथन के बूलियन ऑपरेटरों (और यह भी 30 वर्णों में किया गया है) को प्रदर्शित करते हुए, lambdaवाक्यविन्यास पर जानकारी के लिए लंबाई 15 स्निपेट देखें ।

लंबाई 29:

import math
math.factorial(7)

7 के गुट को खोजता है, लौटता है 5040

लंबाई 25:

import math
print math.pi

पायथन का गणित मॉड्यूल कई उपयोगी कार्य और स्थिरांक प्रदान करता है। यहां पीआई है। लौटता है 3.14159265359। (उपरोक्त कोड में, मैंने एक चरित्र के रूप में नई पंक्ति को गिना।)

लंबाई 24:

f=lambda y:lambda x:x**y

यह एक बंद का उदाहरण है। कॉलिंग cube = f(3)एक क्यूबिक फंक्शन बनाएगी जिसे फिर print cube(24)प्रिंटिंग के साथ बुलाया जा सकता है 13824

लंबाई 19:

print"Hello World!"

अंत में, कुछ बुनियादी आउटपुट प्रिंट करने के लिए पर्याप्त जगह है! यहां स्थान की आवश्यकता नहीं है, क्योंकि उद्धरण और कोष्ठक भी परिसीमनकर्ता हैं। यह केवल पायथन 2 में काम करेगा, क्योंकि पायथन 3 ने printफ़ंक्शन को किसी अन्य फ़ंक्शन की तरह कहा जाता है। पायथन 3 में, उपयोग करें print("Hello World!")। प्रिंट फ़ंक्शन और पायथन 2 और 3 के बीच अंतर के बारे में अधिक जानकारी के लिए, देखें कि नया क्या है पायथन 3.0

लंबाई 16:

[x*3 for x in l]

एक बार फिर, मान lएक सूची या किसी अन्य चलने योग्य वस्तु जैसे स्ट्रिंग या जनरेटर है। इस कथन को सूची बोध के रूप में जाना जाता है । यह लूप संरचना के लिए मानक का उपयोग करने की तुलना में बहुत कम है। यहाँ, यह 3. अलो द्वारा गुणा किए गए सभी नंबरों के साथ एक सूची देता है, तार को गुणा किया जा सकता है! तो सूची में कोई भी तार जोड़ दिया जाएगा (स्वयं के लिए) उस समय की संख्या।

लंबाई 15:

import this #:)

यह वास्तव में एक लंबाई 11 स्निपेट है, लेकिन मुझे एहसास हुआ कि मैं अजगर (भयानक) ईस्टर अंडे का प्रदर्शन करना भूल गया था ! इस मॉड्यूल को आयात करना द ज़ेन ऑफ़ पायथन (फैक्टॉइड देखें।) दिलचस्प तथ्य: मॉड्यूल this.pyको रोट 13 में एन्कोड किया गया था, जिसे मैं बाद में उम्मीद करूंगा।

लंबाई 14:

lambda x:x**.5

यह lambdaएक फंक्शन शाब्दिक के लिए पायथन के सिंटैक्स का उपयोग करके एक स्क्वायर रूट फ़ंक्शन को परिभाषित करता है । पायथन में फंक्शन शाब्दिक में केवल अभिव्यक्ति हो सकती है, कथन नहीं। इस लंबोदर को एक चर को सौंपा जा सकता है (lambda x:x**.5)(9), जो एक फ़ंक्शन में जाता है, या इन-लाइन के साथ निष्पादित होता है , जो वापस लौटता है 3.0। मॉड्यूल sqrtमें फ़ंक्शन को आयात करने के लिए एक वर्गमूल के लिए घातांक का उपयोग करना एक विकल्प है math

लंबाई 13:

1 if x else 0

यह पायथन का एक उदाहरण है यदि ऑपरेटर। इसे बूलियन ऑपरेशन के साथ मैन्युअल रूप से लागू करने से कोडर्स को हतोत्साहित करने के लिए पायथन 2.5 में जोड़ा गया था। यहां, 1यदि xमूल्यांकन किया जाता है True, तो वापस कर दिया जाता है , अन्यथा 0वापस लौटा दिया जाता है।

लंबाई 12:

s=input(">")

यह >शीघ्र पाठ के लिए प्रिंट करेगा और उपयोगकर्ता को एक मूल्य इनपुट करने की अनुमति देगा। अजगर 2 जो भी मूल्य दर्ज किया गया है, उसकी व्याख्या करता है, इसलिए किसी भी स्ट्रिंग को उद्धरण की आवश्यकता होती है। पायथन 3 ने इसे बदल दिया, ताकि दर्ज किए गए इनपुट की स्वचालित रूप से व्याख्या न हो। इसे पायथन 2 में व्याख्या किए बिना इनपुट दर्ज करने के लिए, उपयोग करें raw_input()। पायथन 2 में, input()के बराबर है eval(raw_input())

लंबाई 11:

eval("2e3")

2e3फ्लोट 2 x 10 not के लिए वैज्ञानिक संकेतन है। evalसमारोह की व्याख्या और अभिव्यक्ति के रूप में किसी भी स्ट्रिंग मूल्यांकन करता है। इस मामले में, इसका शाब्दिक 2e3या का उपयोग करने के समान परिणाम है float("2e3")। यह लौट आता है 2000.0

लंबाई 10:

range(013)

यह फ़ंक्शन 0ऑक्टल मान से पूर्णांकों की एक सूची देता है 013, जो कि 11(अनन्य) है, जिसका अर्थ है कि सूची होगी [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]। यह फ़ंक्शन उस sliceफ़ंक्शन के समान तीन पैरामीटर लेता है जिसे हमने पहले समीक्षा की थी range(start, stop[, step]):। अंतर है, केवल एक पैरामीटर के साथ पैरामीटर रोक मूल्य का प्रतिनिधित्व करता है।

ध्यान दें कि पायथन 3.x का कोई समकक्ष नहीं है। यह rangeसमान है, लेकिन वास्तव में पाइथन 2 के समान है, xrangeएक सूची के बजाय एक जनरेटर वस्तु लौटाता है।

लंबाई 9:

a,b = b,a

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

लंबाई 8:

#comment

तुम्हें पता है कि यह क्या है ... रुको, तुम नहीं? आप जानते हैं, वे चीजें जो आपको कोड की एक पंक्ति का वर्णन करने के लिए मनमाना पाठ लिखने देती हैं, जिससे समझना आसान हो जाता है? नहीं? ओह ठीक है...

लंबाई 7:

l[::-1]

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

हम कुछ और दिलचस्प निर्माणों का उपयोग करना शुरू कर सकते हैं।

लंबाई 6:

l[-6:]

इसे स्लाइस ऑपरेशन कहा जाता है । यदि lएक सूची है, तो यह एक सूची के lरूप में अंतिम छह तत्वों से युक्त एक नई सूची लौटाएगा । -6प्रारंभिक सूचकांक (अंत से 6) का प्रतिनिधित्व करता है, और बृहदान्त्र का अर्थ है कि अंत के बाद तक जारी रखने के बाद तक सूचकांक (जो हमने खाली छोड़ दिया, इसलिए अंत तक।) यदि हमारी सूची में 10 के माध्यम से संख्या 1 शामिल है, तो यह वापस आ जाएगी [5, 6, 7, 8, 9, 10]

लंबाई 5:

1<x<5

पायथन की भयानक विशेषताओं में से एक आपको तुलनात्मक ऑपरेटरों की श्रृंखला की अनुमति दे रही है। कई अन्य भाषाओं में, यह टाइप किया जाएगा 1 < x && x < 5। जब आप कई तुलनाओं पर विचार करते हैं तो यह और भी बेहतर हो जाता है: 1 < x < y < 5पूरी तरह से मान्य है!

लंबाई 4:

0256

एक अग्रणी शून्य के साथ एक पूर्णांक एक शाब्दिक अष्टाधारी मूल्य है। यह कोड के रूप में अच्छी तरह से obfuscation के लिए एक अच्छी चाल है। यह दशमलव मान लौटाता है 174। पायथन 3.x में, अष्टक मूल्य के रूप में लिखा जाएगा 0o256

लंबाई 3:

`3`

बैकटिक्स में एक अभिव्यक्ति को घेरना उपयोग करने के समान है repr(), जो किसी वस्तु का स्ट्रिंग प्रतिनिधित्व लौटाता है। फ़ंक्शन स्ट्रिंग को इस तरह से वापस करने का प्रयास करता है कि जब इसे evalफ़ंक्शन के तर्क के रूप में पास किया जाता है , तो यह मूल ऑब्जेक्ट को वापस कर देगा। यह उपयोग करने के समान नहीं है str(), हालांकि परिणाम कभी-कभी समान होते हैं। इस इनपुट के लिए, '3'दोनों मामलों में वापस कर दिया जाता है। यह कोड गोल्फ के लिए मेरा पसंदीदा है!

अजगर 2 में ही काम करता है!

लंबाई 2:

[]

एक खाली सूची।

लंबाई 1:

_

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

फैक्टॉइड : पायथन जावा और सी के समान एक भाषा है। यह एक विशिष्ट डिजाइन दर्शन के साथ बनाया गया था (" पीईपी 20 - द ज़ेन ऑफ़ पायथन " से लिया गया है:

  • सुंदर बदसूरत से बेहतर है
  • निहितार्थ की तुलना में स्पष्ट है
  • सरल जटिल से बेहतर है
  • कॉम्प्लेक्स जटिल से बेहतर है
  • पठनीयता मायने रखती है

इनकी वजह से, हालांकि अर्ध-कॉलोनों को एक बयान परिसीमनकर्ता के रूप में अनुमति दी जाती है, वे आमतौर पर पठनीयता के लिए कई लाइनों का उपयोग करने के पक्ष में छोड़ दिए जाते हैं। इसके अलावा, लाइन इंडेंटेशन बहुत महत्वपूर्ण है!


किसी भी समय! मैं अब स्निपेट नहीं जोड़ने जा रहा हूं (लंबाई 9 एक का विरोध नहीं कर सकता!), क्योंकि आप इसके साथ पहले से ही बहुत अच्छा काम कर रहे हैं। सौभाग्य!
नासर-श

1
लंबाई 6: यह वापस आ जाएगा [5, 6, 7, 8, 9, 10](सूची में अंतिम 6 नंबर)
विंसेंट

लंबाई 16: lएक सूची होने की जरूरत नहीं है, यह किसी भी चलने योग्य वस्तु हो सकती है; tuples, सूचियाँ और जनरेटर सभी काम के लिए
nasser-sh

@ Sp3000: मैंने इसे [प्रतिबंधित-स्रोत] चुनौतियों के साथ उपयोग किया है।
रॉबी विक्सेज़

4
अच्छे पुराने के लिए कोई प्यार नहीं import antigravity?
सिफर

87

जावास्क्रिप्ट

यह सबसे पुराना सबसे नया हो जाता है। खुद के लिए लिंक: [ संपादित करें ]

लंबाई 51 स्निपेट:

console.log(require('fs').readFileSync(__filename))

एक नोड.जेएस क्वीन इस बार, हालांकि यह किसी भी "सख्त क्वीन" आवश्यकताओं को विफल कर देगा, अपने स्वयं के स्रोत कोड को पढ़ने के कारण।

लंबाई 50 स्निपेट:

a=new XMLHttpRequest;a.open('GET','file');a.send()

आखिरकार! एक AJAX अनुरोध ( वेनिला.जेएस का उपयोग करके )। हम आरंभ करते हैं, खोलते हैं, और अनुरोध भेजते हैं, लेकिन मैं संचालकों को जोड़ने के लिए कमरे से बाहर भाग गया और वास्तव में परिणाम के साथ कुछ भी करता हूं

लंबाई 49 स्निपेट:

msg=new SpeechSynthesisUtterance('Hello World!');

एक मुखर "हैलो वर्ल्ड!" तैयार करें। यह वास्तव में इसे बोलने के लिए थोड़ा और काम होगा। हम वॉल्यूम, पिच, रेट और एक्सेंट को भी एडजस्ट कर सकते हैं। HTML5Rocks पर भाषण संश्लेषण एपीआई देखें । फ़ायरफ़ॉक्स द्वारा अभी तक समर्थित नहीं, निश्चित रूप से IE नहीं

लंबाई 48 स्निपेट:

function repeat(){setTimeout(repeat,48)}repeat()

setIntervalपुनरावर्ती setTimeoutआईएनजी द्वारा अनुकरण ।

लंबाई 47 स्निपेट:

module.exports=function MyModule(a) {this.a=a};

एनओडीजेएस फिर से, लेकिन जेएस में हर जगह सिद्धांत समान है। यह एक बहुत ही बुनियादी निर्माण कार्य है, जो एक संपत्ति ( a) के साथ एक वस्तु बनाता है । इसे module.exportsइस्तेमाल करके फंक्शन को एक्सपोर्ट करना require()

लंबाई 46 स्निपेट:

canvas.getContext('2d').fillRect(46,46,46,46);

इसके लिए एक <canvas id="canvas"></canvas>तत्व की आवश्यकता होती है । यह इस तथ्य का लाभ उठाता है कि आईडी वाले तत्व वैश्विक चर के रूप में आबादी वाले हैं, इसलिए canvasजेएस से तत्व सुलभ है । फिर हम इसे x = 46, y = 46 पर 46x46 वर्ग से भरते हैं।

लंबाई 45 स्निपेट:

JSON.parse(require('fs').readFileSync('jsn'))

वापस करने के लिए नोड। यहां, हम एक JSON फ़ाइल jsnको वर्तमान निर्देशिका से नामित करते हैं।

लंबाई 44 स्निपेट:

(a=document.createElement('a')).href="/url";

# 39 पर भवन। अब हम एक तत्व बनाते हैं और एक विशेषता निर्दिष्ट करते हैं। यह अभी भी DOM में नहीं है।

लंबाई 43 स्निपेट:

sq=[1,2,3,4,5].map(function(n){return n*n})

उपयोग करके पहले 5 वर्गों की एक सरणी बनाता है map()

लंबाई 42 स्निपेट:

six="1+5",nine="8+1";eval(six+' * '+nine);

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

लंबाई 41 स्निपेट:

c=function(){var i;return function(){}}()

एक बंद की शुरुआत। cअब आंतरिक चर के उपयोग के साथ एक फ़ंक्शन (आंतरिक एक) है i, लेकिन यह कुछ भी नहीं करता है।

लंबाई 40 स्निपेट:

$('p').click(function(){$(this).hide()})

हम उन पैराग्राफ को पूरी तरह से छोड़ रहे हैं और jQuery का उपयोग कर रहे हैं।

लंबाई 39 स्निपेट:

script=document.createElement('script')

यह एक नई बाहरी स्क्रिप्ट जोड़ने की शुरुआत है। एक खाली <script>तत्व बनाएं , और इसके लिए एक संदर्भ रखें।

लंबाई 38 स्निपेट:

document.getElementsByClassName('abc')

.abcदस्तावेज़ में सभी तत्वों को ढूंढें । बेशक, jQuery के साथ, यह केवल $('.abc')...

लंबाई 37 स्निपेट:

b=JSON.parse(JSON.stringify(a={3:7}))

दो समान, लेकिन डिकॉउंड की गई वस्तुओं को बनाता है a, और b। अगर तुम करोगे

a={a:1};
b=a;
b.a=3;

आप के साथ समाप्त हो जाएगा a=={a:3}, क्योंकि aऔर bएक ही वस्तु को इंगित करें। हम JSON का उपयोग उन्हें डिकूप करने के लिए करते हैं।

लंबाई 36 स्निपेट:

(function f(){return "("+f+")()"})()

एक रानी । यह अपने स्वयं के स्रोत कोड को प्रिंट करता है।

लंबाई 35 स्निपेट:

document.body.style.display="none";

# 32 देखें। यह केवल सामग्री को अधिलेखित किए बिना, दस्तावेज़ को छुपाता है।

लंबाई 34 स्निपेट:

Object.prototype.toString.call(34)

Object.prototype.toStringकिसी वस्तु के प्रकार को बताने के लिए कॉलिंग एक अच्छा तरीका है। जबकि 34..toString()है "34", टुकड़ा है [object Number]

लंबाई 33 स्निपेट: (इसके लिए क्रेडिट एक अनाम उपयोगकर्ता को जाता है )

+0%-0.&(v\u0061r=~void[{}<<!(0)])

लगता है कि यह मान्य जावास्क्रिप्ट नहीं है? बेहतर है इसे आज़माएं ... (क्रोम का उपयोग करें;)

लंबाई 32 स्निपेट:

document.body.innerHTML="hacked"

परिचय सहायता Hazxxors! ग्यारह !! 11!

लंबाई 31 स्निपेट:

a=[];for(i=0;i<31;i++)a.push(i)

कोई मजाक नहीं, मैं वास्तव में एक forपाश का उपयोग करने में सक्षम होने के लिए इतनी देर तक इंतजार कर रहा हूं ! यह एक 0-30 से एक सरणी बनाता है।

लंबाई 30 स्निपेट:

new Date().getDay()==1?"S":"E"

पहली बार टर्नरी ऑपरेटर का उपयोग करना। मैं 30 पात्रों में इससे अधिक फिट नहीं हो सकता था, इसलिए हम केवल यह जानते हैं कि आज रविवार है, या कुछ और। : पी

लंबाई 29 स्निपेट:

Object.keys(window).push('i')

Object.keys(window)वैश्विक चर का एक सरणी (गुण window) मिलेगा । .push()उस सरणी में किसी आइटम को जोड़ देगा। लगता है कि यह बराबर है window.i=undefined? नहीं!

लंबाई 28 स्निपेट:

setTimeout("a=confirm()",28)

28 मिलीसेकंड का इंतजार करना इतना उपयोगी नहीं है, सिवाय एक नया धागा बनाने के।

लंबाई 27 स्निपेट:

document.querySelector('a')

यह शर्म की बात है कि DOM नाम इतने लंबे हैं। मैं यहाँ केवल एक ही लिंक प्राप्त कर सकता था।

लंबाई 26 स्निपेट:

JSON.stringify({twenty:6})

# 16 देखें। अब हमें वास्तविक JSON मिलता है - एक स्ट्रिंग।

लंबाई 25 स्निपेट:

new Badge("Good Answer");

मान लिया गया Badge()कि एक रचनाकार एक तर्क ले रहा है ... एक अच्छा जवाब बिल्ला बनाया गया था!

लंबाई 24 स्निपेट:

do {alert(24)} while(!1)

मैं वास्तव में do..whileबहुत ज्यादा उपयोग नहीं करता, लेकिन कुछ करते हैं। यदि यह एक सामान्य whileलूप होता, तो यह कुछ भी सचेत नहीं करता, क्योंकि यह हमेशा गलत होता है। do..whileहमेशा कम से कम एक बार चलेगा, लेकिन हम 24 को देखते हैं।

लंबाई 23 स्निपेट:

window.parent==self.top

ये सभी एक ही वस्तु को संदर्भित करते हैं, जिसे आमतौर पर जाना जाता है window। यदि आप किसी फ़ंक्शन को सामान्य रूप से कहते हैं, तो वहां भी है this। यह वैश्विक वस्तु तक पहुँचने के 5 तरीके हैं!

लंबाई 22 स्निपेट:

for(i in self)alert(i)

सभी वैश्विक चर अलर्ट करें। ऐसा ही होता है self==window। (अगली स्निपेट देखें।)

लंबाई 21 स्निपेट:

"2"+1==21 && 2+1=="3"

ओह देखो, यह फिर से जेएस के कास्टिंग नियम हैं। यह कथन सत्य है, btw।

लंबाई 20 स्निपेट:

Math.random()<.5?0:1

0-1 से एक यादृच्छिक संख्या चुनें, और टर्नरी ऑपरेटर का उपयोग करके गोल करें। हालांकि इसका इस्तेमाल करना आसान होगा Math.round...

लंबाई 19 स्निपेट:

[1,2,3].map(i=>i*i)

यह एक नया है। जैसे, सचमुच नया। यह 1, 2, और 3 के वर्गों की गणना करने के लिए ES6 तीर फ़ंक्शन का उपयोग करता है । वर्तमान में, यह केवल फ़ायरफ़ॉक्स द्वारा समर्थित प्रतीत होता है।

लंबाई 18 स्निपेट:

location.href="/";

# 15 की तरह, लेकिन इस बार, यह पीपीसीजी होमपेज पर जाता है, एसई नहीं।

लंबाई 17 स्निपेट:

(function(){})()

यह 14 से स्निपेट है, लेकिन बेहतर है! अब यह एक IIFE है।

लंबाई 16 स्निपेट:

obj={not:'json'}

यह मेरे एक पालतू जानवर को समझाता है। यह एक वस्तु है , JSON नहीं ! JSON जावास्क्रिप्ट ऑब्जेक्ट्स पर आधारित एक डेटा-इंटरचेंज प्रारूप है, लेकिन अधिक सख्त प्रारूप ले रहा है।

लंबाई 15 स्निपेट:

open('//s.tk/')

कल्पना करो कि। Http://s.tk/ redirect का उपयोग करके एसई मुखपृष्ठ खोलें ।

लंबाई 14 स्निपेट:

function f(){}

W00t! कार्य! बहुत बुरा वहाँ कुछ भी करने के लिए कोई जगह नहीं है।

लंबाई 13 स्निपेट:

Math.random()

0 से 1 तक एक यादृच्छिक संख्या उत्पन्न करें। अपनी सीमाओं को परिभाषित करना चाहते हैं? कठिन भाग्य। (वास्तव में नहीं, यह आसान है।)

लंबाई 12 स्निपेट:

new Date<=12

जेएस में यह कथन कभी सत्य नहीं रहा। JS को '95 (फैक्टॉइड देखें) तक नहीं बनाया गया था, लंबे समय तक 1/1/1970 00: 00: 00.012 के बाद।

लंबाई 11 स्निपेट:

Math.PI*121

त्रिज्या 11 के साथ एक सर्कल का क्षेत्र।

लंबाई 10 स्निपेट:

if('j')9+1

यदि आपने ध्यान नहीं दिया है, तो मुझे कोड में स्निपेट नंबर के साथ कुछ करना पसंद है। यह एक 10 देता है, और वर्णमाला के दसवें अक्षर j का उपयोग करता है।

लंबाई 9 स्निपेट:

[9].pop()

एक आइटम के साथ एक सरणी बनाएं। नेवला 9 popजाता है ।

लंबाई 8 स्निपेट:

document

सभी डोम काम के लिए आधार। लेकिन हम कुछ नहीं कर सकते, क्योंकि यह बहुत लंबा है। :( जाओ jQuery!

लंबाई 7 स्निपेट:

alert()

ओह यार! एक फ़ंक्शन कॉल! अंत में सामान करने में सक्षम होने के लिए!

लंबाई 6 स्निपेट:

var x=6

# 3 पर आधारित है। हालांकि बेहतर है, क्योंकि अब वैश्विक स्पष्ट है । : पी

लंबाई 5 स्निपेट:

[][5]

void 0पाने के लिए भी कम undefined। BTW: ''.aऔर भी छोटा है; केवल 4 वर्ण।

लंबाई 4 स्निपेट:

+"4"

यह 4स्ट्रिंग से बाहर संख्या बनाएगा "4"। आप विपरीत करने के लिए एक अलग क्रम में इन सटीक 4 वर्णों का पुन: उपयोग कर सकते हैं!

लंबाई 3 स्निपेट:

x=3

ओह खतरा, हम सिर्फ एक अंतर्निहित वैश्विक चर बनाया ...

लंबाई 2 स्निपेट:

{}

यह क्या करता है? यदि आपने कहा है कि एक वस्तु शाब्दिक है, तो आप गलत हैं। यह वास्तव में एक खाली ब्लॉक है। एक कंसोल खोलें और इसे आज़माएं! यह लौटता है undefined, नहीं {}

2018 में, {}क्रोम के कंसोल में वास्तव में एक खाली वस्तु वापस आती है।

लंबाई 1 स्निपेट:

1

बस। कोई भी संख्या एक वैध जेएस अभिव्यक्ति है।

फैक्टॉइड: जावास्क्रिप्ट को मूल रूप से लाइवस्क्रिप्ट कहा जाता था। जावा की लोकप्रियता को भुनाने के लिए इसे जावास्क्रिप्ट में बदल दिया गया, उस समय (1995)। व्यक्तिगत रूप से, उन्हें पुराना नाम रखना चाहिए था; जावास्क्रिप्ट के बाद से भ्रम की स्थिति है। तथ्य यह है कि, जावा और जावास्क्रिप्ट "कार" और "कालीन" के समान हैं


1
स्निपेट 33 फ़ायरफ़ॉक्स पर काम नहीं करता है। क्या यह वास्तव में वैध जेएस है?
ओरिऑल

मुझे लगता है कि यह इतना गंदा कॉपी करने के लिए किसी ऑब्जेक्ट को स्ट्रिंग और रिप्रेसिंग करता है। ECMAScript 6 परिचय देता है Object.assign, इसलिए स्निपेट 37 बन जाता है b = Object.assign({ }, a = {3 : 7})
ओरोल

@ ओरियल हां, ठीक है, केवल फ़ायरफ़ॉक्स अभी इसका समर्थन करता है, इसलिए हमें अभी के लिए गंदे तरीके से रहना होगा। कम से कम यह बेहतर है eval(uneval(a)), है ना? ;)
शिमोनस्टर

# 38 के बारे में, हमेशा होता है document.querySelectorAll("element#id.classname[attribute]:not(somethingwedontwant)")। (किसी भी मान्य सीएसएस चयनकर्ता का समर्थन करता है)।
Mateon1

# 40 स्निपेट स्वयं इतना दिलचस्प नहीं है, लेकिन टिप्पणी अनमोल है।
शिमोनस्टर

85

आर

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

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


लंबाई 32:

`[.data.frame`(swiss,3,2,drop=F)

यह थोड़ा रहस्यमय लगता है ... और वास्तव में यह होना चाहिए! इसे लिखने का एक बेहतर तरीका है:

swiss[3, 2, drop = FALSE]

यह थोड़ा और अधिक परिचित दिखना चाहिए। जब हम कोड के इन टुकड़ों को चलाते हैं तो क्या होता है:

> `[.data.frame`(swiss,3,2,drop=F)
             Agriculture
Franches-Mnt        39.7

swissआर के साथ डेटा फ्रेम जहाजों हम अब तक देखा है कई अन्य लोगों की तरह। इसमें वर्ष 1888 के आसपास से स्विट्जरलैंड के 47 फ्रांसीसी-भाषी प्रांतों के लिए प्रजनन और सामाजिक आर्थिक संकेतक शामिल हैं। तीसरी पंक्ति प्रांत फ्रांसेस-मैन्ट के लिए है, और दूसरा स्तंभ प्रत्येक प्रांत में एक पेशे के रूप में कृषि में शामिल पुरुषों का प्रतिशत है। तो 1888 में, स्विट्जरलैंड के फ्रांसेस-मेंट प्रांत में 39.7% पुरुषों ने कृषि में काम किया।

जब आप सरल संकेतन का उपयोग करके डेटा फ्रेम से पंक्तियों या स्तंभों को निकालते हैं, तो R वास्तव [.data.frameमें पृष्ठभूमि में उपयोग कर रहा है। जैसा कि हमने स्निपेट 24 में देखा, बहुत कुछ भी एक फ़ंक्शन नाम के रूप में परिभाषित किया जा सकता है जब तक कि यह बैक टिक में घिरा हुआ है, इसलिए यहां हमारा स्निपेट वैध है, हालांकि फ़ंक्शन नाम में तकनीकी रूप से बेजोड़ कोष्ठक शामिल हैं।

drop=तर्क आर बताता है कि आप इसे यदि संभव हो तो एक कम आयाम में परिणाम ड्रॉप करना चाहता हूँ। वास्तव में, अगर हम कहते हैं drop=TRUE, हम इसे प्राप्त करते हैं:

> `[.data.frame`(swiss,3,2,drop=T)
[1] 39.7

जहां पहले परिणाम एक डेटा फ्रेम था, आर अब हमें एक डबल देता है।


लंबाई 31:

print(fortune("hadleywickham"))

fortune()समारोह सब जानने से है fortunesपैकेज है, जो बुद्धिमान लोगों की एक किस्म से बुद्धिमान उद्धरण की एक किस्म प्रदान करता है। यह स्निपेट आपको हेडली विकम (23) से सांत्वना को मुद्रित करके निम्नलिखित रत्न प्रदान करेगा:

That's a casual model, not a causal model - you can tell the difference by looking
for the word "excel".
    -- Hadley Wickham (commenting on an Excel chart showing student's SAT score
       increases with family income, without considering future covariates)
       http://twitter.com/#!/hadleywickham (February 2012)

लंबाई 30:

pie(rep(1,12),col=rainbow(12))

एक अच्छा पाई चार्ट किसे पसंद नहीं है? pie()समारोह आप एक ताजा बेक्ड पाई संख्या का एक वेक्टर के आधार पर चार्ट तक प्रस्तुत कर देगा। rep()पहला तत्व r बार दोहराकर वेक्टर बनाता है जहां r दूसरा तर्क है। col=पैरामीटर बताता pie()स्लाइस रंग करने के लिए कैसे। जादुई फ़ंक्शन rainbow()इंद्रधनुष के "समान रूप से स्थानित" रंगों के लिए हेक्स कोड युक्त एक निर्दिष्ट लंबाई का एक वेक्टर उत्पन्न करता है।

आपके पास यहां क्या है "इस चार्ट में प्रत्येक रंग की आपकी मूल राशि" है:

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


लंबाई 29:

summary(lm(mag~depth,quakes))

यहां कुछ चीजें चल रही हैं, तो चलो उन्हें एक बार में एक कदम उठाएं।

quakes एक डेटासेट है जो आर के साथ जहाज करता है। इसमें 1964 से फिजी के पास रिक्टर पैमाने पर 4.0 से अधिक की भूकंपीय घटनाओं के बारे में जानकारी है। डेटासेट में दो कॉलम हैं mag , जो भूकंप का परिमाण है, और depth, जो है किलोमीटर में उपकेंद्र की गहराई।

lm()समारोह, के रूप में टुकड़ा 28 में उल्लेख किया है, रैखिक मॉडल फिट बैठता है। यह एक lmवस्तु, या अधिक सटीक, वर्ग की एक वस्तु लौटाता है lm। भविष्यवक्ता (या स्वतंत्र चर) और प्रतिक्रिया (या आश्रित चर) को निर्दिष्ट करने के दो तरीके हैं , और मैंने सूत्र विधि को चुना है। यह रूप लेता है response ~ predictor। कई भविष्यवक्ता के रूप में निर्दिष्ट किए गए हैं y ~ x1 + x2। सूत्र में वस्तुओं का मूल्यांकन अगले तर्क में दिए गए संदर्भ में किया गया है।

तो जो lm(mag ~ depth, quakes)कर रहा है वह सामान्य से कम वर्ग के प्रतिगमन का उपयोग कर एक रैखिक मॉडल को फिट कर रहा है जहां परिमाण प्रतिक्रिया और गहराई का अनुमान है। यह जानता है कि क्या magऔर क्या depthहैं क्योंकि हमने यह बताया कि वे आते हैं quakes

summary()मुख्य रूप से फिट किए गए मॉडल के परिणामों को सारांशित करने के लिए उपयोग किया जाने वाला एक सामान्य कार्य है। यह अपने तर्क के वर्ग विशेष के लिए एक विधि का आह्वान करता है। जब से हम पास हुएlm ऑब्जेक्ट है, यह वास्तव में एक फ़ंक्शन को आमंत्रित कर रहा है जिसे कहा जाता है summary.lm()

यह सब एक साथ रखकर, हमें भूकंप की गहराई से भूकंप की व्याख्या करने के प्रयास के रैखिक मॉडल का सारांश मिलता है। विशेष रूप से, यह वह है जो आर बाहर निकलता है:

> summary(lm(mag~depth,quakes))

Call:
lm(formula = mag ~ depth, data = quakes)

Residuals:
     Min       1Q   Median       3Q      Max 
-0.72012 -0.29642 -0.03694  0.19818  1.70014 

Coefficients:
              Estimate Std. Error t value Pr(>|t|)    
(Intercept)  4.755e+00  2.179e-02 218.168  < 2e-16 ***
depth       -4.310e-04  5.756e-05  -7.488 1.54e-13 ***
---
Signif. codes:  0***0.001**0.01*0.05 ‘.’ 0.1 ‘ ’ 1

Residual standard error: 0.3921 on 998 degrees of freedom
Multiple R-squared:  0.05319,   Adjusted R-squared:  0.05225 
F-statistic: 56.07 on 1 and 998 DF,  p-value: 1.535e-13

ध्यान दें कि यह पहली बात बताता है कि आप फ़ंक्शन कॉल कैसे कर रहे हैं? ऐसा इसलिए है क्योंकि lm()फ़ंक्शन उपयोग करता है match.call(), जैसे हमने स्निपेट 28 में किया था!


लंबाई 28:

f<-function(x,y)match.call()

आर फ़ंक्शंस अक्सर आपको जो कुछ भी बताते हैं, उसका ट्रैक रखना पसंद करते हैं। दरअसल, कभी-कभी आपके द्वारा सबमिट की गई कमांड आपको वापस दिए गए ऑब्जेक्ट की विशेषता के रूप में वापस दी जाती है। (एक उदाहरण है lm(), जो रैखिक मॉडल बनाता है।) सटीक निर्देशों को याद करते हुए match.call()फ़ंक्शन के भीतर का उपयोग करके पूरा किया जाता है । यह कैप्चर करता है, या मेल खाता है , व्याख्या की गई फ़ंक्शन कॉल।

यहां हमने एक फ़ंक्शन को परिभाषित किया है f()जो दो तर्क लेता है और फिर आपको बताता है कि उसने क्या देखा।

> f(1,2)
f(x = 1, y = 2)

यह मुख्य रूप से तब उपयोगी होता है जब पैकेज के विकास की तरह सामान्य उपयोग (केवल आपके लिए) के लिए कार्य विकसित करना। यदि आप match.call()जंगली का एक उदाहरण देखना चाहते हैं , तो lm()सबमिट करके स्रोत कोड देखें stats:::lm। पहली चीजों में से एक यह फ़ंक्शन कॉल का उपयोग करके कैप्चर करता है match.call()


लंबाई 27:

install.packages("ggplot2")

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

install.packages()ठीक वही करता है जो उसका नाम बताता है। यह आपके डिफॉल्ट CRAN (कॉम्प्रिहेंसिव आर आर्काइव नेटवर्क) मिरर का उपयोग करते हुए संकुल के लिए एक 'हंट-हंटिन' जाता है, फिर उन्हें आपके सिस्टम पर स्थापित करता है जहाँ R उन्हें खोज सकता है। आप इसे स्थानीय स्रोत कोड से पैकेज भी स्थापित कर सकते हैं।

याद रखें स्निपेट 23 जहां हमने ggplot2पैकेज का उपयोग किया था ? यह पैकेज आर के साथ जहाज नहीं करता है, लेकिन केवल 27 पात्रों में आप ggplot2इसे स्थापित करके अपने सभी सपनों को सच कर सकते हैं ।


लंबाई 26:

filled.contour(t(volcano))

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

भटकाव के लिए, आइए दिशाओं की अदला-बदली करें, इसलिए स्तंभ अब पूर्व-पश्चिम और पंक्तियाँ दक्षिण-उत्तर की ओर हैं। हम एक मैट्रिक्स ट्रांसपोज़ का उपयोग करके ऐसा कर सकते हैं, जिसके माध्यम से पूरा किया गया है t()। और जब हम उस पर हों तो समोच्च नक्शा क्यों नहीं बनाते? filled.contour()बस यही करता है।

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


लंबाई 25:

pmatch("s",c("n","size"))

pmatch()समारोह सभी आंशिक मेल हम अब तक देखा है के पीछे जादू प्रदान करता है। पहला तर्क एक स्ट्रिंग है जिसकी तुलना दूसरे तर्क के प्रत्येक तत्व, एक वेक्टर के साथ की जाती है। यदि कोई अनूठा मेल है, तो मिलान तत्व का सूचकांक वापस आ जाता है, अन्यथा आप प्राप्त करते हैंNA

यहां स्निपेट इस फ़ंक्शन के उपयोग का एक "वास्तविक दुनिया" उदाहरण है। 13 स्निपेट पर वापस जाएं जहां हमने sample()फ़ंक्शन का उपयोग किया था । यह स्वीकार करता है तर्क n, size, replace, और prob, लेकिन केवल पहले दो की आवश्यकता है। स्निपेट 13 में हमने s=शॉर्टहैंड के रूप में इस्तेमाल किया size=। वास्तव में पृष्ठभूमि में जो चल रहा है, वह इस स्निपेट जैसा कुछ है, जहां हमने जो प्रदान किया है उसकी तुलना अपेक्षा के अनुरूप है। चूंकि "s" मैच "आकार" विशिष्ट है, इसलिए इसे s=शॉर्टहैंड के रूप में उपयोग करना पूरी तरह से वैध है।


लंबाई 24:

`(`=function(x)9;2*(3-1)

कुछ ऐसा जो आप नहीं करना चाहिए का एक आदर्श उदाहरण! कभी!

आप फ़ंक्शन को तब तक असाइन कर सकते हैं जब तक कि आप फ़ंक्शन को परिभाषित करते समय उन्हें बैक टिक्स में घेर लेते हैं। यहाँ हमने R को बताया कि (एक ऐसा फंक्शन है जो इनपुट की परवाह किए बिना हमेशा 9 देता है। कई अन्य भाषाओं की तरह, ;एक पंक्ति में दो आदेशों को शामिल करने के लिए उपयोग किया जा सकता है। तो हमने जो R को बताया है वह फ़ंक्शन को परिभाषित करता है (, फिर प्रिंट करें 2*(3-1)

अब, किसी भी व्यक्ति के बारे में आपको बताएगा कि 2 * (3-1) 4 होना चाहिए क्योंकि आप 3-1 = 2 करते हैं, फिर 2 * 4 = 4। लेकिन हमने आर को बताया है कि कोष्ठक के अंदर कुछ भी 9. तो 3-1 = 2 है, अब हमारे पास (3-1) = 9 है। फिर हमें 2 * (3-1) = 2 * 9 = 18 मिलता है।

चूंकि इस तरह की भयानक चीजें संभव हैं, हर बार जब आप कोड जमा करते हैं जिसमें एक अभिव्यक्ति में कोष्ठक होते हैं (यानी एक फ़ंक्शन कॉल नहीं), आर दुभाषिया वास्तव में किसी भी फ़ंक्शन की तलाश में चला जाता है, (भले ही आपको (फ़ंक्शन के रूप में परिभाषित किया गया हो । सामान्य तौर पर, जितना अधिक आप लिखते हैं, उतना ही अधिक कार्य R दुभाषिया करता है।


लंबाई 23:

qplot(Na,y=RI,data=fgl)

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

fglडाटासेट से आता है MASSपैकेज। इसमें फोरेंसिक ग्लास के टुकड़ों के गुणों का माप है। यहां हम चर का उपयोग कर रहे हैं Na, जो वजन से प्रतिशत सोडियम (Na) है, और RI, जो कांच का अपवर्तनांक है।

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


लंबाई 22:

unique(presidential$n)

unique()समारोह एक वेक्टर वे किस क्रम में इनपुट में दिखाई देते हैं में अपने इनपुट वेक्टर से अनन्य मानों युक्त देता है। presidentialसाथ डाटासेट जहाजों ggplot2पैकेज (27)। (इसे ठीक करने के लिए Jemus42 का धन्यवाद!) इसका विवरण:

प्रत्येक राष्ट्रपति के नाम, उनके कार्यकाल की शुरुआत और समाप्ति की तारीख, और उनकी पार्टी के 10 अमेरिकी राष्ट्रपति आइजनहावर से बुश टी।

presidentialएक डेटा फ्रेम है, और डेटा फ़्रेम में कॉलम होते हैं जैसे सूचियों में आइटम होते हैं। कॉलम का उपयोग करके नाम से संदर्भित किया जाता है $। इस विशेष डेटासेट में एक कॉलम होता है name, जिसमें राष्ट्रपति का नाम होता है। लेकिन रुको, हम केवल निर्दिष्ट n! दरअसल, यह आंशिक मिलान (13, 16) का एक और उदाहरण है, इसलिए nयह पूरी तरह से वैध है।

इसे प्रस्तुत करने का एक दिलचस्प परिणाम है:

[1] "Eisenhower"  "Kennedy"  "Johson"   "Nixon"  "Ford"  "Carter"
[7] "Reagan"      "Bush"     "Clinton"

ध्यान दें कि कैसे लिंडन बी। जॉनसन का नाम वर्तनी है ... उफ़।

(नोट: यह पोस्ट करने के एक साल बाद, यह ध्यान में आया है, कि जॉनसन टाइपो को ठीक कर दिया गया है। RIP हास्य)


लंबाई 21:

integrate(dexp,0,Inf)

एक परिमित या अनंत अंतराल पर एकल चर के कार्यों के अनुकूली द्विघात के लिए आर में एक अंतर्निहित कार्य होता है। आर में, अनंत को Inf+ अनंत और -Infफॉर- इनफिनिटी के रूप में निर्दिष्ट किया गया है । dexp()समारोह घातीय वितरण के लिए प्रायिकता वितरण समारोह है। चूंकि घातांक वितरण का समर्थन [0, + अनंत) है और प्रायिकता वितरण 1 से एकीकृत है, हम परिणाम 1 होने की उम्मीद करेंगे। एक परिणाम, एक अपेक्षित परिणाम!

1 with absolute error < 5.7e-05

लंबाई 20:

deriv(~cos(x^3),"x")

प्रतीकात्मक व्युत्पत्ति कर सकते हैं! यह रिटर्न:

expression({
    .expr1 <- x^3
    .value <- cos(.expr1)
    .grad <- array(0, c(length(.value), 1L), list(NULL, c("x")))
    .grad[, "x"] <- -(sin(.expr1) * (3 * x^2))
    attr(.value, "gradient") <- .grad
    .value
})

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

वास्तव में साफ कुछ देखना चाहते हैं? एक चर के लिए ऊपर असाइन करें, कहते हैं dxxएक संख्यात्मक वेक्टर के रूप में एक चर को परिभाषित करें । फिर सबमिट करें eval(dx)। आर व्युत्पन्न का मूल्यांकन करता है x!


लंबाई 19:

c(matrix(1,3,3),"a")

आर में, c()"कंबाइन" या "कॉन्टेनेट" के लिए छोटा, अपने तर्कों से एक वेक्टर बनाता है। वैक्टर के तत्व एक ही प्रकार के होने चाहिए और सभी की लंबाई 1. है, लेकिन इसके बारे में आप पर पागल होने के बजाय, आर एक संरचना के साथ एक तत्व को समतल कर देगा, इस मामले में एक मैट्रिक्स, और एक ही प्रकार के लिए सब कुछ डाली।

यदि तर्कों c()में केवल एक ही प्रकार होता है, तो कोई प्रकार की कास्टिंग नहीं होती है, जैसे कि यदि सभी तर्क तार्किक ( TRUEऔर FALSE) हैं, तो वेक्टर सभी तार्किक होंगे। यदि इसमें तार्किक और संख्याएँ हैं, तो यह सभी संख्याएँ होंगी। यदि इसमें चरित्र और कुछ भी शामिल है, तो यह सभी चरित्र होगा। तो हमारा स्निपेट हमें यही देता है:

> c(matrix(1,3,3),"a")
[1] "1" "1" "1" "1" "1" "1" "1" "1" "1" "a"

ध्यान दें कि 3 द्वारा 3 मैट्रिक्स को चपटा किया गया था और "ए" के अलावा ने पात्रों में सब कुछ बनाया।


लंबाई 18:

(1-1/3-1/3-1/3)==0

मशीन परिशुद्धता में एक सबक। यह लौटता है FALSE


लंबाई 17:

example(readline)

example()समारोह आप कैसे किसी भी अंतर्निहित फ़ंक्शन का उपयोग करने का एक उदाहरण दे देंगे। यदि आपको यह पता लगाना है कि उपयोग कैसे करना है readline(), तो आर का आपके लिए एक स्मॉग उत्तर है।

> example(readline)

readln> fun <- function() {
readln+   ANSWER <- readline("Are you a satisfied R user? ")
readln+   ## a better version would check the answer less cursorily, and
readln+   ## perhaps re-prompt
readln+   if (substr(ANSWER, 1, 1) == "n")
readln+     cat("This is impossible.  YOU LIED!\n")
readln+   else
readln+     cat("I knew it.\n")
readln+ }

readln> if(interactive()) fun()
Are you a satisfied R user?

मामूली होने का रास्ता, आर।


लंबाई 16:

acf(lh,t="part")

acf()समारोह एक समय श्रृंखला के लिए autocorrelation समारोह देता है। lhएक डेटासेट है जो आर के साथ जहाज करता है। इसका विवरण:

एक नियमित समय श्रृंखला एक मानव महिला से 10 मिनट के अंतराल पर रक्त के नमूनों में ल्यूटिनाजिंग हार्मोन देती है, 48 नमूने।

इस उदाहरण में, दो बार आंशिक मिलान का उपयोग किया जा रहा है : एक बार फ़ंक्शन पैरामीटर के साथ और एक बार स्ट्रिंग मान पैरामीटर के साथ पारित होने के बाद। पूर्ण पैरामीटर नाम है typeऔर मान्यता प्राप्त मान हैं "correlation", "covariance", और "partial"। स्ट्रिंग के केवल पर्याप्त यह की पहचान के लिए प्रदान किया गया है, इसलिए हम उपयोग कर सकते हैं "part"के लिए "partial"है, जो हमें आंशिक autocorrelation समारोह (PACF) देता है।

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


लंबाई 15:

p3d(bunny,p=99)

फिर से हम बदनाम बनी (11) को देखते हैं। onionपैकेज हमें कभी सबसे अधिक उपयोगी डाटासेट देखने पर, 3 डी की साजिश रचने समारोह का उपयोग कर एक और भी अच्छे रास्ता देती है p3d()। यह persp()पृष्ठभूमि में बेस ग्राफिक्स फ़ंक्शन को कॉल करता है , जो एक घूर्णी तर्क लेता है phi। पैरामीटर नामों (13) के आंशिक मिलान का उपयोग करके, हम केवल p=के स्थान पर निर्दिष्ट कर सकते हैं phi=

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


लंबाई 14:

stats:::rgamma

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

function (n, shape, rate = 1, scale = 1/rate)
{
    if (!missing(rate) && !missing(scale)) {
        if (abs(rate * scale - 1) < 1e-15)
            warning("specify 'rate' or 'scale' but not both")
        else stop("specify 'rate' or 'scale' but not both")
    }
    .External(C_rgamma, n, shape, scale)
}
<bytecode: 0x00000000098cd168>
<environment: namespace:stats>

ध्यान दें कि यह एक फ़ंक्शन का उपयोग करता है .External()। यह कॉल अन्य भाषाओं में लिखा जाता है, आमतौर पर सी और फोरट्रान, वे भाषाएँ जिनमें आर की नींव बहुत ज्यादा होती है, उस सोर्स कोड का पता लगाने में थोड़ी-बहुत विजार्ड्री लगती है। संपादित करें: @Vlo ने बताया कि मात्र नश्वर वास्तव में अंतर्निहित सी कोड को पैकेज के साथ .Internal()और .Primitive()उपयोग करके देख सकते हैं pryr। धन्यवाद, @ वालो!


लंबाई 13:

sample(9,s=4)

यह ज्यादा नहीं दिखता है, लेकिन यह फ़ंक्शन मापदंडों के आंशिक मिलान में आर: में एक शक्तिशाली अवधारणा का उदाहरण देता है । sample()फ़ंक्शन में नामित पैरामीटर हैं size, replaceऔर prob, लेकिन आपको इसे विशिष्ट रूप से पहचानने के लिए नामित पैरामीटर के पर्याप्त अक्षर प्रदान करने की आवश्यकता है। इस प्रकार sample(), आप s=इसके बजाय उपयोग कर सकते हैं size=क्योंकि कोई अन्य पैरामीटर नाम "एस" अक्षर से शुरू नहीं होता है। यहां कोड 1 से 9 के पूर्णांक से आकार 4 का एक यादृच्छिक नमूना चुनता है।


लंबाई 12:

LETTERS[-pi]

एक अंतर्निहित वेक्टर कहा जाता है LETTERSजिसमें सभी बड़े अक्षर होते हैं अंग्रेजी वर्णानुक्रम में आदेश दिए गए हैं। कई अन्य भाषाओं के विपरीत, आप एक अस्थायी बिंदु संख्या का उपयोग करके एक वेक्टर को अनुक्रमित कर सकते हैं। कुछ भी रोमांचक नहीं होता; बस पूर्णांक भाग लेता है। -एक वेक्टर के सूचकांक से पहले का उपयोग वेक्टर से उस सूचकांक के साथ तत्व को हटा देता है। piएक अंतर्निहित स्थिरांक है - आपने यह अनुमान लगाया है - अपरिमेय संख्या constant। तो यह वेक्टर से तत्व 3 को हटाता है और "Z" को "Z" छोड़ कर "C" से वापस करता है।


लंबाई 11:

plot(bunny)

में onionपैकेज, वहाँ एक डाटासेट कहा जाता है bunny। इसे प्लॉट करना आपको देता है जो अब तक का सबसे उपयोगी ग्राफिक हो सकता है:

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


लंबाई 10:

????sample

कहें कि आप वास्तव में sample()फ़ंक्शन के बारे में भ्रमित हैं और आपको सख्त मदद की आवश्यकता है। ?sampleआर मैनुअल पेज को खींचने के लिए सामान्य से अधिक , आप चार प्रश्न चिह्न लगाते हैं। आर आपकी दुर्दशा सुनता है और मदद करने का प्रयास करता है ...

Contacting Delphi...the oracle is unavailable.
We apologize for any inconvenience.

अफसोस।


लंबाई 9:

isTRUE(1)

सबसे पहले यह आर बेस पैकेज के बाकी हिस्सों में कन्वेंशन को अलग करने के लिए लगता है isऔर फ़ंक्शन नाम में निम्नलिखित शब्द ए के साथ .। हालांकि, यह केवल तर्क के एक तार्किक परीक्षण पर लागू होता है कि क्या तर्क एक निश्चित प्रकार का है, जैसा कि नीचे (8)। इस मामले में, हम परीक्षण कर रहे हैं कि क्या यह है TRUE, जो एक प्रकार नहीं है। यह TRUEसामान्य अर्थ में, "1" की एक सख्त परिभाषा का उपयोग नहीं करता है। isTRUE(1)लौटता है FALSE


लंबाई 8:

is.na(8)

अधिकांश अन्य प्रोग्रामिंग भाषाओं के विपरीत, .फ़ंक्शन और वैरिएबल नामों में एक मान्य चरित्र है। यह किसी भी प्रकार की पद्धति या उत्तराधिकार को निरूपित नहीं करता है; यह सिर्फ नाम का हिस्सा है। is.na()समारोह की जाँच करता है कि क्या उसके तर्क का मूल्यांकन NA(लापता) और रिटर्न TRUEया FALSE


लंबाई 7:

stop(7)

यह त्रुटि संदेश के रूप में इनपुट के साथ एक त्रुटि जारी करता है। यदि किसी फ़ंक्शन के अंदर कहा जाता है, तो फ़ंक्शन निष्पादन बंद हो जाएगा। लेकिन इसे एक फंक्शन के बाहर बुलाने से स्क्रिप्ट बंद नहीं होगी। इस मामले में, आउटपुट है Error: 7


लंबाई 6:

x < -1

हालांकि यह तुच्छ लग सकता है, यह असाइनमेंट ऑपरेटर की एक प्रमुख आलोचना प्रदर्शित करता है <-: अर्थात्, स्थान के स्थान के आधार पर अर्थ बदल जाता है। जैसा कि उल्लेख किया गया है, x <- 11 से असाइन करता है x। अलग <और -एक ही स्थान के साथ के रूप में ऊपर यह एक तार्किक परीक्षण के लिए बदलता है कि क्या x-1 से कम है। उस कारण से, कई =असाइनमेंट के लिए पसंद करते हैं ।


लंबाई 5:

x<<-1

करने के लिए इसी तरह के <-सिवाय <<-हमेशा वैश्विक विस्तार करने के लिए चर वर्तमान क्षेत्र की परवाह किए बिना प्रदान करती है।


लंबाई 4:

x<-1

<-मौजूदा दायरे में चर को असाइन करने के लिए R का उपयोग करता है। यह स्निपेट 1 से 1 मान प्रदान करता है x


लंबाई 3:

!0i

!ऑपरेटर के लिए आर है "नहीं," और 0iजटिल संख्या है 0+0i, उर्फ 0 जटिल समतल में। TRUE0 से यह विवरण प्रस्तुत करना गलत है।


लंबाई 2:

NA

यह विशेष आर मान लौटाता है NA, जो एक लापता मूल्य को दर्शाते हुए "उपलब्ध नहीं है" के लिए खड़ा है।


लंबाई 1:

T

यह लौटता है TRUE। आर में, Tऔर क्रमशः Fबूलियन मूल्यों TRUEऔर के लिए समानार्थक शब्द FALSEहैं।


याय आर "!"(T)!
व्लो

@ वलो: का "!"(T)मूल्यांकन करता है FALSE। हालाँकि, "याय आर" कथन कभी भी गलत नहीं है। ;)
एलेक्स ए।

मैं अधिक प्रविष्टियों के लिए और अधिक कैसे बढ़ाऊँ ???? "उस स्रोत कोड का पता लगाने में थोड़ी सी .Internal.Primitivepryr::show_c_source(.Primitive("sum"))
मैजोरिटी लगती

@ हैलो: मैंने pryrपैकेज के बारे में नहीं सुना था । बहुत ही शांत! यह बात बताने के लिए धन्यवाद। मुझे खुशी है कि आप अब तक की प्रविष्टियों को पसंद करते हैं, समर्थन के लिए धन्यवाद। :)
एलेक्स ए।

2
@ Jemus42 आह, लगता है जैसे आपको data(bunny)पहले करने की आवश्यकता है ।
एलेक्स ए।

75

Brainfuck

Factoid: Brainfuck (जिसे brainf * ck के नाम से भी जाना जाता है), शहरी म्यूलर द्वारा बनाई गई सबसे छोटी ट्यूरिंग-पूर्ण भाषा दुभाषिया बनाने के लिए एक प्रयोगात्मक गूढ़ भाषा थी, और वर्तमान में यह अपनी तरह की सबसे प्रसिद्ध भाषा है। इसमें केवल आठ कमांड हैं, सीखना आसान है, लेकिन उपयोग करना कठिन है।

ब्रेनफ़ * ck में 30000 सेल और एए मूवेबल पॉइंटर के साथ एक टेप बेस मेमोरी है, और इसे इस तरह से देखा जा सकता है:

0 0 0 0 0 0
    ^

^सूचक का प्रतिनिधित्व करने वाले चरित्र के साथ , और 0 प्रत्येक कोशिका के लिए मूल्यों का प्रतिनिधित्व करता है।

ब्रेनफक के आठ निर्देश हैं:

Instruction  C Equivalent              Description
+            mem[ptr]++;               Add one to the value under the cell
-            mem[ptr]--;               Subtract one from the value under the cell
>            ptr++;                    Go on cell to the right
<            ptr--;                    Go on cell to the left
,            mem[ptr] = getchar();     Read a ASCII character from input and put the result in the value under the cell
.            putchar(mem[ptr]);        Write a ASCII character to the output using the value under the cell
[            while (mem[ptr]) {        Start a while loop: Continue to matching ']' when value under the cell is 0
]            }                         End a while loop: Go back to matching '[' when value under the cell is NOT 0

ब्रेनफुक टू सी:

#include <stdlib.h>

int main(void) {
    unsigned char* mem = calloc(30000, sizeof(unsigned char));
    unsigned int ptr = 0;

    // Put your brainfuck code here, converted to the matching expressions under "C equivalent"

    return 0;
}

लंबाई 1 स्निपेट

एक चरित्र को पढ़ें और इसे वर्तमान सेल में डालें।

,

मेमोरी (इनपुट के साथ abc)

0 0 97 0 0 0
    ^

लंबाई 2 स्निपेट

वर्तमान सेल में एक जोड़ें, और पॉइंटर को दाईं ओर शिफ्ट करें।

+>

याद

0 0 1 0 0 0
      ^

लंबाई 3 स्निपेट

वर्तमान सेल से एक को तब तक निकालें जब तक कि यह शून्य न हो; वर्तमान सेल को शून्य पर सेट करें

[-]

संभव स्मृति:

मेमोरी: (पहले)

0 0 100 0 0 0
    ^

मेमोरी: (बाद में)

0 0 0 0 0 0
    ^

लंबाई 4 स्निपेट

टिप्पणियाँ: Brainfuck में, एक निर्देश नहीं है सब कुछ नजरअंदाज कर दिया। उस कारण से निम्नलिखित कार्यक्रम पूरी तरह से मान्य (लेकिन खाली) ब्रेनफक कार्यक्रम है:

Hey!

लंबाई 5 स्निपेट

एक साधारण बिल्ली कार्यक्रम (आउटपुट में इनपुट लिखें)

,[.,]

उनकी टिप्पणी के लिए धन्यवाद

लंबाई 6 स्निपेट

वर्तमान सेल के मान को सेल में दाईं ओर ले जाएं (सेल को दाईं ओर मान लें, अन्यथा यह वर्तमान सेल के मूल्य को सेल के मान को दाईं ओर जोड़ देगा):

[>+<-]

सामान्य तौर पर, लोग इस कोड का उपयोग एक चर को स्थानांतरित करने के लिए करते हैं।

मेमोरी: (पहले)

10 0 100 0 0 0
     ^

मेमोरी: (बाद में)

10 0 0 100 0 0
     ^

लंबाई 25 स्निपेट

एक छह वर्ण इनपुट को उल्टा करें और इसे प्रिंट करें, इसके बाद प्रत्येक एएससीआईआई चरित्र (एन -1) .. 1 (जहां एन पहले इनपुट चरित्र का मूल्य है)।

,>,>,>,>,>,.<.<.<.<.<[.-]

लंबाई 53 स्निपेट

main(){i=0;j=0;if(i>=0){if(j<=i)i+=1;i-=1;}return 0;}

यह छोटा सी कार्यक्रम भी भेस में एक ब्रेनफक कार्यक्रम है, और इसके विपरीत! वास्तव में, वे (लगभग) एक ही काम करते हैं। यहां "टिप्पणियों" (सी कोड) के बिना ब्रेनफक कोड है।

><+-

मुझे Brainfuck कोड (और C कोड) समझाएं। जैसा कि आप देख सकते हैं, यह दो कोशिकाओं ( iऔर j) का उपयोग करता है । यह पहली सेल को बढ़ाता iहै ( 1 से वृद्धि )। फिर यह उसी सेल को घटाता iहै ( 1 से घटता है)।

यह केवल कुछ स्रोत कोड का एक मूर्खतापूर्ण उदाहरण है, जिसे दो अलग-अलग भाषाओं के रूप में संकलित किया जा सकता है और समान रूप से चलाया जा सकता है।


2
,[.,]- 5 अक्षर, बिल्ली कार्यक्रम
tomsmeding

13
यह सबसे अच्छा "ब्रेनफक 101" हो सकता है जो मैंने कभी देखा है।
hoosierEE

लंबाई 6: जो योग को सही सेल में रखेगी, और लेफ्ट को शून्य करेगी। हिलना नहीं है, है ना?
फिलाल हाग्लंड

अवधारणा को बेहतर ढंग से समझाने के लिए लंबाई 6 से एक डमी चर जोड़ा गया। कार्यक्रम वास्तव में सेल # 3 को सेल # 4 में जोड़ देगा और सेल # 3 0. बना देगा
YoYoYonnY

58 वोट - क्या आप अपडेट कर सकते हैं? :)
कॉनर ओ'ब्रायन

65

सी ++

इसके प्रीप्रोसेसर, टेम्प्लेट, लैम्ब्डा, टाइप लक्षण और अनगिनत अन्य जटिल विशेषताओं के साथ, जो कोई भी कभी भी इसकी संपूर्णता को समझने की उम्मीद नहीं कर सकता है, C ++ को इसके मानक की प्रत्येक नई पीढ़ी द्वारा फिर से खोजा गया है। संकलन समय पर काम करने के लिए इसके कई तरीके का शोषण करके, एक एक पुस्तकालय संकलन समय पर उनके सुदृढ़ता की जांच करने के क्रम में भौतिक इकाइयों सांख्यिक डेटाटाइप्स के साथ संलग्न कर की अनुमति देता है कि जैसे शून्य उपरि कपोल-कल्पना लिख सकते हैं (उदाहरण के लिए आप के परिणाम असाइन नहीं कर सकते kg* mकरने के लिए N)

लंबाई 1

#

आमतौर पर एक प्रीप्रोसेसर स्टेटमेंट शुरू करते हुए, #अपने आप एक लाइन पर खड़ा हो सकता है। यह अनिवार्य रूप से कुछ भी नहीं का मतलब है और ऐसा प्रतीत होता है कि अधिकांश सिंटैक्स हाइलाइटर्स जो मुझे दिखाई देते हैं, वे इसे नहीं जानते हैं।

लंबाई २

%:

बेशक सभी के पास #चाबी नहीं है, इसलिए C ++ (वास्तव में, यह प्राचीन सी से विरासत में मिला है) उदार आपको इस वैकल्पिक टोकन (उर्फ डिग्राफ ) के साथ लिखने की अनुमति देता है

लंबाई ३

??=

यह C ++ पर एक ऐतिहासिक पाठ्यक्रम है। इन दिनों जरूरी नहीं कि वैध हो, हालांकि कार्यान्वयन उनका समर्थन कर सकते हैं, ट्रिग्राफ हैं। यह अनुक्रम #उन प्रणालियों में अनुवादित है जो इसका समर्थन करते हैं, लेकिन कच्चे स्ट्रिंग शाब्दिकों के साथ हस्तक्षेप नहीं करने के लिए, यह उन लोगों के भीतर अनुमति नहीं है। कार्यान्वयन पूरी तरह से समर्थन छोड़ने के लिए चुना जा सकता है।

लंबाई ४

auto

जेनेरिक कोड के साथ काम करना आसान बनाने के लिए (C ++ 11 के बाद से) नए आविष्कारों में से एक है। यह एक अभिव्यक्ति के प्रकार को कम करने के लिए है, और C ++ 14 के बाद से इसे लैम्ब्डा मापदंडों और रिटर्न प्रकार के कार्यों के लिए भी उपयोग किया जा सकता है।

लंबाई ५

 catch

एक कीवर्ड है जो C ++ में मौजूद कई अन्य भाषाओं से भी जाना जाता है, लेकिन अच्छा मुहावरेदार C ++ प्रोग्रामर लगभग कभी भी ऐसा नहीं करता है। इसके निर्माणकर्ताओं और विध्वंसक के साथ मुहावरेदार C ++ व्यापक रूप से RAII (संसाधन अधिग्रहण प्रारंभिक है) नामक एक सिद्धांत का उपयोग करता है या मैं कैसे इसे कभी-कभी अधिक उचित रूप से कॉल करना पसंद करता हूं: SBRM (स्कोप बाउंड रिसोर्स मैनेजमेंट)। स्मार्ट पॉइंटर्स जैसी कक्षाओं के कारण, कोई अन्य वस्तुओं के लिए गतिशील रूप से आवंटित संसाधनों के जीवनकाल को बाँध सकता है (यह केवल स्मृति नहीं है!)। जब वे कार्यक्षेत्र से बाहर हो जाते हैं (जैसे एक फेंके गए अपवाद द्वारा), तो ये वस्तुएं संसाधनों को स्वचालित रूप से साफ कर देती हैं। यह अपवाद सुरक्षित और आसान उपयोग कोड की अनुमति देता है जिसका उपयोग करने की आवश्यकता नहीं है catch

लंबाई ६

[](){}

[]{}()

जैसा कि टिप्पणियों में उल्लेखित स्टीफन, आप []{}सबसे कम लैंबडा ऑब्जेक्ट के रूप में उपयोग कर सकते हैं , इस प्रकार लैंबडा को कॉल करने के लिए यह सबसे छोटा रूप है । निम्नलिखित पाठ पुराने संस्करण के लिए है:

शायद एक मेमने का सबसे छोटा रूप है। C ++ में लैम्ब्डा ऑब्जेक्ट्स (कार्यान्वयन परिभाषित प्रकार के) हैं जो उस दायरे के हिस्से को पकड़ने में सक्षम हैं जो वे ([[सिंटैक्स इस पर नियंत्रण करता है) में बनाए गए हैं, और कॉल करने योग्य (() सिंटैक्स इसे नियंत्रित करता है)। उनके कोड ({{भाग) में इन चरों तक पहुंच है जैसे कि वे उनके दायरे में थे। C ++ 14 में पेश किए गए उनके वैकल्पिक रिटर्न प्रकार कटौती और ऑटो पैरामीटर कटौती के साथ, वे सभी मानक लाइब्रेरी एल्गोरिदम के लिए उपयोग करने वाले उपकरण हैं जो एक कॉल करने योग्य (उदाहरण के लिए तीसरा एसटी :: सॉर्ट पैरामीटर) की अपेक्षा करते हैं।

लंबाई 7

virtual

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

लंबाई 8

override

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

लंबाई ९

constexpr

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

लंबाई १०

for(i:c){}

एक कंटेनर, या कंटेनर की तरह एक पूर्ण लूप है जो निर्माण का समर्थन करता है std::beginऔर std::endपुनरावृत्तियों को प्राप्त करने के लिए (जिसमें सी शैली सरणियां शामिल हैं)। यह मूल रूप से इसके बराबर है for(auto __i = std::begin(c); __i != std::end(c); ++__i){ auto& i = *__i; }। यह सामान्य कोड में आसान लूपिंग की अनुमति देता है।

लंबाई ११

void f()&&;

सदस्य कार्यों और उस वस्तु पर गुण घोषित करने के लिए एक नया तरीका है जिस पर उन्हें बुलाया जा सकता है। C ++ के पिछले संस्करणों में, हमारे पास केवल यह void f() const;बताने की क्षमता थी कि कंपाइलर को कॉस्ट ऑब्जेक्ट्स पर फ़ंक्शन को कॉल करने में सक्षम होना चाहिए (इस प्रकार बिना कॉन्स के आप उन्हें नॉन-कॉस्ट ऑब्जेक्ट्स पर कॉल नहीं कर सकते)। उसी तरह अब हमारे पास &&r-value संदर्भों के लिए सिंटैक्स है, जिसका उपयोग उन कार्यों को रैलियों पर कॉल करने में सक्षम होने के लिए किया जाता है।

लंबाई १२

int main(){}

यह संभवतः सबसे छोटा पूर्ण कार्यक्रम है जिसे आप लिंक को संकलित कर सकते हैं और चला सकते हैं। यह कुछ भी नहीं करेगा और वापस लौटेगा। यह रिटर्न कई विशेष मामलों में से एक है जो आप C ++ में मुठभेड़ कर सकते हैं। आम तौर पर कुछ भी नहीं लौटाने से अपरिभाषित व्यवहार होता है, लेकिन प्रवेश बिंदु फ़ंक्शन मुख्य के लिए, कुछ भी नहीं लौटाने का मतलब है 0 लौटाना।

लंबाई १३

auto f()->int

किसी फ़ंक्शन के रिटर्न प्रकार को घोषित करने का एक नया तरीका है। आम तौर पर आप ऐसा नहीं करेंगे यदि आप पहले से ही प्रकार जानते हैं, लेकिन जेनेरिक प्रोग्रामिंग में बहुत सारी स्थितियां हैं जहां प्रकार टेम्पलेट मापदंडों और आपके द्वारा उपयोग किए जाने वाले चर पर निर्भर करता है। इस तरह से ऐसा करने से इन मापदंडों के लिए कुछ हद तक आसान पहुंच की अनुमति मिलती template<class T> auto f( const T& t ) -> decltype(t.foo())हैtemplate<class T> decltype(std::declval<T>().foo()) g( const T& t ) { return t.foo(); }


2
मैं ;एक वैकल्पिक 1-चार स्निपेट के रूप में उपयोग करने का सुझाव दूंगा, क्योंकि यह एक प्रीप्रोसेसर मैक्रो नहीं है और इस तथ्य पर कि आपके पास C ++ में 1-वर्ण कथन हो सकता है, चकरा देने वाला लगता है।
जो 5

1
[](){}लंबोदर का सबसे छोटा रूप नहीं है: जैसा कि मापदंडों की सूची खाली है, इसे छोड़ा जा सकता है। इसलिए []{}सबसे छोटा मेमना है। तुच्छ रूप से, लंबोदर []{}()का सबसे छोटा निष्पादन है ;; ideone.com/k8fAvs
stefan

@stefan: वास्तव में, मैं हमेशा इसे भूल जाता हूं क्योंकि यह तब की तरह कार्य नहीं करता है;) मैंने इसे उत्तर में जोड़ा।
प्लाज्माह

@PlasmaHH मैं इसे पूरी तरह से नफरत करता हूं क्योंकि वास्तव में यह एक फ़ंक्शन की तरह नहीं दिखता है; ;-)
स्टीफन

59

regex

लंबाई 2 स्निपेट

[]

जावास्क्रिप्ट : एक खाली चरित्र वर्ग जो कुछ भी मेल नहीं खाता है।

पीसीआरई , जावा , पायथनre , रूबी (संस्करण 2.0 पर परीक्षण): सिंटैक्स त्रुटि।

लंबाई 1 स्निपेट

.

., जिसे डॉट-ऑल कहा जाता है, सभी फ्लेवर में उपलब्ध है, मुझे देखने का मौका मिला।

क्या मेल खाता है?

Į͜n͜͝ ģe҉̡͞n̵͢ȩr͘a̢҉l̡͟, ̨͜ ͟ ̴.̸̴̢̛́ ̸̡̢m͞t̛c͞ąh̴̨e͢͡s̶͘ ͘a҉n̛͜͠ỳ̸ ͢c̵̡hár͘͝ą̨̕͘͘͘͘͢͜͜͠͠͠͠͏̀͠͏̷̷̀̀̀͠ ͝͞͞ex͝͞͞c҉ep̀t̛ ̕f̴҉o͟͜r̨͜ ̨͜n̨͜w̨͜n̨͜n̨͜

जावाPattern : डिफ़ॉल्ट मोड में, इन 5 कोड बिंदुओं को छोड़कर, डॉट-ऑल किसी भी कोड बिंदु से मेल खाता है \r\n\u0085\u2028\u2029UNIX_LINESमोड के साथ (लेकिन बिना DOTALL), डॉट-ऑल को छोड़कर, किसी भी कोड बिंदु से मेल खाता है \nDOTALLमोड के साथ , डॉट-ऑल किसी भी कोड बिंदु से मेल खाता है। जावा 5 से, Patternकोड बिंदु पर संचालित होता है, इसलिए सूक्ष्म वर्णों का मिलान डॉट-ऑल द्वारा किया जाता है।

पायथनre (2.7.8 और 3.2.5 पर परीक्षण किया गया, 3.3+ पर अलग हो सकता है): डिफ़ॉल्ट मोड में, डॉट-ऑल किसी भी UTF-16 कोड इकाई (0000 से FFFF समावेशी) को छोड़कर, से मेल खाता है \nre.DOTALLअपवाद लिफ्ट करता है और .किसी भी UTF-16 कोड इकाई से मेल खाता है। इन संस्करणों में, reUTF-16 कोड इकाइयों पर संचालित होता है, इसलिए .केवल सूक्ष्म विमान में वर्णों की एक कोड इकाई से मेल खाता है।

.NET : पायथन के रूप में भी। .NET में डॉट-ऑल मोड को कहा जाता है Singleline

जावास्क्रिप्ट (C ++ 11 <regex>) : डिफ़ॉल्ट मोड में, इन सभी 4 कोड बिंदुओं को छोड़कर, dot-all किसी भी UTF-16 कोड इकाई से मेल खाता है \n\r\u2028\u2029sझंडे के साथ , डॉट सभी सभी UTF-16 कोड इकाई से मेल खाता है। जावास्क्रिप्ट UTF-16 कोड इकाइयों पर भी काम करती है।

PCRE : निर्माण विकल्प के आधार पर, डॉट-सब बाहर कर सकते हैं \r, \nया \r\n, या सभी 3 सीआर वामो दृश्यों, या डिफ़ॉल्ट मोड में किसी भी यूनिकोड न्यू लाइन अनुक्रम। डिफ़ॉल्ट मोड में, इंजन कोड यूनिट (8, 16 या 32-बिट कोड इकाई हो सकता है) पर काम करता है, इसलिए डॉट-सभी किसी भी कोड इकाई से मेल खाते हैं, सिवाय न्यूलाइन अनुक्रम के। UTF मोड में, इंजन कोड बिंदु पर काम करता है, इसलिए डॉट-सभी न्यूलाइन अनुक्रमों को छोड़कर किसी भी कोड बिंदु से मेल खाते हैं। डॉट-ऑल मोड कहा जाता है PCRE_DOTALL

PHP (ideone पर परीक्षण किया गया): PCRE, UTF-8 लाइब्रेरी के रूप में संकलित किया गया है और \nडिफ़ॉल्ट रूप से एकमात्र न्यूलाइन अनुक्रम है। sध्वज के माध्यम से डॉट-ऑल मोड सुलभ है ।

पोस्टग्रेज : डिफ़ॉल्ट मोड में, बिना किसी अपवाद के किसी भी बिंदु से डॉट-ऑल मेल करता है।

रूबी (संस्करण 2.0.0 पर परीक्षण किया गया): डिफ़ॉल्ट मोड में, .इसके अलावा किसी भी कोड बिंदु से मेल खाता है \n। डॉट-सभी मोड mध्वज (!) के माध्यम से सुलभ है ।

s रूबी में विंडोज -31 जे एन्कोडिंग को इंगित करने के लिए ध्वज का उपयोग किया जाता है।


factoid

̴̢͘͡E҉̷̨eŖ͞x̡́͞ ̛̀҉҉̢cŖ͞a҉̛͠ǹ̷̸ ̴͠͡҉̵ą̧͜͢p̸̸̷̢͝r̢̀͡s̢̀͡e̷̷̷͘͞ ̷͞H̷̛͜T͢M̨̧͜͜L͢.̴̡́ मेरे बाद दोहराएं। R̶̶̢̧̰̞̻̮̳̦̥ͭͯ̓̈ͯͤ̇͊͊͟ĕ̹̩̪͈͈͍̗͎̝͚̽̈ͨ̐̽ͪͮ̍͐ͮͧ̔̏̓ͣĝ̵̢̢̖̤̜̭͔͊͒ͦ͛ͤ͗ͬͧͪ̾͘͟eͦ̄ͭ̑̾҉̨̨̝̬̹̘̭͔͟͢x̣̻͓̠͈͕̥̜͚̝̫͚̳̾̍ͦ̑̈̋̌̉͊ͮ͗̄̆̒̚̚ ̸̦͈̥̬̺͇ͧͧ͐ͮ̌ͤ̈̒̆ͣ̈̏̔͊̐ç̨̬̪̳̦͎̖͕̦͔ͨ̿̓̈ȁ̸̳̺̠̭ͮ̓̐͘̕͜͡ņ̨̫͔͍̬̤̘͎͚̣̟̦͍̜ͭͭ̈ͦ̈̽͗ͥ̑͝͡ पार्स ͉̭̫̰͔̝͓̼̮͚̻͎͎͉̐͗͗͊̇ͣ͒͗͑̆͐̐ͬ͛ͮ͝H̢̥͕̼͓̫͙̺̼̮ͣͦ̍ͨ͒̔̌T̪̦̻̦͖̞̤͒̑ͭ̐̑ͭͣ͐̒̉͊͜͜M̞̪͇͕̩͉͗ͧ̌ͯ͋̉̍ͭ̓̇̐̌͜͠Ĺ̷̨̳̘̯͚͓͛͌ͭ̉̍.ͯ͆̊ ͯ̇̓̏͐ͪ̋̈͑̕҉̷̠̰̼̤


35
मैं किसी के लिए बुरा महसूस करता हूं जिसे फैक्टॉइड का संदर्भ नहीं मिलता है।
रोबोबेनक्लेइन

6
@robobenklein मैं आपके दर्द के लिए एक गुप्त दवा जानता हूं: बस हमें बताएं!
दोष

24
@flawr उन लोगों के लिए जो प्रसिद्ध प्रश्न नहीं जानते हैं: stackoverflow.com/questions/1732348/… पर पहला उत्तर वह है जो आप खोज रहे हैं।
रोबोबेनक्लेइन

1
आप Zalgo'ed पाठ पढ़ सकते हैं, लेकिन दोनों दिशाओं में उन्हें बहुत गंभीरता से नहीं लेते हैं। ज़ाल्गो के तरीके का आँख बंद करके पालन करना सरल है, लेकिन ज़ाल्गो पाठ हर समय गलत नहीं है।
n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

12
@ n @h youa̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳, क्या आप उन सभी वोटों का उपयोग करने नहीं जा रहे हैं जो हमें दिखाते हैं कि HTML को कैसे पार्स करें?
mbomb007

57

जे

पुनश्च: स्निपेट अब TryJ.tk से जुड़ा हुआ है जो आपको J को स्थापित किए बिना आपके ब्राउज़र में जावास्क्रिप्ट में चलने के साथ चारों ओर खेलने देता है।

पीपीएस: मैंने ऑर्डर स्वैप किया; यह भविष्य में संदर्भ में शामिल होने वाले लोगों के लिए और अधिक समझ में आता है।

PPS: मुझे लगता है, समय की कमी के कारण, मैं एक दिन में एक स्निपेट जोड़ूंगा

factoid:

जे एपीएल का वंशज है ( पारिवारिक इतिहास के लिए यहां देखें ) मजेदार चरित्र सेट का है।

लंबाई 1 स्निपेट

_

J का उपयोग अनंत और नकारात्मक सूचक के रूप में_ किया जाता है , जब संख्या शाब्दिक (क्रिया के विपरीत -) से जुड़ी होती है ।

लंबाई 2 स्निपेट

a.

a.वर्णमाला कहा जाता है , जिसमें सभी 1 बाइट वर्ण होते हैं। जैसे कि J में फ़ंक्शन शामिल नहीं हैं atoi, क्योंकि वे वर्णमाला में सरल लुक-अप हैं:a. i. 'z' =122

लंबाई 3 स्निपेट

i.9

i.Integers के लिए है, जब इस्तेमाल किया जाता है monadically (यानी। केवल एक तर्क, सही एक, आमतौर पर y कहा जाता है)। जब रंगाई का उपयोग किया जाता है तो यह ऊपर के उदाहरण के रूप में सूचकांक के रूप में कार्य करता है।

लंबाई 4 स्निपेट

!!6x

J, मनमाने ढंग से सटीक पूर्णांक और परिमेय संख्याओं का समर्थन करता है । यह 6 (1747 अंकों की संख्या) के भाज्य के तथ्य की गणना करता है।

लंबाई 5 स्निपेट

^.^:_ 

घने एक ... सबसे पहले, क्रिया (जे कॉल फ़ंक्शन के रूप में) थीम द्वारा आयोजित की जाती हैं। सभी ^ क्रियाओं को घातांक से बांधा जाता है। ^के लिए घातांक (और expजब monadically इस्तेमाल किया, ^.के लिए लघुगणक^:एक विशेष एक है, बिजली संयोजन (एक उच्च आदेश समारोह), एक समारोह कई बार लागू होता है। जब सही तर्क अनंत (है _कि वह अपने बाएं तर्क निष्पादित करता है (में) उदाहरण ^.) अपने स्वयं के आउटपुट पर तब तक जब तक यह परिवर्तित हो जाता है। वास्तव में, किसी भी तर्क पर लागू होने पर ^.^:_एक क्रिया को हल x = ln(x)करना है, लेकिन 1, उपज 0.318132j1.33724

लंबाई 6 स्निपेट

^0j1p1

या समकक्ष

^o.0j1

जे में यूलर की पहचान ऊपर बताई गई ^है exp()। मनमाने ढंग से सटीक पूर्णांकों और युक्तियों के अलावा, यह पाई और जटिल संख्या की शक्तियों का समर्थन करता है, और संयोजन के रूप में शाब्दिक रूप से। 0j1p1का मतलब है (0 + j) * pi ^ 1

लंबाई 7 स्निपेट

+/&.:*:

किसी भी सदिश का 2-मान लेने वाली क्रिया। यह 2 चीजों को प्रदर्शित करता है:

  • सम्मिलित क्रिया विशेषण जोड़ें क्रिया बदल जाता है +अपने तर्क के प्रत्येक तत्व के बीच यह डालने से बीमा राशि में। इसलिए (0+1+2+3) = +/ i.4

  • संयोजन के रूप तहत जब के रूप में इस्तेमाल v &.: u yकरने के लिए बराबर है vi u v y, जहां viहै अग्रभाग (आम तौर पर उलटा)।

हां, J कार्यात्मक आक्रमणों के बारे में जानता है। इनको मिलाने से क्रिया स्निपेट में %: @: (+/) @: *:या sqrt(sum(y.^2))उदाहरण के लिए मतलाब के बराबर हो जाती है ।

लंबाई 8 स्निपेट

$#:I.@:,

एक कांटा तर्कों के संदर्भ के बिना 3 क्रियाओं से बना है। यह अनुमति देता है कि J में टैसीट (पॉइंट-फ्री) प्रोग्रामिंग को क्या कहा जाता है। एक कांटा f g h, मोनडिक मामले में (जैसा कि इस उदाहरण में) के बराबर है (f y) g (h y)। कांटे के रूप में, बहुआयामी सरणियाँ जे। "इंडीकेट्स" का एक आंतरिक हिस्सा हैं, जो वेक्टर में लोगों के सूचकांकों को लौटाता है, लेकिन उच्च आयामों तक विस्तार नहीं करता है। इस उदाहरण में आकृति , एंटीबेस का उपयोग I.@:,किया गया है और उदाहरण के लिए, उच्च आयामी सरणियों के लिए I को लागू करने वाले फोर्क के 3 टीन्स :

 ($#:I.@:,) 5 = i. 5 5 NB. indices of 5 in i. 5 5

लंबाई 9 स्निपेट

<"1 i.4 6 

बॉक्सेड सरणियां J में एक डेटा प्रकार हैं, जिससे विषम सामग्री (दोनों प्रकार और आकार) को एक मूल्य में संयोजित करने की अनुमति मिलती है। विवादास्पद < बक्से यह तर्क है। रैंक जम्मू में एक केंद्रीय अवधारणा है, और स्वचालित रूप से उच्च आयामों के सरणियों की ओर क्रियाओं का विस्तार करने की अनुमति देता है। संज्ञा और क्रिया दोनों में एक रैंक होती है।

संज्ञा रैंक किसी भी संज्ञा के आयामों की संख्या है, जो क्रिया $@$आपको बता सकती है। उदाहरण के लिए i. 2 3 4रैंक 3 की एक सरणी है।

वर्ब रैंक वह रैंक है जिस पर एक क्रिया स्वयं लागू होगी। प्रत्येक क्रिया में एक आंतरिक रैंक होती है जिसे मूल संयोजन के साथ समझा जा सकता है । v b. 0क्रिया के 3, monadic बाएँ और dyadic दाएँ रैंक के लिए 3 नंबर देता है v।

क्रिया पद की संज्ञा कोशिकाओं पर क्रिया के बराबर होती है, और परिणाम को संज्ञा rank-verb rankफ्रेम में बदल देती है । एक क्रिया की रैंक रैंक संयोजन का उपयोग करके सीमित की जा सकती है , जैसा कि यहां किया गया है, रैंक _ पर काम करने के बजाय रैंक 1 कोशिकाओं (पंक्तियों) को बॉक्सिंग करना। संपूर्ण सरणी बॉक्सिंग। रैंक के बारे में अधिक जानकारी यहां पाई जा सकती है

लंबाई 10 स्निपेट

<./ .+~^:_

यह स्निपेट एक क्रिया है जो भारित डिग्राफ पर सबसे छोटे पथ की गणना करता है । यह न्यूनतम ( <./) और डॉट संयोजन का परिचय देता है । डॉट संयोजन मैट्रिक्स उत्पाद का एक सामान्यीकरण है, जिसे लिखा जा सकता है +/ . *। आम तौर पर, u . vबराबर होता है u@(v"(1+lv,_))जहां lv क्रिया v की बाईं रैंक है। या शब्दों में "u" वाम तर्क कोशिकाओं "की सूचियों पर v के परिणाम पर लागू होता है और सही तर्क में योग"। (रैंक के लिए ऊपर देखें)

जैसे कि आंतरिक क्रिया सभी k के लिए न्यूनतम के साथ <./ .+~आइटम y(i,j)को प्रतिस्थापित करती है y(i,k)+y(k,j)

^:_ अभिसरण तक इस चरण को पुनरावृत्त करता है।

उदाहरण, मूल और सबसे छोटी पथ दूरी प्रदर्शित करना:

(]; <./ .+~^:_ ) wtm=: _6]\0 2 5 _ _ _ _ 0 4 1 3 _ _ _ 0 _ _2 _ _ _ 4 0 _ 5 _ _ _ _1 0 6 _ _ _ _ _ 0

लंबाई 11 स्निपेट

<.@o.10x^99

यह स्निपेट विशेष कोड का परिचय देता है : कुछ जे कोड को कोड द्वारा समर्थित किया जाता है, विशेष रूप से एक निश्चित उपयोग के मामले के लिए लिखा जाता है, जो पार्स समय पर मान्यता प्राप्त है, और अनुकूलित; या तो उच्च सटीकता के लिए (जैसा कि यहां मामला है) या उच्च प्रदर्शन (देखें विशेष संयोजन )

यह वाक्यांश पीआई के 99 अंक देता है (हालांकि 99 दशमलव स्थानों को स्थानांतरित कर दिया गया है)। विशेष कोड सटीक वाक्यांशों पर निर्भर करता है, जो सामान्य रूप से समतुल्य होगा, स्निपेट कोड के समान सटीक नहीं है: विस्तारित परिशुद्धता <.o.10x^99 खो देता है।

लंबाई 12 स्निपेट

($-.1:)($,)]

समय-समय पर, आप उन स्थितियों में समाप्त होते हैं जहां डेटा में किए गए चयनों के कारण रास्ते में चल रहे सिंगलटन आयाम हैं। मतलाब में निचोड़ कहलाने वाली यह उपयोगी उपयोगिता सभी एकल आयामों को निचोड़ देती है। कांटा का बायां टाइन ($-.1:)बिना किसी आयाम के सभी आयाम देता है, जबकि मध्य एक ($), बनाए गए आयामों के लिए बनाए गए सरणी को फिर से आकार देता है। दाहिने टाइन ]इस कांटे को बनाने के लिए सिर्फ कार्य करता है, और सही तर्क का संदर्भ देता है।

लंबाई 13 स्निपेट

1 :'-u%u d.1'

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

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

(_2 + *:) (1 :'-u%u d. 1')^:_ ] 1 NB. root of x^2-1; ] is there to avoid combining _ and 1 into an array.

लंबाई 14 स्निपेट

(%-.-*:)t.i.10

टेलर विस्तार द्वारा फिबोनाची श्रृंखला के पहले 10 नंबर x / (1 - x - x^2)। हुक का विश्लेषण %-.-*:देता है (y % (-.-*:) y) = (y % ( (1 - y) - *: y)

लंबाई 15 स्निपेट

(#{.+//.)!/~i.9

एक और फिबोनाची श्रृंखला पर ले लो। इस बार दूसरे कोण से; पास्कले के त्रिकोण से शुरू हो रहा है '! /~i.9'।

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

क्रिया विशेषण /.एक अजीब एक है, यह लागू होता है यह एक सरणी के विरोधी विकर्ण साथ क्रिया है (यानी। कोशिश </.!/~i.5यहाँ )

तो यह स्निपेट पास्कल के त्रिकोण पर 9 पहले विरोधी विकर्णों पर रकम लेता है, जो एक और घटना फाइबोनैचि श्रृंखला होती है।

लंबाई 16 स्निपेट

;/@~.,. <"0@#/.~:

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

x u/. y: मात्रा में y जहां x अद्वितीय है, या जम्मू में करने के लिए यू लागू होता है (=x) u@# y, जहां =है स्व वर्गीकृत , जो 1 के युक्त एक बूलियन सरणी पदों जहां वे में प्रदर्शित में उत्पन्न करता है nub ~। यहाँ यह स्पष्ट रूप से लागू होता है, इसलिए प्रत्येक अद्वितीय आइटम पर टैली को निष्पादित करते हुए, दिखावे की संख्या की गिनती करें।

जैसा कि जे में अधिकांश क्रियाओं में नब क्रम (नई अनूठी वस्तुओं की उपस्थिति का क्रम, माटलैब uniqueमें उदाहरण के लिए विरोध किया जाता है , जो इसके तर्क को सुलझाता है ), इसका उपयोग स्टिचिंग आइटम को उनकी आवृत्तियों के लिए किया जा सकता है जैसा कि यहां किया गया है। ;/@~.का उपयोग सभी वस्तुओं की बॉक्सिंग सूची बनाने के लिए किया जाता है।

ध्यान दें कि क्योंकि रैंक की पूर्ववर्ती अवधारणा , यह कोड किसी भी आयामीता के लिए काम करता है ।

लंबाई 17 स्निपेट

*./ @:(#&>)@C.@A.

J क्रमपरिवर्तन के बारे में विशेष रूप से कुछ प्राथमिकताओं का समर्थन करता है:

  • एनाग्राम ए। मोनैडिक रूप से यह एनाग्राम इंडेक्स पाता है, डेडिक रूप से, यह एनामग्राम इंडेक्स द्वारा निर्दिष्ट परम्यूटेशन को बाएं तर्क में सही तर्क पर लागू करता है।
  • साइकिल - परमिट सी । क्रमपरिवर्तन के प्रत्यक्ष और चक्र प्रतिनिधित्व के बीच परिवर्तित होता है।

यह स्निपेट एक क्रिया है जो एनाग्राम इंडेक्स को बाईं ओर (0 और !#y) के बीच ले जाता है और दायाँ तर्क वाई सरणी को अनुमति देता है। बाद में, यह चक्र लंबाई के LCM *./ की गणना करता है #&>, अर्थात। वह अवधि जिसके बाद आपको मूल सरणी वापस मिलती है:

]n=: (p=:?!9) *./ @:(#&>)@C.@A. i.9 NB. period of a random permutation
p&A.^:n i.9 NB. applies permutation n times.

लंबाई २१

<:@(#/.~)@(i.@#@[,I.)

यह छोटी क्रिया "आँकड़े / आधार" ऐड-ऑन से आती है, और हिस्टोग्राम कहा जाता है । यह वास्तव में ऐसा करता है कि, बिन शुरू की एक सूची को देखते हुए, अंतराल के बीच डेटा की सभी घटनाओं को ]bn-1,bn]sms करता है जहां bn बिन संख्या n की शुरुआत है।

इसके अंतरालI. को खोजने के लिए यह अंतराल सूचकांक का शोषण करता है:

यदि y में x के आइटम का आकार है, तो x I. y सबसे कम गैर-ऋणात्मक j है, जैसे कि j {x क्रम में y का अनुसरण करता है, या # x यदि y का अनुसरण करता है तो {: x क्रम में या यदि x है तो कोई वस्तु नहीं।

स्निपेट 16 में हाइलाइट किए गए कुंजी का उपयोग करके प्रत्येक अंतराल के योग बनाते हैं ।

Tryj.tk पर जुड़ा स्निपेट इस हिस्टोग्राम का उपयोग करके केंद्रीय सीमा प्रमेय को प्रदर्शित करता है:

(bins=:(%~>:@i.)10) ( [ (graph=:(,&":"0 1 '#'#"0 1~])) (histogram=:<:@(#/.~)@(i.@#@[,I.)) ) (+/%#) ?5 200 $ 0

लंबाई २२

=,&(+/)(~:#[)e.&~.~:#]

जे में मज़ा। यह एक मास्टरमाइंड इंजन को लागू करता है, बाएं तर्क के रूप में एक गुप्त सरणी लेता है, और दाईं ओर एक अनुमान है। लौटाए गए मान सफेद और काले खूंटे की संख्या हैं। हक्का - बक्का किया हुआ:

NB.   ExactMatch: checks where digits correspond:
ExactMatch =: =

NB.   GoodDigitWrongPlace: Copies non-matched numbers from both arguments (left and right
NB.   pairs of parentheses, and checks them for same elements(e.), after eliminating
NB.   doubles in both (&~.)
GoodDigitWrongPlace =: (~: # [) (e.&~.) (~: # ])

NB.   Piecing the conditions together, after summing the booleans:
mm =: ExactMatch ,&(+/) GoodDigitWrongPlace

की तरह इस्तेमाल किया जा सके

secret (=,&(+/)(~:#[)e.&~.~:#]) guess

कहाँ secretऔर guessकिसी भी सरणी में हैं। यह वास्तव में किसी भी डेटा प्रकार के साथ काम करता है।


17
ठीक है, या तो आपको अजीब प्रतीकों का एक अपठनीय ढेर मिलता है, या आपको एएससीआईआई प्रतीकों का एक अपठनीय ढेर मिलता है। अपना ज़हर उठाएं।
जॉन ड्वोरक

16
@JanDvorak जब तक आप उन्हें नहीं सीखते, तब तक सभी भाषाएँ अप्राप्य हैं। ;-)
गैरेथ

5
मैं लंबे, वर्णनात्मक नाम सहायता कोड समझ के बारे में सोचता था। तब मैं गया था प्रबुद्ध
होसिएरईईई

@ गैरेथ, लेकिन आप उन्हें जानने के बाद भी सभी अपठनीय नहीं हैं । कोई नाम नहीं बताने वाला।
दोष

45

RPL (Redstone प्रोग्रामिंग भाषा) [और Minecraft]

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

factoid:

RPL Tossha Inventor की एक प्रोग्रामिंग भाषा है जो कोड को Minecraft रेडस्टोन और कमांड ब्लॉक में परिवर्तित करती है। यह इनपुट और आउटपुट, लूप, पूर्णांक हेरफेर, ट्रिगर फ़ंक्शंस, रूट्स, और बहुत कुछ कर सकता है।

लंबाई 1:

एक बटन (1 बाइट) Minecraft में इनपुट का सबसे सरल रूप है। यह "प्रोग्राम" को शुरू या बंद भी कर सकता है। इसी तरह, एक लीवर (भी 1 बाइट) इनपुट का दूसरा रूप है, और इसे प्रोग्राम को शुरू करने और रोकने के लिए भी इस्तेमाल किया जा सकता है क्योंकि इसमें "ऑन" और "ऑफ" स्थिति है। याद रखने वाली बात यह है कि Minecraft शाब्दिक रूप से एक 3D प्रोग्रामिंग भाषा है, इसलिए जहां बटन / लीवर कार्यक्रम में जगह लेता है, वह बहुत बड़ा बदलाव ला सकता है।

लंबाई 2:

एक रेडस्टोन लैंप से जुड़ा एक बटन आपके बहुत बुनियादी बिल्ली कार्यक्रम से बहुत अधिक है । यह इनपुट लेता है (एक बटन या लीवर के साथ, या तो0 या 1( offया onतो के रूप में दीपक से प्रकाश के रूप में रूप में)) और यह outputs 0या 1( offया on)।

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

लंबाई 3:

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

लंबाई ४

यह "स्निपेट" वास्तव में दो अवधारणाओं को दर्शाता है: देरी, और गेट नहीं। विलंब कुछ रेडस्टोन तत्वों का उपयोग करके किया जाता है जिसमें रेडस्टोन-टिक की देरी होती है। रेडस्टोन-टिक एक सेकंड के दसवें हिस्से के बराबर है। विभिन्न रेडस्टोन घटकों में अलग-अलग देरी होती है: एक मशाल में 1rt विलंब (1 रेडस्टोन-टिक) होता है, एक तुलनित्र में 1rt विलंब होता है, एक पुनरावर्तक में 1, 2, 3 या 4rt विलंब हो सकता है, यह इस बात पर निर्भर करता है कि इसे कैसे सेट किया गया है। इस उदाहरण में, Redstone पुनरावर्तक को 4rt विलंब पर सेट किया गया है।

अगला गेट नहीं है। नहीं गेट एक इनपुट लेता है यह अकशेरित करता है। तो इस सेट अप में, इनपुट चालू होने पर आउटपुट होगा, और इनपुट चालू होने पर आउटपुट बंद हो जाएगा।

लंबाई ५

Orec गेट को Minecraft में पूरा करना बहुत आसान है। दो इनपुट एक ही आउटपुट से जुड़े हैं। बस इतना ही। कोई मज़ेदार छलावा या कुछ भी, यह बहुत आसान है।

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

लंबाई ६

यहां आपके "कोड" को संकुचित करने के लिए एक टिप है। यदि आप जानते हैं कि दो इनपुट की सिग्नल स्ट्रेंथ छोटे हैं जो संबंधित आउटपुट के साथ हस्तक्षेप नहीं करते हैं, तो आप एक दूसरे के लिए रेडस्टोन को सही से तार कर सकते हैं। नीचे दिए गए उदाहरण में, एक साधारण हॉपर टाइमर है, जो प्रत्येक हॉपर में लगभग 0.5s में आगे और पीछे की वस्तुओं को स्थानांतरित करता है, तुलना करने वालों के लिए संकेत दिया गया है कि आउटपुट सिग्नल 1. की ताकत है। इसका मतलब है कि दोनों ouputs एक-दूसरे के साथ हस्तक्षेप नहीं करेंगे। उदाहरण में, लैंप केवल प्रदर्शन उद्देश्यों के लिए हैं और कुल ब्लॉक गणना की ओर गिनती नहीं करते हैं।

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


7
आप 13 अपवित्रों को खतरे में डाल सकते हैं, मैं 10 मौवर के कार्यक्रमों को खतरे में डाल सकता हूं?
R

4
आपका कोई भी कार्यक्रम वास्तव में आरपीएल में नहीं लिखा गया है, इसलिए इसे इस तरह से पास न करें। यह विशुद्ध रूप से Minecraft "कोड" है।
mbomb007 16

2
आपके पास 14 प्रोग्राम m8 की कमी है। मैं यह देखना चाहता हूं कि आपके मन में क्या है;)
कॉनर ओ'ब्रायन

4
आप 21 अपवित्रों को खतरे में डाल सकते हैं, मैं 15 मौस कार्यक्रमों को खतरे में डाल सकता हूं?
wizzwizz4

1
आप 29 अपवित्रों को खतरे में डाल सकते हैं, मैं 23 मोहर कार्यक्रमों को खतरे में डाल सकता हूं?
19010 पर bb010g

42

TI-बेसिक

[भाषा किस कैलकुलेटर पर उपयोग की जाती है, इसके आधार पर भिन्न होती है, लेकिन ये TI-84 का उपयोग करेंगे जब तक कि अन्यथा नोट न किया जाए।]

लंबाई 31 स्निपेट

Menu("","1",A,"2",B
Lbl A
Lbl B

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

Menu("CHOOSE VALUE","AREA",A,"CIRCUMFERENCE",C
Lbl A
Disp πR²
Stop
Lbl C
2πR

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

लंबाई 29 स्निपेट

Real
√(-16
a+bi
Ans
re^θi
Ans

Real(डिफ़ॉल्ट रूप से) कैलकुलेटर को वास्तविक संख्या मोड में रखता है, इसलिए जटिल संख्याओं वाली गणना में NONREAL ANSत्रुटि होती है। जब a+biमोड में रखा जाता है, तो कैलकुलेटर जवाबों को लागू होने पर जटिल संख्याओं के रूप में प्रदर्शित करता है, इसलिए दूसरा उदाहरण देता है 4ire^θiमोड आयताकार निर्देशांक के बजाय ध्रुवीय का उपयोग करता है, इसलिए यह आउटपुट करता है 4e^(1.570796327i)

लंबाई 23 स्निपेट

If A≥9
Then
1→X
7→Y
End

यह सिर्फ एक साधारण शर्त है, हालांकि एक Elseबयान हो सकता है । ThenतथाEnd यह केवल एक बयान नहीं है, तो आवश्यक नहीं है।

लंबाई 21 स्निपेट

(-B+√(B²-4AC))/(2A)→X

सभी का पसंदीदा, द्विघात सूत्र। एक द्विघात Xमान के रूप में द्विघात समीकरण के पहले समाधान को संग्रहीत करता है, कुल्हाड़ी 2 + bx + के रूप में उनके संबंधित चर में संग्रहीत किया जाता है । c के

लंबाई 20 स्निपेट

Shade(|X/2|-3,5-X²,0

यह कई वैकल्पिक मापदंडों के साथ, दो कार्यों के प्रतिच्छेदन को शेड करता है: न्यूनतम और अधिकतम x और दिशा और शेडिंग लाइनों के बीच की दूरी।

लंबाई 18 स्निपेट

LinReg(ax+b) L1,L2

यहाँ हम लीनियर रिग्रेशन समीकरण, या लीनियर इक्वेशन की गणना करते हैं, जो अंकों के समूह के साथ मेल खाने वाले x- वैल्यू L1और लिस्ट में y- वैल्यू के साथ सबसे अच्छे से मेल खाता है ।L2 । द्विघात, घन और घातांक सहित कई अन्य प्रतिगमन विकल्प उपलब्ध हैं।

लंबाई 17 स्निपेट

dbd(1.2711,1.2115

यह दो तिथियों के बीच दिनों की संख्या की गणना करता है, इस मामले में 27 जनवरी, 2011, जिस दिन यह साइट शुरू हुई थी, और 21 जनवरी 2015, जिस दिन यह लिखा गया था। (यह आलसी के लिए 1455 दिन हैं।) तारीखें सांकेतिक शब्दों में बदलना थोड़ा अजीब है: या तो DDMM.YY या MM.DDYY, प्रमुख शून्य वैकल्पिक।

लंबाई 16 स्निपेट

For(A,0,5
Disp A

यह भाषा के प्रोग्रामिंग पक्ष के दो भागों को दर्शाता है। दूसरी भाषाओं की forतरह आपका पहला लूप है for(var A=0;a<5;a++)। (आपको भी उपयोग करना चाहिएEnd लूप से बाहर निकलने के कमांड का ।) दूसरा स्वयं-व्याख्यात्मक है: यह प्रदर्शित करता है A, इस मामले में लूप के कारण 5 बार।

लंबाई 15 स्निपेट

Y1=|X³-4|
Y2=3X

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

ग्राफ़

लंबाई 14 स्निपेट

[[1,2][34,5]]T

ब्रैकेट का उपयोग मैट्रिक्स बनाने के लिए किया जाता है, और Tमैट्रिक्स को स्थानांतरित करता है:

[[1 34]
 [2 5]]

लंबाई 13 स्निपेट

dayOfWk(9,1,6

यह 6 जनवरी, 9 एडी के सप्ताह का दिन पाता है। आउटपुट एक संख्या है जहां 1 रविवार है, 2 सोमवार है, और इसी तरह। यह विशेष तिथि मंगलवार थी, इसलिए आउटपुट है3

लंबाई 12 स्निपेट

Circle(1,3,5

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

लंबाई 11 स्निपेट

randInt(0,8

यह 0 और 8 समावेशी के बीच एक (छद्म-) यादृच्छिक पूर्णांक उत्पन्न करता है। एक वैकल्पिक तीसरा तर्क है जो बताता है कि कितने पूर्णांक उत्पन्न करने के लिए। कई अन्य यादृच्छिक कार्य हैं, जिनमें सामान्य और द्विपद वितरण के लिए एक यादृच्छिक मैट्रिक्स के लिए एक है, और एक बिना किसी पुनरावृत्ति के साथ यादृच्छिक क्रम सूची के लिए। randIntके रूप में एक नंबर भंडारण के द्वारा वरीयता प्राप्त किया जा सकता है rand: 2→rand

लंबाई 10 स्निपेट

4>5 or 2≠7

यहां हमारे पास TI-BASIC (इन) समानता और तर्क ऑपरेटर हैं। असमानता के बयान पहले मूल्यांकन करते हैं 0 or 1, औरor यदि सही है तो दोनों सही हैं, इसलिए यह प्रदर्शित करता है 1

लंबाई 9 स्निपेट

.656▶F◀▶D

यह दशमलव से भिन्न और इसके विपरीत में परिवर्तित हो सकता है, जो बहुत उपयोगी है। समर्पित ▶Fracऔर ▶Decकार्य भी हैं जो केवल एक ही रास्ते पर चलते हैं। प्रिंटों82/125इस मामले में ।

लंबाई 8 स्निपेट

lcm(14,6

यह कम से कम सामान्य एकाधिक प्रिंट करता है 14 और 6 , जो कि 42 है।

लंबाई 7 स्निपेट

getDate

सुंदर आत्म-व्याख्यात्मक, बस वर्तमान प्रणाली की तारीख को इस मामले में एक सूची के रूप में प्रिंट करता है {2015 1 19}

लंबाई 6 स्निपेट

√({4,9

Arrays (या सूचियाँ) ब्रेसिज़ से घिरी होती हैं और कॉमा से अलग हो जाती हैं। यह के समान हैmap कई भाषाओं फ़ंक्शन के , जहां यह सूची के प्रत्येक तत्व के माध्यम से पुनरावृत्ति करता है और ब्रेसिज़ के बाहर ऑपरेशन को लागू करता है, इस मामले में वर्गमूल, इसलिए परिणाम है {2 3}। ध्यान दें कि कोष्ठक बंद करना वैकल्पिक है, इसलिए वे अभी से छोड़ दिए जाएंगे।

लंबाई 5 स्निपेट

4iii6

हमें यहां कुछ अच्छी चीजें मिल रही हैं। सबसे पहले, असली हिस्से, 4 और 6 को गुणा किया जाता है, और फिर काल्पनिक भागों को गुणा किया जाता है: i^3या -i। ये कई गुना देते हैं-24i । यह फंकी-लुकिंग जक्सटैपिशन गुणा और टीआई-बेसिक की काल्पनिक संख्याओं से निपटने का प्रदर्शन करता है।

लंबाई 4 स्निपेट

8°5′

यह 8 डिग्री, 5 आर्कमिन्यूट है, जिसे डिग्री में परिवर्तित किया जाता है 8.0333 ...

लंबाई 3 स्निपेट

8→T

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

लंबाई 2 स्निपेट

4M

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

लंबाई 1 स्निपेट

e

यह यूलर की संख्या के लिए स्थिर है , जो प्रदर्शित करता है 2.718281828

factoid

चर केवल कुछ डेटाटिप्स संग्रहीत कर सकते हैं। उदाहरण के लिए, A- Z(और θ) संख्यात्मक मानों को स्टोर करें, str0- str9स्टोर स्ट्रिंग्स, और [A]- [J]स्टोर मैट्रिसेस (2-आयामी सरणियों)।


वैसे, निचले मामले n(नहीं n) को एक चर के रूप में भी इस्तेमाल किया जा सकता है।
यज्ञपिन

दिलचस्प। मैंने उस चर का कभी उपयोग नहीं किया है।
निन्जाबियरमोंकी

3
कोई str01 वर्ण या होने के बारे में तर्क दे सकता है 4. TI-BASIC में सभी निर्देश 1 वर्ण लंबे हैं।
इस्माईल मिगुएल

@IsmaelMiguel मैंने इसके बारे में सोचा था, लेकिन वे 1 या 2 बाइट्स हैं , और मैंने सामान्य रूप से वर्णों को गिनने का फैसला किया।
निन्जाबियरमोंकी

1
मैं आपके निर्णय का सम्मान करता हूँ। यह इस मामले में बहुत मदद करता है। मुझे वास्तव में अपने पुराने टीआई -83 पर प्रोग्रामिंग का आनंद मिला। (मैंने इसमें एक पेंट प्रोग्राम भी तैयार किया है!)
इस्माइल मिगुएल

41

GNU सेड

मैं एक और अधिक प्रतिबंधात्मक आवश्यकता को लागू कर रहा हूं - सभी स्निपेट पूरे sedकार्यक्रम होंगे।

factoid

sed है एक ट्यूरिंग-पूर्ण भाषा। यहाँ एक प्रमाण है।

लंबाई 0 स्निपेट

मुझे नहीं लगता कि एक लंबाई 0 स्निपेट की सख्त आवश्यकता है, लेकिन चूंकि यह वास्तव में सेड में कुछ करता है, यहां यह है:

सिड "स्ट्रीम एडिटर" है, अर्थात यह STDIN से स्ट्रीम (लाइन-बाय-लाइन) पढ़ता है, संपादन करता है, फिर STDOUT को आउटपुट करता है। जीरो-लेंथ सेड प्रोग्राम बस स्टैडिन को STDOUT में कॉपी करता है। इस प्रकार catउपयोगिता को सीड द्वारा अनुकरण किया जा सकता है। निम्नलिखित समतुल्य हैं:

cat a.txt b.txt > c.txt

तथा

sed '' a.txt b.txt > c.txt

लंबाई 1 स्निपेट

=

यह sed प्रोग्राम STDOUT में प्रत्येक लाइन की लाइन संख्या को प्रिंट करता है। यह लगभग बराबर है:

nl

या

cat -n

हालांकि सेड संस्करण अपनी लाइन पर लाइन नंबर डालता है।

लंबाई 2 स्निपेट

5q

STDIN को STOUT और quits को पंक्ति 5 के बाद। यह इसके बराबर है:

head -n5

आप यहां कुछ पैटर्न देखना शुरू sedकर सकते हैं - जिसका उपयोग कई मानक कोर-बर्तन टूल्स का अनुकरण करने के लिए किया जा सकता है।

लंबाई 3 स्निपेट

iHi

iहर लाइन से पहले "Hi \ n" लिखता है। भावहीन।

लंबाई 4 स्निपेट

/a/d

बहुत सी सेड की शक्ति अपनी रेगेक्स क्षमता में है। इस कार्यक्रम के regex मिलान सभी लाइनों का कारण बनता है aकिए जाने की dधारा से eleted। अन्य सभी लाइनें अभी भी STDOUT में आउटपुट होंगी। यह इसके बराबर है:

grep -v "a"

लंबाई 5 स्निपेट

:l;bl

यह एक अनंत लूप है। हम सभी CPU-hogging अनंत छोरों से प्यार करते हैं। एक लेबल को परिभाषित करता है l, फिर bइसे रेंच (कूदता है)। विज्ञापन अनन्त।

लंबाई 7 स्निपेट

s/a/A/g

डिफ़ॉल्ट रूप से, sed sऐसे आदेश लागू करता है कि यह प्रत्येक पंक्ति पर पहली घटना से मेल खाएगा। यदि आपको एक पंक्ति में प्रत्येक घटना को मैच (और स्थानापन्न) करने की आवश्यकता है, तो gध्वज के अंत मेंs कमांड यह करेगा।

लंबाई 8 स्निपेट

y/01/10/

थोड़ा इस्तेमाल किया जाने वाला yकमांड trशेल उपयोगिता के समान है (हालांकि काफी लचीला नहीं है)। यह कार्यक्रम एस और इसके विपरीत के 0साथ सभी स्विच करेगा 1

लंबाई 9 स्निपेट

1!G;$p;h

यह स्निपेट वास्तव में 8 बाइट्स है, लेकिन डिफ़ॉल्ट आउटपुट को दबाने के लिए sed के लिए -n पैरामीटर की आवश्यकता होती है, इसलिए मानक कोड-गोल्फ नियमों के अनुसार, मैं इसे 9 के रूप में गिन रहा हूं। यह प्रोग्राम स्ट्रीम में लाइनों को उलट देता है। इसलिए:

sed -n '1!G;$p;h'

इसके बराबर है:

tac

लंबाई 10 स्निपेट

s/[ <TAB>]+$//

यह (गलत) लंबाई 6 स्निपेट का पुनरीक्षण है। यह स्ट्रिप्स व्हिटस्पेस (रिक्त स्थान और TAB) को लाइनों से पीछे ले जाती है।


2
SED के लिए USEFUL ONE-LINE SCRIPTS भी देखें , जो मूल रूप से मैंने कैसे सीखा हैsed
एडम काट्ज

आपके पास अधिक वोट हैं। क्या हम कुछ और कर सकते हैं?
लूजर

2
आपका factoid 404'ed।
वुज़ल

1
अच्छा है, लेकिन कृपया इनमे से कई का उपयोग करें GNU एक्सटेंशन पर ध्यान दें और मानक नहीं हैं- विशेष रूप से लंबाई 3 (मानक होगा i\<newline>Hi<newline>), लंबाई 5 (मानक होगा sed -e :l -e blया :l<newline>bl<newline), और लंबाई 10 (जिसे काम करने के लिए +बारी की जरूरत है *)। ध्यान दें कि लंबाई 9 टुकड़ा -n '1!G;$p;h' है , मानक, जबकि tacहै नहीं । :)
वाइल्डकार्ड

1
@Wildcard हाँ - मैंने इसे GNU sed में प्रतिबंधित कर दिया है।
डिजिटल ट्रामा

39

अजगर

( mbomb007 की पोस्ट में पहले से ही पायथन स्निपेट्स का ढेर है, लेकिन मुझे लगा कि मैं कुछ विचित्र तथ्यों के साथ चिपटना चाहूंगा )

factoid

पायथन पठनीयता पर जोर देने के साथ गतिशील रूप से टाइप की जाने वाली भाषा है।

लंबाई 1 स्निपेट

1

पायथन 3 में, ऊपर Trueइस अर्थ में बराबर है कि 1 == True(और भी 0 == False)। ध्यान दें कि यह आवश्यक नहीं है कि पायथन 2 में सही है, जहां आप के मूल्य को फिर से परिभाषितTrue कर सकते हैं

लंबाई 2 स्निपेट

<>

<>के बराबर एक अप्रचलित तुलना ऑपरेटर है !=। यह अभी भी पायथन 2 में काम करता है (हालाँकि इसका उपयोग हतोत्साहित किया जाता है), और इसे पायथन 3 से पूरी तरह हटा दिया गया था।

लंबाई 3 स्निपेट

...

पायथन में कई विशेषताएं हैं जो कोई बिलिन उपयोग नहीं करता है, लेकिन केवल तीसरे पक्ष के पुस्तकालयों के लिए है। यह Ellipsisऑब्जेक्ट उनमें से एक है, और यह आमतौर पर स्लाइसिंग के लिए उपयोग किया जाता है। उदाहरण के लिए, यदि हमारे पास निम्नलिखित 3 डी संख्यात्मक सरणी है:

array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

तब a[..., 0](बराबर a[:,:,0]) सभी पहले तत्व देता है:

array([[1, 4], [7, 10]])

अजगर 3 में ...शाब्दिक टुकड़ा करने की क्रिया वाक्य रचना है, जो amusingly आप के स्थान पर एक "करने के लिए करते हैं" मार्कर के रूप में उपयोग करने की अनुमति देता के बाहर किया जा सकता है passया NotImplemented:

def f(x):
    ... # TODO

लंबाई 4 स्निपेट

(1,)

पायथन में एक-तत्व ट्यूपल।

पायथन में सूचियाँ (जैसे [1, 2, 3, 4]) हैं जो परस्पर हैं, और टुपल्स (जैसे (1, 2, 3, 4)) जो im हैं परिवर्तनशील। Tuples के लिए एक आम उपयोग शब्दकोश कुंजियों के रूप में है, क्योंकि सूची उपलब्ध नहीं हैं।

एक सामान्य शुरुआत करने वाला गलती ऊपर दिए गए अल्पविराम को छोड़ देता है, अर्थात (1), जो कि कोष्ठकों से घिरा नंबर 1 है। एक-तत्व टपल एकमात्र समय होता है जब आपको समापन पार्न्स से पहले अल्पविराम की आवश्यकता होती है - SyntaxErrorयदि आप खाली टपल में से एक को डालने की कोशिश करते हैं, तो यह बढ़ जाता है() , और कम से कम 2 की लंबाई के ट्यूपल्स के लिए वैकल्पिक है।

लंबाई 5 स्निपेट

0or x

इस स्निपेट में कुछ चीजें चल रही हैं, तो चलिए एक नज़र डालते हैं!

or||कई भाषाओं में पसंद है। पाइथन में, A or Bशॉर्ट-सर्किट, रिटर्निंग A(मूल्यांकन किए बिना B) यदि Aसत्य है, अन्यथा यह वापस आ जाता है B। उदाहरण के लिए, 1 or xहमेशा लौटता है 1, जैसा 1कि हमेशा सत्य होता है, और यहां तक ​​कि काम करता है अगर xपरिभाषित नहीं किया गया है। दूसरी ओर, 0 or xया तो रिटर्न xअगर xपरिभाषित है, या एक फेंकता है NameErrorअगर यह नहीं है।

गोल्फिंग करते समय, हम आमतौर पर व्हाट्सएप को एक संख्या और एक के बीच गिरा सकते हैं or, जैसे कि 1 or xबनना 1or x। यह संभव है क्योंकि 1orएक अंक से शुरू होता है, जिससे यह एक अवैध पायथन पहचानकर्ता बन जाता है।

हालाँकि एक अपवाद है - 0orजो रहस्यमय तरीके से फेंकता है SyntaxError। क्यों? क्योंकि पायथन में ऑक्टिकल शाब्दिक 0o(जैसे 0o20 == 16) के साथ शुरू होता है , और जब यह पहुंचता है तो पार्सर चोक हो जाता है r!

नोट: पायथन 2 में, ऑक्टल शाब्दिक भी अग्रणी शून्य से शुरू हो सकते हैं, जैसे 020

लंबाई 6 स्निपेट

*x,y=L

यह स्निपेट पायथन में एक विशेष प्रकार के असाइनमेंट को प्रदर्शित करता है, जहां Lएक सूची, टपल या किसी अन्य प्रकार का चलने योग्य है।

पायथन में, आप ट्यूपल्स को "अनपैक" कर सकते हैं और इस तरह सूचीबद्ध कर सकते हैं:

a,b = [1,2]

यह 1 से a2 और 2 को असाइन करता है b। इस सिंटैक्स का उपयोग कई असाइनमेंट के लिए भी किया जाता है, जैसे कि

a,b = b,a+b

जो कि फिबोनासी श्रृंखला की गणना करने वाले कार्यक्रम को लिखते समय उपयोगी है।

यदि दोनों ओर की लंबाई मेल नहीं खाती है, तो ValueErrorफेंक दिया जाता है। हालांकि, पायथन 3 ने एक नया वाक्यविन्यास, विस्तारित पुनरावृत्ति unpacking (या अधिक बोलचाल की भाषा में, "तारांकित असाइनमेंट") पेश किया, जो आपको इस तरह की चीजें करने की अनुमति देता है:

*x,y = [1, 2, 3, 4, 5]

यह प्रदान करती है yपिछले तत्व, 5 के लिए, और xकरने के लिए सूची के बाकी , अर्थात् [1, 2, 3, 4]। आप भी ऐसा कुछ कर सकते हैं:

a,b,*c,d,e = [1, 2, 3, 4, 5, 6, 7]

जो 1 a, 2 b, [3, 4, 5]टू c, टू , 6 टू dऔर 7 को असाइन करता है e

लंबाई 7 स्निपेट

zip(*x)

zip एक ऐसा कार्य है जो सूचियों का एक गुच्छा लेता है और, ठीक है, उन्हें ज़िप करता है:

>>> zip([1, 2, 3], [4, 5, 6])
[(1, 4), (2, 5), (3, 6)]

नोट: पायथन 3 में एक zipऑब्जेक्ट बदले में लौटाया जाता है, इसलिए यदि आप ऊपर की तरह एक सूची चाहते हैं तो आपको कॉल को लपेटना होगाlist()

यदि आपके पास दो या अधिक संबंधित सूचियाँ हैं, तो यह काफी सुविधाजनक कार्य है, और आप उनकी संबंधित प्रविष्टियों को लिंक करना चाहते हैं।

अब आप सूची को खोलना चाहते हैं - आप ऐसा कैसे करेंगे? हम zipफिर से उपयोग करने की कोशिश कर सकते हैं , लेकिन दुर्भाग्य से यह देता है:

>>> zip([(1, 4), (2, 5), (3, 6)])
[((1, 4),), ((2, 5),), ((3, 6),)]

समस्या यह है कि सब कुछ एक सूची में है, लेकिन zipअलग-अलग सूचियों को अलग-अलग फ़ंक्शन तर्कों के रूप में लेता है। इसे ठीक करने के लिए हम *स्पैट ऑपरेटर का परिचय देते हैं , जो एक सूची / टपल / आदि लेता है। और उन्हें फ़ंक्शन तर्क के रूप में अनपैक करें:

f(*[1,2]) ==> f(1, 2)

और परिणाम है:

>>> zip(*[(1, 4), (2, 5), (3, 6)])
[(1, 2, 3), (4, 5, 6)]

लंबाई 8 स्निपेट

x='a''b'

पहली बार जब मैंने यह देखा, तो मैं थोड़ा पीछे हट गया - एक दूसरे के बगल में दो तार होने का क्या मतलब है? उत्तर सरल था:

>>> x
'ab'

अजगर केवल दो तारों को समेटता है! यह पठनीयता के लिए बेहद उपयोगी है, क्योंकि यह आपको लंबे स्ट्रिंग्स को तोड़ने की अनुमति देता है जैसे (आसपास के कोष्ठकों पर ध्यान दें):

x = ('This is a very long sentence, which would not look very nice '
     'if you tried to fit it all on a single line.')

लंबाई 9 स्निपेट

0!=2 is 2

आप पहले से ही जानते होंगे कि पायथन तुलनात्मक संचालकों को आगे बढ़ाने की अनुमति देता है, ऐसा 5 < x <= 7केवल सच है अगर 5 < xऔर x <= 7। यदि आप नहीं जानते कि ... तो आश्चर्य!

किसी भी तरह, कम ज्ञात तथ्य यह है कि, के बाद से is/ is not/ in/ not inभी कर रहे हैं तुलना ऑपरेटरों, वे भी श्रृंखलित जा सकता है। दूसरे शब्दों में, उपरोक्त कोड समान है (0 != 2) and (2 is 2), जो है True

नोट: 2 is 2आधे के साथ कुछ सूक्ष्मताएं हैं , हालांकि isयह जांचता है कि क्या दो चीजें एक ही वस्तु हैं , न कि यह कि दो चीजें एक ही मूल्य हैं । पायथन छोटे पूर्णांक को कैश करता 1+1 is 2है True, लेकिन 999+1 is 1000यह है False!

लंबाई 10 स्निपेट

x=[];x+=x,

क्या होता है जब आप अपने आप में एक सूची जोड़ते हैं? यदि हम मुद्रण का प्रयास करते हैं x, तो हमें मिलता है:

[[...]]

सौभाग्य से, पायथन printकाफी बुद्धिमान है जो पुनरावर्ती सूचियों को प्रिंट करने की कोशिश नहीं कर रहा है। हम तो मजेदार चीजों का एक गुच्छा कर सकते हैं, जैसे:

>>> x[0][0][0][0][0]
[[...]]
>>> x[0] == x
True

यह सुविधा शब्दकोशों के साथ भी काम करती है, और चक्र के साथ डेटा संरचना बनाने का एक तरीका है, उदाहरण के लिए एक ग्राफ।

लंबाई 11 स्निपेट

help(slice)

helpसमारोह अजगर में डीबगिंग के लिए बहुत उपयोगी है। जब REPL में कोई तर्क नहीं कहा जाता है, तो help()एक सहायता सत्र शुरू होता है, जिसमें आप कार्यों / डेटा प्रकारों आदि के लिए प्रलेखन देख सकते हैं। जब एक विशिष्ट तर्क के साथ कहा जाता है, helpतो संबंधित आइटम पर जानकारी देगा।

उदाहरण के लिए, help(slice)निम्नलिखित जानकारी देता है (काट दिया गया क्योंकि यह काफी लंबा है):

Help on class slice in module __builtin__:

class slice(object)
 |  slice(stop)
 |  slice(start, stop[, step])
 |  
 |  Create a slice object.  This is used for extended slicing (e.g. a[0:10:2]).
 |  
 |  Methods defined here:
 |  
 |  __cmp__(...)
 |      x.__cmp__(y) <==> cmp(x,y)
 |  
 |  __getattribute__(...)
 |      x.__getattribute__('name') <==> x.name
 |
 | ...

जैसा कि slice, जैसा कि हम देख सकते हैं कि हम sliceअनुक्रमण के लिए ऑब्जेक्ट बना सकते हैं । उदाहरण के लिए:

>>> L = list(range(10))
>>> L[slice(2, 5)]         # L[2:5]
[2, 3, 4]
>>> L[slice(2, None)]      # L[2:]
[2, 3, 4, 5, 6, 7, 8, 9]

डिबगिंग के लिए एक और उपयोगी कार्य है dir(), जो बिना तर्क के कॉल किए जाने पर सभी नामों को मौजूदा दायरे में लौटाता है, और किसी दिए गए ऑब्जेक्ट की सभी विशेषताओं को एक तर्क के साथ कॉल करते समय लौटाता है।

लंबाई 12 स्निपेट

round(5.0/2)

इससे क्या मूल्यांकन होता है? जवाब आपके पायथन संस्करण पर निर्भर करता है!

पायथन 2 में, पूर्णांक 2 में दो पूर्णांकों के बीच विभाजन होता है (यानी 5/2 == 2) जबकि पायथन 3 में हमें फ्लोट डिवीजन (यानी 5/2 == 2.5) मिलता है। हालांकि, यह एक फ्लोट और पूर्णांक के बीच का विभाजन है, जिसका परिणाम हमेशा फ्लोट में होना चाहिए। फिर हमें अलग परिणाम क्यों मिलेंगे?

यदि हम roundदोनों पायथन संस्करणों के लिए प्रलेखन पर एक नज़र डालें , तो हमें इसका उत्तर मिलेगा:

  • में अजगर 2 , round0 से दूर गोलाई द्वारा tiebreaks।
  • में अजगर 3 , roundकी ओर गोलाई द्वारा tiebreaks निकटतम सम पूर्णांक

दूसरे शब्दों में, 5.0/2 = 2.5करने के लिए राउंड 3अजगर 2 में है, लेकिन करने के लिए राउंड 2निकटतम सम पूर्णांक अजीब ध्वनि हो सकता है की ओर अजगर 3. गोलाई में, लेकिन यह वास्तव में कहा जाता है बैंकर का राउंडिंग , और धनात्मक और ऋणात्मक मानों इसी तरह के इलाज के लिए पूर्वाग्रह को कम करने की कोशिश करता है।

लंबाई 13 स्निपेट

class C:__x=1

ऑब्जेक्ट-ओरिएंटेड होने के कारण, पायथन में कक्षाएं हैं। उपरोक्त एक वर्ग है Cजिसमें __x1 के लिए एक एकल विशेषता सेट है।

हम डॉट नोटेशन का उपयोग करके वर्ग विशेषताओं तक पहुंच सकते हैं। उदाहरण के लिए, यदि हमारे पास वर्ग है

class MyClass(): my_attr = 42

तब छपाई MyClass.my_attrका परिणाम 42 होगा, जैसा कि अपेक्षित था।

हालाँकि, यदि हम ऐसा ही करते हैं और C.__xऊपर बताए अनुसार उपयोग करने का प्रयास करते हैं, तो हमें यह मिलता है:

AttributeError: type object 'C' has no attribute '__x'

क्या चल रहा है? Cस्पष्ट रूप से एक __xविशेषता है!

कारण यह है कि विशेषताएँ __"निजी" चर के साथ शुरू होती हैं , कुछ ऐसा जो पायथन के पास नहीं है । पायथन __वर्ग के नाम को जोड़ते हुए शुरू होने वाले किसी भी विशेषता का नाम बताता है ताकि नाम पुन: उपयोग करने वाले संघर्ष से बचा जा सके। उपरोक्त उदाहरण में, यदि हम वास्तव में उस तक पहुंचने के लिए दृढ़ हैं, तो हमें 1इसके बजाय करना होगा

>>> C._C__x
1

लंबाई 14 स्निपेट

NotImplemented

न केवल पायथन में कक्षाएं हैं, इसमें ऑपरेटर ओवरलोडिंग भी है। उदाहरण के लिए, आपके पास एक वर्ग हो सकता है

class Tiny():
    def __lt__(self, other):
        return True

__lt__ऑपरेटर से कम कहां है। अब यदि हम इसका उदाहरण Tinyदेते हैं, तो हम ऐसा कर सकते हैं

>>> t = Tiny()
>>> t < 1
True
>>> t < "abc"
True

चूंकि हमने __lt__हमेशा लौटने के लिए परिभाषित किया है True। ध्यान दें कि हम भी कर सकते हैं

>>> 42 > t
True

लेकिन निम्न विराम:

>>> t > 42
Traceback (most recent call last):
  File "<pyshell#18>", line 1, in <module>
    t > 42
TypeError: unorderable types: Tiny() > int()

रुको, वह कैसे काम करता है? हमने अधिक से अधिक के लिए एक व्यवहार निर्दिष्ट नहीं किया है Tiny, इसलिए यह आश्चर्यजनक नहीं है कि अंतिम मामला टूट जाता है। लेकिन फिर एक int(42) कैसे जानता है कि यह हमारी Tinyवस्तु से अधिक है ?

पायथन में एक अंतर्निहित स्थिरांक है NotImplemented, जिसे एक तुलनात्मक विशेष विधि द्वारा वापस किया जा सकता है। आइये इसे आजमाते हैं:

class Unknown():
    def __gt__(self, other):
        # __gt__ for greater-than
        print("Called me first!")
        return NotImplemented

अब अगर हम अपने नए वर्ग का एक उदाहरण बनाते हैं:

>>> u = Unknown()

हम यह कर सकते हैं:

>>> t < u
True
>>> u > t
Called me first!
True

जैसा कि हम देख सकते हैं, यह क्या हुआ u > tकि पायथन ने Unknownपहले के लिए अधिक से अधिक विधि को कॉल करने की कोशिश की , पाया कि इसे लागू नहीं किया गया था, और Tinyइसके बजाय अन्य वर्ग ( ) के लिए कम से कम विधि की कोशिश की !

लंबाई 15 स्निपेट

x=[],;x[0]+=[1]

यह थोड़ा मजेदार है। पहले हम एक टपल के अंदर एक खाली सूची है, यानी xहोने के लिए असाइन करते हैं । फिर हम करते हैं जो दूसरी सूची द्वारा खाली सूची का विस्तार करने की कोशिश करता है ।[],([],)x[0]+=[1][1]

अब, याद रखें कि सूचियों अस्थायी होते हैं और tuples हैं im परिवर्तनशील - क्या होता है जब आप एक अपरिवर्तनीय ऑब्जेक्ट के अंदर एक परिवर्तनशील वस्तु को बदलने की कोशिश?

>>> x=[],;x[0]+=[1]
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    x=[],;x[0]+=[1]
TypeError: 'tuple' object does not support item assignment

ओह, तो यह एक त्रुटि देता है, मुझे लगता है कि उम्मीद की जानी चाहिए। लेकिन क्या होगा अगर हम प्रिंट करने की कोशिश करें x?

>>> x
([1],)

है ना? सूची बदल गई!

यदि आप इस बारे में उत्सुक हैं कि यहां क्या हो रहा है, तो इस ब्लॉग पोस्ट को देखना सुनिश्चित करें ।

लंबाई 16 स्निपेट

@lru_cache(None)

बस कैश जोड़ें! यह पायथन 3 में उपलब्ध डेकोरेटर का एक सरल उदाहरण है ।

मान लें कि हमारे पास निम्नलिखित भोले फाइबोनैचि कार्यान्वयन हैं:

def f(n):
    if n < 2: return 1
    return f(n-1) + f(n-2)

जैसा कि प्रोग्रामिंग पाठ्यक्रमों के अधिकांश परिचय आपको बता सकते हैं, यह फिबोनाची को लागू करने का एक बहुत बुरा तरीका है, जो कि तेजी से चल रहा है, क्योंकि हम प्रभावी रूप से आधार मामले में केवल 1s जोड़ रहे हैं। f(10)? एक दूसरे विभाजन में चलाता है। f(32)? थोड़ी देर ले लो, लेकिन यह वहाँ हो जाता है। f(100)? नहीं।

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

from functools import lru_cache

@lru_cache(None)
def f(n):
    if n < 2: return 1
    return f(n-1) + f(n-2)

जैसा कि हम देख सकते हैं, मैंने जो कुछ किया है lru_cacheवह functoolsमॉड्यूल से आयात किया गया है और @lru_cache(None)मेरे फ़ंक्शन से पहले जोड़ा गया है । @एक डेकोरेटर को निरूपित करता है जो एक फ़ंक्शन के चारों ओर लपेटता है, इस मामले में स्मारक के लिए। lru_cacheपहला तर्क यह है कि maxsize, कैश का अधिकतम आकार - यहाँ हमने इसे निर्धारित किया Noneहै कि कोई अधिकतम आकार न दिखाई दे।

अब अगर हम इसका उपयोग करने की कोशिश करते हैं:

>>> f(100)
573147844013817084101

और यह एक सेकंड भी नहीं लिया!

नोट: f(1000)एक पुनरावृत्ति गहराई त्रुटि की ओर जाता है, लेकिन यह एक और समय के लिए एक कहानी है


isऑपरेटर के लिए पायथन "कैच" छोटे पूर्णांकों की किस सीमा तक है ?
mbomb007

@ mbomb007 इस सवाल से , यह -5 से 256 प्रतीत होता है। आप कोशिश कर सकते हैं -5-1 is -6और 255+2 is 257परीक्षण कर सकते हैं ।
Sp3000

37

संक्षेप में लिख देना

फैक्टॉइड: मैं जोत को 2 अपवोट्स के साथ परिभाषित कर सकता हूं, और यह साबित कर सकता हूं कि यह ट्यूरिंग 8 के साथ पूरा हो गया है (लंबाई 4, 6 या 7 का उपयोग नहीं कर रहा है)।

लंबाई 1

1

यह जोत में दो कार्यों का एक उदाहरण है। पहला खाली स्ट्रिंग है, जो पहचान फ़ंक्शन का मूल्यांकन करता है। दूसरा है 1, जो जोट का समूह संचालक है। ( लंबो कैलकुलस नोटेशन) का 1मूल्यांकन करता है , जहां (यहां, खाली स्ट्रिंग) से पहले का कार्यक्रम है । तो, यह कार्यक्रम वह कार्य है जो सरल करता है ।λxy.[F](xy)[F]1λxy.(λz.z)(xy)λxy.xy

लंबाई २

10

अब हम जोत में अन्य प्रतीक पेश कर रहे हैं: 0। फिर अगर [F]अब तक कार्यक्रम के मूल्य का प्रतिनिधित्व करता है, 0का मूल्यांकन करता है करने के लिए [F]SKहै, जहां Sऔर Kसे कर रहे हैं combinatory तर्क । मैंने अब पूरी भाषा को परिभाषित कर दिया है।

लंबाई ५

11100

अब मैं यह साबित करूंगा कि जोट जुम्मन लॉजिक से एक मैपिंग को परिभाषित कर जोत को पूरा कर रहा है । यह जोत कार्यक्रम K संयोजनकर्ता है

लंबाई 8

11111000

यह एस कॉम्बिनेटर है।

लंबाई ३

1AB

यहां, Aऔर Bजोत का हिस्सा नहीं हैं, बल्कि एक मनमाने ढंग से अभिव्यक्ति के लिए प्लेसहोल्डर हैं। जोत ABमें कॉम्बिनेशन लॉजिक मैप्स में अभिव्यक्ति 1AB, इन तीन नियमों के साथ Aऔर Bफिर से रूपांतरित होती है। QED

लंबाई एन

1
10
11
100
101
110
[...]

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


2
दो अपवोट दिए गए। अब भाषा को परिभाषित करें।
जॉन ड्वोरक

@JDDvorak इस पर काम कर रहा है ... जब से मैंने इस चीज पर शोध किया है, तब तक यह बहुत लंबा हो चुका है ...
फिल फ्रॉस्ट

1
मैं यह नहीं देखता कि क्यों इसे और अधिक बढ़ाना जारी रखना चाहिए। आप बस बढ़ती लंबाई की यादृच्छिक द्विआधारी संख्या उत्पन्न करने जा रहे हैं: |
ऑप्टिमाइज़र

1
आपने upvote नंबर 4 के लिए ऐसा कहा है। लेकिन यहां हम एक "यादृच्छिक संख्या जिसे आपने अभी उत्पन्न किया है"
ऑप्टिमाइज़र को देख रहे हैं

1
आप हॉल्टिंग समस्या को कैसे हल कर सकते हैं? मैं अनुमान लगा रहा हूं कि इसका अनंत (अनंत की संख्या) कार्यक्रम का उपयोग करने के साथ कुछ करना है?
फिलिप हगलुंड

37

दे घुमा के

factoid:

बेहद गंभीर शेलशॉक बग 1989 से बैश में मौजूद था, और एक सदी के एक चौथाई तक अनदेखा रहा। बैश लिखने का बहुत आनंद अपनी कई मूर्तियों और विसंगतियों के साथ आ रहा है।

लंबाई 1 स्निपेट:

[

बिलियन के लिए एक उपनाम test, प्रारूप के कोड की अनुमति देता है if [ a == b ]; then- वास्तव [में एक स्टैंडअलोन कमांड है, न कि एक वाक्यविन्यास तत्व है, और ]विशुद्ध रूप से सजावटी है (हालांकि [इसके द्वारा आवश्यक है, इसकी आवश्यकता मनमाना है और आप इसका उपयोग करके इसे दूर कर सकते हैं alias [=test)।

लंबाई 2 स्निपेट:

||

तार्किक की तरह orअधिकांश भाषाओं में , लेकिन प्रक्रियाओं के लिए। ||गैर-शून्य लौटने से पहले केवल कमांड के बाद कमांड निष्पादित करेगा ।

लंबाई 3 स्निपेट:

x=y

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

लंबाई 4 स्निपेट:

$IFS

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

लंबाई 5 स्निपेट:

${x^}

स्ट्रिंग को x में प्रतिस्थापित करें, लेकिन पहले वर्ण के साथ कैपिटल किया गया! इस तरह की अक्सर इस्तेमाल की जाने वाली विशेषता यह है कि इसमें भाषा सिंटैक्स का अपना समर्पित टुकड़ा है।

लंबाई 6 स्निपेट:

x=($y)

तत्वों की एक सारणी से x, x भरें, जो कि वर्तमान में IFS के लिए तयशुदा रूप से व्हाट्सएप पर विभाजित है। उन्नत बैश प्रोग्रामिंग के लिए एक बहुत ही उपयोगी सुविधा।

लंबाई 7 स्निपेट:

${x[y]}

Arrays! लेकिन रुको, यह क्या है ... y एक स्ट्रिंग है, एक संख्यात्मक सूचकांक नहीं है? हाँ वास्तव में, बैश साहचर्य सरणियों का समर्थन करता है! बहुत से लोग यह नहीं जानते। आपको बस declare -A xपहले की जरूरत है ।

लंबाई 8 स्निपेट:

${x##*,}

सबस्टिट्यूट x, अंतिम ,चरित्र तक सब कुछ (या जो भी आप निर्दिष्ट करते हैं)। सीएसवी के अंतिम क्षेत्र को प्राप्त करने के लिए उपयोगी - यह एक ऐसी चीज है जिसे आप इतनी आसानी से नहीं कर सकते हैं cut, जो केवल बाईं ओर से फ़ील्ड की गणना करती है। % और %% सही से कटौती करने की अनुमति देता है; यूएस कीबोर्ड पर% और # को उनके स्थान के लिए चुना गया था, ताकि यह स्पष्ट हो सके कि जिसका अर्थ बाएं है और जिसका अर्थ दाएं है, लेकिन यह यूएस कीबोर्ड का उपयोग नहीं करने वाले सभी के लिए बहुत अधिक मूल्य नहीं रखता है :)

लंबाई 9 स्निपेट:

[ a = b ]

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

लंबाई 10 स्निपेट:

if [ a=b ]

यदि आप अनिवार्य रिक्त स्थान के बारे में भूल जाते हैं तो यही होता है। कोई त्रुटि नहीं करेगा। हमेशा सच लौटेगा - भले ही aऔर bवे चर हैं जो परेशान हैं, या जो भी वे सेट हैं, कोई फर्क नहीं पड़ता - यह हमेशा सच लौटेगा। if [ "$password"="$correctpass" ]इस "सुविधा" की मज़ेदार क्षमता को देखने के लिए कोड के बारे में सोचें ।

लंबाई 11 स्निपेट:

x=${y//a/b}

रेगेक्स-शैली प्रतिस्थापन प्रतिस्थापन! X को y के मान पर सेट करें लेकिन b के साथ प्रतिस्थापित किए गए हर उदाहरण के साथ।

लंबाई 12 स्निपेट:

[[:upper:]]*

पैटर्न मिलान - तुम सिर्फ खोल में * वाइल्ड कार्ड का उपयोग करने के लिए ही सीमित नहीं हैं, तो आप इस तरह के रूप में किसी भी POSIX मानक मैच उपयोग कर सकते हैं alnum, alpha, digitआदि

लंबाई 13 स्निपेट:

function x(){

सी सिंटैक्स का एक सा रहस्यमय तरीके से क्रेप है! घुंघराले ब्रेसिज़ के लिए कई पूरी तरह से अलग उपयोग करता है, और वैकल्पिक सजावटी तत्वों का एक और उदाहरण में से एक अधिक बैश देखो बनाने के लिए अन्य भाषाओं की तरह - या तो ()या functionयहाँ छोड़ा जा सकता है (लेकिन दोनों)। असंगत स्थानों के साथ और अधिक मज़ा - {अनिवार्य होने के बाद एक स्थान है, लेकिन समापन से पहले नहीं} , जैसा कि अंदर हैfunction x { y;}

लंबाई 14 स्निपेट:

echo {Z..A..3}

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

लंबाई 15 स्निपेट:

echo {a,b,c,d}x

अनुक्रम पीढ़ी में घुंघराले ब्रेसिज़ के लिए एक और समान लेकिन समान उपयोग नहीं; प्रिंट ax bx cx dx, और एक अनुक्रम में तार की एक सूची या सूची से उत्पन्न करने के लिए उपयोगी है। फिर भी, उपयोगिता में सीमित है क्योंकि इसका उपयोग ब्रेसिज़ के अंदर चर के साथ नहीं किया जा सकता है।


दरअसल, ]विशुद्ध रूप से सजावटी नहीं है। [यदि इसका अंतिम तर्क नहीं है तो कार्य करने से इंकार कर देगा ]
फ़ूजएक्सएक्सएल

हां, लेकिन यह सौंदर्य प्रसाधन के अलावा कोई उद्देश्य नहीं है; और यदि आप [इसके अन्य रूप के साथ स्थानापन्न करते हैं test, तो ]कॉल में कुछ और बदले बिना छोड़ा जा सकता है - मैं केवल यह संकेत कर रहा हूं कि यह वास्तविक बैश सिंटैक्स नहीं है, बस दृश्य चीनी है।
दंगा

आप सही है कि यह पार्टी वाक्य रचना नहीं है कर रहे हैं, लेकिन उनके पीछे ]है [वाक्य रचना और आप जैसे कैसे आप अर्धविराम सी में एक बयान समाप्त करने के लिए है यह प्रदान करने के लिए है।
फ़ूजएक्सएक्सएल

यह सच है कि यह अनिवार्य है, लेकिन सी सेमीकोलन के समान नहीं है। इसके लिए आवश्यकता पूरी तरह से मनमानी है, जैसा कि यदि आप बस alias [=testऔर फिर लिखते हैं if [ 1 = 1; thenआदि को देखा जाता है, लेकिन मैं आपकी बात को ध्यान में रखते हुए स्पष्ट करूँगा :)
Riot

1
function x(){वाक्य-विन्यास के बारे में : आप परनों को गिरा सकते हैं, जैसा कि आप कहते हैं, लेकिन आप केवल functionभाग को भी छोड़ सकते हैं । वास्तव में, यह है कि कैसे POSIX शेल कार्यों को परिभाषित करता है, इसलिए यह उस तरह से अधिक पोर्टेबल है। आप 13 वर्णों में एक पूर्ण फ़ंक्शन को परिभाषित कर सकते हैं। उदाहरण के लिए:x(){ startx;}
kojiro

37

एपीएल

factoid

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

आप http://www.tryapl.org पर अधिकांश उदाहरण देख सकते हैं ।

लंबाई 1

चरित्र , जिसे लैंपशेड कहा जाता है, दोनों अपने आकार के लिए और अपनी उपस्थिति से प्राप्त ज्ञान के लिए, एक टिप्पणी का परिचय देते हैं। ऐतिहासिक रूप से, यह एक (जोत) और एक (ऊपर जूता) को उखाड़ कर बनाया गया था ।

लंबाई २

⍳3

मोनैडिक (एक तर्क) फ़ंक्शन (iota) पहले कुछ प्राकृतिक संख्याओं का एक वेक्टर उत्पन्न करता है। उदाहरण के लिए, पूर्वोक्त ⍳3उपज होगी 1 2 3, पहले तीन प्राकृतिक संख्याओं का वेक्टर। एपीएल के कुछ कार्यान्वयन पर, यह प्राप्त होते हैं 0 1 2बजाय, इस के मूल्य पर निर्भर करता है ⎕IO, मैं ओटा rigin।

लंबाई ३

5\3

मोनैडिक के विपरीत , डियाडिक \(विस्तार) फ़ंक्शन दाईं ओर तर्क को कॉपी करता है जितना अक्सर बाईं तरफ तर्क; इस प्रकार, 5\3पैदावार 3 3 3 3 3। आप वेक्टर तर्क (जैसे 1 2 3\4 5 6) के साथ चारों ओर खेलना चाह सकते हैं यह देखने के लिए कि यह तब क्या करता है।

लंबाई ४

A←⍳3

Aके मान को असाइन करता है ⍳3(बायां तीर) असाइनमेंट ऑपरेटर है। एक असाइनमेंट को एक बयान में सबसे बाईं ओर होना नहीं है; असाइनमेंट फ़ंक्शन कॉल की तरह पार्स किए जाते हैं और आगे उपयोग के लिए असाइन किए गए मान प्राप्त करते हैं।

लंबाई ५

∘.×⍨A

एक तीन गुणा तीन तालिका, यानी

1 2 3
2 4 6
3 6 9

यह थोड़ा जटिल है, इसलिए मुझे समझाएं। ⍺∘.f⍵(पढ़ें: अल्फा जोत डॉट ओमेगा च) है बाहरी उत्पाद की और अधिक f। बाहरी उत्पाद fतत्वों की प्रत्येक संभावित जोड़ी के लिए आवेदन करने के परिणाम की एक तालिका है और । इस उदाहरण में, fहै ×(गुणा), एक गुणन तालिका उपज। ऑपरेटर (टिल्ड डाएरेसिस) commutes अपने तर्कों, कि है, ⍺f⍨⍵के बराबर है ⍺f⍵और f⍨⍵बिना एक बाईं संकार्य के बराबर है ⍵f⍵। कम्यूट ऑपरेटर के बिना यह स्निपेट होगा a∘.×a। बाहरी उत्पाद ऑपरेटर बहुत बहुमुखी है; बाहर की जाँच करता है, तो आप विकल्प क्या होता है =के लिए ×!

लंबाई ६

{×/⍳⍵}

एक तथ्यात्मक समारोह। घुंघराले ब्रेसिज़ की एक जोड़ी एक dfn (डायनामिक फ़ंक्शन) को संलग्न करती है , अर्थात, एक अनाम फ़ंक्शन (cf. lambda अभिव्यक्तियाँ)। एक dfn के तर्क चर के लिए बाध्य होते हैं और या यदि केवल dfn को एक विवादास्पद (एकल तर्क, दोदिक के विपरीत) फ़ंक्शन के रूप में कहा जाता है। हम लागू सही तर्क के लिए, से पूर्णांकों उपज 1करने के लिए /(स्लैश) ऑपरेटर कम कर देता है, वह यह है कि f/⍵आवेषण fके आइटम के बीच । उदाहरण के लिए, +/⍳5बस है 1+2+3+4+5। इस मामले में, हम ×उन वस्तुओं के उत्पाद की पैदावार कम कर देते हैं ⍳⍵, जिनमें से केवल तथ्य है

लंबाई 7

2×3*4+5

पैदावार 39366⍺*⍵(अल्फा स्टार ओमेगा) की शक्ति के लिए उठाया जाता है । एपीएल का एक बहुत ही सरल पूर्ववर्ती नियम है: हर चीज का मूल्यांकन दाएं से बाएं किया जाता है, सभी कार्य दाएं-सहयोगी होते हैं। ऑपरेटर कार्यों की तुलना में अधिक मजबूत होते हैं और बाएं से दाएं का मूल्यांकन होता है। इस प्रकार, स्पष्ट कोष्ठकों के साथ ऊपर की अभिव्यक्ति 2×(3*(4+5))को सामान्य के विपरीत लिखा जाएगा (2×(3*4))+5

लंबाई 8

¯1+3 3⍴A

इस स्निपेट से पैदावार मिलती है

0 1 2
3 4 5
6 7 8

और दो महत्वपूर्ण अवधारणाओं को दर्शाता है: पहली अवधारणा है (रो) समारोह है, जो नया स्वरूप दे आकार अपनी बाईं तर्क में निर्दिष्ट करने का अधिकार तर्क। एक सरणी का आकार सरणी में प्रत्येक अक्ष की लंबाई का एक वेक्टर है। एक स्केलर का आकार खाली वेक्टर है। इस प्रकार, तीन मैट्रिक्स द्वारा एक तीन में 3 3⍴Aफेरबदल किया Aजाता है। दूसरी अवधारणा यह है कि इसके अलावा कैसे उपयोग किया जाता है: हम जोड़ते हैं ¯1(ओवरबार एक), जिसका अर्थ है नकारात्मक एक ( ¯नकारात्मक संख्या निर्दिष्ट करने के लिए एक उपसर्ग है, जबकि -एक ऑपरेटर है) एक सरणी के लिए। दो ऑपरेंड के अलग-अलग आकार होते हैं, इसलिए कम आकार के साथ ऑपरेंड दूसरे ऑपरेंड पर वितरित किया जाता है, उत्पन्न मैट्रिक्स में प्रत्येक आइटम से एक को घटाकर।

लंबाई ९

+.×⍨3 3⍴A

A, 3 गुणा 3 मैट्रिक्स से, अपने आप से गुणा किया जाता है। .(डॉट) ऑपरेटर दो कार्यों लेता है और एक का निर्माण आंतरिक उत्पाद है, जिसकी पहली समारोह का प्रतिनिधित्व करता है इसके अलावा और दूसरा समारोह गुणा। बूलियन मैट्रिसेस के लिए एक सादा, पुराना, मैट्रिक्स गुणा +.×, एक सामान्य प्रकार है ≠.∧(जहां बराबर नहीं है और (ऊपर की देखभाल) तार्किक है); कई दिलचस्प बातें के स्थान पर कुछ ऑपरेटरों के साथ एक आंतरिक उत्पाद के रूप में तैयार किया जा सकता +है और ×

लंबाई १०

(.5×⊢+÷)⍣≡

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

यह कैसे काम करता है? (.5×⊢+÷)पहले बाएं हिस्से से शुरू करते हैं, यह अभिव्यक्ति J में उत्पन्न होने वाले टैसीटेशन नोटेशन का उपयोग करती है जिसे बाद में Dyalog APL में वापस लाया गया। Tacit अंकन शुरुआती लोगों के लिए थोड़ा कठिन है, इसलिए कृपया इस अनुभाग को ध्यान से पढ़ें। एक अलग अनुक्रम, जैसे कि +/÷≢, "सामान्य" पार्सिंग नियम भाषण के एक हिस्से को हल नहीं करते हैं, एक ट्रेन कहा जाता है। दो या तीन कार्यों की एक ट्रेन एक फ़ंक्शन का उत्पादन करती है और (दोहराया संकल्प द्वारा), किसी भी लंबाई की एक फ़ंक्शन ट्रेन भी एक फ़ंक्शन का उत्पादन करती है। तीन कार्यों की एक ट्रेन fghजैसा व्यवहार करती है {(⍺f⍵)g⍺h⍵}, वह है, fऔर hपरिणामी फ़ंक्शन के तर्कों पर लागू होता है और इनका परिणाम करने के लिए लागू होता हैg । एक सरणी की एक ट्रेन और दो कार्य जैसेAfgजैसे व्यवहार{Af⍺g⍵}इस , यहgपरिणामी फ़ंक्शन के तर्कों पर लागू होता है Aऔर उस परिणाम पर लागू होता है f। दो कार्यों की एक ट्रेन में एक शब्दार्थ भी है, जिसे प्रलेखन में समझाया गया है, लेकिन इस उदाहरण में इसका उपयोग नहीं किया गया है।

इस विशेष ट्रेन में, एक नया फ़ंक्शन, (दाएं कील) का उपयोग किया जाता है। यह व्यवहार करता है {⍵}, अपने सही तर्क की उपज। इस प्रकार, पूरी अभिव्यक्ति के बराबर है {.5×⍵+⍺÷⍵}, जो बेबीलोन के सूत्र का सिर्फ पुनरावृत्ति कदम है। यह देखना आसान है कि टैलीट नोटेशन गोल्फर को कैसे फायदा पहुंचाता है; यह आपको लागू होने वाले कुछ अनमोल चरित्रों से दाढ़ी बनाने की अनुमति देता है।

पहेली का अंतिम टुकड़ा (स्टार डायरेसिस), पावर ऑपरेटर है। यदि सही तर्क एक सरणी है, तो कुल बार f⍣A⍵लागू होता fहै । उदाहरण के लिए, के बराबर है । गिनती नकारात्मक हो सकती है, जिस स्थिति में एपीएल एक उलटा कार्य करने की कोशिश करता है और वह लागू होता है। सही तर्क को अगर एक समारोह है, भी, लागू होता है करने के लिए जब तक जहां के बार-बार आवेदन का परिणाम है करने के लिए । विशेष रूप से, अगर है (बराबर) या (समान), एक गणना करता है ठीक बिंदुAf⍣3⍵fff⍵ff⍣g⍵f(fY)gYYfg=f⍣≡ कीf। यह वही है जो हमें बेबीलोनियन पद्धति के लिए चाहिए! हम परिणाम को परिवर्तित करने तक इसे पुनरावृत्त करना चाहते हैं। अंत में, अगर चीजों की एक जोड़ी के लिए लागू किया जाता है एक dyadic फ़ंक्शन के रूप में लागू किया जाता है, तो बाएं तर्क बाईं ओर बाध्य होता है f, अर्थात जहां जैसा व्यवहार ⍺f⍣g⍵होता है, उसके बराबर होता है ।(⍺∘f)⍣g⍵A∘f{Af⍵}


आपको अधिक वोट मिले हैं! क्या हम कुछ और कर सकते हैं?
लूसर

@luserdroog ज़रूर, मुझे कुछ और सोचने दें।
फ़ूजक्कल

क्या मैं इसे संपादित और विस्तारित कर सकता हूं?
एडम जूल

@ Adám हां, कृपया।
फ़ूजएक्सल जूल

∘.×⍨a मुझे एक मूल्य त्रुटि देता है । क्या मैं इसका सही इस्तेमाल कर रहा हूं?
साइओस

37

Matlab

स्निपेट 26 - मैट्रिस पर पुनरावृति

यह कुछ ऐसा है जिसे मैंने अभी हाल ही में खोजा है। आमतौर पर आप लूप के लिए दिए गए वेक्टर पर पुनरावृति करते हैं। लेकिन वैक्टर के बजाय, आप rand(10)मैट्रीस का भी उपयोग कर सकते हैं ( 0 और 1 के बीच समान रूप से वितरित संख्याओं के साथ 10x10 मैट्रिक्स का उत्पादन करता है)।

for k=rand(10);disp(k);end

इसके बाद पुनरावृति मैट्रिक्स के यादृच्छिक मैट्रिक्स का एक कॉलम वेक्टर प्रदर्शित करता है।

स्निपेट 25 - आसान प्लॉटिंग

हम जानते हैं कि मटैलैब में प्लॉटिंग आसान है, लेकिन एक सुपर आसान फंक्शन है ezplot( E-Zइसे प्राप्त करें! जब तक मुझे आखिरकार मिल गया, तब तक काफी समय लग गया, क्योंकि मैंने Zहमेशा sedकी तरह c, जो भी हो ...) हर किसी को अण्डाकार वक्र पसंद हैं:

ezplot('y^2-x^3+9*x-10.3')

अण्डाकार वक्र

स्निपेट 24 - एकीकरण

एकीकरण के लिए पुराने जमाने का शब्द (लेकिन अभी भी संख्यात्मक गणना में उपयोग में है) 'क्वाडरेचर' है, क्या आप अनुमान लगा सकते हैं कि निम्नलिखित में से एक क्या है?

quad(@(x)4./(1+x.^2),0,1)

स्निपेट 23 - चित्र

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

imrotate(rand(99),9,'c')

यहाँ

स्निपेट 22 - संगीत

load handel;sound(y,Fs)

यह इस तरह के बारे में आवाज़ करेगा (यूट्यूब लिंक)

स्निपेट 21 - अंतर और एकीकृत

polyint(polyder(p),c)

आप आसानी से उन दो कार्यों का उपयोग करके बहुपद को अलग और एकीकृत कर सकते हैं। एकीकृत करते समय, आप एक दूसरा तर्क पारित कर सकते हैं जो स्थिर होगा।

स्निपेट 20 - बहुपद में वापस

p=poly(r);cp=poly(A)

में जड़ों के साथ बहुपद चाहते हैं r? आसान: p=poly(r)। एक मैट्रिक्स की विशेषता बहुपद चाहते हैं A? आसान: cp=poly(A)। तो roots(p)बिल्कुल r(या एक क्रमपरिवर्तन r) है।

स्निपेट 19 - एक और जादू की चाल

fminsearch(fun,x0);

ऐसे लोग हैं जो इस फ़ंक्शन को बिल्कुल पसंद करते हैं। यह मूल रूप से किसी भी स्थिति के बिना funप्रारंभिक मूल्य x0( न्यूनतम वेक्टर हो सकता है) के साथ न्यूनतम खोज करता है fun। यह उन छोटे मॉडलों को फिट करने के लिए बहुत अच्छा है जहाँ आप त्रुटि / दंड / उद्देश्य फ़ंक्शन को अलग करने के लिए (या आप बहुत आलसी हैं) नहीं कर सकते। यह नेल्डर-मीड सिम्प्लेक्स एल्गोरिथ्म का उपयोग करता है जो उन कार्यों के लिए बहुत तेज़ है जहां आप कोई भी धारणा नहीं बना सकते हैं।

स्निपेट 18 - बहुपद का परिचय

p=polyfit(x,y,deg)

Matlab में बहुपद के साथ मुकाबला करने का एक अच्छा समाधान है। polyfitआप के साथ डिग्री के एक कम से कम वर्गों बहुपद मिलता है degकि अंक में अनुमान लगाता है x,y। आपको एक वेक्टर मिलता है pजो बहुपद के गुणांक को संग्रहीत करता है, क्योंकि यही एकमात्र चीज है जो आपको बहुपद का प्रतिनिधित्व करने के लिए आवश्यक है। यदि आप स्निपेट 15 पर वापस जाते हैं, तो आप एक ही काम लिखकर कर सकते हैं c = polyfit(x,y,2)। इसलिए उदाहरण [1,-2,3]बहुपद का प्रतिनिधित्व करता है x^2 - 2*x+3। बेशक अन्य प्राथमिक, या मनमाने कार्यों के लिए उपयुक्त कार्य भी हैं।

स्निपेट 17 - कोण और असंतोष

unwrap(angle(c))

यदि आप जटिल संख्याओं के एक 'निरंतर' वेक्टर के तर्क को प्राप्त करना चाहते हैं, तो आपको अक्सर ऐसे मान मिलते हैं जो एक असंगतता है। उदाहरण के angle([-1-0.2i,-1-0.1i,-1,-1+0.1i,-1+0.2i])लिए और के बीच केवल एंगल्स मिलने [-2.94,-3.04,3.14,3.04,2.94]से ईजी आपको मिल जाएगा । फ़ंक्शन यह ध्यान रखेगा! यदि आपको इस तरह की छूट मिलती है, तो इसे हटाने के लिए बस एक बहु जोड़ना होगा : '[-2.94, -3.04, -3.14, -3.24, -3.34]' यह भी 2d-matrices के लिए काम करता है! यदि आप जटिल संख्याओं के तर्क को एक नकारात्मक वास्तविक भाग के साथ प्लॉट करते हैं, तो आपको पहला ग्राफिक्स मिलेगा जिसमें आपको पहली छवि मिलेगी, दूसरे को प्राप्त करने के लिए:angle-pipiunwrap2*pi

बिना बकवास के अनपरा के साथ

[x,y] = meshgrid(-1:0.01:0,-0.5:0.01:0.5);
z = x+i*y;
imagesc(angle(z))
imagesc(unwrap(angle(z)))

स्निपेट 16 - स्केलर उत्पाद

[1;2;3]'*[4;5;6]

बेशक वहाँ तरीकों (जैसे dot) में बनाया गया है , लेकिन मैट्रिक्स-परिवर्तन ऑपरेटर के साथ 'यह उतना ही सरल है। यदि आप नहीं जानते हैं कि आपके पास पंक्ति या स्तंभ वैक्टर है, तो आप बस उपयोग कर सकते हैं a(:)'*b(:)जहां a(:)हमेशा एक कॉलम वेक्टर लौटाता है।

स्निपेट 15 - रैखिक कम वर्ग, जादू की छड़ी के साथ बदसूरत विधि

[x.^2,x,x.^0]\y

xx- अक्ष पर मानों, yशोर y- मानों के साथ (स्तंभ) वेक्टर है । टाइप करें c=[x.^2,x,x.^0]\yऔर आपको 2 डिग्री बहुपद के गुणांक मिलते हैं। बेशक आप मैटलैब के अरब बिल्टइन फिट फंक्शंस में से एक का उपयोग कर सकते हैं (कैसे उबाऊ) जादू की छड़ी का उपयोग क्यों नहीं? =)

x = (-1:0.1:2)';
y = 3*x.^2-2*x+1+randn(size(x)); %add some gaussian (normal) noise
A = [x.^2,x,x.^0];
c = A\y              %output: c = ]3.0049; -2.3484; 1.1852]
plot(x,y,'x',x,A*c,'-')

linreg

स्निपेट 14 - रेखांकन

gplot(graph,x)

कि कैसे एक ग्राफ की साजिश है। graphएक वर्ग आसन्न मैट्रिक्स xहोना चाहिए और एक nx2 मैट्रिक्स होना चाहिए जिसमें प्रत्येक नोड के निर्देशांक शामिल हों। एक यादृच्छिक ग्राफ graph = triu( rand(8)>.7)बनाते हैं : (एक मैट्रिक्स बनाएं जिसमें 0s और 1s शामिल हों, एक दिलचस्प ग्राफ के लिए केवल ऊपरी त्रिकोण प्राप्त करें)। x = rand(8,2)फिर कुछ फैंसी शैलियों के साथ साजिशgplot(graph,x,'k-.d')

ग्राफ (मैं इसे आधुनिक कला घोषित करता हूं।)

स्निपेट 13 - मेषग्रिड

meshgrid(a,b)

यह सबसे अजीब कार्यों में से एक है, सरल लेकिन उपयोगी है। यदि आप दो चर के आधार पर एक वास्तविक मूल्यवान फ़ंक्शन को प्लॉट करना चाहते हैं, तो आप केवल x- अक्ष के लिए और y- अक्ष (a और b) के लिए मानों के वेक्टर को परिभाषित कर सकते हैं। फिर मेशग्रिड के साथ, आप आकार के दो मैट बना सकते हैं len (a) x len (b) जहां एक में केवल वेक्टर aही कॉलम के रूप में होता है, और दूसरे में केवल कॉलम bमें पंक्तियों के रूप में केवल वैक्टर होते हैं। उपयोग उदाहरण: a = -3:0.2:3;[x,y]=meshgrid(a)(यदि दोनों वैक्टर समान हैं, तो यह केवल एक पास करने के लिए पर्याप्त है।) फिर आप बस टाइप कर सकते हैं z=x.^2+-y.^2और जैसेmesh(x,y,z)। यह आयामों की एक मनमानी संख्या के लिए काम करता है! तो यह न केवल साजिश रचने के लिए, बल्कि विभिन्न वैक्टरों आदि के सभी संभावित संयोजनों को प्राप्त करने के लिए भी बहुत अच्छा है ... (इसलिए, यदि आप एक नया कोड गोल्फ भाषा बनाना चाहते हैं, तो यह वहां होना चाहिए, बस यह सुनिश्चित करें कि आप एक छोटे का उपयोग करें समारोह का नाम ...)

जाल

स्निपेट 12 - प्लॉटिंग

plot(x,x.^2)

एक वेक्टर लें x=-3:0.5:3और plotबाकी काम करें। साजिश रचने के लिए कई और कार्य हैं यह सिर्फ एक बहुत ही बुनियादी है जिसे आप हर समय उपयोग कर सकते हैं। यह लिखने के लिए पहले से ही पर्याप्त होगा plot(v)और डेटा vको सरणी सूचकांकों के खिलाफ प्लॉट किया जाएगा। कितना सरल है? यदि आप अपने प्लॉट को स्टाइल करना चाहते हैं, तो बस एक स्ट्रिंग को तीसरे तर्क के रूप में जोड़ें: जैसे 'r:o'डेटा बिंदुओं के चारों ओर हलकों के साथ एक लाल, बिंदीदार रेखा बना देगा। यदि आप एक से अधिक भूखंड चाहते हैं, तो बस अधिक तर्क जोड़ें, या वैक्टर के बजाय मैट्रिसेस का उपयोग करें। सरल।भूखंड

स्निपेट 11 - फ़ंक्शन हैंडल

f=@(x,y)x+y

यह एक फंक्शन हैंडल का एक उदाहरण है जो इसमें स्टोर हो जाता है f। अब आप कॉल कर सकते हैं f(1,2)और प्राप्त कर सकते हैं 3। गणित के कार्यों (जैसे प्लॉटिंग) के लिए मतलाब में फ़ंक्शन हैंडल बहुत उपयोगी होते हैं और आप उन्हें एक पंक्ति में परिभाषित कर सकते हैं। लेकिन एक दोष यह है कि आपके पास सशर्त या टुकड़े-टुकड़े (और इसलिए कोई पुनरावृत्ति नहीं) हो सकते हैं। यदि आप यह चाहते हैं, तो आपको functionस्टेटमेंट का उपयोग करना होगा और एक नया फ़ंक्शन घोषित करना होगा, और उनमें से प्रत्येक को एक अलग फ़ाइल में संग्रहीत करना होगा ... (WHYYYYYYY ????)

पुनश्च: यदि आप whyकंसोल में टाइप करते हैं तो आपको एक और मज़ेदार ईगस्टर अंडा मिलेगा : उन्होंने एक बहुत बड़ा फंक्शन किया, जो यादृच्छिक संदेश उत्पन्न करता है जैसे:

The tall system manager obeyed some engineer.
The programmer suggested it.
It's your karma.
A tall and good and not excessively rich and bald and very smart and good tall and tall and terrified and rich and not very terrified and smart and tall and young hamster insisted on it.

... यदि आप सांत्वना मांगने के लिए पर्याप्त हताश हैं, तो यह बहुत ही सुकूनदायक है why...

स्निपेट 10 - मेरा मैट्रिक्स कैसा दिखता है?

spy(eye(9))

जैसा कि आप अब तक जानते हैं eye(9)कि एक 9x9 पहचान मैट्रिक्स बनाता है। spyबस एक बनाता है जो मैट्रिक्स के शून्य / नॉनजरो प्रविष्टियों को दर्शाता है। लेकिन आप इसका उपयोग किसी भी बाइनरी 2 डी डेटा को प्रदर्शित करने के लिए भी कर सकते हैं। यदि आप spyतर्क के बिना फोन करते हैं तो आपको एक अच्छा सा ईस्टर अंडे मिलेगा)

पहचान पर जासूसी जासूस पूर्वी

स्निपेट 9

kron(a,b)

kronसमारोह का मूल्यांकन करता है क्रोनेकर उत्पाद दो मैट्रिक्स की। यह विवेकाधीन बहुआयामी रैखिक ऑपरेटरों के लिए बहुत उपयोगी है। मैंने इसे अब हर बार कोड गोल्फिंग के लिए भी इस्तेमाल किया। आप की प्रविष्टियों में से सभी संभव उत्पादों चाहते हैं aऔर b? kron(a,b), हेयर यू गो।

स्निपेट 8

5*a\b.*b

ठीक है यहाँ मैंने 3 अलग-अलग ऑपरेटर को मिलाया। आप किसी भी मैट्रिक्स को स्केलर द्वारा केवल उपयोग करके गुणा कर सकते हैं *। (फिर मैट्रिक्स की हर प्रविष्टि उस स्केलर से गुणा हो जाती है)। लेकिन *मैट्रिक्स गुणन भी करता है। यदि आप एक .*ऑपरेटर को प्रीपेड करते हैं, तो आपको ऑपरेटर मिलता है , यह एक ही आकार के दो मेट्रिलिस को गुणा करता है, लेकिन प्रवेश वार । (यह भी डिवीजन ऑपरेटरों जैसे /और के साथ किया जा सकता है \।)

इसके बाद, बैकस्लैश ऑपरेटर को लेफ्ट डिवीजन के रूप में इस्तेमाल किया जा सकता है (इसके विपरीत /जो आपके द्वारा उपयोग किए जाने के रूप में राइट डिवीजन करता है) लेकिन यह मैटलैब का सबसे शक्तिशाली और विशेषता ऑपरेटर भी है: यह एक 'मैट्रिक्स डिवीजन' करता है। कहते हैं कि आपके पास रैखिक समीकरणों की प्रणाली है A*x=bऔर आप इसे हल करना चाहते हैंx , तो आप बस टाइप कर सकते हैं x=A\b। और \(आप भी उपयोग कर सकते हैं /लेकिन यह मैट्रिसेस के लिए कम आम है) पहले मैट्रिक्स का जल्दी विश्लेषण करता है, और इस उलटा-गुणा करने के लिए सबसे तेज़ एल्गोरिदम खोजने के लिए परिणामों का उपयोग करता है! ( यहां देखें उदाहरण )

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

स्निपेट 7

[a,b;c]

ठीक है जो बहुत कुछ नहीं दिखता है, लेकिन यह एक बहुत ही सुविधाजनक उपकरण है: मैट्रिक्स संयोजन। दो अभिव्यक्तियों के बीच अल्पविराम का मतलब है कि वे क्षैतिज रूप से समवर्ती हो जाते हैं (इसका मतलब है कि उनके पास समान ऊंचाई है) और एक अर्धविराम का मतलब है कि पिछली 'रेखा' अगली 'रेखा' से ऊपर होगी (रेखा से मेरा मतलब है कि दो अर्धविराम से सब कुछ है। बस एक सरल उदाहरण: a = [1,2;3,4]; b = [5;6]; c =[7,8,9]; d=[a,b;c];d रूप में एक ही परिणाम होगा d=[1,2,5; 3,5,6; 7,8,9]?

छीन लिया ६

eye(7)

यह फ़ंक्शन पूर्ण 7x7 पहचान मैट्रिक्स का उत्पादन करता है। यह इतना आसान है। ऐसे अन्य कार्य हैं nan,inf,ones,zeros,rand,randi,randnजो उसी तरह काम करते हैं। (यदि आप दो तर्क पास करते हैं, तो आप परिणामी मैट्रिक्स की ऊंचाई / चौड़ाई निर्धारित कर सकते हैं।) जैसा कि मैं बाद में दिखाऊंगा, आप आसानी से बना सकते हैं (और बहुत ही दृश्य तरीके से) समरूप मेट्रिसेस (2d-arrays) जो बहुत उपयोगी है। और आसान है अगर आपको आंशिक अंतर समीकरणों को संख्यात्मक रूप से हल करना है। (जब आप पीडीई को हल करते हैं तो सामान्य दृष्टिकोण व्युत्पन्न ऑपरेटरों के विवेकहीन होता है, मूल रूप से आपको रैखिक समीकरणों की एक विशाल प्रणाली मिलेगी जिसे हल करने की आवश्यकता होती है। ये मैटर आमतौर पर विरल होते हैं (केवल बहुत कम गैर-शून्य तत्व होते हैं और कुछ प्रकार के होते हैं) समरूपता। इसीलिए आप आसानी से उस मैट्रिक्स को 'कंपोज़' कर सकते हैं जिसकी आपको आवश्यकता है।

स्निपेट 5

a(a>0.5)

मुझे आशा है कि आप सरणियों तक पहुँचने के सभी तरीकों से थक नहीं रहे हैं। यह एक सरणी के सभी तत्वों को प्राप्त करने का एक आसान तरीका दिखाता है जो कुछ शर्तों को पूरा करता है। इस स्थिति में आपको a0.5 से अधिक के सभी तत्वों का एक वेक्टर मिलता है । अभिव्यक्ति a>0.5बस एक ही आकार का एक मैट्रिक्स लौटाती है जो aप्रत्येक तत्व के लिए है जो स्थिति और एक को संतुष्ट करता है0 प्रत्येक तत्व के लिए जो नहीं करता है।

स्निपेट 4

a(:)

यह फिर से की सामग्री देता है a एक कॉलम वेक्टर (nx1 मैट्रिक्स) रूप । यह अच्छा है यदि आप नहीं जानते कि आपने अपना डेटा कॉलम या पंक्ति वेक्टर के रूप में संग्रहीत किया है, या यदि आपका डेटा दो आयामी है (उदाहरण के लिए 2d परिमित अंतर के तरीके)।

स्निपेट 3

1:9

आप आसानी से अर्धचालक ऑपरेटर के साथ वैक्टर (इस मामले में 1xn matrices) बना सकते हैं। इस मामले में आप वेक्टर प्राप्त करते हैं [1,2,3,4,5,6,7,8,9]। यह विशेष रूप से अन्य वैक्टर के स्लाइस तक पहुंचने के लिए अच्छा है, जैसे a(2:4)कि वेक्टर के दूसरे, तीसरे और चौथे तत्व तक पहुंचता है a। आप इसे स्टेप साइज के साथ भी इस्तेमाल कर सकते हैं, जैसे0:0.5:10 या तो।

स्निपेट 2

i;

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

स्निपेट 1

i

कॉम्प्लेक्स नंबर एक बेसिक नंबर टाइप होता है। (बहुत बुरे लोग iलूप के लिए एक गिनती के चर के रूप में उपयोग करते हैं , जिस स्थिति में यह ओवरराइड हो जाता है।)

पहचान

जो लोग नहीं जानते हैं, उनके लिए MatLab एक प्रोग्रामिंग लैंग्वेज (अच्छी IDE है जिसे MatLab भी कहा जाता है?) जो कि संख्यात्मक गणना * और डेटा हेरफेर के लिए सबसे पहले है। ("ऑक्टेव" नामक एक खुला स्रोत समकक्ष है) जैसा कि यह केवल ** की व्याख्या है यह बहुत तेज नहीं है, लेकिन यह ताकत है कि आप आसानी से मैट्रिसेस को हेरफेर कर सकते हैं और कई एल्गोरिदम को अनुकूलित तरीके से लागू किया जाता है जैसे कि वे बहुत तेजी से चलते हैं जब matrices पर लागू किया जाता है। यह सीखने के लिए एक बहुत आसान भाषा है, लेकिन मैं इसे स्टार्टर भाषा के रूप में अनुशंसित नहीं करता हूं क्योंकि आप बहुत खराब 'प्रोग्रामिंग' आदतों को मान लेंगे।

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

** आप अपने कार्यक्रमों को संकलित कर सकते हैं, लेकिन यह मुख्य रूप से स्रोत कोड को एक अपठनीय फ़ाइल (मनुष्यों के लिए) में परिवर्तित करता है, जो निष्पादित होने पर उतना तेज़ नहीं होता है।


1
मुझे यह समस्या बहुत बार होती है ... iकिसी चीज़ के लिए सेट करना और फिर जटिल इकाई नहीं होने पर अप्रत्याशित व्यवहार का अनुभव करना।
feersum

3
अच्छा ईस्टर अंडा! अगर आप 'एडिट जासूस' टाइप करते हैं, तो आपको कोड
ऑब्सफेकेशन

1
मैं इसे उभारने गया और तब मुझे एहसास हुआ कि मेरे पास पहले से ही है। काश, अगर केवल मैं इसे फिर से बढ़ा सकता था। "उन्हें आते रहो, @flawr!
एलेक्स ए।

2
यदि आप चीजों को दिखाने के लिए प्रेरणा से बाहर चल रहे हैं, तो मैं मैथवर्क्स ब्लॉग की सिफारिश कर सकता हूं : लोरेन वर्शुर द्वारा MATLAB की कला पर अक्सर वे सर्वश्रेष्ठ प्रथाओं का वर्णन करते हैं जिन्हें चरित्र सीमा के भीतर दिखाया जा सकता है। जिज्ञासाओं के लिए परित्याग
मतलूब

1
@flawr - फैक्टॉइड के लिए, यह इस तथ्य का उल्लेख करने के लिए अच्छा हो सकता है कि ऐतिहासिक रूप से, MATLAB मूल रूप से न्यू मैक्सिको विश्वविद्यालय में कंप्यूटर विज्ञान में छात्रों के लिए बनाया गया था (क्लीव मोलर उस समय अध्यक्ष थे) एक आसान इंटरफ़ेस के रूप में Linpack और EISPACK (... अब द्वारा ले जा रही LAPACK ) FORTRAN जानने के लिए बिना .... और इसके उपयोग में आसानी की वजह से, यह अन्य शैक्षणिक संस्थानों के लिए बहुत तेजी से फैली :)
rayryeng

35

CJam

नीचे दिए गए स्निपेट को यहाँ देखें

लंबाई 20 स्निपेट:

q~{]__~z\z<=\~*0>*}*

एक मिन-मॉड कैलकुलेटर । प्रश्न का एक अंश:

Minmod समारोह परिचित का एक संस्करण है मिनट है, जो आंशिक अंतर समीकरणों के लिए ढाल सीमित उच्च संकल्प योजनाओं में प्रकट होता है। कई ढलानों को देखते हुए, यह समतल ढलान को बाहर निकालता है, जबकि ढलानों के बीच सापेक्ष संकेतों का ध्यान रखता है।

फ़ंक्शन मापदंडों की एक मनमानी संख्या लेता है। फिर माइनमॉड (x 1 , x 2 , ..., x n ) को इस प्रकार परिभाषित किया गया है:

  • न्यूनतम (x 1 , x 2 , ..., x n ) , यदि सभी x i कड़ाई से सकारात्मक हैं
  • अधिकतम (x 1 , x 2 , ..., x n ) , यदि सभी x i कड़ाई से नकारात्मक हैं
  • , अन्यथा।

लंबाई 18 स्निपेट:

l'[,65>Dm>_el+_$er

एक ROT13 एनकोडर। a-zA-ZSTDIN के माध्यम से केवल इनपुट स्ट्रिंग से वर्णों को बदलता है

लंबाई 15 स्निपेट:

T1{_2$+}ri2-*]p

एक पूर्ण Nसंख्या को फाइबोनैचि श्रृंखला से मुद्रित करने के लिए एक पूर्ण कार्यक्रम जहां Nएसटीडीआईएन के माध्यम से इनपुट के रूप में प्रदान किया जाता है।

लंबाई 12 स्निपेट:

{{_@\%}h;}:G

एक साधारण जीसीडी फ़ंक्शन। इसका उपयोग 2706 410 Gजीसीडी को स्टैक पर प्राप्त करने के लिए किया जा सकता है ।

लंबाई 11 स्निपेट:

123456 789#

#बिजली ऑपरेटर है। यह स्निपेट सीजेएम की एक शांत विशेषता को दर्शाता है कि यह लगभग सभी गणितीय कार्यों के लिए बिगइंट का समर्थन करता है। तो उपरोक्त कोड का आउटपुट है

1596346205622537943703716803040694151242100030904924074732295184521676912291137885341977590649991707684635184329980991487148618486236239062505001539322685142817506810040361209550544146292158784625519911512640361780862459268161619223326802388689703997604303632605734938879647069477372395799326590488746599202521617640394227957532720581758771344616555153473551874187964029973716015080326283503474062024803237072761129557356772954771383125420283743787215768524095651476398918270831514362626616089349128838080859262141293069421199363839940462244772673481244848208112002212957221705577938865719802035511067875502253218277834350725436729497351901219311577128600087062378434520948898301738545267825952998284599001356281260973911216650526574435975050678439968995805415462116669892745933523276658479456263859786003695570642598885206779863730608803831608206418317758451327165760242416052588688579435998154295782751455020445483571514197850814391880423853968520336337963918534259580183058727377932419280412466915889059399591196961188841001024998633317094826403760131868252088477018937989608302521450181593409274231460335072324865982559395114735391976545471553525054490202974741119144469523879456646833238659929705233941114530149037245274032070536718197592615630616792756562341411027203615235147973615347081993563361626845258162606172599728677944001956482301240050182368840648532697569098833480384074404562991348377266778603059081932412368912313845464302833428950934701568958836851009236647605585910687215977468114323293396641238344799575626940766355697576957869656153567798618227770961980620119004224798449940378878601283741944503399682599666873704888519152796472231721010884561046439019823540214190109829183178504573391524533915085342799888899681052113605127068137552531204917650779012455136663716975904242872042805633443567570913936237754642040107392687168596924804730637819953463737212774674563401663682370631910559669378413063684132477269578881395521544729393136204246705936061735379354437327940116154383441927197123218522827575163913310005036963663583344508839784971260123709283218409462028161021477446586507813599051643059982983426688872855309396405653159417356549291603532443699350168178837164682957610433456205211423600319694496115159970718912091395232327389520091646132878609779171226748990343349416763319432268713023302555895744813731889452605219001900815755497209921418814092923394321459962373890912709775151652200071533644718727513889263907829300496554849544461628702471995210369421320165755673222520834013956492183306187393652197405863508709529644837118590847002900783148394313160749018413291215958936871830666201928218294362550829287373305552379418641499562597137520153409556227576809855521876196531587454478159211299517511047868125975115347272184123454929507976958328038242400918390689757262398695703472270927183494613959476164389143107240083171566284628032072645081703351075328092783401422849512230275075331561337345714881104575020436358133210849231625973013523497330004645467493618279226202227586584610761439335895760888873155403816627190368675397978355381544497413492223577022267403347927237298551052219150516984577176643706356698282552857754120841266435149587248192704898338826251727748499150285409036076919533685800933215325289882260771526293167171975367192287689881199864600661035143522211647660445960687046757311913589429739868592726372013684511683081229044622752191694278221303073075505531920922815724661725685493922212700535444400760813940151761980008355835574184921854364539924999643954874549857103642483664109073938527328920827803218865362851320233433429604394590974694396314165313743853607609394553133883545319222169958204731303672940856293527174545435349105954532301106962634516087237739490953930886293289854731305112253177512851251930821765454042415085420000484369355605183062368648992392499663861508991984554431113080399485470268940148600970493633737364443822752829774334511729579419931500217970224646496435527826186627011323464848141074486509849545954714213290443775688291020289759390171236344528896

लंबाई 10 स्निपेट:

"`%W_"_W%`

हम पहले ही कर चुके हैं, इसे उलटने दें! यह सीजेएम में सबसे छोटी रिवर्स क्वीन में से एक है। रिवर्स क्वीन एक ऐसी क्वीन है जो रिवर्स सोर्स में अपने सोर्स कोड को प्रिंट करती है।

लंबाई 9 स्निपेट:

5,K,+_&S*

इस स्निपेट ने CJam की कई विशेषताओं को प्रदर्शित किया,

5, "create an array of numbers 0 to 4"
K, "create an array of numbers 0 to 19"
+  "List concatination"
_  "Duplicate top stack element"
&  "Set distinct operator in this case"
S* "Join array elements with space character"

लंबाई 8 स्निपेट:

"`_~"`_~

CJam में सबसे छोटी संभव quines में से एक। यह इस मायने में एक सच्ची बात है कि यह वास्तव में किसी भी तरीके से स्रोत कोड को नहीं पढ़ता है। (स्रोत कोड पढ़ना CJam में भी संभव नहीं है)

लंबाई 7 स्निपेट:

"AB"_m*

m*शीर्ष दो स्टैक तत्वों के सभी कार्टेशियन उत्पादों को बनाता है। उदाहरण के लिए, उपरोक्त कोड ["AA" "AB" "BA" "BB"]स्टैक पर रखा जाएगा , जो कि कार्टेशियन उत्पाद है "AB"और "AB"

लंबाई 6 स्निपेट:

"_~"_~

एक अच्छा लग रहा दोहराया कोड। इसे न चलाएं :)। कोड का यह प्रतिनिधित्व CJam में सबसे सरल क्वीन का आधार है। आप "_~"स्टैक पर स्ट्रिंग डालते हैं , एक प्रतिलिपि बनाते हैं ( _) और इसका मूल्यांकन करते हैं। जब तक आप एक ही चीज़ को फिर से (और फिर से ..) नहीं करते हैं जब तक कि आप अधिकतम पुनरावृत्ति अपवाद तक नहीं पहुंचते हैं।

लंबाई 5 स्निपेट:

{A}:F

यह एक मूल फ़ंक्शन CJam में कैसे काम करता है, उपरोक्त अभिव्यक्ति {A}चर को कोड ब्लॉक प्रदान करती है F। अब आपके कोड में, आप Fकोड ब्लॉक को चलाने के लिए कहीं भी रख सकते हैं (और 10इस मामले में प्राप्त करें)

लंबाई 4 स्निपेट:

"A"~

आप किसी भी कोड ब्लॉक या स्ट्रिंग या एक भी वर्ण का उपयोग करके मूल्यांकन कर सकते हैं ~। उपरोक्त अभिव्यक्ति का परिणाम है10

लंबाई 3 स्निपेट:

Kmr

0 से लेकर K20 तक एक विशिष्ट यादृच्छिक संख्या जनरेटर ।

लंबाई 2 स्निपेट:

es

यह वर्तमान टाइमस्टैम्प (युग से मिलीसेकंड) देता है। CJam में etस्थानीय समय के लिए एक अधिक प्रयोग करने योग्य प्रारूप है जो एक सरणी देता है जिसमें वर्तमान समय के विभिन्न हिस्सों (दिन, घंटे आदि) शामिल होते हैं।

लंबाई 1 स्निपेट:

A

सीजेएम में पूर्वनिर्धारित चर के रूप में लगभग सभी पूंजी अक्षर हैं। A10, B11 और जब तक Kहै 20 Pहै pi (3.141592653589793), Nनई लाइन और है कई अन्य लोगों के । ये तब बहुत काम आ सकते हैं जब आपको चर में शुरुआती मूल्यों की आवश्यकता होती है, या तब भी जब आपको 1 बाइट में दो अंकों की संख्या की आवश्यकता होती है।

factoid

CJam, गोल्फस्क्रिप्ट से प्रेरित है, लेकिन इसके ऊपर बहुत सारी सुविधाएँ बनाता है, जिसमें एक नेटवर्क GET कॉल: D का समर्थन भी शामिल है

पुनश्च: मैं हर 5 अपवोट्स या हर 2 घंटे में उत्तर देने का प्रयास करूंगा (जो पहले कभी भी हो)


आपके ROT13 उदाहरण के साथ कुछ मुद्दे हैं: p लेकिन मैं क्वीन से प्रभावित हूं, मुझे लगता है कि मैं इसे उधार
लूंगा

@aditsu क्या मुद्दा है?
अनुकूलक

यह nz अक्षरों के मामले को बदल देता है। इसके अलावा, इसमें बिना किसी कारण के एक @ है, आप इसके बजाय डी डाल सकते हैं।
aditsu

@aditsu बहुत यकीन है कि एक Z-ZA-Z रेंज में इसकी ROT 13 है और यही मामला बदलने का कारण है। क्या आप इसे नहीं पढ़ सकते हैं? इसकी केवल आपकी अपनी भाषा: P @ 18 चरों के लिए है जो मुझे लगता है: D
ऑप्टिमाइज़र

ROT13 सामान्य रूप से ऐसा नहीं करता है। मुझे समझ नहीं आ रहा है कि आप यह क्यों पूछ रहे हैं कि क्या मैं अपनी भाषा पढ़ सकता हूं, मुद्दा यह समझने का नहीं है कि कार्यक्रम क्या करता है, बल्कि इस तथ्य के बारे में कि यह वह नहीं करता है जो अपेक्षित है।
17-04 को

34

आम लिस्प

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

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

लंबाई 1

*

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

लंबाई २

()

यह खाली सूची है, लिस्प में सबसे महत्वपूर्ण प्रतीकों में से एक है। लिस्प में हर उचित सूची को एक खाली सूची के साथ समाप्त किया जाता है, सी के हर उचित स्ट्रिंग के साथ कैसे समाप्त होता है \0

लंबाई ३

(*)

यह एक बुनियादी फ़ंक्शन कॉल है, जिसमें कोष्ठकों में लिपटे एक प्रतीक होते हैं। लिस्प में ऑपरेटर नहीं होते हैं, वे सिर्फ कार्य करते हैं। मैंने गुणा को विशेष रूप से उठाया क्योंकि यह वास्तव में एक बाइनरी फ़ंक्शन नहीं है; लिस्प में गुणन संचालक अनिश्चित संख्या में तर्क लेता है। यदि इसे कोई तर्क नहीं दिया जाता है 1, तो यह गुणन के लिए पहचान ऑपरेटर है।

लंबाई ४

`(1)

यह एक व्यंजन कोशिका है, जो यह कहने का एक और तरीका है कि यह तत्वों की एक जोड़ी है। लिस्प में, प्रत्येक सूची में कॉन्स सेल्स से जुड़े कॉन्स सेल्स होते हैं, जहां पहला एलीमेंट (a car) वैल्यू होता है और दूसरा एलिमेंट ( cdr) अगले कॉन्स सेल की ओर इशारा करता है। यह लिस्ट का आधार लिंक की गई सूचियों पर आधारित है। इस विशेष वाणिज्य सेल में 1कार और खाली सूची के रूप में सीडीआर है।

लंबाई 7

(not t)

मैं लिस्प में सत्य मूल्यों को छूना चाहता हूं। यह वापस आ जाएगी nil। कॉमन लिस्प में, tसच थोड़ी देर के लिए प्रतीक है nilऔर ()झूठे प्रतिनिधित्व करते हैं और एक दूसरे के बराबर हैं, लेकिन ध्यान दें कि इस परिभाषा सभी लिस्प बोलियों के लिए मानक नहीं है, योजना, उदाहरण के लिए, #fझूठी और '()खाली सूची के बीच अंतर करती है ।

लंबाई ९

(cdr ())

जैसा कि मैंने पहले कहा, सीडीआर एक सूची का पूंछ तत्व है, जिसे आप फ़ंक्शन के साथ प्राप्त कर सकते हैं cdr। इसी तरह, आप फ़ंक्शन के साथ सिर तत्व, कार प्राप्त कर सकते हैं car। बहुत आसान है, है ना? खाली सूची की कार और सीडीआर दोनों हैंnil

लंबाई १०

(cons 1 2)

अंत में, सूचियों के साथ काम करना शुरू करने के लिए पर्याप्त लंबाई। consकार के रूप में पहले पैरामीटर के साथ एक कॉन्स सेल बनाता है और दूसरा सीडीआर के रूप में। लेकिन प्रिंट आउट के बजाय (1 2)यह देता है (1 . 2)। लंबाई 2 स्निपेट पर वापस जाने पर, खाली सूची के साथ एक उचित सूची समाप्त होनी चाहिए, इसलिए अंतिम कंसोल सेल के सीडीआर को खाली सूची को इंगित करना चाहिए। इस मामले में, अंतिम कॉन्स सेल इंगित करता है 2, इसलिए लिस्प हमें सूचित करता है कि हमारे पास एक अनुचित सूची है, लेकिन फिर भी हमें यह करने की अनुमति देता है, जैसे कि आप बिना सी-स्ट्रिंग कैसे बना सकते हैं \0

लंबाई ११

(cons 1 ())

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

लंबाई १२

(cdr `(1 2))

यह आउटपुट होगा (2), 2जैसा कि कुछ लोग अनुमान नहीं लगाते हैं। याद रखें, प्रत्येक सीडीआर को किसी अन्य कंसोल या खाली सूची को इंगित करना चाहिए; स्पष्ट रूप 2से खाली सूची नहीं है, इसलिए यह एक अन्य कॉन्स सेल होनी चाहिए, जिसमें से एक कार 2और एक सीडीआर है()

लंबाई १३

'#1=(1 . #1#)

यह केवल एक मान के साथ एक गोलाकार सूची का उत्पादन करेगा। यदि मुद्रित किया गया है, तो यह "(1 1 1 1 ..." हमेशा के लिए प्रिंट होगा, ताकि व्यवहार में इसे एक अनंत सूची माना जा सके (जिस पर आप cdrअनंत बार कर सकते हैं हमेशा एक ही परिणाम प्राप्त करने के लिए, अपने आप को!) जब तक कोई Tवैश्विक वैरिएबल को असाइन नहीं करता है *print-circle*, उस स्थिति में इसे मुद्रित किया जाएगा #1=(1 . #1#)


वह आखिरी संपादन! त्वरित, कोई बीटल्स-थीम वाला एसोलैंग बनाता है: डी
एस।

1
@fedes। जॉन मैक्कार्थी, पॉल मेकार्टनी ... भाषा को कार्थकार्टनी कहा जाएगा।
बिल्ली

33

GNU मेक

मैं इस एक अंग पर बाहर जाऊँगा। मुझे लगता है कि यह पहली बार हो सकता है कि makeपीपीसीजी में चित्रित किया गया है।

factoid

मेक को एक कार्यात्मक भाषा माना जा सकता है।

लंबाई 0 स्निपेट

मुझे नहीं लगता कि लंबाई 0 स्निपेट की आवश्यकता है, लेकिन यहाँ एक वैसे भी है। मुझे लगता है कि यह सभी लंबाई 0 कार्यक्रमों में सबसे उपयोगी हो सकता है। एक खाली मेकफाइल (या यहां तक ​​कि कोई मेकफाइल नहीं) के साथ, अभी भी अंतर्निहित नियमों का एक गुच्छा है। जैसे वर्तमान निर्देशिका में मौजूद .c फ़ाइल को .c फ़ाइल या बाइनरी में संकलित करने के लिए डिफ़ॉल्ट अंतर्निहित नियम हैं। तो अगर हम करते हैं:

make hello.o

बनाने के लिए .c से .o नियम मिलेगा और hello.o देने के लिए hello.c संकलित करेंगे

इसी तरह अगर हम करते हैं:

make goodbye

यदि वर्तमान निर्देशिका में कोई अलविदा फ़ाइल है तो इसे अलविदा बाइनरी में संकलित किया जाएगा।

लंबाई 1 स्निपेट

TAB

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

लंबाई 2 स्निपेट

$@

यह व्यंजनों में उपयोग के लिए एक स्वचालित चर है। यह नियम के लक्ष्य के फाइलनाम तक विस्तारित होगा। कर रहे हैं अन्य उपयोगी स्वत: चर

लंबाई 3 स्निपेट

a:=

सबसे छोटा बस चर असाइनमेंट का विस्तार किया। वैरिएबल को पहली बार पार्स किए जाने के तुरंत बाद वेरिएबल सेट कर दिया जाता है। यदि इसके बजाय हम करते हैं a=, तो असाइनमेंट का पुन: विस्तार किया जाता है, अर्थात जब तक कि वास्तव में चर को संदर्भित नहीं किया जाता है, तब तक विस्तार को स्थगित कर दिया जाता है।

लंबाई 4 स्निपेट

W:;w

सबसे छोटा मामूली उपयोगी पूर्ण नियम विनिर्देश। यह एक लक्ष्य के Wसाथ एक लक्ष्य को परिभाषित करता है जो केवल wशेल कमांड चलाता है । इस प्रकार

make W

के बराबर है:

w

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

लंबाई 5 स्निपेट

$(@D)

एक और स्वचालित चर। के समान है $@, लेकिन यह फ़ाइल नाम और अनुगामी / निकाले जाने के साथ पथ के निर्देशिका भाग में फैलता है।


शायद कुछ स्ट्रिंग फ़ंक्शंस जैसे $(basename )या $(patsubst )? ( जैसे। )
लूजर

32

Marbelous

लंबाई 14 स्निपेट

}0}1
Mulx
HxHx

यह स्निपेट मारबेलस लाइब्रेरी के कुछ और हिस्सों को दिखाता है और एक नई अवधारणा का परिचय देता है, जिसका नाम है, मल्टी-सेल बोर्ड। Mulxसभी स्तरों पर इनपुट के रूप में दो पत्थर ले जाता है और 2 पत्थर आउटपुट। मार्बल्स जो Mulxवसीयत के बाएं सेल में प्रवेश करते हैं }0, उस बोर्ड के उपकरणों और सबसे सही सेल के अनुरूप होंगे }1। आमतौर पर, आउटपुट अलग-अलग कोशिकाओं से भी निकलेंगे। एक बोर्ड की चौड़ाई के रूप में गणना की जा सकती हैMAX(1, highest output device + 1, highest input device + 1) कोशिकाओं के है, जो इनपुट डिवाइस के अनुरूप नहीं हैं, जो किसी भी संगमरमर को उन पर गिर जाएगी।

लंबाई 13 स्निपेट

7E
??
>Y!!
{0

यह एक ऐसा बोर्ड है जो प्रत्येक टिक पर एक यादृच्छिक प्रिंट करने योग्य अस्की चरित्र को थूक देगा। Marbelous यादृच्छिक मान उत्पन्न करने के दो तरीके हैं। वहाँ है ??जो 0 और इनपुट मार्बल के बीच एक यादृच्छिक मान देता है, जो क्रमशः प्राप्त होता है, और ?n: ?0तक ?Z। जो बहुत ही समान कार्य करते हैं ??। हमारे पास वह भी है !!जो बोर्ड को समाप्त करता है, भले ही सभी आउटपुट भरे हुए न हों। क्या आप यह पता लगा सकते हैं कि ?nमारबेलस के उपयोग से बोर्ड के रूप में उपकरणों को कैसे लागू किया जा सकता है ???

लंबाई 12 स्निपेट

}0}1
Fb//
Dp

यहाँ हम कार्रवाई में Marbelous के कुछ पुस्तकालय कार्यों को देखते हैं। Fbजहाँ n n इनपुट मार्बल है, nth रिट्रेसमेंट संख्या को आउटपुट करता है। Dpदशमलव के रूप में STDOUT में इनपुट मार्बल प्रिंट करता है। इन दोनों को मारबेलस में लागू किया गया है और जब आप चेक करते हैं तो ऑनलाइन इंटरप्रेटर में लाइब्रेरी शामिल कर सकते हैं , अजगर इंटरप्रेटर के लिए, आपको प्रत्येक फ़ाइल को स्पष्ट रूप से शामिल करना होगा। इन बोर्डों के कार्यान्वयन को जीथब पर पाया जा सकता है । ध्यान दें कि यह विशेष कार्यक्रम 2 इनपुट लेता है और फाइबोनैचि बोर्ड को दो बार कॉल करेगा। जिन बोर्डों को बुलाया जाता है वे बोर्ड के एक टिक के भीतर वापस आ जाते हैं जो उन्हें कहते हैं।

लंबाई 11 स्निपेट

}0}0
{<{0{>

यह कुछ स्पष्टीकरण की जरूरत है। }0उपकरणों, imputs हैं, क्योंकि वे एक ही नंबर (0) है, वे एक ही मूल्य में शामिल होंगे जब इस बोर्ड बुलाया जाता है। निचली पंक्ति के तीन उपकरण आउटपुट हैं। {<बोर्ड के बाईं ओर {0आउटपुट , बोर्ड के पहले सेल के नीचे {>आउटपुट और दाईं ओर आउटपुट। आउटपुट को केवल तभी धक्का दिया जाता है जब सभी अलग-अलग आउटपुट डिवाइस भरे जाते हैं। हालांकि इस मामले में, सही आउटपुट डिवाइस कभी नहीं पहुंचता है। गतिविधि की कमी के कारण बोर्ड बाहर निकल जाएगा और वैसे भी दो मूल्यों का उत्पादन करेगा। क्या आप सोच सकते हैं कि कोई /\एक मारबेलस बोर्ड के रूप में कैसे लागू हो सकता है ?

लंबाई 10 स्निपेट

..40
FF
\\

वहाँ कुछ चीजें हैं जो यहाँ Marbelous में एक महत्वपूर्ण भूमिका निभाती हैं। सबसे पहले, इसके अलावा है। यदि आप बोर्ड पर दो मार्बल्स का मार्ग ट्रेस करते हैं, तो आप देखेंगे कि वे एक ही समय में एक ही सेल पर समाप्त होंगे। जब ऐसा होता है, तो उन्हें एक साथ जोड़ा जाएगा। (मजेदार तथ्य: कुछ बिंदु पर यह माना जाता था कि एक साथ जोड़े जाने के बजाय, मार्बल्स को एक स्टैक का रूप देना चाहिए) हालांकि, मारबेलस एक 8 बिट भाषा है, इसलिए इसमें से संगमरमर को जोड़ना FF1 से घटाना बराबर है।

लंबाई 9 स्निपेट

00
\\/\]]

यह मारबेलस में बिल्ली के अल्पविकसित संस्करण को लागू करने का सबसे छोटा तरीका है। 00 \ / \ एक लूप है जो डिवाइस पर हर दूसरे टिक 00पर एक मूल्य संगमरमर डालता है ]]। यह एक STDIN डिवाइस है। जब इस उपकरण पर एक संगमरमर की भूमि होती है, तो यह STDIN के पहले चरित्र को पढ़ने की कोशिश करता है, अगर वहाँ एक है, तो इसे नीचे धकेल दिया जाता है (और इस मामले में फिर से मुद्रित होता है)। यदि कोई नहीं है, तो मूल amrble दाईं ओर धकेल दिया जाता है। (और इस मामले में ट्रैश किया गया)

लंबाई 8 स्निपेट

}0
~~
{0

यह स्निपेट कुछ विशेषताएं दिखाता है। सबसे पहले यह} 0 के माध्यम से इनपुट लेता है। इस मामले में यह मुख्य बोर्ड है और इसे कमांड लाइन इनपुट द्वारा प्रतिस्थापित किया जाएगा। आप इस फ़ंक्शन को भी कॉल कर सकते हैं, उस स्थिति में, कमांड लाइन इनपुट के बजाय तर्क लिया जाएगा। फिर वहाँ है ~~, जो एक बिटवाइज़र नहीं ऑपरेटर है। उसके बाद, हम करने के लिए मिलता है }0, यदि सभी }nडिवाइस भरे हुए हैं, इन मानों को फ़ंक्शन रिटर्न मान के रूप में लौटाया जाता है। (Marbelous प्रति फ़ंक्शन एक से अधिक वापसी मान का समर्थन करता है)

लंबाई 7 स्निपेट

00
\\/\

यह सबसे कॉम्पैक्ट अनंत लूप है जिसे आप मारबेलस में बना सकते हैं। \\डिवाइस सही करने के लिए किसी भी संगमरमर धक्का, /\प्रतियां एक संगमरमर और सही करने के लिए छोड़ दिया और एक से दूसरे की नकल धक्का। चूँकि बोर्ड केवल दो कोशिकाएँ चौड़ी होती हैं, दाहिनी ओर का संगमरमर यद्यपि धराशायी हो जाता है।

लंबाई 6 स्निपेट

46MB75

यहाँ पुनरावृत्ति का एक उदाहरण है, MB(मुख्य रूप से नामांकित मुख्य बोर्ड को हर टिक पर बुलाया जाता है, लेकिन Fuप्रत्येक कॉल पर STDOUT पर प्रिंट करने से पहले नहीं । परिणाम के रूप में निम्न में: FuFuFuFuFuFu...यह स्पष्ट रूप से कॉलस्टाप को ओवरफ्लो करता है।

लंबाई 5 स्निपेट

2A
++

कुछ अंकगणितीय, द मार्बल विथ वैल्यू 2Aनीचे गिरता है और पहले ++सेल पर टिक पाता है । यह एक ऑपरेटर है। यह विशेष ऑपरेटर किसी भी संगमरमर को बढ़ाता है जो उस पर उतरता है और इसे नीचे गिरने देता है। संगमरमर में अब मूल्य है 2Bऔर बोर्ड से गिर जाता है। यह +STDOUT को प्रिंट करता है।

लंबाई 4 स्निपेट

:
24

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

लंबाई 3 स्निपेट

:Bo

यह एक नामित बोर्ड है, जिसमें कोई निकाय नहीं है, हम इस बोर्ड Boको किसी भी बोर्ड ( Boस्वयं सहित ) के सेल में लिखकर कॉल कर सकते हैं

लंबाई 2 स्निपेट

3A

यह कोड 1x1 सेल का शरीर है (प्रत्येक सेल दो अक्षर चौड़ा है) बोर्ड, जिसका MBमुख्य रूप से नाम (मुख्य बोर्ड के लिए) है। यह हेक्साडेसिमल के एससीआई मूल्य को प्रिंट करता है 3Aजब संगमरमर बोर्ड से गिरता है। इस कार्यक्रम का आउटपुट सिर्फ इतना है कि इसका स्रोत कोड क्या है:

लंबाई 1 स्निपेट

:

इसके साथ ही #, यह दो में से एक वैध 1 चरित्र कार्यक्रम है। #बहुत दिलचस्प नहीं एक टिप्पणी का एक संकेतक है। :यह बताता है कि आप एक बोर्ड घोषित करने वाले हैं। न तो दो संकलक देखभाल करते हैं कि आप वास्तव में बोर्ड का नाम या परिभाषित नहीं करते हैं। कार्यक्रम कुछ भी नहीं करता है।

factoid:

इस साइट पर लोगों द्वारा मारबेलस को विकसित किया गया था, कुछ नाम जो इस भाषा के लिए चल रहे थे वे थे रुब और बस मार्बल्स


2
मुझे इससे हराएं। अच्छा स्निपेट!
Sparr

आपकी लंबाई 12 स्निपेट में दो इनपुट लगते हैं, और दो अलग-अलग संख्याओं को प्रिंट करते हैं। क्या वह जानबूझकर था?
शुक्राणु

@ शेपर, हां यह प्रदर्शित करना था कि मारबेलस में फ़ंक्शन कैसे काम करता है।
ओवरएक्टर

शायद स्पष्टीकरण में जोड़ें? आपने जो लिखा है, उससे मुझे उम्मीद है कि स्निपेट एक इनपुट लेगा और एक फ़ाइब नंबर आउटपुट करेगा।
20

मुझे वास्तव में उम्मीद है कि आपको 40 अंक मिलेंगे, इसलिए मेरा
रिटायरमेंट

31

आगे

फोर्थ में केवल दो प्रकार होते हैं, इन्टस और फ्लोट्स (और फ्लोट्स वैकल्पिक होते हैं!) लेकिन यह अभी भी चार्ट्स, स्ट्रिंग्स, लॉन्ग लॉन्ग इनट्स, पॉइंटर्स, फंक्शन पॉइंटर्स, स्ट्रक्चर्स और बहुत कुछ मैनेज करता है। यह सब है कि आप इसका उपयोग कैसे करते हैं!

लंबाई 1

.

.आदेश (या "शब्द" जैसा कि हम इसे कहते हैं) डेटा ढेर के शीर्ष पर पूर्णांक मान बाहर मुद्रण करता है; यदि स्टैक खाली है, तो आपको एक रनटाइम त्रुटि मिलती है। यह स्टैक से मूल्य को भी हटा देता है - अपवोट यह देखने के लिए कि हम इसे कैसे रख सकते हैं!

लंबाई २

.s

.s शब्द स्टैक पर वर्तमान में उन मूल्यों को प्रदर्शित करता है, जिनमें से किसी को भी हटाए बिना। यह मानों की कुल संख्या भी प्रदर्शित करता है। Gforth में, .sकेवल 9 शीर्ष मानों को दिखाने के लिए डिफ़ॉल्ट रूप से सीमित है; शायद हमें पता चलेगा कि और कैसे दिखाना है?

लंबाई ३

see

प्रकार seeउस शब्द के स्रोत कोड को देखने के लिए किसी भी फोर्थ शब्द के बाद । अधिकांश फोर्थ शब्द फोर्थ में ही परिभाषित किए गए हैं, और विधानसभा में केवल कुछ आदिम परिभाषित किए गए हैं।

लंबाई ४

1 0=

क्या मैंने उल्लेख किया है कि फोर्थ पोस्टफिक्स ऑपरेटरों के साथ एक स्टैक-आधारित भाषा है? टाइपिंग स्टैक पर 1 0=धकेलती है 1और फिर 0=शब्द को निष्पादित करती है, जो स्टैक से शीर्ष मान को पॉप करता है और trueयदि यह 0 के बराबर होता है, falseतो यह पुश नहीं करता है। 0=के लिए एक सुविधा शब्द है 0 =; सामान्य मूल्य + शब्द संयोजन, जैसे 1+और इसके लिए कई शॉर्टहैंड शब्द हैं 0<>। इसके अलावा, जबकि falseफोर्थ में 0 है और कोई भी नॉनजेरो वैल्यू सही है, बिल्ट-इन टेस्ट शब्द trueसही परिणाम के लिए लौटते हैं , और trueसभी तरह से चलते हैं - यह सभी बिट्स सेट के साथ वैल्यू है, यानी -1!

लंबाई ५

-1 u.

-1स्टैक पर पुश करें , फिर इसे पॉप करें और इसे अहस्ताक्षरित पूर्णांक के रूप में प्रिंट करें। यह फोर्थ के अपने संस्करण पर एक अहस्ताक्षरित int के लिए अधिकतम मूल्य को जल्दी से देखने के लिए इस्तेमाल किया जा सकता है (लेकिन मूल रूप से समर्थन करने वाले अधिकतम अभिन्न मूल्य नहीं!)। आप पूछ रहे होंगे, "हमें कैसे पता चलेगा कि कब इंट के साथ प्रिंट होना चाहिए .और कब होना चाहिए u.?" उत्तर: .जब यह हस्ताक्षरित हो, u.जब अहस्ताक्षरित हो। "ऐसा मेरा मतलब नहीं है," आप कहते हैं। "हमें कैसे पता चलेगा कि स्टैक के शीर्ष पर मूल्य कब हस्ताक्षरित है और जब यह अहस्ताक्षरित है?" उत्तर: आप प्रोग्रामर हैं - यह आपका काम है! आपको यह जानना होगा कि स्टैक पर प्रत्येक पूर्णांक एक int, अहस्ताक्षरित int int*, a, a का प्रतिनिधित्व करता हैchar*, एक फ़ंक्शन पॉइंटर, या अन्य, या फिर आप अपनी नाक में राक्षसों को प्राप्त करते हैं। फोर्थ आपके लिए उस पर नज़र रखने वाला नहीं है; यह क्या है, सी?

लंबाई ६

." Hi"

प्रिंट करता है Hi."एक फोर्थ शब्द है (जो, सभी फोर्थ शब्दों की तरह, व्हॉट्सएप या ईओएफ द्वारा पीछा किया जाना चाहिए) जो अगले के माध्यम से इनपुट स्ट्रीम को पढ़ता है "और बीच में किसी भी बाइट को प्रिंट करता है। यदि आप एक से अधिक स्थान रखते हैं .", तो सभी लेकिन ."वसीयत के तुरंत बाद का स्थान मुद्रित किया जाएगा। एस्केप सीक्वेंस समर्थित नहीं हैं (इसलिए आप "इसके साथ एक स्ट्रिंग नहीं प्रिंट कर सकते हैं ."), लेकिन Gforth .\"भाषा में जोड़ता है, जो उनका समर्थन करता है।

लंबाई 7

: + - ;

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

नोट: कुछ शब्द अन्य शब्दों की परिभाषाओं के अंदर अलग-अलग चीजें करते हैं, जितना कि वे बाहर करते हैं, लेकिन नियंत्रण संरचनाओं के अलावा, वे सभी बहुत गूढ़ हैं। अधिकांश शब्द एक परिभाषा के अंदर एक ही चीज़ को बाहर की तरह करते हैं, लेकिन कभी-कभी यह बात स्पष्ट नहीं होती है - : show-see see see ;आप जो सोचते हैं वह नहीं करेंगे!

लंबाई 8

: 42 - ;

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

लंबाई ९

IF 1 THEN

अंत में , कुछ परिचित! जाहिर है, इस कोड का परीक्षण करता है कि क्या इसका तर्क 1सही है और यदि हां, तो जो कुछ भी THENसही है , उसे निष्पादित करता है ? गलत। जब निष्पादन तक पहुँच जाता है IF, तो स्टैक के शीर्ष पर मौजूद मान बंद हो जाता है, और यदि वह मान सत्य है (यानी, नॉनज़रो), तो निष्पादन जो कुछ भी अंदर है IF ... THENऔर फिर जो कुछ भी है उसके बाद भी जारी रहता है THEN; यदि मान शून्य है, तो हम सीधे बाद में छोड़ देते हैं THEN। ध्यान दें कि, इन शब्दों को आंतरिक रूप से कैसे लागू किया जाता है (जो अन्य फोर्थ शब्दों के संदर्भ में है!), IFऔर THENइसका उपयोग केवल एक शब्द परिभाषा के अंदर किया जा सकता है, न कि "व्याख्या की स्थिति" में।

लंबाई १२

( x y -- y )

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

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

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

लंबाई १३

1 2 3 4 d+ d.

जैसा कि पहले संकेत दिया गया है, एक फोर्थ वैल्यू का प्रकार यह है कि आप इसे कैसे उपयोग करते हैं - यदि आप एक पॉइंटर के रूप में मान लेते हैं, तो यह एक पॉइंटर है, और यदि वह मान एक अच्छा पॉइंटर नहीं है , तो इसे एक मानने के लिए यह आपकी गलती है। हालाँकि, इस बात पर ध्यान दिए बिना कि आप किस प्रकार का मान ले रहे हैं, यह हमेशा डेटा स्टैक पर एक सेल लेगा; अपवाद डबल सेल या डबल सटीक पूर्णांक हैं । ये पूर्णांक हैं जिन्हें स्टैक पर दो मानों द्वारा दर्शाया गया है, जिससे आप सामान्य रूप से दो बिट्स के साथ अंकगणितीय प्रदर्शन कर सकते हैं। अधिक महत्वपूर्ण या उच्च-बिट सेल को कम महत्वपूर्ण या निम्न-बिट एक के ऊपर रखा जाता है, ताकि 1 0डबल सेल प्रतिनिधित्व 1और0 1या तो 2 ^ 32 या 2 ^ 64 है, यह इस बात पर निर्भर करता है कि आपके फोर्थ की नियमित कोशिकाएं कितनी बड़ी हैं। स्वाभाविक रूप से, एक डबल-सेल मान का इलाज करने के लिए, हमें उन शब्दों का उपयोग करने की आवश्यकता है जो स्पष्ट रूप से डबल-सेल मानों पर काम करते हैं; ये आम तौर पर सिर्फ d(या udअहस्ताक्षरित के लिए) होते हैं, जिसके बाद संबंधित एकल-कोशिका शब्द का नाम होता है: d+इसके अलावा, d<तुलना के लिए, d.छपाई के लिए, आदि।


फोर्थ के लिए +1। मैं उन भाषाओं की तलाश शुरू कर रहा था जो अभी तक नहीं हुई थीं। पहले ही यहां देख कर खुशी हुई।
mbomb007

2
इसके अलावा, अगर आप कभी भी +1675 पर जाते हैं, तो मुझे आउटपुट के लिए एक अच्छी ASCII छवि मिली है। : D
mbomb007

31

Pyth

आगे के स्निपेट्स के लिए, मैं गोल्फ चुनौतियों के समाधान और समस्या की एक कड़ी पोस्ट करूंगा।

लंबाई 17:

<ussC,cG\_GUQ*zQQ

nइनपुट स्ट्रिंग को हमेशा के लिए दोहराते हुए गठित अनंत अनुक्रम के पहले वर्णों का पता लगाएं , फिर अनुक्रम के साथ अपने अंडरस्कोर को भरना, फिर उस हमेशा के लिए दोहराएं।

रिक्त स्थान भरें

लंबाई 14:

#QX=Qhf>FT.:Q2

अद्वितीय तत्वों की सूची को देखते हुए, सभी मध्यवर्ती परिणामों को प्रिंट करते हुए, पड़ोसी तत्वों के जोड़े को स्वैप करके सूची को सॉर्ट करें।

क्रम में संख्याओं का एक सेट पुनर्व्यवस्थित करना

लंबाई 13:

?hu]+HG_UQYQY

निम्नलिखित संरचना बनाएँ [0, [1, [2, [3]]]]:।

सूचियों की सीमा पर घर

लंबाई 12:

uxyG*HQjvz2Z

XOR गुणन।

XOR गुणन

लंबाई 11:

lfqSzST.:wz

गणना करें कि पहले शब्द के कितने सब्सट्रिंग्स दूसरे शब्द के एनाग्राम हैं।

अभिभावक स्ट्रिंग के भीतर विपर्यय का पता लगाना

लंबाई 9:

fqJjQT_J2

सबसे निचला आधार ढूंढें जिसमें इनपुट एक पैलिंड्रोम है।

सबसे निचला-आधार पैलिंड्रोम

लंबाई 5:

!%lQ1

जांचें कि क्या इनपुट 2 की शक्ति है। लॉग बेस 2 को लें, परिणाम मॉड 1 लें, और तार्किक को न लें।

जांचें कि क्या पूर्णांक +, - संचालन का उपयोग किए बिना 2 की शक्ति है

लंबाई 4:

sjQ2

इनपुट के आधार 2 प्रतिनिधित्व को जोड़कर इनपुट के हैमिंग वजन की गणना करता है।

अहस्ताक्षरित 16 बिट पूर्णांक में लोगों की संख्या की गणना करें

लंबाई 3:

^G2

^ अनुक्रम पर, इंट, पहले तर्क के कार्टेशियन उत्पाद को स्वयं n समय के साथ देता है, जहां n दूसरा तर्क है।

इस मामले में, चूंकि Gवर्णमाला है ( abcdefghijklmnopqrstuvwxyz), ^G2सभी 2 अक्षर तार देता है, के aaमाध्यम से zz

लंबाई 2:

lT

l, जबकि सामान्य रूप से सेवारत len(), का उपयोग लॉग बेस 2 के रूप में भी किया जा सकता है। चूंकि Tयह वेरिएबल इनिशियलाइज्ड है 10, यह प्रिंट 3.3219280948873626, लॉग बेस 2 का 10 है।

लंबाई 1:

H

HPyth में खाली शब्दकोष (हैश-टेबल) है, और Pyth में एक शब्दकोश प्राप्त करने का एकमात्र तरीका है, v(eval) या $(पायथन शाब्दिक) का उपयोग करने से कम ।

factoid:

पायल में शाब्दिक के अलावा कोई बहु-चरित्र निर्माण नहीं है। इसके अलावा, पायथन अनिवार्य रूप से पायथन में एक-से-एक संकलन करता है।


इससे पहले कि आपके आदेशों के साथ आपका फैक्टॉइड जोड़ा गया था .?
लीक नून

@LeakyNun हां ..
isaacg
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.