दिए गए कोष्ठकों का उपयोग करते हुए एक स्ट्रिंग का संकेत दें

Question

कार्यक्रम के लिए निम्नलिखित इनपुट को देखते हुए:

1. ब्लॉक स्टार्ट पात्रों की सूची
2. ब्लॉक अंत पात्रों की सूची
3. प्रारूप करने के लिए एक स्ट्रिंग

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

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

उदाहरण के लिए {[(<और }])>उद्घाटन और समापन चरित्र सेट और निम्नलिखित स्ट्रिंग के रूप में:

abc{xyz{text[note{comment(t{ex}t)abc}]}}

निम्नलिखित आउटपुट की उम्मीद की जाएगी:

abc
{
  xyz
  {
    text
    [
      note
      {
        comment
        (
          t
          {
            ex
          }
          t
        )
        abc
      }
    ]
  }
}

आप "कोष्ठक" वर्णों की सूची को हार्ड-कोड नहीं कर सकते हैं। इनपुट कैसे दिया जाता है, हालांकि निर्दिष्ट नहीं है; जैसा कि आप चाहें, यह कमांड-लाइन तर्क या मानक इनपुट के माध्यम से हो सकता है।

Comments

क्या हम मान सकते हैं कि प्रत्येक कोष्ठक के लिए एक समापन एक है, और उसी क्रम में?

— जुआन

क्या कार्यक्रम को तर्क के रूप में दिए गए किसी भी कोष्ठक पात्रों का समर्थन करना है? उदाहरण के लिए ./program 'p' 'q' <<< '1p23p45q67q8' या इसे केवल समर्थन की आवश्यकता है {[(<और }])>?

— जॉय एडम्स

@ जॉय, मैं नहीं मानूंगा, हालांकि यह सब अधिक प्रभावशाली होगा।

— नील

joey: इनपुट 1. ओपन कोष्ठक वर्ण हैं। 2. लघु कोष्ठक वर्ण 3. इंडेंट को स्ट्रिंग। जुआन: हम यह मान सकते हैं कि, हालांकि कोड को उस पर भरोसा करने की आवश्यकता नहीं है, मेरा क्या मतलब है कि यदि परिसीमन कोष्ठक चार्ट खोलने का हिस्सा है, तो इंडेंट बढ़ाएं, अन्यथा अगर कोष्ठक चार्ट बंद करने का हिस्सा इंडेंट कम हो जाता है।

— प्रशांत भाटे

@ चरण भाटे: और आउटपुट में?

— लोअरजैकर

Answer 1

रूबी, 106 101 96 95

s,e,i=$*
i.scan(/[#{z=Regexp.quote s+e}]|[^#{z}]*/){|l|puts'  '*(s[l]?~-$.+=1:e[l]?$.-=1:$.)+l}

कमांड लाइन के माध्यम से इनपुट प्रदान किया जाता है।

Comments

के ~-j+=1बजाय का उपयोग करके आप 4 वर्णों को बचा सकते हैं (j+=1;j-1)। इसके अतिरिक्त, $.हर जगह का उपयोग करने से jआपको हटाने की अनुमति मिलती है j=0, जो दूसरे वर्ण को बचाता है।

— वेंटरो जूल

Answer 2

पर्ल - 131 96 94 चार्ट

$i="";for$_(split/([\Q$ARGV[0]$ARGV[1]\E])/,$ARGV[2]){$i=~s/..// if/[\Q$ARGV[1]\E]/;print "$i$_\n"if$_;$i.='  'if/[\Q$ARGV[0]\E]/;}

ऐसा लगता है कि सामान्य अभिव्यक्तियों को खत्म करने के लिए जगह होनी चाहिए, कम से कम, लेकिन यह एक त्वरित कदम है जो उदाहरण को संभालता है, साथ ही साथ जॉय एडम्स की मनमानी कोष्ठक के बारे में काल्पनिक है।

---

वास्तव में, सुधार के लिए बहुत जगह थी:

$_=pop;($s,$e)=map"[\Q$_\E]",@ARGV;for(split/($s|$e)/){print"  "x($i-=/$e/),"$_\n"if$_;$i+=/$s/}

---

... और अभी भी थोड़ा और:

$_=pop;($s,$e)=map"[\Q$_\E]",@ARGV;map{print"  "x($i-=/$e/),"$_\n"if$_;$i+=/$s/}split/($s|$e)/

Answer 3

गणितज्ञ (गैर कोड गोल्फ)

indent[str_String]:=Module[{ind,indent,f},
ind=0;
indent[i_]:="\n"<>Nest["    "<>ToString[#]&,"",i];
f[c_] :=  (indent[ind] <> c <> indent[++ind]) /; StringMatchQ["[({",___~~c~~___];
f[c_] := ( indent[--ind] <> c <>indent[ind])  /; StringMatchQ["])}",___~~c~~___];
f[c_] := (c <>indent[ind])       /; StringMatchQ[";,",___~~c~~___];
f[c_] := c  ;
f /@ Characters@ str//StringJoin
]

परीक्षा

indent["abc{xyz{text[note{comment(t{ex}t)abc}]}}"]
abc
{
    xyz
    {
        text
        [
            note
            {
                comment
                (
                    t
                    {
                        ex
                    }
                    t
                )
                abc
            }

        ]

    }

}

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

format[expr_] := indent[expr // FullForm // ToString]

---

EDIT (नॉन कोड गोल्फ) जिस तरह से नई कहानियों को प्रस्तुत किया जाता है, उस पर बारीक नियंत्रण होता है

indent[str_String, ob_String, cb_String, delim_String] := 
  Module[{ind, indent, f, tab}, ind = 0; tab = "    ";
   indent[i_, tab_, nl_] := nl <> Nest[tab <> ToString[#] &, "", i];
   f[c_] := (indent[ind, "", " "] <> c <> indent[++ind, tab, "\n"]) /;StringMatchQ[ob, ___ ~~ c ~~ ___];
   f[c_] := (indent[--ind, "", " "] <> c <> indent[ind, tab, "\n"]) /;StringMatchQ[cb, ___ ~~ c ~~ ___];
   f[c_] := (c <> indent[ind, tab, "\n"]) /;StringMatchQ[delim, ___ ~~ c ~~ ___];
   f[c_] := c;
   f /@ Characters@str // StringJoin];
format[expr_] := indent[expr // InputForm // ToString, "[({", "])}", ";"];

format[Hold@Module[{ind, indent, f, tab}, ind = 0; tab = "    ";
 indent[i_, tab_, nl_] := nl <> Nest[tab <> ToString[#] &, "", i];
 f[c_] := (indent[ind, "", " "] <> c <> indent[++ind, tab, "\n"]) /;StringMatchQ[ob, ___ ~~ c ~~ ___];
 f[c_] := (indent[--ind, "", " "] <> c <> indent[ind, tab, "\n"]) /;StringMatchQ[cb, ___ ~~ c ~~ ___];
 f[c_] := (c <> indent[ind, tab, "\n"]) /;StringMatchQ[delim, ___ ~~ c ~~ ___];
 f[c_] := c;
 f /@ Characters@str // StringJoin]]

उत्पादन

Hold [
    Module [
         {
            ind, indent, f, tab }
        , ind = 0;
         tab = "    ";
         indent [
            i_, tab_, nl_ ]
         := StringJoin [
            nl, Nest [
                StringJoin [
                    tab, ToString [
                        #1 ]
                     ]
                 & , "", i ]
             ]
        ;
         f [
            c_ ]
         := StringJoin [
            indent [
                ind, "", " " ]
            , c, indent [
                ++ind, tab, "\n" ]
             ]
         /;
         StringMatchQ [
            ob, ___~~c~~___ ]
        ;
         f [
            c_ ]
         := StringJoin [
            indent [
                --ind, "", " " ]
            , c, indent [
                ind, tab, "\n" ]
             ]
         /;
         StringMatchQ [
            cb, ___~~c~~___ ]
        ;
         f [
            c_ ]
         := StringJoin [
            c, indent [
                ind, tab, "\n" ]
             ]
         /;
         StringMatchQ [
            delim, ___~~c~~___ ]
        ;
         f [
            c_ ]
         := c;
         StringJoin [
            f / @
                 Characters [
                    str ]
                 ]
             ]
         ]

Comments

यह शायद ही कोड गोल्फ है, जिसमें बहु-चरित्र नाम हैं indent। क्या आपका लक्ष्य अधिकतम कोड है, या पठनीयता है? उस कोड को कम करने के कई तरीके हैं, यदि वह वास्तव में आपका लक्ष्य है। इसके अलावा: "आप" कोष्ठक "वर्णों की सूची को हार्ड-कोड नहीं कर सकते हैं।" अभी तक आप यहाँ क्या किया है कि वास्तव में नहीं है? वैसे भी, इतने नकारात्मक ध्वनि के लिए खेद है; यह सिर्फ मुझे अपनी चुनौती के लिए एक अजीब जवाब के रूप में हमला करता है।

— श्री। छिपकली

@ Mr.Wizard इसकी कोड गोल्फ नहीं है, मैंने इसे अपने संदर्भ के लिए जोड़ा है [इसे स्पष्ट करने के लिए अपडेट किया गया]। मैं बार-बार इसका इस्तेमाल अनमैटेड मैथमेटिका कोड को समझने के लिए करता हूं, जो एक पेज से बड़ा होता है

— प्रशांत भाटे

Answer 4

जावास्क्रिप्ट, 255 227 205 अक्षर

अरे, इसकी लंबाई एक बाइट में पूरी तरह से फिट होती है! : डी

function(s,e,t){R=eval.bind(0,"Array(n).join(' ')");for(i=n=0,b=r='';c=t[i++];)~s.indexOf(c)?(r+=b,b='\n'+R(++n)+c+'\n '+R(++n)):~e.indexOf(c)?b+='\n'+((n-=2)?R()+' ':'')+c+'\n'+(n?R()+' ':''):b+=c;return r+b}

यह एक फ़ंक्शन है, इसे प्रारंभ वर्ण, अंत वर्ण, फिर पाठ पास करें।

Comments

आपकी स्वयं की संपादित टिप्पणी का उपयोग आपके खिलाफ किया गया है। : डी

— दरवाज़े

@ डॉर्कनोब: मुझे लगता है कि मैंने कभी ऐसा नहीं किया। D: मुझे बहुत खेद है। (आप शिकार कर रहे थे?)

— Ry-

@ डॉर्कनोब: और मुझे इस बारे में याद दिलाने के लिए धन्यवाद; छोटा किया गया :)

— Ry-

नहीं, मैं शिकार नहीं कर रहा था, तो बस इस सवाल पर ठोकर खाई है, लेकिन मैं करने का फैसला किया, और मैंने पाया इस : हे: पी

— दरवाज़े

Answer 5

अजगर - 162 वर्ण

i=f=0
s=""
l,r,z=[raw_input()for c in'   ']
o=lambda:s+("\n"+"  "*i)*f+c
for c in z:
 if c in l:f=1;s=o();i+=1
 elif c in r:i-=1;f=1;s=o()
 else:s=o();f=0
print s

Comments

ध्यान दें कि कार्य कोष्ठकों के दो सेटों को इनपुट का हिस्सा बनाने के लिए कहता है, हार्डकोड नहीं।

— जॉय

@ जॉय ने उल्लेख किया, मैं थोड़ी देर में इसे ठीक कर दूंगा। धन्यवाद

— जुआन

Answer 6

पायथन 2.7.X - 136 चार्ट

import sys
a,c=sys.argv,0
for i in a[3]:
 if not(i in a[2]):print ' '*c+i
 else:print ' '*(c-4)+i
 if i in a[1]:c+=4
 if i in a[2]:c-=4

उपयोग : $ ./foo.py

परिणाम आउटपुट:

(
    a
    b
    (
        c
        d
        (
            e
            f
        )
        g
        h
    )
    i
    j
)

Comments

क्या आपको printबयानों के बाद रिक्त स्थान की आवश्यकता है ?

— जकार्इ

Answer 7

सी - 213 209

^{मुझे बेवकूफ गलतियों से नफरत है ...> <}

#include<stdio.h>
#include<string.h>
int main(int i,char**s){for(char q,r,c,t,a=0;~(c=getchar());t=q|r){q=!!strchr(s[1],c);a-=r=!!strchr(s[2],c);for(i=0;t|q|r&&i<2*a+1;putchar(i++?' ':'\n'));a+=q;putchar(c);}}

पहले कमांड-लाइन तर्क से बाएं-पैरेंस, दूसरे तर्क से राइट-पैरेंस और स्टड पर इंडेंट करने के लिए इनपुट पढ़ता है।

सुंदर-मुद्रित और टिप्पणी:

int main(int i, char **s) {
  for (char q, r, /* is left-paren? is right-paren? */
            c,    /* character read from input */
            t,    /* last char was a paren-char */
            a=0;  /* indentation */
       ~(c = getchar());
       t = q|r) {
         q = !!strchr(s[1],c);
    a -= r = !!strchr(s[2],c);
    for (i=0; t|q|r && i<2*a+1; putchar(i++? ' ' : '\n'));
    a += q;
    putchar(c);
  }
}

Answer 8

सी ( 159 225 वर्ण)

#define q(s,c)strchr(s,c)
#define p(i,j,k)printf("\n%*s%c%c%*s",i,"",*s,k,j,"")
g(char*b,char*e,char*s){int i;for(i=0;*s;s++)q(b,*s)?p(i-2,i+=2,'\n'):q(e,*s)?q(b,*(s+1))||q(e,*(s+1))?p(i-=2,i-2,0):p(i-=2,i-2,'\n'):putchar(*s);}

यह मुझे खाली लाइनों के साथ बग को ठीक करने के लिए 66 अतिरिक्त वर्णों की लागत है :( सच कहूँ तो, मुझे एक नए दृष्टिकोण की आवश्यकता है, लेकिन मैं इसे अभी के लिए एक दिन कहूंगा।

#define p(i,j)printf("\n%*s%c\n%*s",i,"",*s,j,"")
f(char*b,char*e,char*s){int i;for(i=0;*s;s++){strchr(b,*s)?p(i-2,i+=2):strchr(e,*s)?p(i-=2,i-2):putchar(*s);}}

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

char * b उद्घाटन कोष्ठक सेट है, char * e समापन कोष्ठक सेट है और char * s इनपुट स्ट्रिंग है।

Answer 9

पर्ल - 69 बाइट्स

TMTOWTDI कोड को सरल बनाता है

#!perl -p
s/([[{(<])|([]})>])|\w+/"  "x($1?$t++:$2?--$t:$t)."$&
"/ge

Comments

आप कोष्ठक को इनपुट के रूप में लेना चाहते हैं, न कि उन्हें हार्डकोड के रूप में।

— गारेथ

Answer 10

स्काला (2.9), 211 वर्ण

object P extends App{def x(j:Int)={"\n"+"  "*j}
var(i,n)=(0,"")
for(c<-args(2)){if(args(0).exists(_==c)){print(x(i)+c)
i+=1
n=x(i)}else{if(args(1).exists(_==c)){i-=1
print(x(i)+c)
n=x(i)}else{print(n+c)
n=""}}}}

Answer 11

पर्ल - 89 85 बाइट्स

होजंग यूं के उत्तर का एक संस्करण जो दो तर्कों के माध्यम से ब्लॉक पात्रों को स्वीकार करता है।

#!perl -p
BEGIN{$b=pop;$a=pop}s/([$a])|([$b])|\w+/"  "x($1?$t++:$2?--$t:$t)."$&
"/ge

जैसे कहा जाता है:

perl golf.pl<<<'abc{xyz{text[note{comment(t{ex}t)abc}]}}' '[{(<' ']})>'

Comments

बहुत अच्छी अवधारणा, @ होजंग और सोरपाइगल। यह थोड़ा नाजुक है, हालांकि। उदाहरण के लिए, अदला-बदली तर्क में] और} को स्वैप करें, और] वर्ण वर्ग को बंद कर देता है, जिससे एक बेजोड़ परन त्रुटि हो जाती है। इसी तरह, मान लीजिए कि ओपन सेट ^ से शुरू होता है, शायद नजदीकी सेट में वी से मेल खाने के लिए; आपको इच्छित [$ a] वर्ग का पूरक मिलेगा। इसलिए मैंने अपने उत्तर में \ Q ... \ E का उपयोग किया है। गैर-पैरा पात्रों के लिए \ w + उदाहरण के लिए काम करता है, लेकिन 'x (फू-बार) y' '(' '') जैसे इनपुट के बारे में क्या? बेशक, यह स्पष्ट नहीं है कि कोड को कुछ इस तरह संभालने की जरूरत है।

— DCharness

Answer 12

पायथन 3, 184 182 वर्ण

import sys
_,p,q,t=sys.argv
i,f,x=0,1,print
for e in t:
 if e in p:f or x();x(' '*i+e);i+=2;f=1
 elif e in q:f or x();i-=2;f=1;x(' '*i+e)
 else:not f or x(' '*i,end='');f=x(e,end='')

उदाहरण:

$ python3 ./a.py '{[(<' '}])>' 'abc{xyz{text[note{comment(t{ex}t)abc}]}}'
abc
{
  xyz
  {
    text
    [
      note
      {
        comment
        (
          t
          {
            ex
          }
          t
        )
        abc
      }
    ]
  }
}

Comments

heinrich5991 ने दूसरी पंक्ति को बदलकर दो पात्रों को बचाने का सुझाव दिया_,p,q,t=sys.argv

— पीटर टेलर

Answer 13

ग्रूवी, 125

p=args;i=0;s={a,b->"\n"+"\t"*(b?i++:--i)+a+"\n"+"\t"*i};p[0].each{c->print p[1].contains(c)?s(c,1):p[2].contains(c)?s(c,0):c}

आप स्क्रिप्ट को एक फ़ाइल indent.groovy में सहेज सकते हैं और इसके साथ प्रयास कर सकते हैं:
groovy indent.groovy "abc {xyz {text [नोट {टिप्पणी (t {ex} t) abc}]}}}" {[("") ]} "

Comments

मैंने आपके उत्तर को देखने से पहले एक घंटे तक घेरने की कोशिश की, मैंने एक समान aproach का उपयोग किया, लेकिन मेरा आपके से बहुत लंबा है इसलिए मैं पोस्ट करने की जहमत नहीं उठाऊँगा। अच्छा काम! :)

— फेल्स

Answer 14

अजगर - 407

from sys import*;o=argv[1];c=argv[2];t=argv[3];p=0;n=False;a=lambda:h not in e;b=lambda s:print(s+(" "*p)+h);r="";e=o+c
for h in t:
 for k in o:
  if h==k:
   if(r in e)and(r!=""):b("")
   else:b("\n")
   p+=2;n=True;break
 for k in c:
  if h==k:
   p-=2
   if(r in e)and(r!=""):b("")
   else:b("\n")
   n=True;break
 if a()and n:print((" "*p)+h,end="");n=False
 elif a():print(h,end="")
 r=h

कार्यक्रम का एक अनगुल्ड संस्करण:

import sys

open_set = sys.argv[1]
close_set = sys.argv[2]
text = sys.argv[3]
spaces = 0
newline = False
a = lambda : char not in b_set
b = lambda s: print(s + (" " * spaces) + char)
prev = ""
b_set = open_set + close_set

for char in text:
    for bracket in open_set:
        if char == bracket:
            if (prev in b_set) and (prev != ""):
                b("")
            else:
            b("\n")
        spaces += 2
        newline = True
        break
    for bracket in close_set:
        if char == bracket:
            spaces -= 2
            if (prev in b_set) and (prev != ""):
                b("")
            else:
                b("\n")
            newline = True
            break
    if a() and newline:
        print((" " * spaces) + char, end="")
        newline = False
    elif a():
        print(char, end="")
    prev = char

कार्यक्रम के तर्क (क्रम में) हैं: उद्घाटन कोष्ठक, समापन कोष्ठक और पाठ इंडेंट करने के लिए।

उदाहरण ($ कमांड लाइन प्रॉम्प्ट है):

$ python indent.py "{[(<" "}])>" "abc{xyz{text[note{comment(t{ex}t)abc}]}}"
abc
{
  xyz
  {
    text
    [
      note
      {
        comment
        (
          t
          {
            ex
          }
          t
        )
        abc
      }
    ]
  }
}

Answer 15

डी (300)

C[] i(C,S)(ref S s,C p){if(!*s)return[];static C[] w;w~=" ";C[] r;C c=s[0];while(c!=p){s=s[1..$];r~=(c=='{'||c=='['||c=='<'?"\n"~w~c~"\n"~i(s,cast(char)(c+2)):c=='('?"\n"~w~c~"\n"~i(s,')'):[c]);c=*s;}w=w[1..$];if(*s)s=s[1..$];c=*s;return" "~w~r~"\n"~w~(c=='}'||c==']'||c=='>'||c==')'?[p]:p~"\n"~w);}

सीमा जाँच के लिए एक शून्य समाप्त स्ट्रिंग की if(*s)आवश्यकता है (अन्यथा बदलने की आवश्यकता है if(s.length))

Comments

ध्यान दें कि कार्य कोष्ठकों के दो सेटों को इनपुट का हिस्सा बनाने के लिए कहता है, हार्डकोड नहीं।

— जॉय

Answer 16

जावा

गैर codegolf version! मान लें कि हमारे पास विभाजन का यह संस्करण है () जिसमें डीलिम्स शामिल हैं,

public static String indent(String input, String openPars,
        String closingPars) {
    String re = "["
            + (openPars + closingPars).replace("[", "\\[").replace("]",
                    "\\]") + "]";
    String[] split = inclusiveSplit(input, re, 0);
    int indent = 0;
    StringBuilder sb = new StringBuilder();
    for (String string : split) {
        if (StringUtils.isEmpty(string))
            continue;
        if (closingPars.indexOf(string) != -1) {
            indent--;
        }
        sb.append(StringUtils.repeat(" ", indent * 2));
                    sb.append(string);
                    sb.append("\n");
        if (openPars.indexOf(string) != -1) {
            indent++;
        }
    }
    String string = sb.toString();
    return string;
}

Comments

StringUtilsमानक JDK का हिस्सा नहीं है।

— 4

Answer 17

सी 284 गैर सफेद अंतरिक्ष वर्ण

मैं मोटापे का कोई प्रशंसक नहीं हूँ, लेकिन अच्छी तरह से ...

#include<cstdio>
#include<cstring>
#define g printf
#define j char
int main(int a,j**b){int c=0;for(j*f=b[3];*f!='\0';++f){if(strchr(b[1],*f)!=0){g("\n%*c\n%*c",c,*f,c+2,'\0');c+=2;}else if(strchr(b[2],*(f))!=0){c-=2;g("\n%*c",c,*f);if(strchr(b[2],*(f+1))==0)g("\n%*c",c,'\0');}else putchar(*f);}}

उपयोग: ./program start_brackets end_brackets string_to_parse

Answer 18

php (187) (153)

function a($s,$o,$e){while(''!=$c=$s[$i++]){$a=strpbrk($c,$o)?2:0;$b=strpbrk($c,$e)?2:0;echo ($a+$b||$r)?"\n".str_pad('',$t-=$b):'',$c;$t+=$a;$r=$a+$b;}}

फ़ंक्शन स्ट्रिंग लेता है, सीमांकक खोल रहा है, तर्कों के रूप में सीमांकक को समाप्त करता है।

Answer 19

सी, 256

पैरामीटर:

• ई एंडिंग चार्ज है,
• n इंडेंटेशन है,
• ख खुलने वाले कोष्ठक,
• d समापन कोष्ठक।

मैंने क्षैतिज स्क्रॉलबार से बचने के लिए कोड को तोड़ दिया।

#define r char
#define P(c) putchar(c);
#define N P(x)
#define W printf("%*s",n,"");
r*s,x='\n';i(r e,int n,r*b,r*d){r*t=s,*p;int l=0;W while(*s!=e)    
{if(p=strchr(b,*s)){if(s!=t){N W}P(*s++)N i(d[p-b],n+2,b,d); N W 
P(*s++);l=1;}else{if(l){N W l=0;}P(*s++)}}}

पूरा कार्यक्रम 363 वर्णों का है।

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#define r char
#define P(c) putchar(c);
#define N P(x)
#define W printf("%*s",n,"");
r*s,x='\n';i(r e,int n,r*b,r*d)
{r*t=s,*p;int l=0;W while(*s!=e)
{if(p=strchr(b,*s)){if(s!=t){N W}
P(*s++)N i(d[p-b],n+2,b,d); N W
P(*s++);l=1;}else{if(l){N W l=0;}
P(*s++)}}}main(int c,r*v[]){s =
v[3];i('\0',0,v[1],v[2]);}

Answer 20

VB.net (सी? सी)

भाषा कोड गोल्फिंग के अनुकूल नहीं है, इसलिए मैंने एक असामान्य दृष्टिकोण का उपयोग किया। कंसोल पर आउटपुट के लिए ट्रेस श्रोता का उपयोग करना।

Imports System.Diagnostics.Debug
Module Module1
  Sub Main(args() As String)
    IndentText(args(0), args(1), args(2)) 'openings, closings, text)
  End Sub
  Sub IndentText(o As String, e As String, t As String)
    Dim x = 0
    Listeners.Add(New Diagnostics.ConsoleTraceListener)
    IndentSize = 2
    For Each c In t
      If o.Contains(c) Then
        WriteLine("")
        WriteLine(c)
        Indent()
        x = 1
      ElseIf e.Contains(c) Then
        If x = 0 Then WriteLine("")
        Unindent()
        WriteLine(c)
        x = 1
      Else
        Write(c)
        x = 0
      End If
    Next
  End Sub
End Module

इनपुट के लिए कमांडलाइन आर्ग का उपयोग करता है

args(0) is the indenting chars
args(1) is the undenting chars
args(2) is the text to be indented.

Answer 21

पॉवर्सशेल, 146 बाइट्स

param([char[]]$s,[char[]]$e,[char[]]$f)$f|%{}{if($_-in$s){$o;'  '*$i+$_;$o='  '*++$i;}elseif($_-in$e){$o;'  '*--$i+$_;$o='  '*$i}else{$o+=$_}}{$o}

अघोषित स्पष्टीकरण

param([char[]]$start,             # Cast as array of Chars
      [char[]]$end,
      [char[]]$string)
$string | foreach-object { } {    # For every char in string. Empty Begin block
    if ( $_ -in $start ) {        # If char is in start
        $o                        # Print stack ($o)
        '  ' * $i + $_            # Newline, indent, insert start char
        $o = '  ' * ++$i          # Set stack to ident (incremented)
    } elseif ( $_ -in $end ) {    # If char is in end
        $o                        # Print stack
        '  ' * --$i + $_          # Newline, decrement indent, insert end char
        $o = '  ' * $i            # Set stack to indent
    } else {
        $o+ = $_                  # Otherwise add character to stack
    }
} { $o }                          # Print remaining stack (if any)

Answer 22

सी, 181 अक्षर

#define d(m,f)if(strchr(v[m],*s)){puts("");for(j=f;j--;)printf("  ");}
i;main(j,v,s)char**v,*s;{for(s=v[3];*s;s++){d(1,i++)d(2,--i)putchar(*s);d(1,i)if(!strchr(v[2],*(s+1)))d(2,i)}}

सुंदर सबसे सरल दृष्टिकोण कल्पना। स्ट्रिंग (v [3]) के माध्यम से इरेट करें, यदि यह एक लेफ्ट ब्रेस है (जैसा कि v [1] में परिभाषित किया गया है), इंडेंट लेवल बढ़ाएं, अगर यह राइट ब्रेस है (जैसा कि v [2] में परिभाषित है), इंडेंट लेवल को कम करें ।

Answer 23

सी, 114 121

main(i,x,s,c){while(~(c=getchar()))(s=x)|(x=2*!!strchr("(){}[]<>",c))?s=c-1&x,i-=x-2*s,printf("\n%*c",i-s,c):putchar(c);}

बहुत अच्छा नहीं है, लेकिन एक समाधान .. एक खाली लाइन से पहले / बाद में प्रकट हो सकता है कि क्या इनपुट एक कोष्ठक के साथ शुरू / खत्म होता है।

नए प्रतिबंध के साथ, गोल्फ के लिए यह दृष्टिकोण लगभग बेकार है।

Comments

उद्घाटन के कोष्ठकों को अधिक दूर तक इंडेंट नहीं करता है और लगातार समापन के बीच खाली लाइनों को आउटपुट करता है।

— जॉय

@joey तय, प्रतिक्रिया के लिए धन्यवाद!

— esneider

यह अभी भी कोष्ठकों को हार्ड-कोड करता है जबकि उन्हें इनपुट का हिस्सा होना चाहिए। वर्तमान में सभी उत्तर विनिर्देश के अनुरूप नहीं हैं।

— जॉय