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


46

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

आइए जेली में गोल्फिंग के लिए कुछ उपयोगी टिप्स एकत्रित करें। (हमेशा की तरह, प्रति उत्तर एक टिप, कृपया!)


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

2
मुझे लगता है कि पहले से ही बहुत सारे सुझाव हैं, जिनसे यह समझ में आना चाहिए कि भाषा में क्या बदलाव होते हैं। पायथ में गोल्फ के लिए युक्तियाँ एक ही समस्या है, मुझे लगता है, लेकिन यह समय की कसौटी पर अभी तक अच्छी तरह से पारित कर दिया है; उत्तर आम तौर पर अपडेट किए जाते हैं जब भी वे भाषा में बदलाव के कारण लागू नहीं होते हैं, तो कुछ देरी के साथ।
लिन

3
यहाँ एक अच्छी टिप है: @ डेनिस की प्रशिक्षु बनें। फिर, आप वास्तव में गोल्फिंग जेली में अच्छे होंगे ।
कॉनर ओ'ब्रायन

12
@ लायन मुझे बहुत अच्छा लगा कि आप हमारे खुद के डेनिस को कैसे कहते हैं ऐसा लगता है कि हम सभी एक बड़े परिवार हैं: डी।

वास्तव में जेली कोड पृष्ठ वर्णों को टाइप करने के तरीके पर जेली के गिटहब मुद्दों में यह धागा शायद एक टिप या दो के लायक है: github.com/DennisMitchell/jelly/issues/6 मेरे पास विंडोज मशीन तक पहुंच नहीं है, हालांकि, इसलिए मैं डॉन उन बिट्स को लिखने में आत्मविश्वास महसूस होता है।
जॉर्डन

जवाबों:


25

स्ट्रिंग संपीड़न

आप एक अधिक अनुकूलित / स्वत: स्ट्रिंग कंप्रेसर के लिए देख रहे हैं, की कोशिश इस एक

इसे ऑनलाइन आज़माएं!

एक संकुचित स्ट्रिंग की तरह दिखता है “...», जहां डॉट्स आधार-250-एन्कोडेड डेटा का एक हिस्सा है। विघटन एल्गोरिथ्म थोड़ा जटिल है: divmodइस पूर्णांक के विभिन्न हिस्सों को तोड़ने और उनमें से एक स्ट्रिंग का निर्माण करने के साथ, चंक को "मिश्रित-आधार" पूर्णांक के रूप में व्याख्या की गई है ।

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

import dictionary
code_page = '''¡¢£¤¥¦©¬®µ½¿€ÆÇÐÑ×ØŒÞßæçðıȷñ÷øœþ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~¶°¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƊƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḤỊḲḶṂṆỌṚṢṬỤṾẈỴẒȦḂĊḊĖḞĠḢİĿṀṄȮṖṘṠṪẆẊẎŻạḅḍẹḥịḳḷṃṇọṛṣṭụṿẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż«»‘’“”'''

class Compress(list):
    def character(self, c):
        if c in '\n\x7f¶':
            o = 95
        elif ' ' <= c <= '~':
            o = ord(c)-32
        else:
            raise ValueError(c + " is neither printable ASCII nor a linefeed.")
        self += [lambda z: 3*z+0, lambda z: 96*z+o]; return self
    def string(self, s):
        for c in s: self.character(c)
        return self
    def dictionary(self, w):
        ts = bool(self)
        if w[:1] == ' ': w = w[1:]; ts = not ts
        dct = dictionary.short if len(w) < 6 else dictionary.long
        W, sc = (w, 0) if w in dct else (w[:1].swapcase() + w[1:], 1)
        if W not in dct: raise ValueError(w + " isn't in the dictionary.")
        f = ts or sc; j = (2 if sc else 1) if ts else 0; i = dct.index(W)
        self += [lambda z: 3*z+2, lambda z: 3*z+j] if f else [lambda z: 3*z+1]
        self += [lambda z: 2*z+int(len(w) < 6), lambda z: len(dct)*z+i]
        return self
    def go(self):
        compressed = []; z = 0
        for f in self[::-1]: z = f(z)
        while z:
            c = z % 250
            if c == 0: c = 250
            z = (z - c) // 250
            compressed.append(code_page[c - 1])
        return '“{0}»'.format(''.join(compressed[::-1]))

निम्नानुसार कंप्रेसर का उपयोग करें।

print(Compress()
      .dictionary('public')
      .dictionary(' static')
      .dictionary(' boolean')
      .string(' is')
      .dictionary('Power')
      .string('Of')
      .dictionary('Ten')
      .string('(')
      .dictionary('long')
      .dictionary(' input')
      .string(') {\n ')
      .dictionary(' return')
      .string('\n   ')
      .dictionary(' input')
      .string(' ==')
      .go())

Compress एक स्ट्रिंग बिल्डर है:

  • .string(s) स्ट्रिंग में कच्चे, मुद्रण योग्य ASCII वर्ण सम्मिलित करेगा।

    (प्रत्येक चरित्र की लागत लगभग ०. compressed२ 0.8 संकुचित बाइट्स है।)

  • .dictionary(w)जेली के अंतर्निहित शब्दकोशों में एक स्ट्रिंग देखेंगे। यदि आप एक स्थान चाहते हैं, तो आप स्ट्रिंग को एकल स्थान से शुरू कर सकते हैं। यदि इसे सामान्य स्ट्रिंग-जोड़ने वाले व्यवहार से विचलित करने की आवश्यकता है, या किसी शब्दकोश शब्द के कैपिटलाइज़ेशन को फ्लिप करें, तो यह तदनुसार झंडे जोड़ देगा।

    (छोटे शब्दों के लिए लगभग 1.997 बाइट्स, लंबे शब्दों के लिए 2.433 बाइट्स; यदि झंडे हैं, तो 0.199 बाइट्स जोड़ें।)


15
यह उपयोगी है! मैं इन्हें हाथ
डेनिस

1
@ डेनिस को जेली में ही शामिल किया जा सकता है, इसलिए हमें हर बार इसे यहां से कॉपी नहीं करना पड़ेगा?
पुरकाकूदरी

@ Pietu1998 एक परमाणु के रूप में या कुछ और?
डेनिस

@ डेनिस रिपॉजिटरी में एक यूटिलिटी स्क्रिप्ट के रूप में।
पुरकाकूदरी

1
शायद जेली में कुछ की आवश्यकता है।
कैलक्यूलेटरफ्लीन

19

यह जेली विकी ट्यूटोरियल बन गया है ।

चेन

(यह टैकिट प्रोग्रामिंग के लिए अनुवर्ती है ।)

जेली एक श्रृंखला का मूल्यांकन कैसे करती है? जैसा कि पहले बताया गया है, इस पर विचार करने के लिए तीन मामले हैं: क्या इस श्रृंखला को निलादि , मौद्रिक रूप से , या डियाडली कहा जाता था ।


1. निलादिक जंजीर

ये गुच्छा के सबसे आसान हैं। एक niladic श्रृंखला का मूल्यांकन करने के लिए कि शुरू होता है एक nilad साथ, की तरह α f g h, monadic श्रृंखला का मूल्यांकन f g hकि nilad पर α। (कैविट्स: यदि पूरी श्रृंखला खाली है, तो इसके बजाय 0 वापस कर दिया जाता है। यदि एक निलाड α नहीं है, तो α=0इसके बजाय इसका उपयोग करें ।)

उदाहरण के लिए, बस ½मूल्यांकन किया जाता है 4, जो है 2


2. मोनाडिक श्रृंखला

जब तक विचार करने के लिए कोई लिंक नहीं छोड़ा जाता है, तब तक मोनाडिक श्रृंखलाएं बाएं से दाएं टूट जाती हैं। इसके अलावा, हम ωयहाँ कुछ तर्क पारित कर रहे हैं। जवाब देने के लिए दो प्रश्न हैं:

इस बाएं से दाएं मूल्यांकन के लिए शुरुआती मूल्य क्या है?

  • यदि हमारी श्रृंखला एक निलाद से शुरू होती है α, और उसके बाद शून्य या अधिक मोनड्स (जैसे ½), डियाड-निलाड जोड़े (जैसे +2), और निलाद-डाग जोड़े (जैसे 4*): हम मूल्यांकन करके शुरू करते हैं α, और फिर शेष श्रृंखला पर विचार करते हैं ।

  • अन्यथा, हम इस श्रृंखला में दिए गए तर्क से शुरू करते हैं ω, और पूरी श्रृंखला पर विचार करते हैं।

हम कैसे चेन से नीचे चलते हैं?

चलो Vवर्तमान मूल्य को कॉल करते हैं - शुरू में, यह ऊपर वर्णित मूल्य है, लेकिन यह अपडेट हो जाता है क्योंकि हम श्रृंखला के माध्यम से जाते हैं - और निरूपित करते हैं

  • अंकों का उपयोग करते हुए,
  • लोअरकेस अक्षरों का उपयोग करने वाले भिक्षु,
  • ऑपरेटर प्रतीकों का उपयोग dyads +, ×, ÷

फिर निम्न पैटर्न का मिलान ऊपर से नीचे तक होता है:

                                 ┌───────────┬─────────┐
                                 │ old chain │ new V   │
                                 ╞═══════════╪═════════╡
                                 │ + × 1 ... │ (V+ω)×1 │ *
                                 │ + f ...   │ V+f(ω)  │
                                 │ + 1 ...   │ V+1     │
                                 │ 1 + ...   │ 1+V     │
                                 │ + ...     │ V+ω     │
                                 │ f ...     │ f(V)    │
                                 └───────────┴─────────┘
      (* Only if `...` consists of monads, dyad-nilad pairs, and nilad-dyad pairs.)

चलो इस श्रृंखला पर बाहर की कोशिश करो +²×

  • +एक निलाद नहीं है, इसलिए हम शुरू करते हैं V = ω
  • फिर, हम दूसरे पैटर्न से मेल खाते हुए काटते हैं , और मिलते हैं V = ω+ω²
  • फिर, हम ×पाँचवें पैटर्न से मेल खाते हैं, और काट लेते हैं V = (ω+ω²)×ω
  • श्रृंखला अब खाली है, इसलिए (ω+ω²)×ωहमारा अंतिम परिणाम है।

3. डायैडिक चेन

ये मूल रूप से मोनैडिक श्रृंखलाओं की तरह हैं, लेकिन इस बार, दो तर्क हैं, λ(बाएं) और ρ(दाएं)।

शुरुआती मूल्य क्या है?

  • यदि श्रृंखला तीन रंगों की तरह शुरू होती है + × %, तो हम शुरू करते हैं λ+ρ, और × % ...आगे की श्रृंखला पर विचार करते हैं ।

  • अन्यथा, हम शुरू करते हैं λ, और पूरी श्रृंखला पर विचार करते हैं।

हम कैसे चेन से नीचे चलते हैं?

इस बार, पैटर्न हैं

                                 ┌───────────┬─────────┐
                                 │ old chain │ new V   │
                                 ╞═══════════╪═════════╡
                                 │ + × 1 ... │ (V+ρ)×1 │ *
                                 │ + × ...   │ V+(λ×ρ) │
                                 │ + 1 ...   │ V+1     │
                                 │ 1 + ...   │ 1+V     │
                                 │ + ...     │ V+ρ     │
                                 │ f ...     │ f(V)    │
                                 └───────────┴─────────┘
      (* Only if `...` consists of monads, dyad-nilad pairs, and nilad-dyad pairs.)

चलो इस श्रृंखला पर बाहर की कोशिश करो +×÷½

  • श्रृंखला तीन रंगों से शुरू होती है, इसलिए हम शुरू करते हैं V = λ+ρ, और दूर फेंक देते हैं +
  • फिर, हम ×÷दूसरे पैटर्न से मेल खाते हुए काटते हैं , और मिलते हैं V = (λ+ρ)×(λ÷ρ)
  • फिर, हम ½छठे पैटर्न से मेल खाते हुए काटते हैं , और प्राप्त करते हैं V = sqrt((λ+ρ)×(λ÷ρ))
  • श्रृंखला अब खाली है, इसलिए हमने काम किया है।

2
तो क्या यह जेली ट्यूटोरियल के लिए अधिक है जो इसमें गोल्फिंग के लिए सुझाव देता है? ;)
मार्टिन एंडर

5
मुझे ऐसा लगता है। अगर भाषा समझने के लिए बहुत मुश्किल है, तो मुझे लगता है कि "यह कैसे भी काम करता है?" एक अच्छी टिप है ^ ^ मैं अंत में गैर-स्पष्ट चाल और बाइट को बचाने के तरीकों पर जाने का इरादा रखता हूं। यदि यह यहां से बाहर है, तो मैं इसे गिथब में स्थानांतरित कर सकता हूं, या (यदि डेनिस इसे पसंद करता है) जेली रेपो।
लिन

16

विशेष-आवरण संख्यात्मक मान

जेली के न्यूमेरिक्स पार्सर के कुछ विशेष मामले इस प्रकार हैं:

  • - का मूल्यांकन करता है -1
  • . का मूल्यांकन करता है 0.5
  • ȷमूल्यांकन 1000( ȷवैज्ञानिक संकेतन के लिए है, उदाहरण के 2ȷ6लिए 2000000)
  • ıमें विकसित होता है 1j( ıजैसे जटिल संख्या के लिए, उदाहरण के 2ı3लिए 2+3j)

यह भी ध्यान देने योग्य है कि वास्तव में ऐसा कुछ है 4+1j, बजाय 4

आप इन्हें मिक्स एंड मैच कर सकते हैं, जैसे:

  • -.है -0.5और है-1000
  • है -1+1j, ı-है -1jऔर -ı-है-1-1j
  • है 500.0
  • है 0.5+1j, ı.है 0.5jऔर .ı.है0.5+0.5j
  • ȷıहै 1000+1j, ıȷहै 1000jऔर ȷıȷहै1000+1000j

ध्यान दें कि ȷ-है 0.1, लेकिन यह किसी भी बाइट से अधिक नहीं बचाता है .1। फिर निम्न भी है, जो पहले से ही बाइट के 10 ( ) के लिए वैरिएबल चर का उपयोग करके संबंधित संख्या में किया जा सकता है , लेकिन दुर्लभ मामले में उपयोगी हो सकता है कि बेसिन अनुपलब्ध है या उपयोग करने की आवश्यकता पर सहेजने के लिए ¤:

  • ȷ.है sqrt(10) ~ 3.162277, .ȷ.है sqrt(10)/2 ~ 1.5811और ȷ-.है1/sqrt(10) ~ 0.31162

13

अनुकूलित स्ट्रिंग कंप्रेसर

इसे ऑनलाइन आज़माएं!

लिन की पोस्ट में बताया गया है कि कंप्रेस्ड स्ट्रिंग्स वास्तव में क्या होती हैं, साथ में एक कंप्रेसर होता है जो इन कंप्रेस्ड स्ट्रिंग्स का उत्पादन करेगा। हालांकि, जबकि जेली में एक कार्यक्रम के साथ चारों ओर संवारता है, मैं यह गठबंधन करने के लिए थका पाया .dictionaryऔर .stringइतने पर इतना आगे रिक्त स्थान की सही प्लेसमेंट के साथ ही और और, आदेश कम से कम स्ट्रिंग प्राप्त करने के लिए।

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

जिस तरह से कार्यक्रम काम करता है वह 3 अलग-अलग तरीकों का उपयोग करके संपीड़ित करना और निर्धारित करना है जो सबसे छोटा है:

  1. विधि 1 बस एक बार में इनपुट के प्रत्येक बाइट को एन्कोड करता है, जो दूसरों की तुलना में सबसे लंबे परिणाम का उत्पादन करता है। यहां तक ​​कि जब इनपुट बहुत कम होता है, तब भी यह लंबे विकल्प का निर्माण करता है। उदाहरण के लिए, सबसे छोटा तरीका जो testसंकुचित किया जा सकता है “¡ḌY», जबकि यह विधि वापस आती है “¡⁷ƑKʂ»(2 बाइट्स लंबे समय तक)। एक सामान्य नियम के रूप में, यह केवल तभी काम करता है जब स्ट्रिंग 4 वर्णों से कम लंबी हो

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

    विराम चिह्नों में रिक्त स्थान शामिल हैं, जो कि विधि संख्या 3 खेलने में आता है, लेकिन पहले और विधि 2 का मूल्यांकन: चलो विधियों की तुलना एक और दो स्ट्रिंग को संकुचित करते हैं Hello, World!(शब्द, विराम चिह्न और रिक्त स्थान शामिल हैं, इसलिए सही है)। के अंतिम स्ट्रिंग में चरित्र परिणामों से चरित्र को संपीड़ित “ŒCdẉa÷¹ṂȤƓ(Ẋ)»(15 बाइट्स लंबे) है, जो, के रूप में यह पता चला है, उत्पादन के लिए आसान तरीका नमस्कार, दुनिया !: से अधिक लंबी है “Hello, World!। अब विधि दो पर एक नज़र डालते हैं। यह संकुचित स्ट्रिंग पैदा करता है “Ọƥ⁷Ƭė3⁶»जो 9 बाइट्स में वजन करता है , पुराने पर एक महान सुधार। हालांकि, सबसे कम नमस्ते, विश्व! जेली में कार्यक्रम 8 बाइट्स है , इसलिए कुछ सुधार किया जा सकता है

  3. यहाँ तरीका 3 आता है, जिससे यह और भी छोटा हो जाता है। जैसा कि अपेक्षित था, हैलो के लिए आउटपुट, विश्व, निश्चित रूप से, “3ḅaė;œ»जो सबसे कम संभव कार्यक्रम है। तो क्या विधि 3 करता है, वह विधि 2 नहीं है? विधि 3 अग्रणी स्थानों में लोन स्पेस को जोड़ती है, जिसके लिए जेली डीकंप्रेसर में एक झंडा होता है। कंप्रेसर और डीकंप्रेसर दोनों के लिए कोड में, आप कोड की तरह देख सकते हैं if flag_space: word = ' ' + word, जिससे पता चलता है कि प्रमुख स्थान a) समर्थित और b) बाइट-सेविंग हैं। इसलिए, विधि दो से स्ट्रिंग स्प्लिटर को अनुकूलित किया जाता है ताकि अग्रणी द्वारा स्ट्रिंग बनाने के लिए रिक्त स्थान को सीधे स्ट्रिंग में जोड़ दिया जाए। इसका मतलब यह है कि Hello, World!इसे पार्स किया जाता है ["Hello", ",", " World", "!"], जब संपीड़ित केवल 6 बाइट्स (8 जब सीमांकक सहित) होता है। यह लगभग हमेशा संपीड़न की सबसे छोटी विधि है, "एक्सटेंशन" को छोड़कर, मैंने जोड़ा,

यह कार्यक्रम का बड़ा हिस्सा है, लेकिन कुछ और विकल्प हैं जो डेटा को और भी अधिक संपीड़ित करने में मदद करते हैं।

  • कार्यक्रम की जाँच करता है कि प्रत्येक संपीड़ित संस्करण सही है या नहीं, डेनिस के sss डीकंप्रेसर का उपयोग करके, जेली का उपयोग करता है (सीधे स्रोत पर जाएं)
  • आप पहले कमांड लाइन तर्क करके सभी अलग-अलग संपीड़ित तार देख सकते हैं --debug, जो कि केवल सबसे छोटी संकुचित स्ट्रिंग दिखा रहा है, सभी 3 को "यह सबसे छोटा है" प्रतिलिपि के साथ दिखाता है
  • कार्यक्रम "गैर-शब्द" संभालता है

गैर-शब्द

मैंने इस संदेश को देखने के बाद लिन के कंप्रेसर पर काम शुरू किया , इस पर एक दरार ले ली और इस तथ्य पर निराश हो गया कि मैं इसे संक्षिप्त करने के लिए सबसे छोटा तरीका नहीं ढूंढ सका (यह रिकॉर्ड के लिए 29 या 32 बाइट्स है)। हालाँकि, अपने सुधारों का परीक्षण करते समय, मैंने पाया कि ऐसे शब्द knownsजेली के शब्दकोश में नहीं हैं। इसलिए, मैंने कम से कम जेली कोड में इन "गैर-शब्दों" को संपीड़ित करने का एक तरीका खोजने के लिए निर्धारित किया है।

मैंने एक फ़ंक्शन ( trim) बनाया जो स्ट्रिंग को एक बिंदु के रूप में विभाजित करता है जहां स्ट्रिंग के कम से कम एक शब्द हैं। उदाहरण के लिए knownsमें विभाजित किया जाएगा ["known", "s"]और प्रोग्राम में पहले शब्द को डिक्शनरी ऐड ( .dictionary) और दूसरे भाग में .stringकॉल के जरिए जोड़ा जाएगा । लेकिन यह अभी भी दो किनारे मामलों को छोड़ देता है: तार जिनके पास कोई शब्द नहीं है (जैसे कि ajdl) और गैर-शब्द जिनके पास अंत में शब्द हैं, जैसे कि abctest, जो trimफ़ंक्शन द्वारा विभाजित नहीं होगा ।

जैसा कि एक स्ट्रिंग में शब्दों को खोजने का कोई तरीका नहीं है जिसमें इसमें कोई शब्द नहीं है, इन्हें संभालने का सबसे सरल और छोटा तरीका यह है कि उन्हें एक .stringकॉल के माध्यम से चरित्र द्वारा चरित्र में जोड़ दिया जाए । तो ajdlद्वारा जोड़ा जाएगा .string('ajdl')। जबकि गैर-शब्द जो मान्यता प्राप्त शब्दों के साथ समाप्त होते हैं, अनिवार्य रूप से ट्रिमर को लागू करते हैं लेकिन रिवर्स में, और आवेदन करते हैं .dictionaryऔर .stringदूसरे तरीके से आगे की ओर ट्रिमर।

जैसा कि यह पता चला है, स्ट्रिंग को ट्रिम करना, या तो शुरुआत या अंत से, निश्चित रूप से, कंप्रेसर के प्रत्येक चरित्र को जोड़ने की तुलना में कम, के इनपुट के रूप में प्रदर्शित होता है abctest this string, जो डीबग आउटपुट का उत्पादन करता है

Original        : abctest this string

Optimised       : “¡J+v(p⁸ụƘ$,»
Seperate spaces : “Ç⁴ṭḍµḄ7oeṂdḷp»
No trimmer      : “¤ɦ?Ɓ¢#fḲOạ⁾¶ɼȥƬ»
All characters  : “µẓþ"Y7_ḣṗḢ))9Þ⁴⁺Ẉ²)ɱ»
Non-compressed  : “abctest this string
Shortest        : “¡J+v(p⁸ụƘ$,»
=====

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

बेशक, इसके लिए बहुत सारा श्रेय मूल कंप्रेसर बनाने के लिए लिन को जाता है


क्या अब इसे हटा दिया जाना चाहिए कि हमारे पास codegolf.stackexchange.com/a/151721/39328 है ?
lirtosiast

@lirtosiast उसी तर्क से, आप कह सकते हैं कि इस पोस्ट को हटा दिया जाना चाहिए। इसका कोई नुकसान नहीं है, और यह पूरी तरह से वैध जवाब है, इसे हटाने का कोई कारण नहीं है, बस इसलिए कि बेहतर जवाब है।
caird coinheringaahing

10

आप ³⁴⁵⁶⁷⁸⁹आमतौर पर उपयोग किए जाने वाले कुछ मानों को गोल्फ के लिए तीन से नौ ( ) तक सुपरस्क्रिप्ट का उपयोग कर सकते हैं , लेकिन यह कमांड लाइन के तर्कों की मात्रा पर निर्भर करता है, और लिंक के तर्कों पर लिंक के मामले में।

  • ³ 100 लौटाता है, और केवल तभी काम करता है जब कोई इनपुट न हो।
  • 16 लौटाता है, और केवल तभी काम करता है जब अधिकांश इनपुट हो।
  • 10 लौटाता है, और केवल तभी काम करता है जब अधिकांश दो इनपुट हों।
  • यदि कोई स्थान तीन से अधिक इनपुट पर देता है।
  • यदि अधिकतम चार इनपुट पर कोई नई पंक्ति देता है।

यदि पाँच इनपुट हैं, हालाँकि, आप भाग्य से बाहर हैं।

हाल ही में, भाषा के एक नए संस्करण ने ³100 के मूल्य को कम कर दिया , और कुछ नए परमाणुओं को पेश किया जो मानों (लिंक के लिए) को उनके तर्कों को वापस करते हैं।

  • उन लिंक को छोड़कर हर जगह एक खाली सूची देता है जो उनके पास एक वाम तर्क है।
  • लिंक को छोड़कर हर जगह 256 रिटर्न देता है जो उनके पास एक सही तर्क है।

यदि आप एक लिंक में हैं, और दोनों पक्षों की ओर से तर्क दिए गए हैं, हालांकि, आप भाग्य से बाहर हैं।


1
दरअसल, अप्रयुक्त इनपुट डिफ़ॉल्ट मानों से भरे होते हैं! ऐसी सुविधा!
कैलकुलेटरफ्लीन

9

दुर्व्यवहार स्ट्रिंग कीड़े

क्रेडिट करने के लिए जाना अदनान इस का लाभ लेने के पहले में के लिए तार elasticize के लिए एक कार्यक्रम लिखें

जेली को एक दिन चरित्र अंकगणित मिलना चाहिए, लेकिन जब तक ऐसा नहीं होता, हम इस तथ्य का लाभ उठा सकते हैं कि पायथन अधिकांश अंकगणितीय ऑपरेटरों को ओवरलोड करता है और जेली किसी भी प्रकार की जाँच नहीं करता है।

उदाहरण के लिए

“abcd”Ḥ

अभी कुछ भी उपयोगी नहीं माना जाता है, लेकिन चूंकि (अनहेल्वे) को लागू किया जाता है

lambda z: z * 2

और अंकगणित परमाणु 0 पर गहराई से उत्पन्न होते हैं (यानी, वे संख्या या वर्णों पर काम करते हैं), ऊपर जेली कोड पैदावार

['aa', 'bb', 'cc', 'dd']

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

इसी तरह, +/समान गुहाओं के साथ तार को समतल करने के लिए उपयोगी हो सकता है।


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

1
ज्यादा या कम। मैं एक संख्यात्मक प्रकार बनाने की योजना बना रहा हूं जो आंतरिक रूप से एक संख्या है लेकिन एक चरित्र ध्वज है। यह ध्वज केवल मुद्रण को प्रभावित करेगा; वर्णों का उपयोग पूर्णांक के बजाय हर जगह किया जा सकता है।
डेनिस

1
Sतार को जोड़ने के 0लिए कभी उपयोगी नहीं हो सकता है, यह उन्हें जोड़ने का प्रयास करेगा ।
एर्ग आउटफोलर

@EriktheOutgolfer राइट, पेसकी बेस केस। +/हालांकि काम करता है।
डेनिस

@ डेनिस हाँ, मैंने अभी तक के साथ एक चुनौती जीती है +/
आउटगोल्फर

8

इष्टतम स्ट्रिंग कंप्रेसर

हाल ही में मैं पूछा एरिक Outgolfer जोड़ने के लिए अनुकूलित स्ट्रिंग कंप्रेसर के लिए JHT संदर्भ पेज , पर वे कहा कि

क्षमा करें, लेकिन ऐसा लगता है कि कंप्रेसर पूरी तरह से लागू नहीं होता है
यह कहता “ugtestslug”है कि यह सबसे कम संभव है ugtestslug, जबकि “#ṀȮụḄPƇ»यह काम भी करता है

इसलिए मैं इष्टतम स्ट्रिंग कंप्रेसर को लागू करने का निर्णय लेता हूं।

सरल दृष्टिकोण, लेकिन सबसे छोटा संभव मान (और इसलिए बाइट काउंट) खोजने की गारंटी

stdinआउटपुट से , के लिए इनपुट लें stdout। मूल कंप्रेसर की तरह, या (शाब्दिक न्यूलाइन वर्ण) को न्यूलाइन के रूप में दर्ज किया जा सकता है।

बहुत सारे विराम चिह्न (उदाहरण के लिए, इनपुट ¶-----¶) के साथ इसे चलाने की कोशिश करने से असम्पीडित स्ट्रिंग का उत्पादन होगा।

बेशक, इसके लिए बहुत सारा श्रेय मूल कंप्रेसर बनाने के लिए लिन को जाता है ।


7

यह जेली विकी ट्यूटोरियल बन गया है ।

टैसिट प्रोग्रामिंग

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

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

  • निलाद कोई तर्क नहीं लेते हैं (arity 0); कुछ I / O और स्टेटफुल कमांड के अलावा, वे ज्यादातर निरंतर मूल्यों का प्रतिनिधित्व करते हैं। उदाहरण के लिए, शाब्दिक 3एक निलाद है।

  • मोनाड्स एक तर्क (arity 1) लेते हैं। (यहां कार्यात्मक प्रोग्रामिंग मोनड्स से कोई संबंध नहीं है।) उदाहरण के लिए, ½(वर्गमूल) एक मोनड है।

  • डायएड्स दो तर्क लेते हैं ( एरीटी 2): एक बायां और एक सही तर्क। उदाहरण के लिए, +एक रंग है।

(विशेषण का प्रयोग, हम कहते हैं कि एक कड़ी है niladic , monadic , या dyadic ।)

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

एक उदाहरण के रूप में, (जोड़) और (वर्गमूल) की एक श्रृंखला है । जैसा कि इस श्रृंखला के तत्वों की संबंधित संख्या 2 और 1 है, हम इसे 2,1-श्रृंखला कहते हैं । दुभाषिया की श्रृंखलाओं को तोड़ने के लिए विशिष्ट नियम होते हैं, उनके आधार पर: वे नियम तय करते हैं कि, एक इनपुट को देखते हुए , यह नया नियम लागू होता है । (आप "... प्लस इसके वर्गमूल के रूप में पढ़ सकते हैं ।" )+½nn + sqrt(n)

फिर, जेली प्रोग्रामिंग, अनिवार्य रूप से इन नियमों को अच्छी तरह से सीखने की कला है, और चतुर श्रृंखलाओं की रचना करता है जो कि काम करवाते हैं , शांति से


क्या त्रिकालज्ञ हैं?
कॉनर ओ'ब्रायन

नहीं! मैं यह देखने के लिए उत्सुक हूं कि कैसे डेनिस लागू करेगा, कहते हैं, स्ट्रिंग प्रतिस्थापन, जो थोड़ा स्वाभाविक रूप से ट्रायडिक ( replace(str, old, new)) है।
लिन

मैं जेली को नहीं जानता, लेकिन मैं जे का एक सा जानता हूं। हो सकता है, यह कहना string (operator) (list), जहां (list)एक द्विआधारी सूची है old, new। यह समझ में आता है, जेली में एक अंतर्निहित pairऑपरेटर होता है। उस योजना के तहत, हालांकि, यह ऑपरेटर के लिए दो बाइट्स होगा।
कॉनर ओ'ब्रायन

5
रुको ... ½वर्गमूल है? क्यों नहीं ½, उम ... आधा? वर्गमूल के लिए क्यों नहीं ? :(
साइओस

@Cyoce क्योंकि Hपी: पहले से ही आधा जाहिर है,
Ven

6

यह जेली विकी ट्यूटोरियल बन गया है ।

कार्यक्रम की संरचना

जेली कार्यक्रम में प्रत्येक पंक्ति एक लिंक परिभाषा है । लिंक मूल रूप से कार्य हैं। निचला रेखा " main" का प्रतिनिधित्व करती है : यह वह लिंक है जिसका मूल्यांकन कमांड लाइन पर दिए गए तर्कों का उपयोग करके किया जाता है।

सभी लिंक लेकिन अंतिम एक, तब, फ़ंक्शन परिभाषाएँ हैं: आप उन्हें अभिनेताओं का उपयोग करके संदर्भित कर सकते हैं । उदाहरण के लिए, çहै "यह एक ऊपर के लिंक, एक द्विआधारी ऑपरेटर (दो का समूह) के रूप में" । इस उदाहरण कार्यक्रम पर विचार करें , जो इसके तर्कों के योग के वर्ग की गणना करता है:

+
ç²

यह छद्मकोड की तरह है:

define f:
    the built-in link +
define main:
    apply the dyad f
    square the result

6

यह जेली विकी ट्यूटोरियल बन गया है ।

मल्टी-चेन लिंक

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

इस कार्यक्रम पर विचार करें:

C+H

यह प्लस आधा है । यह एक इनपुट मूल्य लेता है nऔर गणना करता है (1-n)+(n/2)। बहुत रोमांचक नहीं है, मुझे पता है। लेकिन संरचना वास्तव में इस तरह है:

                                                    संरचना 1

हमने जो लिंक लिखा है, वह वास्तव में एक श्रृंखला है, जिसमें एक श्रृंखला है।

मान लीजिए कि हम (1-n)+(1-n)(n/2)इसके बजाय गणना करना चाहते हैं । डाइएडिक श्रृंखला काम करेगी: चेनिंग नियमों द्वारा , यह गणना करता है λ+(λ×ρ), जो बहुत कुछ दिखता है जो हमें चाहिए। हालांकि, बस की जगह +से हमारे कार्यक्रम से काम नहीं चलेगा में: C+×Hएक 1,2,2,1 श्रृंखला है - पूरक, तो (तर्क) गुणा आधे से जोड़ें, फिर - कंप्यूटिंग ((1-n)+n)×(n/2)

हम इलाज के लिए जेली चाहते एक इकाई के रूप में, और उप-श्रृंखलाओं के एक 1,2,1-श्रृंखला बनाने C, और Hमल्टी-चेन लिंक हमें बस यही करते हैं! उनका निर्माण करने के लिए, हम श्रृंखला विभाजकों का उपयोग करते हैं øµð: ऊपर की छवि में, वे क्रमशः एक नई नीली आयत पेश करेंगे, क्रमशः 0, 1 और 2 की। हमारे मामले में, हम उन जंजीरों को समूह बना सकते हैं, जिन्हें हम लिखकर चाहते हैं Cð+×µH:

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

आगे भी इन चीजों को घोंसला बनाने का कोई तरीका नहीं है। आपको इसके बजाय कई लिंक परिभाषित करने होंगे।


आपने उन चार्टों को कैसे बनाया, जिज्ञासा से बाहर?
कॉनर ओ'ब्रायन

4
मैंने उन्हें Paint.NET में हाथ से पकड़ लिया :)
Lynn

4
वाह! प्रभावशाली! यह हार्ड जेली कार्यक्रमों के लिए अच्छा होगा, एक उपकरण की तरह जो ऐसा करता है। (अकिन से हेक्सागोनीकॉलर या इसे जो भी कहा जाता है)
कोनोर ओ'ब्रायन

5

यदि TMTOWTDI, अपनी श्रृंखला में फिट होने वाले को चुनें।

मौन भाषा के फायदों में से एक यह है कि आप आमतौर पर चर संदर्भों का उपयोग किए बिना दूर हो सकते हैं। हालाँकि, यह केवल तभी काम करता है जब आपकी श्रृंखला के लिंक में सही एरीटीज़ हों।

उदाहरण के लिए, एक 2D सरणी में सभी सरणियों का योग लेने का सीधा तरीका है

S€

जो सरणी के सभी तत्वों पर योग परमाणु को दर्शाता है।

अब कहते हैं कि आपके पास एक मोनडिक श्रृंखला है जिसमें परमाणु शामिल हैं

*

जो नक्शे प्रत्येक एक्स के लिए एक 2 डी सरणी के एक्स एक्स । उदाहरण के लिए, ए = [[१, २], [३, १], [२, ३]] के लिए , श्रृंखला को बुलाने से [[१, ४], [ २ 1, १], [४, २]] की प्राप्ति होगी। ।

अब, हम प्रत्येक जोड़ी का योग लेना चाहते हैं। दुर्भाग्य से,

*S€

तब से *काम नहीं करता क्योंकि हुक की तरह काम नहीं करता ( ए को ही सही तर्क के रूप में इस्तेमाल किया जाता है), लेकिन कांटे के रूप में , जिसका अर्थ है कि पहले पर S€लागू होता है , और परिणाम सही तर्क है ।*

इसे ठीक करना काफी आसान है:

*¹S€
*⁸S€

दोनों वांछित परिणाम उत्पन्न करते हैं: एक कांटा है जहां ¹पहचान समारोह है, और *⁸एक शीर्ष है , जहां श्रृंखला के बाएं तर्क ( ) का संदर्भ है ।

हालाँकि, बाइट को बचाने का एक तरीका है! ऊपर ḅ1(एकल से परिवर्तित पूर्णांक तक) भी प्रत्येक सरणी की राशि की गणना करता है एक एक है, लेकिन विपरीत S€, एक है dyadic लिंक।

श्रृंखला

*ḅ1

रिटर्न [5, 28, 31] (इच्छानुसार); के बाद से dyadic है, *कांटे के बजाय हुक


"सबसे ऊपर ḅ1"?
कैलकुलेटरफैनलाइन

Atop J शब्दावली है। जेली में, यह एक प्रकार की श्रृंखला है जो सीधे अंतिम रिटर्न मूल्य पर संचालित होती है, इसलिए इसे श्रृंखला के पिछले लिंक के शीर्ष पर निष्पादित किया जाता है ।
डेनिस

इस भाषा को सीखने की कोशिश न करने का एक और कारण ...: P
CalculatorFeline

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

4

पूर्णांक संपीड़न

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

अब जब जेली के पास एक स्थिर के रूप में अपना स्वयं का कोड पेज है, तो पूर्णांकों के लिए संपीड़न एल्गोरिथ्म केवल जेली में ही व्यक्त किया जाता है:

ḃ250ịØJ”“;;”’ṄV

इसे ऑनलाइन आज़माएं!

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

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


4

उपयोगी पूर्णांक मैट्रिक्स बनाने के लिए बाहरी उत्पादों का उपयोग करें

यहाँ एक gist है जो मैंने इस पोस्ट को थोड़ा अच्छे HTML HTML फॉर्मेटिंग के साथ बनाया है।

बाहरी उत्पाद त्वरित þरंजक से जुड़ा हो सकता है और रंजक को इसके बाएं और दाएं तर्कों में प्रत्येक जोड़ी तत्वों पर कार्य करने का कारण बनता है। इसके लिए आशुलिपि है €Ð€। उदाहरण के लिए यदि हमारे पास कोड होता [1,2]+€Ð€[0,10]तो हम उसे छोटा कर सकते थे [1,2]+þ[0,10] और वे दोनों उपज देते थे [[1,2],[11,12]]। मैं बाहरी उत्पाद रंग के रूप में þलागू (जैसे ) के साथ एक रंजक का उल्लेख करूंगा ।

जब एक पूर्णांक बाहरी उत्पाद रंग के तर्कों में से एक होता है, तो जेली उस नंबर की सीमा को पहले लेती है फिर परिणाम को तर्क के रूप में उपयोग करती है। यह जानकर, उपरोक्त उदाहरण को और छोटा किया जा सकता है 2+þ[0,10]। यह बाहरी उत्पाद रंग के बाएँ और दाएँ दोनों तर्कों के लिए सही है।

कुछ बाहरी उत्पाद रंजक जब पूर्णांक पर अभिनय करते हैं, तो कुछ पूर्णांक मैट्रिक्स प्राप्त होते हैं जो गोल्फ (विशेष रूप से ASCII कला चुनौतियों) में उपयोगी हो सकते हैं, लेकिन अन्यथा निर्माण के लिए कई बाइट्स लेंगे। उदाहरण के लिए जब पूर्णांक पर लागू किया जाता nहै तो एक n×nपहचान मैट्रिक्स प्राप्त होता है। ऑनलाइन कोशिश करो !

नीचे डायड्स की एक तालिका है और वे उस प्रकार के मेट्रिसेस हैं, जो बाहरी उत्पाद डाइएड्स में बदल जाते हैं और एक पूर्णांक पर मोनडली काम करते हैं। एक ही पंक्ति में सूचीबद्ध डायड समान मेट्रिसेस प्राप्त करेंगे। वहाँ dyads मैं की तरह तालिका में शामिल नहीं किया है &, |, %, w, और वह भी मैट्रिक्स पूर्णांक उत्पादन लेकिन उनके पैटर्न सरल रूप में नहीं कर रहे हैं और संभावना कम स्थितियों में उपयोगी होगा। ऑनलाइन कोशिश करो !

+ ------------------------------------------------- ---- +
| दयद | परिणाम मैट्रिक्स | उदाहरण |
+ ------------------------------------------------- ---- +
| = ⁼ | | १ ० ० |
| ċ | पहचान मैट्रिक्स | 0 1 0 |
| | | 0 0 1 |
+ ------------------------------------------------- ---- +
| | विकर्ण से ऊपर के तत्व 1 हैं, | 0 1 1 |
| <| अन्य सभी तत्व 0 हैं | 0 0 1 |
| | | 0 0 0 |
+ ------------------------------------------------- ---- +
| | विकर्ण के नीचे के तत्व 1 हैं, | 0 0 0 |
| > | अन्य सभी तत्व 0 हैं | १ ० ० |
| | | १ १ ० |
+ ------------------------------------------------- ---- +
| | विकर्ण तत्व 0 हैं, | 0 1 1 |
| एन ⁻ | बंद विकर्ण तत्व हैं 1 | १ ० १ |
| | | १ १ ० |
+ ------------------------------------------------- ---- +
| a ȧ | | 1 1 1 |
| ị ị | प्रत्येक तत्व का पंक्ति सूचकांक | 2 2 2 |
| | | ३ ३ ३ |
+ ------------------------------------------------- ---- +
| ओ ḷ | | १ २ ३ |
| ȯ | प्रत्येक तत्व का कॉलम इंडेक्स | १ २ ३ |
| | | १ २ ३ |
+ ------------------------------------------------- ---- +
| | मुख्य विकर्ण 0, ऊपरी | 0 1 2 |
| _ | विकर्ण 1, 2 हैं ..., कम | -1 0 1 |
| | विकर्ण -1, -2 हैं ... | -2 -1 0 |
+ ------------------------------------------------- ---- +
| | मुख्य विकर्ण 0, निचला | 0 -1 -2 |
| _ @ | विकर्ण 1, 2 हैं ..., ऊपरी | 1 0 -1 |
| | विकर्ण -1, -2 हैं ... | 2 1 0 |
+ ------------------------------------------------- ---- +
| | मुख्य विकर्ण 0, ऊपरी | 0 1 2 |
| ए | और निचले विकर्ण 1 हैं, | १ ० १ |
| | 2, 3 ... | 2 1 0 |
+ ------------------------------------------------- ---- +
| | | २ ३ ४ |
| + | रो इंडेक्स प्लस कॉलम इंडेक्स | ३ ४ ५ |
| | | ४ ५ ६ |
+ ------------------------------------------------- ---- +
| | न्यूनतम पंक्ति | 1 1 1 |
| «| और कॉलम सूचकांक | १ २ २ |
| | | १ २ ३ |
+ ------------------------------------------------- ---- +
| | अधिकतम पंक्ति | १ २ ३ |
| »| और कॉलम सूचकांक | २ २ ३ |
| | | ३ ३ ३ |
+ ------------------------------------------------- ---- +

2

सूची कमांड और शाब्दिक

आप में से कई का उपयोग करने का प्रयास करते हैं गैर vectorizing सूची आदेशों एक पर शाब्दिक n या एक शाब्दिक की सूची z , सूची आदेश पहले किसी प्रकार की एक सूची के लिए परिवर्तित कर देंगे और फिर उस सूची पर आदेश बाहर ले जाने के।

ये कमांड jelly.pyiterable फ़ंक्शन को कॉल का उपयोग करते हुए दिखाई देते हैं ।

def iterable(argument, make_copy = False, make_digits = False, make_range = False):
    the_type = type(argument)
    if the_type == list:
        return copy.deepcopy(argument) if make_copy else argument
    if the_type != str and make_digits:
        return to_base(argument, 10)
    if the_type != str and make_range:
        return list(range(1, int(argument) + 1))
    return [argument]

यहाँ कुछ अपूर्ण सूची दी गई है कि उन सूची कमांड क्या करेंगे।

एक सूची में लपेटता है

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

-------------------------------------------------------------------------------
| Command | Description     | Process                       | Effect          |
-------------------------------------------------------------------------------
| F       | Flattens a list | 4953F -> [4953]F -> [4953]    | Same as W       |
-------------------------------------------------------------------------------
| G       | Format a list   | 4953G -> [4953]G -> [4953]    | Same as W       |
|         | as a grid       |                               |                 |
-------------------------------------------------------------------------------
| I       | Increments      | 4953I -> [4953]I -> <nothing> | Empty list      |
-------------------------------------------------------------------------------
| S       | Sums a list     | 4953S -> [4953]S -> 4953      | Same as ¹       |
-------------------------------------------------------------------------------
| Ṭ       | Boolean array,  | 4Ṭ -> [4]Ṭ -> [0, 0, 0, 1]    | n-1 zeroes,     |
|         | 1s at indices   |                               | 1 at end        |
-------------------------------------------------------------------------------
| Ụ       | Sort indices by | 4Ụ -> [4]Ụ -> [1]             | Yields [1]      |
|         | by their values |                               |                 |
-------------------------------------------------------------------------------
| Ė       | Enumerate list  | 4Ė -> [4]Ė -> [[1, 4]]        | Yields [[1, n]] |
-------------------------------------------------------------------------------
| Ġ       | Group indices   | 4Ġ -> [4]Ġ -> [[1]]           | Yields [[1]]    |
|         | by values       |                               |                 |
-------------------------------------------------------------------------------
| Œr      | Run-length      | 4Œr -> [4]Œr -> [[4, 1]]      | Yields [[n, 1]] |
|         | encode a list   |                               |                 |
-------------------------------------------------------------------------------

बेस 10 में कन्वर्ट करें

यहां फ़ंक्शन iterableएक संख्या को अपने अंकों की सूची में धर्मान्तरित करने के लिए कहते हैं D, और फिर उन अंकों पर चलते हैं।

-------------------------------------------------------------------------
| Command | Description     | Process                      | Effect     |
-------------------------------------------------------------------------
| Q       | Unique elements | 299Q -> [2, 9, 9]Q -> [2, 9] | Unique     |
|         | ordered by      |                              | digits     |
|         | appearance      |                              | of n       |
-------------------------------------------------------------------------
| Ṛ       | Non-vectorized  | 4953Ṣ -> [4, 9, 5, 3]Ṛ       | Reverses D |
|         | reverse         | -> [3, 5, 4, 9]              |            |
-------------------------------------------------------------------------
| Ṣ       | Sort a list     | 4953Ṣ -> [4, 9, 5, 3]Ṣ       | Sorts D    |
|         |                 | -> [3, 4, 5, 9]              |            |
-------------------------------------------------------------------------

श्रेणी के साथ सूची में परिवर्तित करें

यहां फ़ंक्शन एक संख्या को श्रेणी में परिवर्तित करते हैं R = [1 ... n], और फिर उस सीमा पर चलते हैं।

-----------------------------------------------------------------------------------------
| Command | Description       | Process                             | Effect            |
-----------------------------------------------------------------------------------------
| X       | Random element    | 4R -> [1 ... 4]X -> 2               | Random element    |
|         |                   |                                     |  of R             |
|         |                   |                                     |                   |
-----------------------------------------------------------------------------------------
| Ḋ       | Dequeue from list | 4R -> [1 ... 4]Ḋ -> [2, 3, 4]       | Range [2 ... n]   |
-----------------------------------------------------------------------------------------
| Ṗ       | Pop from list     | 4Ṗ -> [1 ... 4]Ṗ -> [1, 2, 3]       | Range [1 ... n-1] |
-----------------------------------------------------------------------------------------
| Ẇ       | Sublists of list  | 4Ẇ -> [1 ... 4]Ẇ                    | All sublists of R |
|         |                   | -> [[1], [2], [3], [4], [1, 2],     |                   |
|         |                   |     [2, 3], [3, 4], [1, 2, 3],      |                   |
|         |                   |     [2, 3, 4], [1, 2, 3, 4]]        |                   |
-----------------------------------------------------------------------------------------
| Ẋ       | Shuffle list      | 4Ẋ -> [1 ... 4]Ẋ -> [2, 1, 3, 4]    | Shuffles R        |
-----------------------------------------------------------------------------------------
| Œ!      | All permutations  | 3Œ! -> [1, 2, 3]Œ!                  | All permutations  |
|         | of a list         | -> [[1, 2, 3], [1, 3, 2],           | of R              |
|         |                   |     [2, 1, 3], [2, 3, 1],           |                   |
|         |                   |     [3, 1, 2], [3, 2, 1]]           |                   |
-----------------------------------------------------------------------------------------
| ŒḄ      | Non-vectorized    | 4ŒḄ -> [1 ... 4]ŒḄ                  | Bounces R         |
|         | bounce,           | -> [1, 2, 3, 4, 3, 2, 1]            |                   |
|         | z[:-1] + z[::-1]  |                                     |                   |
-----------------------------------------------------------------------------------------
| Œc      | Unordered pairs   | 4Œc -> [1 ... 4]Œc                  | Unordered pairs   |
|         | of a list         | -> [[1, 2], [1, 3], [1, 4], [2, 3], | of R              |
|         |                   |     [2, 4], [3, 4]]                 |                   |
-----------------------------------------------------------------------------------------
| Œċ      | Unordered pairs   | 4Œċ -> [1 ... 4]Œċ                  | Unordered pairs   |
|         | with replacement  | -> [[1, 1], [1, 2], [1, 3], [1, 4], | with replacement  |
|         | of a list         |     [2, 2], [2, 3], [2, 4], [3, 3], | of R              |
|         |                   |     [3, 4], [4, 4]]                 |                   |
-----------------------------------------------------------------------------------------
| ŒP      | Powerset of       | 3ŒP -> [1 ... 3]                    | Powerset of R     |
|         | a list            | -> ['', [1], [2], [3], [1, 2],      |                   |
|         |                   |     [1, 3], [2, 3], [1, 2, 3]]      |                   |
-----------------------------------------------------------------------------------------
| Œp      | Cartesian         | 4,2Œp -> [[1 ... 4], [1 ... 2]]Œp   | Cartesian product |
|         | product of z's    | -> [[1, 1], [1, 2], [2, 1], [2, 2], | of [1 ... z[i]]   |
|         | items             |     [3, 1], [3, 2], [4, 1], [4, 2]] | for i in z        |
-----------------------------------------------------------------------------------------

यह पूरी तरह से सही नहीं है। हां, dequeue और Cartesian उत्पाद ऐसा करते हैं, लेकिन पहले 10 आधार पर श्रेणी, सॉर्ट और रिवर्स कन्वर्ट करने के बजाय सम रैप करते हैं ।
डेनिस

2

कभी-कभी दो इनपुट होने पर मानक इनपुट से पढ़ना सार्थक होता है

जेली कमांड-लाइन तर्कों से इनपुट लेने के लिए अनुकूलित है। हालाँकि, यह रंजक के बजाय सनक लिखने के लिए भी अनुकूलित है; डायड्स के साथ प्रत्येक बिल्डिन के लिए बहुत सारे संभावित अर्थ हैं कि आपको अक्सर पात्रों को खंडित करने के लिए खर्च करने की आवश्यकता होती है, जबकि मठों के साथ आमतौर पर एक ही बात कहने के कई तरीके होते हैं।

जैसे, अगर आप दो आदानों की एक केवल एक बार उपयोग करते हैं, और समस्या ऐसी है कि यह आसानी से परोक्ष से पढ़ा नहीं जा सकता (बनाने के लिए या तो जरूरत यानी आप स्पष्ट, वरना पर एक चरित्र खर्च }, @या की तरह) , इसे Ɠकमांड लाइन पर रखने के बजाय मानक इनपुट से पढ़ने पर विचार करें ; इसकी मदद से आप इनपुट को ठीक उसी जगह पर रख सकते हैं, जहां आपको अपने प्लेसमेंट के माध्यम से इसकी आवश्यकता होती है Ɠ, जबकि यह सुनिश्चित करते हुए कि हर दूसरे निहित इनपुट को अन्य इनपुट से लिया जाएगा। यह एक बाइट का खर्च करता है और एक बाइट बचाता है, और समस्या के आधार पर, कोड को फिर से व्यवस्थित करने के लिए आपको अधिक गुंजाइश देकर एक दूसरी बाइट को बचा सकता है।


2

एक तर्क के गुणों की जांच करने के कई गैर-स्पष्ट तरीके हैं Ƒ। नीचे कुछ हैं। मैं इस त्वरित का उपयोग करता है के बहुत बाहर छोड़ दिया (उदाहरण के लिए , ŒuƑ, ), क्योंकि वे पहले से ही कर रहे हैं उनके व्यवहार को प्राप्त करने का सबसे सरल तरीकों।

OƑ  Is number?
ỌƑ  Is character? (errors on negative numeric input)
ḂƑ  Between 0 and 2? 0<=x<2 (python). <2aAƑƊ or of course ⁼Ḃ$ in Jelly.
ḞƑ  Is integer?
UƑ  Like `ŒḂ`, but checks if all sublists of depth 1 are palindromes.
ṠƑ  Is one of -1, 0, 1? (e-r1¤$)

अधिक दिलचस्प मामलों को जोड़ने के लिए इसे संपादित करने के लिए स्वतंत्र महसूस करें।


2

आप आसानी से जेली भाषा में कोड बनाने के लिए डिज़ाइन किया गया एक ऑनलाइन संपादक जेली बॉल्स आज़माना चाह सकते हैं ।

सुविधाओं में शामिल हैं:

  • प्रकार द्वारा आयोजित सभी परमाणुओं और वाक्यविन्यास वर्णों के साथ कमांड पैलेट
  • कोड में शाब्दिक और 2-बाइट परमाणुओं को पहचानने वाले ऑनलाइन पार्सर
  • जावास्क्रिप्ट में वेबपेज पर अपने जेली कोड को चलाने के लिए सरलीकृत इन-ब्राउज़र जेली दुभाषिया
  • TIO या किसी अन्य जेली बॉल्स सत्र में कोड को स्थानांतरित करने के लिए सीधे लिंक
  • स्वचालित संकेत
  • मोबाइल उपकरणों के लिए अनुकूलित

इसे आज़माइए: https://jellyballs.github.io

जेली बॉल्स

  • विस्तृत ट्रेस रिपोर्ट हर निष्पादित कदम के तर्क और परिणाम दिखाती है

जेली बॉल्स

  • हर चरण का विवरण दिखाने वाली कोड रिपोर्ट

जेली बॉल्स

  • व्यंजनों पृष्ठ जेली उदाहरण के साथ

जेली बॉल्स

  • 256 जेली पात्रों के इंटरएक्टिव कोड पेज

जेली बॉल्स



3
मुझे लगता है कि एक आईडीई के लिए एक लिंक जो आपको कस्टम कीबोर्ड लेआउट के बिना जेली लिखने की सुविधा देता है, बल्कि एक उपयोगी टिप है। कई जेली शुरुआती ने उससे संघर्ष किया है।
डेनिस
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.