ब्रैकेट विस्तार!

36

आपकी चुनौती कार्यक्रम के इनपुट में कुछ कोष्ठक का विस्तार करना है जैसा कि दिखाया गया है:

  1. समापन ब्रैकेट के बाद एक एकल अंक n के साथ दो मिलान ब्रैकेट और , के बीच एक स्ट्रिंग एस का पता लगाएं ।[]
  2. कोष्ठक निकालें।
  3. बदलें रों खुद के साथ दोहराया n बार। (यदि एन 0 है, तो बस एस हटा दें ।)
  4. चरण 1 पर जाएं जब तक कि इनपुट में अधिक मिलान वाले ब्रैकेट न हों।

अतिरिक्त नियम और स्पष्टीकरण:

  • आप इनपुट लेंगे और किसी भी अनुमत साधनों के माध्यम से आउटपुट देंगे।
  • आउटपुट में अनुगामी न्यूलाइन की अनुमति है।
  • आपको केवल इनपुट में मुद्रण योग्य ASCII को संभालने की आवश्यकता है।
  • आप मान सकते हैं कि सभी कोष्ठक मेल खाते हैं, अर्थात आपको कभी भी इनपुट प्राप्त नहीं होगा []]]]या [[[[]।
  • आप मान सकते हैं कि प्रत्येक समापन ब्रैकेट ]में इसके बाद एक अंक होता है।

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

Input                -> Output
[Foo[Bar]3]2         -> FooBarBarBarFooBarBarBar
[one]1[two]2[three]3 -> onetwotwothreethreethree
[three[two[one]1]2]3 -> threetwoonetwoonethreetwoonetwoonethreetwoonetwoone
[!@#[$%^[&*(]2]2]2   -> !@#$%^&*(&*($%^&*(&*(!@#$%^&*(&*($%^&*(&*(
[[foo bar baz]1]1    -> foo bar baz
[only once]12        -> only once2
[only twice]23456789 -> only twiceonly twice3456789
[remove me!]0        -> 
before [in ]2after   -> before in in after

जैसा कि यह कोड-गोल्फ है , प्रत्येक भाषा में सबसे कम उत्तर जीतता है। सौभाग्य!

code-golf  string  compression  decode 
— एमडी एक्सएफ
स्रोत
— एमडी एक्सएफ
13
आपको एक और चुनौती पोस्ट करनी चाहिए कि एक स्ट्रिंग को उसके सबसे छोटे प्रारूप में वापस नीचे कर दिया जाए
— Jo King
क्या यह स्पष्ट रूप से कहने योग्य है कि आपकी स्ट्रिंग में sकभी अन्य ब्रैकेट नहीं होने चाहिए? उदाहरण के लिए, [Foo[Bar]3]2स्ट्रिंग को Foo[Bar3 बार विस्तारित करके हल करने का प्रयास करने से अमान्य राज्य हो जाएगाFoo[BarFoo[BarFoo[Bar]2
— ब्रैडेक
@BradC कि यह सब इस बात पर निर्भर करता है कि आप कार्य को कार्यान्वित करने के लिए कैसे चुनते हैं।
— एमडी एक्सएफ
क्या इसका मतलब यह है कि दो मान्य उत्तर हैं [a[b]2c[d]2e]2? आप abbcddeabbcddeविस्तार कर रहे हैं bऔर dपहले, लेकिन ababcdbcdedbabcdbcdedeविस्तार a[bऔर d]2eपहले से।
— ब्रैडेक

जवाबों:

13

गेमा , 17 वर्ण

[#]?=@repeat{?;#}

नमूना रन:

bash-4.4$ gema '[#]?=@repeat{?;#}' <<< '[three[two[one]1]2]3'
threetwoonetwoonethreetwoonetwoonethreetwoonetwoone
— आदमी काम पर है
स्रोत
वाह, नौकरी के लिए सही भाषा खोजने के बारे में बात करो!
— एमडी एक्सएफ
या भाषा के लिए सही नौकरी। कई चुनौतियों को छोड़ना पड़ा क्योंकि पुनरावर्ती तर्क पर्याप्त लचीला नहीं था।
— मैनटवर्क
इसे अभी के लिए स्वीकार करने के कारण मुझे ऐसा कोई तरीका नहीं दिखाई दे रहा है जो इसे हरा रहा है, लेकिन यह उस असंभावित मामले में अस्वीकार्य होगा जो यह करता है।
— एमडी एक्सएफ
8

रेटिना , 24 23 22 बाइट्स

+`\[([^][]*)](.)
$2*$1

इसे ऑनलाइन आज़माएं! यह व्यावहारिक रूप से रेटिना में निर्मित एक है। संपादित करें: @Kobi के लिए 1 बाइट का धन्यवाद सहेजा गया। रेटिना 0.8.2 में 47 45 बाइट्स:

].
]$&$*¶
{+`\[([^][]*)]¶
$1[$1]
\[([^][]*)]

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

— नील
स्रोत
7

हास्केल , 101 96 बाइट्स

fst.(""%)
infix 4%
s%']':d:r=(['1'..d]>>s,r)
s%'[':r|(t,q)<-""%r=s++t%q
s%x:r=s++[x]%r
s%e=(s,e)

इसे ऑनलाइन आज़माएं! अधिकांश अन्य उत्तरों की तरह नियमित अभिव्यक्ति का उपयोग करने के बजाय, यह एक पुनरावर्ती पार्सर को लागू करता है।

बीएमओ को -5 बाइट्स धन्यवाद !

— Laikoni
स्रोत
4
के लिए एक स्थिरता घोषणा (%)आप 1 बाइट की बचत होती है और ['1'..d]आप एक और 4 बचाता है, देखना यह ।
— ბიმო
3
@ बीएमओ नाइस, मुझे उम्मीद नहीं थी कि एक घोषणा घोषणा कभी कोड गोल्फ के लिए उपयोगी होगी। मुझे लगता है कि आपको सुझावों पर सवाल जोड़ना चाहिए।
— लैकोनी
7

पर्ल 5 , 34 33 29 + 1 ( -p) = 30 बाइट्स

s/.([^[]*?)](.)/$1x$2/e&&redo

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

@ शागिर्गी और @ टोंहोस्पेल की कुछ मदद से इसे काटें।

— Xcali
स्रोत
3
मैं मोती नहीं जानता, लेकिन फिर से बहुत खूबसूरत लगता है!
— अधिकारिक
मुझे लगता है कि आपको बचकर नहीं जाकर एक बाइट को बचाने में सक्षम होना चाहिए ] ।
— झबरा
1
मैं पर्ल पता नहीं है, लेकिन यह लगता है 30 + 1 बाइट के लिए काम करने के लिए।
— झबरा
2
ये 29 + 1 भी काम करते हैं: perl -pe 's/.([^[]*?)](.)/$1x$2/e&&redo'औरperl -pe 's/.([^][]*)](.)/$1x$2/e&&redo'
— टन हास्पेल
5

जाप v2 , 21 20 19 बाइट्स

@ बग्घी के लिए 2 बाइट्स को सहेजा गया

e/.([^[]*?)](./@YpZ

इसे ऑनलाइन टेस्ट करें!

eपुनरावर्ती प्रतिस्थापन है, जो एक समय में एक प्रतिस्थापन करता है जब तक कि अधिक मैच न हों। इस मामले में, रेगेक्स के मैचों को /\[([^[]*?)](\d)/g<आंतरिक पाठ> बार-बार <अंक> के साथ बदल दिया जाता है जब तक कि अधिक मैच न हों।

मैंने जो ( यहां ) योजना बनाई है, उसके अनुसार , यह रेगेक्स अंततः कम से कम 3 2 बाइट्स छोटा होना चाहिए :

‹[“⁽[»₋”]“.›
— ETHproductions
स्रोत
2
जैसा कि हम " मान सकते हैं कि प्रत्येक समापन ब्रैकेट ]में एक अंक है उसके बाद " आपको (\dसाथ बदलने में सक्षम होना चाहिए (.।
— झबरा
आप इसके \[साथ बदल सकते हैं.
— झबरा
@ शिग्गी नाइस, धन्यवाद!
— ETHproductions
4

जावास्क्रिप्ट, 71 67 66 बाइट्स

मेरे पास एक 54 बाइट समाधान था, लेकिन यह दूसरे परीक्षण मामले से खराब हो गया! :(

f=s=>s!=(x=s.replace(/.([^[]*?)](.)/,(_,y,z)=>y.repeat(z)))?f(x):x

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

f=s=>s!=(x=s.replace(/.([^[]*?)](.)/,(_,y,z)=>y.repeat(z)))?f(x):x
o.innerText=`[Foo[Bar]3]2
[one]1[two]2[three]3
[three[two[one]1]2]3
[!@#[$%^[&*(]2]2]2
[[foo bar baz]1]1
[only once]12
[only twice]23456789
[remove me!]0
before [in ]2after`.split`\n`.map(x=>x.padEnd(22)+`:  `+f(x)).join`\n`
<pre id=o></pre>
स्निपेट का विस्तार करें

— झबरा
स्रोत
4

पायथन 3 , 110 93 92 बाइट्स

import re
f=lambda s:f(re.sub(r'\[([^][]+)\](.)',lambda m:m[1]*int(m[2]),s))if'['in s else s

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

-17 बाइट्स धन्यवाद करने के लिए pizzapants184 -1 केविन क्रूज़सेन को धन्यवाद

— गैबोर फेकेट
स्रोत
1
पायथन 3 में -17 बाइट्स। रीचैच इंडेक्सिंग और सबस्ट्रिंग चेक का उपयोग करके in।
— pizzapants184
1
-1 बाइट बदलकर (\d)करने के लिए (.), क्योंकि हम एक ब्लॉक ब्रैकेट पता ]हमेशा एक अंकों द्वारा पीछा किया।
— केविन क्रूज़सेन
4

स्काला , 173 बाइट्स

l.foreach{x=>def r(c:String):String={val t="""\[([^\[\]]*)\](.)""".r.unanchored;c match{case t(g,h)=>r(c.replaceAllLiterally(s"[$g]$h",g*h.toInt));case _=>c}};println(r(x))}

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

विस्तारित:

l.foreach { x =>
  def remove(current: String): String = {
    val test ="""\[([^\[\]]*)\](.)""".r.unanchored
    current match {
      case test(g, h) => remove(current.replaceAllLiterally(s"[$g]$h", g * h.toInt))
      case _ => current
    }
  }

  println(remove(x))
}

पुराना हल

स्काला , 219 215 213 212 199 बाइट्स

l.foreach{x=>def r(c:String):String={"""\[([^\[\]]*)\](.)""".r.findFirstMatchIn(c).map{x=>val g=x.group(1);val h=x.group(2).toInt;r(c.replaceAllLiterally(s"[$g]$h",g*h))}.getOrElse(c)};println(r(x))}

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

विस्तारित:

l.foreach { x =>
  def remove(current: String): String = {
    """\[([^\[\]]*)\](.)""".r.findFirstMatchIn(current).map { x =>
      val g = x.group(1)
      val h = x.group(2).toInt
      remove(current.replaceAllLiterally(s"[$g]$h", g * h))
    }.getOrElse(current)
  }
  println(remove(x))
}

जहाँ l स्ट्रिंग्स की सूची है जिसे हम प्रोसेस करेंगे।

धन्यवाद केविन क्रूज़सेन -1 बाइट के लिए

अप्रयुक्त पैरामीटर को हटाकर 212 से 199 तक गए, ध्यान नहीं दिया।

— Shikkou
स्रोत
4
PPCG में आपका स्वागत है! Tio.run/#scala पर tio का scala दुभाषिया आज़माएं और देखें कि क्या आप उत्तर के लिए लिंक सबमिट कर सकते हैं, ताकि अन्य इसे ऑनलाइन आज़मा सकें। :)
— आधिकारिक
2
धन्यवाद! मैंने लिंक को शामिल करने के लिए उत्तर संपादित किया। उम्मीद है कि यह ठीक है कि कैसे हेडर, कोड और पाद को एक उचित प्रस्तुत करने के लिए घोषित किया जाता है।
— शिक्कू
1
नमस्ते, PPCG में आपका स्वागत है! महान पहला जवाब, +1 मुझसे। मुझे लगता है कि आप को बदलने के द्वारा 1 बाइट बचा सकते हैं (\d)करने के लिए (.), क्योंकि हम जानते हैं एक ब्लॉक ब्रैकेट ]हमेशा एक अंकों द्वारा पीछा किया।
— केविन क्रूज़सेन
3

स्टैक्ड , 39 38 बाइट्स

1 बाइट के लिए धन्यवाद Shaggy के लिए धन्यवाद, regex गोल्फ!

['\[([^[\]]+)](.)'{.y x:x#~y*}recrepl]

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

बस '\[([^[\]]+)](.)'पुनरावृत्ति नियम के साथ एक रेगेक्स को पुन: बदल देता है ।

— कोनोर ओ ब्रायन
स्रोत
मुझे लगता है कि आप अंतिम बचकर बाइट बचा सकते हैं ]।
— झबरा
3

पायथन 3, 155 148 101 97 बाइट्स

def f(x):
 a=x.rfind('[')
 if~a:b=x.find(']',a);x=f(x[:a]+x[a+1:b]*int(x[b+1])+x[b+2:])
 return x

यह ऑनलाइन की कोशिश करो

हाइपरन्यूट्रिनो और मीगो को -47 बाइट्स के लिए धन्यवाद और -4 बाइट्स के लिए उपयोगकर्ता 202729।

— मनीष कुंडू
स्रोत
युगल बाइट को बचाने के लिए इसे वन-लाइनर बनाएं:def f(x):a=x.rfind('[');b=x.find(']',a);return f(x[:a]+x[a+1:b]*int(x[b+1])+x[b+2:])if~a else x
— मैथमैडैन
3

जावास्क्रिप्ट - 77 75 72 बाइट्स

f=a=>a.replace(/(.*)\[([^[]*?)](.)(.*)/,(a,b,c,d,e)=>f(b+c.repeat(d)+e))

संपादित करें: झबरा की सिफारिश के साथ अद्यतन रेगेक्स

स्निपेट:

कोड स्निपेट दिखाएं

— max890
स्रोत
2
PPCG में आपका स्वागत है! आप अपने RegEx को कम करके 70 बाइट्स तक प्राप्त कर सकते हैं ।
— झबरा
हाँ, 72 बाइट्स, जाहिर है, क्षमा करें; मैं गिनना भूल गया था f=!
— झबरा
2

≡तर्क के साथ QuadR , 30 28 बाइट्स

\[[^[]+?].
∊(⍎⊃⌽⍵M)⍴⊂1↓¯2↓⍵M

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

\[[^[]+?]. " [गैर- [सामान ]चरित्र" के साथ बदलें

¯2↓⍵M के अंतिम दो पात्रों ड्रॉप एम atch ( " ]अंकों")
1↓ पहला वर्ण ड्रॉप ( " [")
⊂ लगा देना एक पूरे के रूप में देखा जाना चाहिए
(... )⍴ आर लंबाई में eshape:
 ⌽⍵M रिवर्स एम atch
 ⊃ पहले (अंक) लेने
 ⍎ का मूल्यांकन
∊ ε nlist ( समतल)

≡ तब तक दोहराएं जब तक कि अधिक परिवर्तन न हों

समतुल्य Dyalog APL फ़ंक्शन 47 बाइट्स है:

'\[[^[]+?].'⎕R{∊(⍎⊃⌽⍵.Match)⍴⊂1↓¯2↓⍵.Match}⍣≡

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

— एडम
स्रोत
2

जावा 8, 250 249 241 239 बाइट्स

s->{for(;s.contains("[");)for(int i=0,j,k;i<s.length();)if(s.charAt(i++)==93){String t="",r=t;for(j=k=s.charAt(i)-48;j-->0;)t+=s.replaceAll(r="(.*)\\[([^\\]]+)\\]"+k+"(.*)","$2");s=k<1?t:s.replaceFirst(r,"$1$3").replace("",t);}return s;}

@JonathanFrech के लिए -2 बाइट्स के लिए धन्यवाद (कोड में अभी दो अप्राप्य ASCII वर्ण हैं, जिन्हें नीचे TIO- लिंक में देखा जा सकता है)।

Sigh ... regex के साथ जावा इतना सीमित है .. मैं यहाँ एक और उत्तर से खुद को उद्धृत करूँगा:

जावा के WWWWसाथ प्रतिस्थापित 222Wकरना आसान है, लेकिन 4Wनहीं .. यदि केवल जावा के पास कुछ के लिए रेगेक्स कैप्चर-ग्रुप का उपयोग करने का एक तरीका है .. लंबाई के साथ हो रही है "$1".length(), मैच को खुद के साथ बदलना "$1".replace(...), मैच को पूर्णांक के साथ new Integer("$1")या उपयोग करके परिवर्तित करना। रेटिना (यानी s.replaceAll("(?=(.)\\1)(\\1)+","$#2$1"))या जावास्क्रिप्ट (यानी s.replaceAll("(.)\\1+",m->m.length()+m.charAt(0))) के समान कुछ मेरी नंबर 1 चीज होगी जिसे मैं भविष्य में जावा में देखना चाहता हूं ताकि कोडगुल्फिंग को लाभ मिल सके ..>> मुझे लगता है कि यह 10 वीं बार है जब मैं जावा से नफरत नहीं कर सकता। कैप्चर-ग्रुप मैच के साथ कुछ भी ..
यहाँ से उद्धरण।

स्पष्टीकरण:

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

s->{                           // Method with String as both parameter and return-type
  for(;s.contains("[");)       //  Loop as long as the String contains a block-bracket
    for(int i=0,j,k;i<s.length();)
                               //   Inner loop over the characters of the String
      if(s.charAt(i++)==93){   //    If the current character is a closing block-bracket:
        String t="",r=t;       //     Create two temp-Strings, starting empty
        for(j=k=s.charAt(i)-48;//     Take the digit after the closing bracket
            j-->0;)            //     Loop that many times:
          t+=s.replaceAll(r="(.*)\\[([^\\]]+)\\]"+k+"(.*)","$2");
                               //      Append `t` with the word inside the block brackets
        s=k<1?                 //     If the digit was 0:
           t                   //      Replace the input with an empty String as well
          :                    //     Else:
           s.replaceFirst(r,"$1$3").replace("",t);}
                               //      Replace the word between brackets by `t`,
                               //      and remove the digit
  return s;}                   //  Return the modified input-String as result
— केविन क्रूज़सेन
स्रोत
1
मुझे लगता है कि आप दो बाइट्स को बचाने के लिए वास्तव में ASCII का उपयोग कर सकते हैं, हालांकि यह अनुचित चरित्र है । (आपका समाधान वास्तव में 241 बाइट्स, 239 अक्षर लेता है।)
— जोनाथन फ्रीच
@JonathanFrech धन्यवाद! मुद्रण योग्य ASCII सीमा के बाहर 1-बाइट वर्ण के लिए देख रहा था। एक
— अप्राप्य
2

सी, 407 368 बाइट्स

बाइट्स बचाने के लिए जोनाथन फ्रेच को धन्यवाद।

गोल्फ (फ़ाइल कोष्ठक।):

i,j,k,l,n;char*f(a,m)char*a;{for(i=0;a[i];++i){a[i]==91&&(j=i+1);if(a[i]==93){k=a[i+1]-48;if(!k){for(l=i+2;l<m;)a[++l-i+j-4]=a[l];a=realloc(a,m-3);return f(a,m-3);}for(l=j;l<i;)a[~-l++]=a[l];for(l=i+2;l<m;)a[++l-4]=a[l];m-=3;n=m+~-k*(i---j--);a=realloc(a,n);for(l=i;l<m;)a[l+++~-k*(i-j)]=a[l];for(m=0;m<k;++m)for(l=j;l<i;)a[l+++m*(i-j)]=a[l];return f(a,n);}}return a;}

कार्यक्रम में शामिल नहीं:

#include <stdlib.h>
#include <stdio.h>

// '[' = 133
// ']' = 135
// '0' = 48

i, j, k, l, n;

char* f(a,m) char*a;
{
  for (i=0; a[i]; ++i) {
    a[i]==91&&(j=i+1);

    if (a[i]==93) {
      k=a[i+1]-48;

      if (!k) {
        for (l=i+2; l<m; )
          a[++l-i+j-4] = a[l];

        a = realloc(a,m-3);
        return f(a,m-3);
      }
      for (l=j;l<i;)
        a[~-l++] = a[l];
      for (l=i+2; l<m; )
        a[++l-4] = a[l];
      m -= 3;
      n = m+~-k*(i---j--);
      a = realloc(a,n);

      for (l=i; l<m; )
        a[l+++~-k*(i-j)] = a[l];
      for (m=0; m<k; ++m)
        for (l=j; l<i;)
          a[l+++m*(i-j)] = a[l];

      return f(a,n);
    }
  }
  return a;
}

int main()
{
  char c[]="[Foo[Bar]3]2";
  char *b;

  char cc[]="[remove me!]0";
  char *bb;

  char ccc[]="[only once]12";
  char *bbb;

  b=malloc(13);
  bb=malloc(14);
  bbb=malloc(14);

  for (i=0; i<13; ++i)
    b[i] = c[i];

  for (i=0; i<14; ++i)
    bb[i] = cc[i];

  for (i=0; i<14; ++i)
    bbb[i]=ccc[i];

  printf("%s\n", f(b, 13));
  printf("%s\n", f(bb, 14));
  printf("%s\n", f(bbb, 14));

  return 0;
}

जीसीसी 5.4.1 के साथ संकलित, gcc bracket.c

— Tsathoggua
स्रोत
1
— जोनाथन फ्रीच
आवश्यक के साथ 387 (realloc के लिए) शामिल हैं। मैं बाद में एक साफ अपडेट (अनगुल्ड संस्करण के साथ) करूंगा। धन्यवाद
— Tsathoggua
यदि आप GCC का उपयोग करते हैं, तो मुझे लगता है कि संकलक दोनों की परिभाषा का अनुमान लगाने का प्रयास करेगा mallocऔर realloc, stdlib.hअपने सहित ।
— जोनाथन फ्रीच
मुझे नहीं पता था। कोड गोल्फिंग के लिए अच्छी सुविधा। धन्यवाद।
— Tsathoggua
2

लाल , 147 बाइट्स

f: func[t][a: charset[not"[]"]while[parse t[any a some[remove["["copy h any a"]"copy d a](insert/dup v: copy""h to-integer d)insert v | skip]]][]t]

Ungolfed:

f: func [t][
    a: charset [not "[]"]                          ; all chars except [ and ]
    while [ parse t [                              ; repeat while parse is returning true
        any a                                      ; 0 or more chars other than [ and ]
        some [                                     ; one or more block:
            remove ["[" copy h any a "]" copy d a] ; remove the entire block, store the
                                                   ; substring between the [] in h,
                                                   ; the digit into d
            (insert/dup v: copy "" h to-integer d) ; makes d copies of h 
            insert v                               ; and inserts them in place 
            | skip ]                               ; skip if no match
        ]                                       
    ][]                                            ; empty block for 'while'
    t                                              ; return the modified string
]

मैंने कल ही Red's Parse बोली सीखना शुरू किया था, इसलिए मुझे यकीन है कि मेरे कोड को और बेहतर बनाया जा सकता है। पार्स रेपेक्स की तुलना में अतुलनीय रूप से अधिक क्रियात्मक है, लेकिन बहुत स्पष्ट, लचीला और पठनीय है और लाल भाषा के बाकी हिस्सों के साथ स्वतंत्र रूप से मिलाया जा सकता है।

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

— गैलेन इवानोव
स्रोत
1

जेली , 30 बाइट्स

œṡ”]µḢUœṡ”[ẋ€1¦Ṫ©Ḣ$FṚ;®
Çċ”]$¡

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

स्पष्टीकरण।


œṡ”]µḢUœṡ”[ẋ€1¦Ṫ©Ḣ$FṚ;®    Helper link 1, expand once.
                           Assume input = "ab[cd]2ef".

œṡ      Split at first occurence of
  ”]      character "]".
    µ   Start new monadic chain. Value = "ab[cd","2ef".

Ḣ       Ḣead. "ab[cd"
 U      Upend. "dc[ba"
  œṡ”[  Split at first occurence of "[". | "dc","ba".

ẋ€        Repeat ...
  1¦        the element at index 1...
          by ...
    Ṫ Ḣ$    the Ḣead of the Ṫail of ...
          the input list ("ab[cd","2ef") (that is, 2)

          The command Ḣ also pop the head '2'. The remaining
            part of the tail is "ef".
     ©    Meanwhile, store the tail ("ef") to the register.

          Current value: "dcdc","ba"
FṚ        Flatten and Ṛeverse. | "abcdcd"
  ;®      Concatenate with the value of the register. "abcdcdef"

Çċ”]$¡    Main link.

 ċ”]$     Count number of "]" in the input.
     ¡    Repeatedly apply...
Ç           the last link...
            that many times.
— user202729
स्रोत
1

सी, 381 बाइट्स

कॉम्पैक्ट संस्करण:

while(1){int t=strlen(i);int a,c=-1;char*w;char*s;char*f;while(c++<t){if(i[c]==']'){int k=c-a;w=calloc((k--),1);memcpy(w,&i[a+1],k);s=calloc((t-c-1),1);memcpy(s,&i[c+2],t-c-2);i[a]=0;int r=i[c+1]-48;if(r==0){f=calloc(t,1);sprintf(f,"%s%s",i,s);}else{f=calloc((t+k),1);sprintf(f,"%s%s[%s]%d%s",i,w,w,r-1,s);}free(i);i=f;break;}else if(i[c]=='[')a=c;}free(w);free(s);if(c>=t)break;}

पूर्ण संस्करण:

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

void proceed(char* input)
{
  while(1)
  {
    int t=strlen(input);
    int start,cursor=-1;
    char* word;
    char* suffix;
    char* final;
    while(cursor++<t)
    {
      if(input[cursor]==']')
      {
        int wordlength = cursor-start;
        word=calloc((wordlength--),sizeof(char));
        memcpy(word, &input[start+1], wordlength );
        suffix=calloc((t-cursor-1),sizeof(char));
        memcpy( suffix, &input[cursor+2], t-cursor-2 );
        input[start]='\0';
        int rep=input[cursor+1]-'0';
        if(rep==0)
        {
          final=calloc(t,sizeof(char));
          sprintf(final,"%s%s",input,suffix);
        }
        else
        {
          final=calloc((t+wordlength+5),sizeof(char));
          sprintf(final,"%s%s[%s]%d%s",input,word,word,rep-1,suffix);
        }
        free(input);
        input=final;
        break;
      }
      else if(input[cursor]=='[')
        start=cursor;
    }
    free(word);
    free(suffix);

    if(cursor>=t)break;
  }
}

int main()
{
  char* input=calloc(256,sizeof(char));
  sprintf(input,"a[[toto]2b]2[ana]3");
  printf("in : %s\n",input);
  proceed(input);
  printf("out: %s\n",input);
  return 0;
}
— raphchar
स्रोत
3
PPCG में आपका स्वागत है!
— झबरा
1
साइट पर आपका स्वागत है! ध्यान दें कि सी सबमिशन को केवल स्निपेट नहीं बल्कि पूरे कार्यक्रम या फ़ंक्शंस होने चाहिए।
— एमडी एक्सएफ
1

पायथन, 80 बाइट्स

import re
b=re.sub
s=lambda x:eval(b(r"\](.)",r"')*\1+'",b(r"\[","'+('","%r"%x)))

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

s("[Foo[Bar]3]2")को परिवर्तित [Foo[Bar]3]2करता है''+('Foo'+('Bar')*3+'')*2+'' , और मूल्यांकन करता है।

कोष्ठक में उद्धरण के साथ इनपुट के लिए विफल (जैसे [']3)

— ugoren
स्रोत
मैंने इस उत्तर को अस्वीकार कर दिया क्योंकि प्रश्न को इनपुट में किसी भी मुद्रण योग्य ASCII को संभालने की आवश्यकता है, और यह उत्तर नहीं देता है। यदि आप इसे ठीक करते हैं तो मुझे सूचित करें, और मैं ख़ुशी से अपना वोट वापस लूंगा।
— caird coinheringaahing
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.