सीजेएम में गोल्फ के लिए टिप्स

43

CJam एक गोल्फस्क्रिप्ट-प्रेरित स्टैक-आधारित गोल्फिंग भाषा है, जो PPCG उपयोगकर्ता aditsu द्वारा बनाई गई है ।

तो, अन्य भाषा-विशिष्ट युक्तियों के सवालों की नस में:

सीजेएम में गोल्फ के लिए आपके पास क्या सामान्य सुझाव हैं? कृपया प्रति उत्तर एक टिप पोस्ट करें ।

code-golf  tips  cjam 
— मार्टिन एंडर
स्रोत
4
गोल्फस्क्रिप्ट में गोल्फ के लिए टिप्स भी देखें ; भाषाएं समान हैं कि कई तरह के ट्रिक्स को किसी भी तरह से अनुकूलित किया जा सकता है।
— इल्मरी करोनन
2
@IlmariKaronen उस प्रश्न के उत्तर से गुजरने के बाद, मैं कहूंगा कि उनमें से लगभग आधे लोग भाषाओं में वाक्य रचना या तार्किक अंतर के कारण CJam पर लागू होते हैं।
— ऑप्टिमाइज़र

जवाबों:

23

नकारात्मक संख्याओं के लिए सही मोडुलो

यह अक्सर कष्टप्रद होता है कि मोडुलो ऑपरेशन का परिणाम पहले ऑपरेंड के समान संकेत देता है। जैसे की जगह -5 3%देता -2है 1। अधिक बार आप बाद वाले को नहीं चाहते हैं। भोली तय है modulo लागू करने के लिए, भाजक एक बार जोड़ने और modulo फिर से लागू:

3%3+3%

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

3,=

के लिए लागू -5, यह 1उम्मीद के मुताबिक देता है। और यह बिल्ट-इन से केवल एक बाइट लंबा है %!

यदि मापांक 2 की शक्ति है, तो आप बिटवाइज़ एरीथिमिक (जो बहुत तेज़ भी है) का उपयोग करके एक और बाइट बचा सकते हैं। की तुलना करें:

32,=
31&

65536 == 2^16एक अन्य बाइट के विशेष मामले के लिए चरित्र प्रकार के रैपिंग व्यवहार का उपयोग करके बचाया जा सकता है:

ci
— मार्टिन एंडर
स्रोत
13

कंकरीट वर्ण श्रेणियों को धक्का देना

  • सभी अंकों वाले तार को इस प्रकार "0123456789"लिखा जा सकता है

    A,s

  • अपरकेस ASCII अक्षरों ( A-Z) को धक्का दिया जा सकता है

    '[,65>

    जो Z तक सभी वर्णों की स्ट्रिंग उत्पन्न करता है , फिर पहले 65 ( @ तक ) का त्याग करता है ।

  • सभी ASCII पत्र ( A-Za-z) के रूप में धकेल दिए जा सकते हैं

    '[,65>_el+

    जो ऊपर काम करता है, फिर एक प्रति बनाता है, लोअरकेस में परिवर्तित होता है और जुड़ जाता है।

    लेकिन ऐसा करने का एक छोटा तरीका है!

    फिर अक्सर अनदेखा किया गया ^ऑपरेटर (सूचियों के लिए सममित अंतर) तीन बाइट्स को बचाते हुए समान रेंज बनाने की अनुमति देता है:

    '[,_el^

    '[,Z तक सभी ASCII वर्णों की श्रेणी _elबनाता है , एक लोअरकेस प्रतिलिपि बनाता है और ^केवल एक में दिखाई देने वाले दोनों तारों के वर्ण रखता है।

    चूंकि पहले स्ट्रिंग के सभी अक्षर अपरकेस हैं, दूसरे में सभी लोअरकेस हैं और सभी गैर-अक्षर वर्ण दोनों स्ट्रिंग्स में हैं, अक्षरों के स्ट्रिंग में परिणाम।

  • RFC 1642 बेस 64 वर्णमाला ( A-Za-z0-9+/) को उपरोक्त तकनीक का उपयोग करके और गैर-अक्षरों को जोड़कर धक्का दिया जा सकता है:

    '[,_el^A,s+"+/"+

    इस स्ट्रिंग को धकेलने का एक समान रूप से उपयोग केवल सममित अंतर का उपयोग करता है:

    "+,/0:[a{A0":,:^

    हम शुरुआत में स्ट्रिंग कैसे पा सकते हैं?

    सभी इस्तेमाल किया चरित्र पर्वतमाला ( A-Z, a-z, 0-9, +, /) रेंज के सममित अंतर यह है कि अशक्त बाइट, अर्थात् में शुरू के रूप में भेजा जा सकता है 'A,'[,^, 'a,'{,^, '0,':,^, '+,',,^और '/,'0,^।

    इसलिए, को क्रियान्वित करने :,:^पर "A[a{):+,/0"वांछित पात्रों धक्का होगा, लेकिन सही क्रम में नहीं।

    हमें सही क्रम कैसे मिलेगा? बचाव के लिए क्रूर बल! कार्यक्रम

    '[,_el^A,s+"+/"+:T;"0:A[a{+,/0"e!{:,:^T=}=

    स्ट्रिंग के सभी संभावित क्रमपरिवर्तन पर पुनरावृत्त करता है, :,:^परिणाम और वांछित आउटपुट ( पर्मलिंक ) की तुलना करता है ।

  • .-9A-Za-zउपरोक्त विधि का उपयोग करके मूलांक ( ) द्वारा प्रयुक्त मूलांक -64 वर्णमाला का उपयोग किया जा सकता है:

    ".:A[a{":,:^

    यह सबसे छोटा तरीका है जो मुझे पता है।

    चूंकि वांछित आउटपुट में सभी वर्ण ASCII के क्रम में हैं, इसलिए क्रमपरिवर्तन की पुनरावृत्ति की आवश्यकता नहीं है।

  • सभी क्रमबद्ध वर्ण श्रेणियों का उपयोग करके वांछित क्रम में नहीं धकेला जा सकता है :,:^।

    उदाहरण के लिए, सीमा को किसी भी क्रमपरिवर्तन पर 0-9A-Za-z;-?निष्पादित करके धकेल नहीं दिया जा सकता :,:^है "0:A[a{;@"।

    हालांकि, हम कोड का उपयोग करके वांछित स्ट्रिंग की घुमाई गई भिन्नता पा सकते हैं

    A,'[,_el^'@,59>]s2*:T;"0:A[a{;@"e!{:,:^T\#:I)}=Ip

    जो निम्नलिखित को प्रिंट ( पर्मलिंक ) करेगा:

    10
0:@[a{A;

    इस का मतलब है कि

    "0:@[a{A;":,:^Am>

    के रूप में एक ही प्रभाव है

    A,'[,_el^'@,59>]s

    जो केवल एक खाली स्टैक के साथ इस्तेमाल किया जा सकता है बिना एक पूर्वनिर्मित के [।

— डेनिस
स्रोत
11

बचें {…} {…}?

मान लें कि आपके पास स्टैक पर पूर्णांक है। यदि यह विषम है, तो आप इसे 3 से गुणा करना और 1 जोड़ना चाहते हैं; अन्यथा आप इसे 2 से भाग देना चाहते हैं।

एक "सामान्य" यदि / अन्यथा विवरण इस तरह दिखाई देगा:

_2%{3*)}{2/}?

हालांकि, ब्लॉक का उपयोग करना आमतौर पर जाने का तरीका नहीं है, क्योंकि {}{}पहले से ही चार बाइट्स हैं। ?स्टैक पर दो वस्तुओं में से एक का चयन करने के लिए भी इस्तेमाल किया जा सकता है:

_2%1$3*)@2/?

यह एक बाइट छोटी है।

Block-? खाली के साथ अगर बयान हमेशा एक नहीं है। उदाहरण के लिए,

{}{2/}?

की तुलना में दो बाइट्स है

{2/}|

अगर इसके बजाय आपके पास है

{2/}{}?

और आप जिस चीज की जांच कर रहे हैं वह गैर-नकारात्मक पूर्णांक है, आप कर सकते हैं

g)/

नया {}&और {}|आसान है, लेकिन कभी-कभी समस्याग्रस्त होता है यदि आप स्टैक को अव्यवस्थित नहीं कर सकते हैं।

फिर भी, के मामले में

_{…}{;}?

आप इसके बजाय एक अस्थायी चर का उपयोग कर सकते हैं:

:T{T…}&
— डेनिस
स्रोत
1
!)/और g)/उदाहरणों में छोटे हैं।
— jimmy23013
11

स्टेटमेंट स्विच करें

CJam में स्विच स्टेटमेंट नहीं हैं। नेस्टेड अगर बयान के रूप में अच्छी तरह से काम करते हैं, लेकिन {{}{}?}{}?पहले से ही 12 बाइट्स लंबा है ...

यदि हम स्थिति को एक छोटे, गैर-नकारात्मक पूर्णांक में बदल सकते हैं, तो हम सभी केस स्टेटमेंट को एक सीमांकित स्ट्रिंग में बदल सकते हैं और संबंधित परिणाम का मूल्यांकन कर सकते हैं।

उदाहरण के लिए, यदि हम code0स्टैक का पूर्णांक 0 है , code1यदि यह 1 है , और code2यदि यह 2 है , तो हम निष्पादित करना चाहते हैं , हम या तो उपयोग कर सकते हैं

_{({code2}{code1}?}{;code0}?

या

[{code0}{code1}{code2}]=~

या

"code0 code1 code2"S/=~

S/स्ट्रिंग को अंदर विभाजित करता है ["code0" "code1" "code2"], =संबंधित चंक को निकालता है, और ~कोड का मूल्यांकन करता है।

कार्रवाई में स्विच स्टेटमेंट देखने के लिए यहां क्लिक करें ।

अंत में, @ jimmy23013 और @RetoKoradi द्वारा सुझाए गए अनुसार, हम कुछ मामलों में स्विच को और भी छोटा कर सकते हैं। कहते हैं code0, code1और क्रमशः एल 0 , एल 1 और एल 2 कीcode2 लंबाई है।

यदि L 0 = L 1 2 L 2

"code0code1code2"L/=~

बजाय इस्तेमाल किया जा सकता है, जहां Lहै एल 0 । एक सीमांकक में विभाजित होने के बजाय, /स्ट्रिंग को समान लंबाई के विखंडू में विभाजित करें।

यदि L 0 L L 1 2 L 2 - L 0 - 1 ,

"cccooodddeee012">3%~

के बजाय इस्तेमाल किया जा सकता है। >स्ट्रिंग की शुरुआत से 0, 1 या 2 तत्वों को 3%निकालता है और हर तीसरे तत्व (पहले के साथ शुरू) को निकालता है।

— डेनिस
स्रोत
अंतिम उदाहरण के लिए, क्या इसका कोई फायदा है "code0code1code2"5/=~? मेरे लिए बहुत अधिक सीधा लगता है, और यह एक ही लंबाई है।
— रेटो कोराडी
@RetoKoradi यदि सभी स्निपेट की लंबाई समान है, तो कोई फायदा नहीं है। अलग-अलग लंबाई के लिए, आपका तरीका मापांक विधि की तुलना में कम और लंबा दोनों हो सकता है।
— डेनिस
11

सामान्य सरणी और स्ट्रिंग मानों को गोल करना

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

  • [0 1]के रूप में लिखा जा सकता है 2,।
  • [1 0]के रूप में लिखा जा सकता है YYb(यानी बाइनरी में 2)।
  • [1 1]के रूप में लिखा जा सकता है ZYb(यानी बाइनरी में 3)।
  • मैट्रिक्स के [[0 1] [1 0]]रूप में लिखा जा सकता है 2e!।
  • [LL] के रूप में लिखा जा सकता है SS/(रिक्त स्थान द्वारा एकल स्थान को विभाजित करना)।
  • "\"\""के रूप में लिखा जा सकता है L`।
  • "{}"के रूप में लिखा जा सकता है {}s।

उत्तरार्द्ध को उन मामलों तक बढ़ाया जा सकता है जहां आप सभी ब्रैकेट प्रकारों को एक अन्य बाइट को बचाने के लिए चाहते हैं:

  • "[{<()>}]"के रूप में लिखा जा सकता है {<()>}a`।
  • "()<>[]{}"के रूप में लिखा जा सकता है {<()>}a`$।

विशेष रूप से आधार रूपांतरण ट्रिक कुछ अस्पष्ट मामलों के लिए ध्यान में रखना उपयोगी हो सकता है जो हर अब और फिर से पॉप अप करते हैं। जैसे [3 2]होगा E4b(बेस 4 में 14)।

यहां तक ​​कि दुर्लभ मामलों में आप भी कारक संचालक को mfउपयोगी पा सकते हैं । जैसे [2 7]है Emf।

कृपया इस सूची का विस्तार करने के लिए स्वतंत्र महसूस करें यदि आप किसी अन्य उदाहरण पर आते हैं।

— मार्टिन एंडर
स्रोत
10

ढेर को साफ करना

यदि आप संपूर्ण स्टैक को खाली करना चाहते हैं, तो इसे एक सरणी में लपेटें और इसे पॉप करें:

];

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

]W=

(ऑप्टिमाइज़र का धन्यवाद जिसने दूसरे दिन मुझे यह दिखाया।)

बेशक, यदि स्टैक पर केवल दो तत्व हैं, \;तो कम है।

— मार्टिन एंडर
स्रोत
\;केवल टीओएस के नीचे के तत्व को पॉप करेगा। क्या आपका मतलब था ;;?
— कैलक्यूलेटरफलाइन
1
@CalculatorFeline उत्तर का दूसरा भाग सब कुछ साफ़ करने के बारे में है, लेकिन टीओएस।
— मार्टिन एंडर
9

e और दस की शक्तियां

जैसा कि ओह-इतनी-अन्य भाषाओं में, आप सीजेएम के 1e3बजाय लिख सकते हैं 1000।

यह गैर-पूर्णांक आधारों और यहां तक ​​कि गैर-पूर्णांक घातांक के लिए भी काम करता है। उदाहरण के लिए, 1.23e2धक्का 123.0 और 1e.5धक्का 3.1622776601683795 (का वर्गमूल 10 )।

जो तुरंत स्पष्ट नहीं है वह 1e3वास्तव में दो टोकन है:

  • 1स्टैक पर पूर्णांक 1 को धकेलता है ।

  • e3इसे 1000 से गुणा करता है ।

वह महत्वपूर्ण क्यों है?

  • आप किसी e<numeric literal>ऐसी चीज पर कॉल कर सकते हैं जो पहले से ही स्टैक पर हो।

    2 3 + e3 e# Pushes 5000.

  • आप e<numeric literal>एक सरणी पर मैप कर सकते हैं ।

    5 , :e3  e# Pushes [0 1000 2000 3000 4000].
— डेनिस
स्रोत
9

यूक्लिडियन मानदंड

एक सदिश के यूक्लिडियन मान की गणना का सीधा तरीका, अर्थात, इसके तत्वों के वर्गों के योग का वर्गमूल है,

2f#:+mq

हालाँकि, वहाँ एक बहुत छोटा रास्ता है।

mhकर्ण संचालक, स्टैक से दो पूर्णांक a और b को हटाता है और sqrt ( 2 + b 2 ) को धकेलता है ।

यदि हमारे पास एक वेक्टर x है: = [x 1 … x n ], n> 1 स्टैक पर, :mh(कर्ण को कम करें) निम्न प्राप्त करेगा:

  • स्टैक पर पहले x 1 और x 2 को धकेल दिया जाता है और sqrt (x 1 2 + x 2 2 ) कोmh छोड़ दिया जाता है ।

  • फिर, x 3 को धकेल दिया जाता है और mhफिर से निष्पादित किया जाता है, जिससे
    sqrt (sqrt (x 1 2 + x 2 2 ) 2 + x 3 2 ) = sqrt (x 1 2 + x 2 2 + x 3 2 ) को स्टैक पर छोड़ दिया जाता है।

  • X n संसाधित होने के बाद , हमें sqrt (x 1 2 +… x n 2 ) के साथ छोड़ दिया जाता है, x का यूक्लिडियन मानदंड ।

यदि n = 1 और x 1 <0 , उपरोक्त कोड गलत परिणाम देगा। :mhzबिना शर्त काम करता है। (इस ओर इशारा करने के लिए @ मार्टिनबटनर को धन्यवाद।)

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

— डेनिस
स्रोत
2
बेशक, यह आपके कार्यक्रम के संख्यात्मक विश्लेषण के लिए निहितार्थ है ...
— पीटर टेलर
8

N की तुलना में अधिक संख्या की सूची के साथ आधार n से परिवर्तित करें

CJam एक सूची को इस सूत्र के साथ एक संख्या में परिवर्तित करता है: A 0 * n l + A 1 * n l-1 + A 2 * n l-2 + A l * n 0 (नॉनगेटिव के साथ n)। nआधार है और lसूची की लंबाई है। इसका अर्थ है कि मैं कोई भी पूर्णांक हो सकता है, जिसकी सीमा में होना आवश्यक नहीं है [0,n)।

कुछ उदाहरण:

  • 0bअंतिम आइटम को निकालता है और इसे पूर्णांक में डालता है। W=iअगर यह पूर्णांक नहीं था तो एक बाइट की तरह काम करता है और बचाता है। लेकिन सूची में बाकी सब कुछ भी पूर्णांक में डालने में सक्षम होना चाहिए।
  • 1bयोग देता है। :i:+अगर वे पूर्णांक नहीं थे तो दो बाइट्स की तरह काम करता है और बचाता है। यह खाली सूचियों के साथ भी काम करता है जबकि :+ऐसा नहीं है।
  • [i{_1&9 32?_@\m2/}16*;]W%:cएक चरित्र को लाइन एंडिंग और टैब के स्ट्रिंग में कनवर्ट करता है, जिसे वापस साथ में परिवर्तित किया जा सकता है 2bc। एन्कोडिंग फ़ंक्शन कोड-गोल्फ प्रोग्राम में गोल्फ होना आसान नहीं है, हालांकि। लेकिन आपको आमतौर पर इसकी आवश्यकता नहीं होती है।

  • आप एक स्ट्रिंग को यूनिकोड वर्णों में बदलने के लिए निम्नलिखित कोड का उपयोग कर सकते हैं 16 बिट में नहीं, जिसे वापस साथ में परिवर्तित किया जा सकता है 2A#b128b:c। (स्पष्टीकरण बाद में जोड़ा जाएगा। या शायद मैं बाद में एक नया संस्करण लिखूंगा।)

    128b2A#b         " Convert to base 1024. ";
W%2/)W%\:+       " Convert to two base 1024 digit groups. ";
[0X@
{
  _54+
  @I+_Am>@\-
  _Am<@+ 0@-@1^
}fI
]);)
@\+[~+]2A#b_2G#<!{2A#b}*
\W%+:c

इसी तरह की विधि nपूर्णांक के किसी भी सेट के साथ काम करती है, जिसमें भिन्न मान होते हैं n, यदि आप सबसे महत्वपूर्ण अंक से छुटकारा पाने का कोई तरीका पा सकते हैं।

— jimmy23013
स्रोत
8

$यदि त्रिगुट के रूप में उपयोग करना

जब आप मेमोरी को लीक करने में कोई आपत्ति नहीं करते हैं, अर्थात, आपके द्वारा बाद में स्पष्ट किए गए स्टैक पर अनुपयोगी तत्वों को छोड़ते हुए ];, कॉपी ऑपरेटर $टेनेरी ऑपरेटर के लिए एक आसान विकल्प हो सकता है ?।

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

यदि आपके पास A B Cस्टैक है, तो आप निष्पादित कर सकते हैं

!$

के बजाय

\@?

नकल करने के लिए Bकरता है, तो Ctruthy और है Aअन्यथा।

यदि Cएक वास्तविक बूलियन ( 0या 1) है, तो आप निष्पादित कर सकते हैं

$

के बजाय

@@?

नकल करने के लिए Aकरता है, तो Ctruthy और है Bअन्यथा।

— डेनिस
स्रोत
दृष्टिहीनता में, यह एक स्पष्ट चाल है, लेकिन मैंने इसके बारे में पहले कभी नहीं सोचा था। मैंने पहली बार इस उत्तर में इसका उपयोग किया है ।
— डेनिस
7

नेस्टेड सूचियों के लिए मानचित्र

कहो कि आपको मैट्रिक्स की तरह एक नेस्टेड सूची मिली है:

[[0 1 2][3 4 5][6 7 8]]

या तार की एक सरणी:

["foo""bar"]

और आप नेस्टेड स्तर पर एक ब्लॉक मैप करना चाहते हैं (यानी इसे प्रत्येक नंबर या प्रत्येक वर्ण पर लागू करें)। भोला समाधान एक नेस्टेड है %:

{{...}%}%

हालाँकि, आप वास्तव में आंतरिक ब्लॉक को स्टैक पर धक्का दे सकते हैं और फिर उपयोग कर सकते हैं f%। f"अतिरिक्त पैरामीटर वाला मानचित्र" है, इसलिए यह %बाहरी पैरामीटर पर मैप करेगा , ब्लॉक को दूसरे पैरामीटर के रूप में उपयोग करेगा:

{...}f%

दो बाइट बचाता है।

ऐसा करने के लिए एक और साफ-सुथरी चाल for (i=0; i<5; ++i) for (j=0; j<5; ++j) {...}है

5,_f{f{...}}

बाहरी fपहली सीमा पर मैप करेगा, दूसरे रेंज को अतिरिक्त पैरामीटर के रूप में आपूर्ति करेगा। लेकिन अब, यदि आप fफिर से उपयोग करते हैं, तो केवल शीर्ष स्टैक तत्व एक सरणी है, इसलिए आप fउस पर आंतरिक ब्लॉक को मैप करते हैं, बाहरी "पुनरावृत्ति चर" को एक अतिरिक्त पैरामीटर के रूप में आपूर्ति करते हैं। इसका मतलब यह है भीतरी ब्लॉक के साथ रन है iऔर jढेर पर।

इसमें वर्णों की समान संख्या होती है, जैसे किसी कार्टेशियन उत्पाद पर ब्लॉक को मैप करना (हालाँकि उत्तरार्द्ध छोटा हो जाता है यदि आपको एरियर्स के रूप में जोड़े की आवश्यकता होती है):

5,_m*{~...}%

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

मुझे यह चाल दिखाने के लिए डेनिस का धन्यवाद।

0.6.4 अपडेट करें

fऔर :अब खुद सहित किसी अन्य ऑपरेटर को ले कर बहुत सुधार हुआ है। इसका मतलब है कि आप अभी और भी बाइट्स बचा सकते हैं। नेस्टेड सूची पर ऑपरेटर को मैप करना अब और कम हो गया है:

{:x}%
{x}f%
::x

यह वास्तव में नेस्टेड सूचियों पर ब्लॉक मैपिंग के साथ मदद नहीं करता है।

कार्टेसियन उत्पाद के लिए ब्लॉक या ऑपरेटरों को लागू करने के लिए, यह अब ब्लॉक के साथ-साथ ऑपरेटरों के लिए भी छोटा हो गया है:

5,_f{f{...}}
5,_ff{...}

5,_f{fx}
5,_ffx

क्या अच्छा है कि आप अब इन घोंसला बना सकते हैं। इसलिए आप किसी ऑपरेटर को किसी सूची में तीसरे स्तर तक आसानी से लागू कर सकते हैं:

:::x

या कुछ चाल के साथ एक ब्लॉक:

{...}ff%
— मार्टिन एंडर
स्रोत
महान अद्यतन। लेकिन अभी भी नहीं है f~...
— jimmy23013
@ user23013 fएक द्विआधारी ऑपरेटर की उम्मीद करता है, एकात्मक है ~; क्या आप शायद चाहते थे :~? इसके अलावा, हम इस पर चर्चा कर सकते हैं
— aditsu
क्या मुझे इस 0.6.4 अपडेट के बारे में कुछ याद आ रहा है? मुझे अभी भी उन संदेशों को करने में त्रुटि संदेश मिला है, जैसे Unhandled char after ':': :( लिंक )
— रनर ११
2
@ Runer112 मेरे लिए काम करता है। सुनिश्चित करें कि आपने ठीक से लोड किया है (यानी कैश से नहीं)। आपके ब्राउज़र के आधार पर Ctrl + F5 काम करना चाहिए।
— मार्टिन एंडर
@ मार्टिनबटनर यह वास्तव में मूर्खतापूर्ण कैशिंग के कारण था। धन्यवाद।
— रनर
7

ASCII कला के लिए वेक्टर ऑपरेटर्स

कई ASCII कला चुनौतियों के लिए, बाद में उन्हें अलग करने के लिए दो अलग-अलग पैटर्न उत्पन्न करना उपयोगी है। विभिन्न प्रकार के सुपरपोजिशन को प्राप्त करने के लिए वेक्टर ऑपरेटर्स बहुत मददगार हो सकते हैं।

ऑपरेटर वेक्टराइजेशन की एक उपयोगी संपत्ति यह है कि ऑपरेटर को छोटी स्ट्रिंग / सरणी के प्रत्येक तत्व के लिए केवल एक बार निष्पादित किया जाता है, जबकि बड़े वाले तत्व जिनमें समकक्ष नहीं होते हैं, अछूता रहता है।

  • .e<

    e<तार, वर्ण, सरणियों और पूर्णांक के जोड़े के लिए न्यूनतम ऑपरेटर काम करते हैं; यह स्टैक से दो आइटमों को पॉप करता है और लोअर को ई बैक पर धकेलता है।

    चूंकि अंतरिक्ष में अन्य सभी मुद्रण योग्य ASCII वर्णों की तुलना में एक कम कोड बिंदु होता है, इसलिए .e<इसका उपयोग जनरेट किए गए भागों के "मिटाने" के लिए किया जा सकता है:

    "\/\/\/\/\/" "    " .e<

e# This pushes "    \/\/\/".

    एक पूर्ण उदाहरण के लिए, मी वॉन्ट हनीकॉम्ब का मेरा उत्तर देखें ।

  • .e>

    अधिकतम ऑपरेटर e>विपरीत परिणाम के साथ न्यूनतम ऑपरेटर के रूप में काम करता है।

    फिर से, अंतरिक्ष के कम कोड बिंदु के कारण, .e>रिक्त स्थान के एक मुद्रण योग्य वर्णों के पैटर्न को सम्मिलित करने के लिए उपयोग किया जा सकता है:

    [[" " " " " " " "] [" " " " " " " "]][["+" "" "-" ""]["" "*" "" "/"]] ..e>

e# This pushes [["+" " " "-" " "] [" " "*" " " "/"]].

    एक पूर्ण उदाहरण के लिए, सेवन स्लैश डिस्प्ले में मेरा उत्तर देखें ।

  • .e&

    तार्किक और ऑपरेटर e&इसके बाएं तर्क को धक्का देता है यदि यह गलत है और इसका सही तर्क है अन्यथा।

    यदि न तो पैटर्न में गलत तत्व होते हैं, तो इसका उपयोग एक पैटर्न को दूसरे पर लगाने के लिए किया जा सकता है:

    "################" " * * * *" .e&

e# This pushes " * * * *########".

    एक पूर्ण उदाहरण के लिए, अमेरिकी ध्वज को मुद्रित करने के लिए मेरा उत्तर देखें ! ।

  • .e|

    तार्किक या ऑपरेटर e|को उल्टे तर्क क्रम के साथ ऊपर के रूप में इस्तेमाल किया जा सकता है:

    " * * * *" "################" .e|

e# This pushes " * * * *########".
— डेनिस
स्रोत
6

&यह जांचने के लिए उपयोग करें कि कोई सूची में कोई आइटम है या नहीं

के लिये

1 [1 2 3] #W>
1 [1 2 3] #)

आप उपयोग कर सकते हैं

1 [1 2 3] &,
1 [1 2 3] &

इसके बजाय, जो क्रमशः 0/1 और सत्य / असत्य देता है।

— jimmy23013
स्रोत
6

z और गैर-आयताकार सरणियाँ

ज़िप ऑपरेटर zदो-आयामी 1 सरणी A की पंक्तियों और स्तंभों को स्थानांतरित करता है , जिनके तत्व पुनरावृत्त भी हो सकते हैं।

गैर-आयताकार सरणियों के लिए - अंतर्निहित zipकार्यों के विपरीत , उदाहरण के लिए, पायथन (समान लंबाई में पंक्तियों को nilकाटता है ) या रूबी (पंक्तियों को पैड करता है ) - CJam बस पंक्तियों में उनकी लंबाई को अनदेखा करते हुए पंक्तियों में सरणी के स्तंभों को परिवर्तित करता है और अंतराल।

उदाहरण के लिए, सरणी को ज़िप करना

[
  [1]
  [2 4]
  [3 5 6]
]

सरणी zipping के बराबर है

[
  [1 4 6]
  [2 5]
  [3]
]

या सरणी

[
  [1]
  [2 4 6]
  [3 5]
]

के रूप में सभी तीन कार्रवाई धक्का

[
  [1 2 3]
  [4 5]
  [6]
]

ढेर पर।

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

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

  • हम किसी सरणी के स्तंभों को ऊपर से जोड़ सकते हैं (यानी, पहली सरणी को दूसरे में बदलकर) दो बार जिप करके:

    zz

  • उपरोक्त विधि के मामूली संशोधनों का उपयोग समान समस्याओं के लिए किया जा सकता है।

    उदाहरण के लिए, किसी सरणी के स्तंभों को नीचे (यानी दूसरे सरणी को पहले में बदलने के लिए) संरेखित करने के लिए, हम दो बार उलट पंक्ति क्रम से ज़िप कर सकते हैं:

    W%zzW%

  • तार की एक सरणी को देखते हुए, हम इस तरह की सबसे लंबी स्ट्रिंग की लंबाई की गणना कर सकते हैं:

    :,:e>

    हालाँकि, परिणाम की पंक्तियों की संख्या की गणना और गणना करके, हम तीन बाइट्स बचा सकते हैं:

    z,

1 यदि A की "पंक्तियों" में से कोई भी इसके चलने योग्य नहीं है z, तो उन्हें एकल के रूप में मानते हैं, इसलिए ज़िपिंग मनमानी सरणियों के लिए काम करती है।

— डेनिस
स्रोत
1
एक ही चीज़ को विज़ुअलाइज़ करने का एक अलग तरीका है, लेकिन मेरे लिए व्यवहार बहुत अधिक तार्किक है अगर मैं zस्तंभों को पंक्तियों में परिवर्तित करता हूं , जबकि खाली मानों को छोड़ दिया जाता है। उदाहरण में, इनपुट में पहला कॉलम 1, 2, 3, दूसरा कॉलम 4, 5 (खाली स्थिति छोड़ दिया गया है) है, और तीसरा कॉलम 6. ये तो परिणाम की पंक्तियाँ हैं।
— रेटो कोराडी
@RetoKoradi यह वर्णन करने का एक बेहतर तरीका है।
— डेनिस
6

अपवाद

सीजेएम में सभी अपवाद घातक हैं। चूंकि STDERR के आउटपुट को डिफ़ॉल्ट रूप से अनदेखा किया जाता है , इसलिए हम इसका उपयोग अपने लाभ के लिए कर सकते हैं।

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

यहाँ कुछ उपयोग के मामले हैं:

  • एक छोटा सा ढेर साफ़ करना

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

    कोई अन्य ऑपरेटर जो तीन तत्वों को पॉप करता है, उसी उद्देश्य को पूरा करेगा।

    इसे यहां कार्रवाई में देखें ।

  • स्टैक से दो या तीन तत्वों को निकालना

    इन विशेष तत्वों के लिए लागू किसी भी ऑपरेटर को बाहर निकलने से ठीक पहले स्टैक से दो या तीन तत्वों को पॉप करने के लिए उपयोग किया जा सकता है।

    दो तत्वों को पॉप करने के लिए, bकाम करता है यदि उनमें से एक चरित्र है या उनमें से कोई भी पूर्णांक नहीं है।

    तीन तत्वों को पॉप करने के लिए, tकाम करता है यदि नीचे-दो में से कोई भी एक चलने योग्य नहीं है, तो नीचे-सबसे अधिक चलने योग्य खाली है या उनमें से कोई भी पूर्णांक नहीं है।

  • एक पाश से बाहर निकलना

    अवसरों पर, हमें एक लूप से बाहर निकलने की आवश्यकता होती है जब एक पूर्णांक शून्य हो जाता है या एक स्ट्रिंग बहुत छोटा हो जाता है। इन स्थितियों के परीक्षण के बजाय, यदि संलग्‍न ऑपरेशन शून्य, खाली स्ट्रिंग या एकल के लिए विफल होते हैं, तो हम प्रोग्राम को केवल अपना प्राकृतिक पाठ्यक्रम ले सकते हैं।

    अंकगणित से जुड़े एक उदाहरण के लिए, यहां देखें ।

    एक उदाहरण जिसमें तार शामिल हैं, यहां देखें ।

  • सशर्त निष्पादन

    यदि स्रोत कोड को कुछ प्रकार के इनपुट के लिए निष्पादित नहीं किया जाना चाहिए, तो हम कभी-कभी एक ऑपरेटर का उपयोग कर सकते हैं जो उस तरह के इनपुट को विफल कर देता है।

    उदाहरण के लिए, iउन स्ट्रिंग्स के लिए विफल हो जाएगा जो पूर्णांक का मूल्यांकन नहीं करते हैं और ewलंबाई 0 या 1 के स्ट्रिंग्स के लिए विफल हो जाएंगे।

    इसे यहां कार्रवाई में देखें ।

— डेनिस
स्रोत
5

एक सरणी से अधिकतम / मिनट

यहाँ शुरुआत के लिए एक है!

जब आपको किसी सरणी से अधिकतम या न्यूनतम संख्या खोजने की आवश्यकता होती है, तो सबसे आसान और सबसे छोटा तरीका सरणी को सॉर्ट करना है और फिर पहले या अंतिम तत्व को निकालना है।

तो अगर सरणी चर में है A

A$W=

अधिकतम है और 

A$0=

न्यूनतम है।

एक ही समय में दोनों प्राप्त करें यह भी संभव है

A$)\0=

पढ़ने के बाद यह स्पष्ट लग सकता है, लेकिन किसी का पहला प्रयास सरणी के माध्यम से e<या इसके e>माध्यम से पुनरावृति की ओर जाता है, जो इस प्रकार है

A{e<}*

जो कि 2 बाइट्स से अधिक लंबा है, और इससे भी अधिक समय यदि आप अधिकतम और न्यूनतम दोनों चाहते हैं।

— अनुकूलक
स्रोत
बेशक, यदि आप स्टैक पर शेष सरणी के बारे में बुरा नहीं मानते हैं, तो आप वास्तव में उपयोग कर सकते हैं (और )इसके बजाय 0=और W=।
— मार्टिन एंडर
अब वहाँ है :e<और:e>
— aditsu
@aditsu हालांकि, वे ऊपर दिए गए टिप से कम नहीं हैं।
— ऑप्टिमाइज़र
5

बड़ी संख्या के लिए टाइमस्टैम्प का उपयोग करें

यदि आपको एक बहुत बड़ी, लेकिन मनमानी संख्या की आवश्यकता है, तो आप आमतौर पर या तो वैज्ञानिक संकेतन का उपयोग करेंगे 9e9या बड़े बिल्ट-इन चर में से एक को समान शक्ति के समान बढ़ा सकते हैं KK#। हालांकि, अगर आपको परवाह नहीं है कि वास्तविक संख्या क्या है, और इसे लगातार एक ही होने की आवश्यकता नहीं है (जैसे कि यादृच्छिक संख्या के लिए ऊपरी बाउंड), तो आप इसका उपयोग करके दो बाइट्स में कर सकते हैं

es

बजाय। यह मिलीसेकंड में वर्तमान टाइमस्टैम्प देता है, और 10 12 के आदेश पर है

— मार्टिन एंडर
स्रोत
3
यह भी ध्यान दें कि यदि आप एक बड़ी मनमानी संख्या चाहते हैं, और एक सकारात्मक संख्या को एक साथ छोड़ना चाहते हैं, तो आप उपयोग कर सकते हैं e9।
— jimmy23013
5

यह जाँचना कि दो तार / सरणियाँ समान नहीं हैं

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

=!

समानता के लिए जाँच करें, और परिणाम उल्टा। हालांकि, कुछ शर्तों के तहत आप उपयोग कर सकते हैं

#

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

दो सरणियों पर हमें कुछ अतिरिक्त स्थिति की आवश्यकता होती है, यह है कि यह एक गलत मान भी देता है यदि दूसरा सरणी पहले का गैर-तुच्छ उपसर्ग है, जैसे:

"abc""ab"#

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

— मार्टिन एंडर
स्रोत
5

c और 16-बिट पूर्णांक

उचित रैपिंग के साथ अहस्ताक्षरित 16-बिट पूर्णांक जोड़ने (या घटाना) के लिए, आप उपयोग +65536%या कर सकते हैं +2G#%।

हालाँकि,

+ci

बहुत छोटा है। कैरेक्टर रैप 65536 पर घिरे हुए हैं , इसलिए कैरेक्टर ( c) को फिर से लॉन्ग ( i) करने के लिए कास्टिंग का एक समान प्रभाव पड़ता है 65536%, अतिरिक्त लाभ के साथ कि परिणाम नकारात्मक नहीं होगा।

उसी चाल का उपयोग 65535 को धकेलने के लिए किया जा सकता है :

Wci
— डेनिस
स्रोत
4

पावर सेट

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

[1 2 3 4 5]La\{1$f++}/

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

[1 2 3 4 5]1a\{1$f*+}/
— मार्टिन एंडर
स्रोत
4

जांचें कि क्या किसी सूची में आइटम सभी समान हैं

मुझे लगता है कि यह भी ध्यान देने योग्य है। उपयोग:

)-

यदि सभी समान नहीं हैं या सभी समान हैं तो रिक्त सूची में सत्यता लौटाता है। सूची खाली है तो त्रुटियां।

मामले में निकाली गई वस्तु स्वयं एक सरणी (या स्ट्रिंग) हो सकती है:

)a-

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

_|,(
— jimmy23013
स्रोत
4

0= तार के लिए

किसी सरणी के पहले तत्व को पुनः प्राप्त करने के लिए, आपको उपयोग करना होगा 0=(या (, यदि आपको स्टैक पर बाकी सरणी को छोड़ने का मन नहीं है)।

हालांकि, अगर वह सरणी एक स्ट्रिंग है, तो चरित्र के लिए कास्टिंग पर्याप्त है।

उदाहरण

"xyz"c e# Pushes 'x.
— डेनिस
स्रोत
मैं यह नहीं देखता कि CJam cकिसी भी एरे के पहले तत्व को निकालने की अनुमति क्यों नहीं देता , जो अधिक उपयोगी और सुसंगत होगा।
— ०५:३ Fruit पर फलों को तोड़ना
4

बाईं ओर एक इकाई (या स्टैक) को घुमाते हुए

CJam में रोटेट लेफ्ट ऑपरेटर होता है m<, जो आम तौर पर आपको एक सरणी को बाईं ओर इकाइयों की एक मनमानी संख्या को घुमाने के लिए उपयोग करना चाहिए।

में कुछ मामलों में, आप भी उपयोग कर सकते हैं (+पाली और संलग्न करने के लिए:

[1 2 3]       (+ e# Pushes [2 3 1].
[[1] [2] [3]] (+ e# Pushes [[2] [3] 1].

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

इसके अलावा, यदि आप स्टैक पर घुमाए गए सरणी को डंप करना चाहते हैं, तो आप :\बिना शर्त के (स्वैप करके कम) का उपयोग कर सकते हैं :

[1 2 3]       :\ e# Pushes 2 3 1.
[[1] [2] [3]] :\ e# Pushes [2] [3] [1].

जब तक आपके पास एक खुला नहीं है [, तब तक इस ट्रिक का उपयोग पूरे स्टैक को घुमाने के लिए भी किया जा सकता है, यानी नीचे-सबसे स्टैक आइटम को शीर्ष पर लाने के लिए:

]:\
— डेनिस
स्रोत
3

सूची को प्रिंट करना और स्टैक को साफ़ करना

कहते हैं कि आपके स्टैक में तार / संख्या / आदि की एक सूची है। शीर्ष पर और इसके नीचे कुछ अन्य अतिरिक्त आइटम। अर्थात

123 "waste" ["a" "b" "rty" "print" "me" "please"]

अब आप केवल अंतिम सूची को प्रिंट करने में रुचि रखते हैं, इसलिए आप ऐसा करते हैं

S*]W=

जो आउटपुट देता है

a b rty print me please

जो वास्तव में स्मार्ट लगता है क्योंकि हम स्टैक ट्रिक को क्लीयर करने का उपयोग करते हैं और केवल रिक्त स्थान के साथ शामिल की गई सूची को प्रिंट करते हैं (जो कई बार सूची को प्रिंट करने का वांछित तरीका नहीं हो सकता है)।

यह आगे गोल्फ हो सकता है!

p];

यह 2 बाइट्स कम है !

और यदि आपके पास सूची के अलावा अन्य स्टैक पर केवल 1 आइटम है, तो यह और भी छोटा है!

p;

की सुंदरता pयह है कि यह स्टैक से शीर्ष सबसे अधिक आइटम को निकालता है, इसे स्ट्रिंग करता है (कोड के अंत में एक नई पंक्ति भी जोड़ता है) और कोड पूरा होने का इंतजार किए बिना, तुरंत STDOUT को प्रिंट करता है।

तो उपरोक्त कोड आउटपुट करेगा

["a" "b" "rty" "print" "me" "please"]

जब यह स्टैक में था, तो किसी सूची का सटीक प्रतिनिधित्व है!

— अनुकूलक
स्रोत
3

कार्तीय उत्पाद या दो या अधिक सेटों के सभी संभावित संयोजन

CJam में एक इनबिल्ट कार्टेशियन उत्पाद कैलकुलेटर है m*जो स्टैक पर शीर्ष दो सरणी / स्ट्रिंग्स लेता है और इसके साथ सभी संभव जोड़े बनाता है। उदाहरण के लिए

[1 2 3 4]"abc"m*

पत्ते

[[1 'a] [1 'b] [1 'c] [2 'a] [2 'b] [2 'c] [3 'a] [3 'b] [3 'c] [4 'a] [4 'b] [4 'c]]

ढेर के रूप में

लेकिन क्या होगा यदि आप 2 से अधिक सूचियों / स्ट्रिंग्स से सभी संभव संयोजन चाहते हैं। आप m*कई बार उपयोग करते हैं? उदाहरण के लिए

[1 2 3 4][5 6]"abc"m*m*

स्टैक पर निम्नलिखित छोड़ देंगे

[[1 [5 'a]] [1 [5 'b]] [1 [5 'c]] [1 [6 'a]] [1 [6 'b]] [1 [6 'c]] [2 [5 'a]] [2 [5 'b]] [2 [5 'c]] [2 [6 'a]] [2 [6 'b]] [2 [6 'c]] [3 [5 'a]] [3 [5 'b]] [3 [5 'c]] [3 [6 'a]] [3 [6 'b]] [3 [6 'c]] [4 [5 'a]] [4 [5 'b]] [4 [5 'c]] [4 [6 'a]] [4 [6 'b]] [4 [6 'c]]]

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

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

[1 2 3 4][5 6]"abc"]{m*{(+}%}*

यह छोड़ देता है 

[['a 5 1] ['b 5 1] ['c 5 1] ['a 6 1] ['b 6 1] ['c 6 1] ['a 5 2] ['b 5 2] ['c 5 2] ['a 6 2] ['b 6 2] ['c 6 2] ['a 5 3] ['b 5 3] ['c 5 3] ['a 6 3] ['b 6 3] ['c 6 3] ['a 5 4] ['b 5 4] ['c 5 4] ['a 6 4] ['b 6 4] ['c 6 4]]

ढेर पर।

आदेश बनाए रखना चाहते हैं? , बस पॉप्ड आइटम को सरणी में वापस जोड़ने से पहले स्वैप करें। अर्थात

{m*{(\+}%}*

केवल क्रमपरिवर्तन चाहते हैं?

{m*{(+$}%_&}*

संयोजनों में केवल अद्वितीय तत्व चाहते हैं?

{m*{(+_&}%}*

बस आज के लिए इतना ही। अभी के लिए ।

— अनुकूलक
स्रोत
1
अब आप ]:m*:e_किसी भी संख्या में सरणियों के साथ भी कर सकते हैं
— aditsu
3

तार पर परिचालन

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

उदाहरण के लिए, आप बिट्स की एक 2 डी सरणी में पहला या अंतिम कुछ आइटम प्राप्त करने के लिए, और लौट आए प्रकार के बारे में परवाह नहीं करना चाहते हैं, sA<से एक बाइट की बचत होती है 0=A<या :+A<।

या यदि आप इनपुट में कुछ बिट्स को संशोधित करना चाहते हैं, तो आप इसका मूल्यांकन करने से पहले स्ट्रिंग को संशोधित कर सकते हैं।

या यदि आपको यह संरचना मिली है और आप इसे एक साधारण सूची में बदलना चाहते हैं:

[[[[[[[[[1]2]3]4]5]6]7]8]9]

आप इसे अन्य तरीकों से कई पात्रों के साथ कर सकते हैं:

[a{~)\}h;]W%

लेकिन यह तार के साथ बहुत छोटा हो सकता है:

s:~

यदि यह एक से अधिक अंकों के साथ संख्याएँ हो सकती है तो भी यह छोटी है:

[`La`-~]

या:

`']-~]

यदि आपको ऐसे सरणी वाले कई अन्य सरणी की आवश्यकता नहीं है।

— jimmy23013
स्रोत
नहीं है e_अब
— aditsu
@aditsu इस उत्तर और टिप्पणी को देखें । कभी-कभी sअभी भी बेहतर काम करता है।
— jimmy23013
ज़रूर, जब आप सीधे स्ट्रिंग के साथ काम कर सकते हैं, तो यह छोटा है।
— aditsu
3

के Nबजाय का उपयोग करLa

कई मामलों में आपको किसी सरणी को खाली करने की आवश्यकता होती है La, जिसमें एक खाली सरणी होती है , जो इसका एकमात्र तत्व है, जो कि अनावश्यक रूप से 1 बाइट लंबे समय तक है।

कई मामलों में आपको मुद्रण से पहले प्रत्येक तत्व के बाद एक नई पंक्ति जोड़ने की आवश्यकता होती है, जो कुछ इस तरह होगी Noया N*।

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

कभी-कभी Sयह भी काम करता है यदि आपको रिक्त स्थान के साथ आउटपुट को अलग करने की आवश्यकता है।

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

— jimmy23013
स्रोत
2

एक या अधिक घटनाओं पर विभाजन

कहते हैं कि आपके पास एक स्ट्रिंग है "abbcdbbfghbdbb"और आप इसे विभाजित करना चाहते हैंb

"abbcdbbfghbdbb"'b/

यह ढेर पर छोड़ देता है:

["a" "" "cd" "" "fgh" "d" "" ""]

खाली तारों को नोटिस करें? वे वहाँ हैं क्योंकि दो bएक साथ थे और उनके बीच कुछ भी नहीं था। कई बार आप इससे बचना चाहते हैं। आप इससे कर सकते हैं

"abbcdbbfghbdbb"'b/La-

या खाली तारों को छानना

"abbcdbbfghbdbb"'b/{},

लेकिन वह 3 अतिरिक्त बाइट्स है।

इस विशेष उपयोग के मामले के लिए थोड़ा कम ज्ञात ऑपरेटर है %। संख्या और ( "abcd"2%= "ac") के आधार पर मॉड और मैप और विभाजन के अलावा , %तार / सरणियों पर भी विभाजित हो सकते हैं। तो उपरोक्त उपयोग के मामले के लिए:

"abbcdbbfghbdbb"'b%

छोड़ दूंगा

["a" "cd" "fgh" "d"]

ढेर पर।

आज मेरे एक उत्तर में इसे इंगित करने के लिए @ user23013 के लिए धन्यवाद।

— अनुकूलक
स्रोत
मुझे लगता है कि इसे "गोल्फस्क्रिप्ट भी सीखना चाहिए" नाम दिया जाना चाहिए, जिसके प्रलेखन में बेहतर उदाहरण हैं।
— jimmy23013
@ user23013 लेकिन हमें कभी भी यकीन नहीं होता कि जीएस के समान क्या है और क्या नहीं है।
— ऑप्टिमाइज़र
2

का प्रयोग करें गुना / कम infix foreach के रूप में

हमारे पास :xएक {x}%और के लिए एक आशुलिपि है और {x}*(इस पर निर्भर करता है कि क्या xएकात्मक या द्विआधारी है)। दुर्भाग्य से, छोटा करने के लिए कोई समान इन्फिक्स ऑपरेटर नहीं है {x}/। हालांकि, बहुत बार जब हम करते हैं {x}/, xवास्तव में एक द्विआधारी ऑपरेटर होता है जो बार-बार स्टैक पर नीचे की ओर स्थित वस्तु को संशोधित करता है। यदि ऐसा है, और कहा गया है कि आइटम एक सरणी नहीं है, तो हम एक बाइट को फोल्ड के रूप में गुना / घटाकर बचा सकते हैं:

5 [1 2 3 4]{-}/  e# Gives -5
5 [1 2 3 4]+:-

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

— मार्टिन एंडर
स्रोत
2

प्रिंट करें और प्रिंट करें

सीजेएम के पास printऑपरेटर हैं o:। यह काम करता है लेकिन सभी कोड निष्पादित होने के तुरंत बाद स्टैक प्रिंट कर रहा है। यदि आप प्रोग्राम के अंत में स्टैक साफ़ करते हैं तो आप इसे रोक सकते हैं। सीधे शब्दों में कहें:

];

प्रिंट करने के लिए आप उपयोग कर सकते हैं oNoया p(जैसा काम करता है `oNo)

— username.ak
स्रोत
3
वहाँ के बीच एक बड़ा अंतर है oऔर p। pआइटम को एक अस्पष्ट स्ट्रिंग प्रतिनिधित्व में मुद्रित करने के लिए परिवर्तित करके शुरू होता है। pनिष्पादित करने के लिए बराबर है ​`oNo।
— डेनिस
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.