एक Pythlike स्ट्रिंग को अनमनी करें

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

पायथ कोड को अक्सर पढ़ना मुश्किल होता है। यहां तक कि डिबग मोड (ट्रांसप्लेड पायथन) के आउटपुट में अक्सर एक लंबी लाइन होती है, कभी-कभी कोष्ठक के साथ दस गहरी नेस्टेड होते हैं। हालांकि, सही ढंग से स्वरूपित पायथ बहुत पठनीय है।

यहाँ प्ले वर्ड चेन में @isaacg द्वारा लिखा गया Pyth कोड का एक टुकड़ा है ।

.MlZfqhMtTeMPT+Lzs.pMyQ

यह इस तरह बहुत अधिक पठनीय है।

.M                     Filter by gives-maximal-value of
   l Z                   lambda Z:length(Z) over
   f                     filter by (lambda T:
     q                     equal
       hM t T                head-map tail T
       eM P T                end-map Pop T)
     +L                    Append z to each element in
        z                        
        s .pM y Q            flattened permutations of each subset of Q

इस चुनौती के लिए, हम Pyth वर्णों को श्रेणीबद्ध करने और स्वरूपण पर ध्यान केंद्रित करने के kolmogorov-complexity पहलू को समाप्त करते हैं । Pyth कोड होने के बजाय, इनपुट में वर्ण शामिल होंगे 0123456789M। अंक , nएरिटी के एक फंक्शन को दर्शाता है nऔर Mएक ऑपरेटर को दर्शाता है। उदाहरण के लिए, उपरोक्त कोड को इस रूप में दर्शाया गया है 210221M101M102M011M10। यहाँ कदम हैं:

स्ट्रिंग को टोकन में अलग करें।

एक टोकन मेल खाता है [0-9]M*। 0Mइनपुट में नहीं होगा।

अनुगामी 0 s जोड़ें।

जब पर्याप्त तर्क नहीं होते हैं, तो Pyth कोड को कई निहित चर (लैम्ब्डा वैरिएबल या Qs) के रूप में जोड़ देता है, जैसा कि कार्यक्रम के तर्कों को भरने के लिए आवश्यक है; इन्हें 0एस द्वारा दर्शाया जाना चाहिए ।

समूह टोकन लाइनों में।

एक टोकन की शुद्धता उसके अंक का मूल्य है।

एक Arity-0 टोकन (यानी 0) एक पंक्ति को समाप्त करता है।
एक arity-1 टोकन के लिए अगला टोकन एक ही लाइन पर जाना चाहिए, एक स्थान द्वारा अलग किया गया।
एक तर्क> = 2 टोकन के लिए, इसके तर्क अलग-अलग पंक्तियों पर चलते हैं, क्रम में वे कोड में दिखाई देते हैं, प्रत्येक के बाद उनके स्वयं के सबरगमेंट और इतने पर। एक टोकन के तर्क उस टोकन के अंत में एक स्थान से अधिक होते हैं।

इनपुट

एक गैर-रिक्त स्ट्रिंग (या चार सरणी, लंबाई -1 स्ट्रिंग्स की सरणी, आदि) मानक I / O विधियों द्वारा अनुमत है 0123456789M, जिसमें विकल्प शामिल नहीं होंगे 0M।

उत्पादन

उपरोक्त नियमों के अनुसार स्ट्रिंग स्वरूपित है।

परीक्षण के मामलों

210221M101M102M011M10

2
  1 0
  2
    2
      1M 1 0
      1M 1 0
    2M
       0
       1 1M 1 0


123M4M

1 2
    3M
       4M
          0
          0
          0
          0
       0
       0
    0


2MM

2MM
    0
    0


11011100

1 1 0
1 1 1 0
0


9000000

9
  0
  0
  0
  0
  0
  0
  0
  0
  0

code-golf string parsing

— lirtosiast
स्रोत

संबंधित प्रश्न: codegolf.stackexchange.com/questions/47798/…

— lirtosiast

क्या मैं इनपुट को अंकों / स्ट्रिंग की एक सरणी के रूप में ले सकता हूं? उदाहरण 210221M101M102M011M10होगा[2,1,0,2,2,1,'M',1,0,1,'M',1,0,2,'M',0,1,1,'M',1,0]

— लुइस फेलिप डी जीसस मुनोज़

@LuisfelipeDejesusMunoz नहीं, जब तक कि मानक I / O नियमों की आवश्यकता नहीं होती है कि आपको अनुमति दी जाती है (जो मुझे नहीं लगता कि वे ऐसा करते हैं।) IMO यह चुनौती को थोड़ा बदल देगा यदि Ms को पूर्णांक से भिन्न डेटाटाइप होने दिया जाए।

— lirtosiast

@lirtosiast तो पात्रों / एकल-वर्ण स्ट्रिंग्स की एक सरणी ठीक है, बस अंकों और अंकों के बीच अलग-अलग डेटाटिप्स का उपयोग नहीं कर रहे हैं M?

— कामिल दकरी

@LeakyNun खाली स्ट्रिंग अब अपरिभाषित व्यवहार है।

— lirtosiast

जवाबों:

जावास्क्रिप्ट (ईएस 8), 160 159 बाइट्स

f=(s,a=[d=0,p=[1]])=>s.replace(/(.)M*/g,(s,c)=>(g=_=>a[d]?s+(P=p[d]-=c--&&~s.length,c?`
`.padEnd(P):' '):g(d--))(a[d]--,a[++d]=+c,p[d]=p[d-1]))+(d?f('0',a):'')

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

टिप्पणी की गई

f = (                          // f = recursive function taking:
  s,                           //   s   = input string
  a = [                        //   a[] = array holding the number of expected arguments
    d = 0,                     //   d   = current depth, initialized to 0
    p = [1]                    //   p[] = array holding the padding values
  ]                            //
) =>                           //
  s.replace(                   // search in s all substrings
    RegExp('(.)M*', 'g'),      // consisting of a digit followed by 0 to N 'M' characters
    (s, c) =>                  // for each substring s beginning with the digit c:
      ( g = _ =>               //   g = recursive function
          a[d] ?               //     if we're still expecting at least one argument at
                               //     this depth:
            s + (              //       append s
              P = p[d] -=      //       update the padding value P = p[d] for this depth:
                c-- &&         //         decrement c; unless c was equal to 0,
                ~s.length,     //         add the length of s + 1 to p[d]
              c ?              //       if c is not equal to 0 (i.e. was not equal to 1):
                `\n`.padEnd(P) //         append a linefeed followed by P - 1 spaces
              :                //       else:
                ' '            //         append a single space
            )                  //
          :                    //     else (all arguments have been processed):
            g(d--)             //       decrement the depth and call g again
      )(                       //   before the initial call to g:
        a[d]--,                //     decrement the number of arguments at depth d
        a[++d] = +c,           //     set the number of arguments for the next depth
        p[d] = p[d - 1]        //     set the padding value for the next depth,
      )                        //     using a copy of the previous depth
  ) + (                        // end of replace()
    d ?                        // if we're not back at depth 0:
      f('0', a)                //   do a recursive call to f with an extra '0'
    :                          // else:
      ''                       //   stop recursion
  )                            //

— Arnauld
स्रोत

हास्केल , 192 190 187 बाइट्स

unlines.snd.f
f(n:r)|(m,t)<-span(>'9')r,(s,l)<-n#t=(s,n?((n:m):map((' '<$(n:n:m))++)l))
f e=(e,["0"])
'1'?(a:b:r)=(a++drop(length a)b):r
_?s=s
'0'#s=(s,[])
n#s|(r,l)<-f s=(l++)<$>pred n#r

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

एरिटी -1 केस को संभालने के लिए एक बेहतर तरीका होना चाहिए, वर्तमान में 45 बाइट्स का समय लगता है।

संपादन:

1 को संभालने की एक अलग विधि पर स्विच करके -2 बाइट्स, हालांकि पिछली विधि में संभवतः अधिक अनुकूलन क्षमता है।
-3 बाइट्स वर्ण अंकों को संख्याओं में परिवर्तित न करके और predइसके बजाय उपयोग करके n-1।

unlines.snd.f
f(n:r)|(m,t)<-span(>'9')r,(s,l)<-read[n]#t,w<-map((' '<$(n:n:m))++)=(s,last$((n:m):w l):[(n:m++' ':h):w t|n<'2',h:t<-[l]])
f e=(e,["0"])
0#s=(s,[])
n#s|(r,l)<-f s=(l++)<$>(n-1)#r

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

— Laikoni
स्रोत

चारकोल , 75 बाइट्स

ＦＳ⊞υ⎇⁼ιM⁺⊟υιι≔⮌υυ≔⟦⟧θ≔⟦⟧ηＷ∨υη«≔⎇υ⊟υ0ιι¿⊖Σι↘→⊞θι⊞ηΣιＷ∧η¬§η±¹«⊟ηＭ⊕Ｌ⊟θ←¿η⊞η⊖⊟η

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

ＦＳ⊞υ⎇⁼ιM⁺⊟υιι

इनपुट वर्णों पर लूप करें और उन्हें वैकल्पिक Mप्रत्ययों के साथ अंकों की सूची में बदल दें ।

≔⮌υυ

इस सूची को उल्टा कर दें ताकि हम इसका Popउपभोग कर सकें।

≔⟦⟧θ

यह चर टोकन का एक ढेर है, जिसकी विविधता अभी तक पूरी नहीं हुई है।

≔⟦⟧η

यह चर अधूरी पड़ी टोकन की शेष आरी का ढेर है।

Ｗ∨υη«

तब तक दोहराएं जब तक हम सभी टोकन का सेवन नहीं कर लेते और ढेर को खाली नहीं कर देते।

     ≔⎇υ⊟υ0ι

अगला टोकन प्राप्त करें या 0यदि कोई नहीं है।

     ι¿⊖Σι↘→

टोकन प्रिंट करें और फिर कर्सर को क्षैतिज रूप से स्थानांतरित करें यदि यह 1अन्यथा तिरछे से शुरू होता है ।

     ⊞θι⊞ηΣι

टोकन और उसकी शुद्धता को उपयुक्त चर में जोड़ें।

     Ｗ∧η¬§η±¹«

रिपीटी स्टैक नॉनमिप्ट है, जबकि दोहराएं, लेकिन शीर्ष आर्टरी शून्य है।

              ⊟η

शून्य की संख्या को त्यागें।

              Ｍ⊕Ｌ⊟θ←

इसके टोकन निकालें और ले जाएँ कि कई वर्ण बचे हैं।

              ¿η⊞η⊖⊟η

यदि कोई भी अर्तांता शेष है तो शीर्ष धमनी को घटाएं।

— नील
स्रोत