टेलीस्कोपिक कोष्ठक

Question

सही ढंग से संतुलित कोष्ठक के एक गैर-खाली स्ट्रिंग पर विचार करें:

(()(()())()((())))(())

हम कल्पना कर सकते हैं कि कोष्ठक की प्रत्येक जोड़ी एक ध्वस्त दूरबीन निर्माण में एक अंगूठी का प्रतिनिधित्व करती है । तो आइए दूरबीन का विस्तार करें:

(                )(  )
 ()(    )()(    )  ()
    ()()    (  )
             ()

इसे देखने का एक और तरीका यह है कि गहराई n पर कोष्ठक अपनी क्षैतिज स्थिति को बनाए रखते हुए, पंक्ति n पर ले जाया जाता है ।

आपका कार्य संतुलित कोष्ठकों की ऐसी स्ट्रिंग लेना और विस्तारित संस्करण का उत्पादन करना है।

आप STDIN (या निकटतम समतुल्य), कमांड-लाइन तर्क या फ़ंक्शन पैरामीटर, और STDOUT (या निकटतम समतुल्य), रिटर्न वैल्यू या फ़ंक्शन (आउट) पैरामीटर के माध्यम से आउटपुट उत्पन्न करके इनपुट या प्रोग्राम लिख सकते हैं।

आप मान सकते हैं कि इनपुट स्ट्रिंग वैध है, अर्थात इसमें केवल कोष्ठक हैं, जो सही ढंग से संतुलित हैं।

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

उदाहरण

उपरोक्त उदाहरण के अलावा, यहां कुछ और परीक्षण मामले हैं (इनपुट और आउटपुट एक खाली रेखा द्वारा अलग किए गए हैं)।

()

()

(((())))

(      )
 (    )
  (  )
   ()

()(())((()))(())()

()(  )(    )(  )()
   ()  (  )  ()
        ()

((()())()(()(())()))

(                  )
 (    )()(        )
  ()()    ()(  )()
             ()

संबंधित चुनौतियां:

• स्थलाकृतिक स्ट्रिंग्स , जो आपको इस चुनौती में आउटपुट के पूरक का उत्पादन करने के लिए कहता है।
• कोड स्पष्टीकरण सूत्र, इस चुनौती में विचारों का एक व्यापक सामान्यीकरण, हाल ही में PhiNotPi द्वारा पोस्ट किया गया। (वास्तव में, PhiNotPi के अपने विचार का मूल विवरण इस चुनौती से प्रेरित था।)

लीडरबोर्ड

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

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){$.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(e){answers.push.apply(answers,e.items);if(e.has_more)getAnswers();else process()}})}function shouldHaveHeading(e){var t=false;var n=e.body_markdown.split("\n");try{t|=/^#/.test(e.body_markdown);t|=["-","="].indexOf(n[1][0])>-1;t&=LANGUAGE_REG.test(e.body_markdown)}catch(r){}return t}function shouldHaveScore(e){var t=false;try{t|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(n){}return t}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading);answers.sort(function(e,t){var n=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0],r=+(t.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0];return n-r});var e={};var t=0,c=0,p=-1;answers.forEach(function(n){var r=n.body_markdown.split("\n")[0];var i=$("#answer-template").html();var s=r.match(NUMBER_REG)[0];var o=(r.match(SIZE_REG)||[0])[0];var u=r.match(LANGUAGE_REG)[1];var a=getAuthorName(n);t++;c=p==o?c:t;i=i.replace("{{PLACE}}",c+".").replace("{{NAME}}",a).replace("{{LANGUAGE}}",u).replace("{{SIZE}}",o).replace("{{LINK}}",n.share_link);i=$(i);p=o;$("#answers").append(i);e[u]=e[u]||{lang:u,user:a,size:o,link:n.share_link}});var n=[];for(var r in e)if(e.hasOwnProperty(r))n.push(e[r]);n.sort(function(e,t){if(e.lang>t.lang)return 1;if(e.lang<t.lang)return-1;return 0});for(var i=0;i<n.length;++i){var s=$("#language-template").html();var r=n[i];s=s.replace("{{LANGUAGE}}",r.lang).replace("{{NAME}}",r.user).replace("{{SIZE}}",r.size).replace("{{LINK}}",r.link);s=$(s);$("#languages").append(s)}}var QUESTION_ID=49042;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/;var NUMBER_REG=/\d+/;var LANGUAGE_REG=/^#*\s*([^,]+)/

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js></script><link rel=stylesheet type=text/css href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id=answer-list><h2>Leaderboard</h2><table class=answer-list><thead><tr><td></td><td>Author<td>Language<td>Size<tbody id=answers></table></div><div id=language-list><h2>Winners by Language</h2><table class=language-list><thead><tr><td>Language<td>User<td>Score<tbody id=languages></table></div><table style=display:none><tbody id=answer-template><tr><td>{{PLACE}}</td><td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table><table style=display:none><tbody id=language-template><tr><td>{{LANGUAGE}}<td>{{NAME}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table>

Comments

वैकल्पिक शीर्षक: De-Lisp-ify a string। : पी

— एलेक्स ए।

क्या आउटपुट के रंग पर कोई प्रतिबंध है?

— मट्टियो इटालिया

@ मार्टिनबटनर: कोई बात नहीं, मुझे एक क्लीनर रास्ता मिला; चलो बस यह कहना है कि मेरे पिछले विचार ने सियान पर नीले रंग के सभी बंद कोष्ठक झपकी छोड़ते हुए बाइट मुंडा दी होगी ... :-)

— माटेओ इटालिया

@MatteoItalia ओह भगवान, मुझे खुशी है कि ऐसा नहीं हुआ। ;)

— मार्टिन एंडर

@MatteoItalia: उस संस्करण को पोस्ट करें! यह देखने लायक है।

— user2357112

Answer 1

CJam, 17 16 15 बाइट्स

0000000: 72 3a 69 22 28 0b 20 9b 41 29 22 53 2f 66 3d     r:i"(. .A)"S/f=

ऊपर एक प्रतिवर्ती xxd डंप है, क्योंकि स्रोत कोड में unprintable अक्षर VT (0x0b) और CSI (0x9b) हैं।

जैसा इस जवाब , इसे इस्तेमाल करता है एएनएसआई भागने दृश्यों , लेकिन यह भी खड़ी टैब का उपयोग करता है और इसके उपयोग से बचने के लिए सीधे नियंत्रण वर्ण प्रिंट printf ।

इसके लिए एक सहायक वीडियो टेक्स्ट टर्मिनल की आवश्यकता होती है, जिसमें अधिकांश गैर-विंडोज टर्मिनल एमुलेटर शामिल हैं।

परीक्षण चालन

हमें शेल वैरिएबल LANG और टर्मिनल एमुलेटर की एन्कोडिंग को ISO 8859-1 पर सेट करना होगा। पूर्व निष्पादित करके प्राप्त किया जाता है

$ LANGsave="$LANG"
$ LANG=en_US

इसके अलावा, वास्तविक कोड निष्पादित करने से पहले, हम संकेत को अक्षम कर देंगे और स्क्रीन को साफ़ कर देंगे।

$ PS1save="$PS1"
$ unset PS1
$ clear

यह सुनिश्चित करता है कि आउटपुट ठीक से दिखाया गया है।

echo -n '()(())((()))(())()' | cjam <(base64 -d <<< cjppIigLIJtBKSJTL2Y9)
()(  )(    )(  )()
   ()  (  )  ()
        ()

LANG और प्रॉम्प्ट को पुनर्स्थापित करने के लिए , इसे निष्पादित करें:

$ LANG="$LANGsave"
$ PS1="$PS1save"

यह काम किस प्रकार करता है

हम प्रत्येक कर्सर के बाद एक ऊर्ध्वाधर टैब डालें ( कर्सर को नीचे ले जाने के लिए और बाइट अनुक्रम 9 बी 41 ( "\x9bA"प्रत्येक से पहले ) कर्सर को ऊपर ले जाने के लिए।

r         e# Read a whitespace-separated token from STDIN.
:i        e# Replace each character by its code point.
          e#   '(' -> 40, ')' -> 41
"(. .A)"  e# Push the string "(\v \x9bA)".
S/        e# Split at spaces into ["(\v" "\x9bA)"].
f=        e# Select the corresponding chunks.
          e# Since arrays wrap around in CJam, ["(\v" "\x9bA)"]40= and 
          e# ["(\v" "\x9bA)"]41= select the first and second chunk, respectively.

Answer 2

x86 मशीन कोड, 39 34 33 30 29 बाइट्स

00000000  68 c3 b8 07 31 ff be 82  00 b3 a0 ad 4e 3c 28 7c  |h...1.......N<(||
00000010  f0 77 05 ab 01 df eb f3  29 df ab eb ee           |.w......)....|
0000001d

D86 के लिए x86 असेंबली, कुछ ट्रिक्स के साथ:

    org 100h

section .text

start:
    ; point the segment ES to video memory
    ; (c3 is chosen so that it doubles as a "ret")
    push 0b8c3h
    pop es
    ; di: output pointer to video memory
    xor di,di
    ; si: input pointer from the command line
    mov si,82h
    ; one row=160 bytes (assume bh=0, as should be)
    mov bl,160
lop:
    ; read & increment si (assume direction flag clean)
    ; we read a whole word, so that later we have something nonzero to
    ; put into character attributes
    lodsw
    ; we read 2 bytes, go back 1
    dec si
    ; check what we read
    cmp al,'('
    ; less than `(`: we got the final `\n` - quit
    ; (we jump mid-instruction to get a c3 i.e. a ret)
    jl start+1
    ; more than `(`: assume we got a `)`
    ja closed
    ; write a whole word (char+attrs), so we end
    ; one position on the right
    stosw
    ; move down
    add di,bx
    ; rinse & repeat
    jmp lop
closed:
    ; move up
    sub di,bx
    ; as above
    stosw
    jmp lop

सीमाएं :

• यह हमेशा पहले मिटाए बिना, स्क्रीन के निचले भाग पर शुरू होता है; एक clsचलाने से पहले लगभग अनिवार्य है;
• रंग बदसूरत हैं; रंग चरित्र के रूप में अगले चरित्र को पुनरावर्तन करने का परिणाम है कि दो बाइट्स यहां और वहां बचाने के लिए;
• कोड मान लेता है bh=0और दिशा ध्वज प्रारंभ पर स्पष्ट होता है, दोनों अनिर्दिष्ट; OTOH, bxस्पष्ट रूप से मेरे द्वारा देखे गए सभी डॉस वेरिएंट में शून्य पर सेट है (DosBox, MS-DOS 2, FreeDOS), और हर जगह मैंने परीक्षण किया कि झंडे पहले से ही ठीक थे।

Comments

बस यह सत्यापित किया गया। हाँ यह काम करता है। क्या आप वाकई करना cldचाहते हैं ?

— FUZxxl

@FUZxxl: डॉसबॉक्स पर इसके बिना भी यह ठीक काम करता है, लेकिन इसके स्रोतों को देखते हुए यह कहता है कि झंडे डीओएस और टीआरएस में पहले जो कुछ भी हुआ है, उससे संरक्षित हैं, इसलिए शायद इसे सुरक्षित खेलने की आवश्यकता होगी। किसी भी तरह, कि सिर्फ एक बाइट होगा, असली अदायगी उन बड़े (= 4 बाइट प्रत्येक) add/ में से कम से कम एक को मारने के लिए होगी sub।

— मट्टियो इटालिया

हम्म ... कोई विचार नहीं, वास्तव में।

— फूजएक्सएक्सएल

आप बदल सकते हैं lopकरने के लिए loop?

— mbomb007

@ mbomb007: हो सकता है? मुझे यकीन नहीं है कि अगर एक लेबल और असेंबली इंस्ट्रक्शन के nasmबीच का अंतर हो जाए, तो मैं लिखता हूं जैसा कि हर कोई करता है। looplooplop

— मट्टियो इटालिया

Answer 3

जे, 32 28 बाइट्स

यह एक मजेदार था।

0|:')(('&(i.-<:@+/\@i:){."0]

व्याख्या

यह इस तरह से काम करता है, जिसमें यह व्याख्या की गई है कि इसे कैसे रखा गया है।

   NB. Let a be a test case
   a =. '((()())()(()(())()))'

   NB. level alterations
   _1 + ').(' i. a
1 1 1 _1 1 _1 _1 1 _1 1 1 _1 1 1 _1 _1 1 _1 _1 _1

   NB. absolute levels
   +/\ _1 + ').(' i. a
1 2 3 2 3 2 1 2 1 2 3 2 3 4 3 2 3 2 1 0

   NB. adjusted levels
   (+/\ _1 + ').(' i. a) - ')(' i. a
0 1 2 2 2 2 1 1 1 1 2 2 2 3 3 2 2 2 1 0

   NB. take level from end of each item of a and transpose
   |: a {."0~ _1 - (+/\ _1 + ').(' i. a) - ')(' i. a
(                  )
 (    )()(        ) 
  ()()    ()(  )()  
             ()     

   NB. code as a tacit verb
   [: |: ] {."0~ _1 - ([: +/\ _1 + ').(' i. ]) - ')(' i. ]

   NB. subtractions pulled into the prefix insert
   [: |: ] {."0~ (')(' i. ]) - [: <:@+/\ ').(' i. ]

   NB. i: instead of i. so we can use the same string constant
   [: |: ] {."0~ (')((' i. ]) - [: <:@+/\ ')((' i: ]

   NB. get rid of the caps
   0 |: ] {."0~ (')((' i. ]) - ')((' <:@+/\@i: ]

   NB. join the two usages of ')((' into a single dyadic phrase
   0 |: ] {."0~ ')((' (i. - <:@+/\@i:) ]

   NB. bond ')((' and flip arguments to {."0
   0 |: ')(('&(i. - <:@+/\@i:) {."0 ]

Comments

बहुत अच्छा! समाधान महान भागों से भरा है!

— रैंडमरा

(मैं आम तौर पर फ़ंक्शन का एक उदाहरण आह्वान जोड़ता हूं ताकि गैर-अनुभवी उपयोगकर्ता इसे भी आज़मा सकें।)

— रैंडम

यह समाधान मेरे सिर को चोट पहुँचाता है:')

— निक हार्टले

@QPaysTaxes मैं इसे एक प्रशंसा के रूप में लेता हूं।

— फ़ूजएक्सल

@FUZxxl यह है। यह वर्णों के अनुक्रम पर आधारित एक वाक्य भी है जो आपके उत्तर में दिखाई देता है।

— निक हार्टले

Answer 4

सी, 150 बाइट्स

t;f(char*c){char l=strlen(c)+1,o[l*l],*A=o,m=0;for(t=1;t<l*l;t++)o[t-1]=t%l?32:10;for(t=-1;*c;c++)A++[l*(*c-41?++t>m?m=t:t:t--)]=*c;A[m*l]=0;puts(o);}

यह गोल्फ के लिए पागल मज़ा था । मुझे अभी भी यकीन नहीं हो रहा है कि मैं इसके साथ हूँ।

हम एकल फ़ंक्शन को परिभाषित करते हैं, fजो स्ट्रिंग को इनपुट के रूप में लेता है और स्टडआउट को आउटपुट करता है।

कोड के माध्यम से चलते हैं, लाइन से लाइन:

/* t will represent the current depth of a parentheses. It must be an int. */
t;
f(char*c){
    //Our variables:
    char l=strlen(c)+1,    //The length of each row of output, including newlines
         o[l*l],           //The output string. It's way larger than it needs to be.
         *A=o,             //We need another pointer to keep track of things.
         m=0;              //The maximum depth recorded thus far.

    for(t=1;t<l*l;t++)     //For each character in our output...
        o[t-1]=t%l?32:10;  //If it's at the end of a line, make it '\n'. Else, ' '.
    for(t=-1;*c;c++)       //While we have an input string...
        //Perhaps a personal record for ugliest warning-less line...
        A++[l*(*c-41?++t>m?m=t:t:t--)]=*c;
    /* 
        A breakdown:
        A++        --> Go to the next *column* of output, after writing. 
                   --> There will only ever be one parentheses per output column.
        [l*(...)]  --> A[l*X] is the character in the current column at depth X.
        (*c-41?    --> If the character is a '('...    
        ++t>m?     --> Increment t *before* we write it. If this is a new highest depth
        m=t:       --> Set m to t, and set the whole expression to t.
        t:         --> If it's not a new highest depth, don't set m.
        t--)       --> If the character was a ')', decrement t *after* we write it.
        =*c        --> Write our output character to whatever the input read.
    */    

    A[m*l]=0; //The last character of the maximum-depth line should be null terminated.
    puts(o);  //Output!
}

मैं आपके किसी भी प्रश्न का उत्तर दूंगा!

ऑनलाइन एक परीक्षण कार्यक्रम की कोशिश करो !

Comments

मैं यह याद रखना चाहता हूं कि "char l = strlen (c) +1, o [l * l]" मान्य नहीं है क्योंकि आप इस तरह एक चर आकार के सरणी को परिभाषित नहीं कर सकते हैं, लेकिन जब से मैंने कुछ भी करने की कोशिश की है, तब से 15 साल हो गए हैं सी। में उस तरह

— शुक्राणु

@ मेरा कंपाइलर एक चेतावनी भी नहीं देता है। मेरा मानना ​​है कि यह C99 में "आधिकारिक तौर पर" मानक था। मैं इसके लिए एक संदर्भ खोजने की कोशिश करूंगा।

— ब्रेनसैट

@ शेपर यहाँ एक संदर्भ है।

— ब्रेनसैट

धन्यवाद। ऐसा लगता है कि चीजें इस संबंध में 15 साल पहले (एक जोड़े को दो या दो) बदल गईं :)

— स्पियर

@CoolGuy होगा, लेकिन इसके बाद के कॉल पर f, m0 पर रीसेट नहीं होगा। यह "आपके पर्यावरण को तोड़ने," के रूप में यहां गिना जाता है ।

— ब्रेनसैट

Answer 5

रेटिना + बैश, 27 बाइट्स (14 + 10 + 3 = 27)

यह एएनएसआई से बचने का उपयोग करता है:

\(
(\e[B
\)
\e[A)

के बराबर है sed -e "s/(/(\\\e[B/g;s/)/\\\e[A)/g"। \e[Bभागने कोड का मतलब है नीचे ले जाने के कर्सर को एक पंक्ति है, और \e[Aइसका मतलब है एक पंक्ति ऊपर कर्सर ले जाने के, तो यह समाधान करने के बाद बस और आरंभ और कोष्ठक में से प्रत्येक नेस्टेड जोड़ी के अंत से पहले उन कोड सम्मिलित करता है। इनपुट STDIN के माध्यम से पारित किया जाता है।

printf $(Retina ...)आउटपुट को सही ढंग से देखने के लिए आपको इसे कॉल करना होगा।

उत्पादन

(((())))
(\e[B(\e[B(\e[B(\e[B\e[A)\e[A)\e[A)\e[A)
^C
amans:~ a$ printf "(\e[B(\e[B(\e[B(\e[B\e[A)\e[A)\e[A)\e[A)"
(      )amans:~ a$ 
 (    )
  (  )
   ()

((()())()(()(())()))
(\e[B(\e[B(\e[B\e[A)(\e[B\e[A)\e[A)(\e[B\e[A)(\e[B(\e[B\e[A)(\e[B(\e[B\e[A)\e[A)(\e[B\e[A)\e[A)\e[A)
^C
amans:~ a$ printf "(\e[B(\e[B(\e[B\e[A)(\e[B\e[A)\e[A)(\e[B\e[A)(\e[B(\e[B\e[A)(\e[B(\e[B\e[A)\e[A)(\e[B\e[A)\e[A)\e[A)"
(                  )amans:~ a$ 
 (    )()(        )
  ()()    ()(  )()
             ()

Comments

खैर, बुरा नहीं है! यदि आप एक विशिष्ट टर्मिनल को इंगित कर सकते हैं जिसकी आवश्यकता नहीं है printfजो बहुत अच्छा होगा। अन्यथा, मुझे लगता | printfहै कि बाइट की गिनती में जोड़ना उचित होगा ।

— मार्टिन एंडर

@ मार्टिनबटनर यह होना चाहिए printf $()या printf $(Retina )।

— jimmy23013

वह रेटिना बात क्या है?

— फ़ूजक्कल

@FUZxxl यह मेरी खुद की रेगेक्स-आधारित प्रोग्रामिंग भाषा है। गिटहब देखें ।

— मार्टिन एंडर

क्यों \eप्लस printf? आप बस प्रतिस्थापन पैटर्न में नियंत्रण वर्ण रख सकते हैं।

— डेनिस

Answer 6

टीआई-बेसिक, 69 60 56 55 बाइट्स

यह TI-83 + / 84 + कैलकुलेटर के परिवार के लिए है, हालांकि यह 84+ C सिल्वर एडिशन पर लिखा गया था।

वैट + आकार की जानकारी को शामिल किए जाने के कारण कार्यक्रम बड़ा-कैल्क दिखाता है। इसके अलावा, यहां 56 से अधिक वर्ण हैं; इसका कारण 56 बाइट्स है, क्योंकि सभी कमांड जो एक से अधिक वर्ण हैं, टोकन नीचे संकुचित हैं जो आकार में एक या दो बाइट्स हैं।

Input Str1
1→B
For(A,1,length(Str1
sub(Str1,A,1→Str2
Ans="(
Output(B+Ans,A,Str2
B-1+2Ans→B
End

थोमस-क्वा की बदौलत एक और बाइट शेव की गई ! (उनसे भी 60 से 56 की छलांग थी।)

Comments

आह, मेरी पहली प्रोग्रामिंग लैंग्वेज। उदासीनता के लिए धन्यवाद, हाहा।

— एलेक्स प्रिटचर्ड

हाईस्कूल गणित वर्ग के लिए अभी भी टीआई को प्रोग्राम करना, इसमें बनाए गए फॉर्मूले का बहुत उपयोगी होना परीक्षण और असाइनमेंट पर आपके लिए गणना करेगा।

— एलियास बेनेवेदेस

यदि आप अपने आस-पास की चीजों को शिफ्ट करते हैं, तो आप cos(piAnsकिसी अन्य बाइट को बचाने के लिए ट्रिक का उपयोग कर सकते हैं ।

— lirtosiast

Answer 7

पायथन 2, 115 बाइट्स

def f(L,n=0,O=()):
 for c in L:n-=c>"(";O+=" "*n+c,;n+=c<")"
 for r in map(None,*O):print"".join(c or" "for c in r)

जैसे कॉल करें f("((()())()(()(())()))"), और आउटपुट STDOUT को है।

व्याख्या

हम साथ शुरू करते हैं n = 0। इनपुट लाइन में प्रत्येक चार के लिए:

• यदि चर है (, तो हम nरिक्त स्थान को बढ़ाते हैंn
• यदि चार है ), nतो हम nरिक्त स्थान को बढ़ाते हैं

परिणाम फिर ज़िपित और मुद्रित किया जाता है। ध्यान दें कि सबसे छोटे तत्व zipकी लंबाई से मेल करने के लिए पायथन के ज़िप , जैसे

>>> zip([1, 2], [3, 4], [5, 6, 7])
[(1, 3, 5), (2, 4, 6)]

आमतौर पर यदि कोई सबसे लंबे तत्व की लंबाई को पैड करना चाहता है, तो वह उपयोग करेगा itertools.zip_longest( izip_longest) ।zip

>>> import itertools
>>> list(itertools.izip_longest([1, 2], [3, 4], [5, 6, 7]))
[(1, 3, 5), (2, 4, 6), (None, None, 7)]

लेकिन पायथन 2 में, इस व्यवहार को मानचित्रण द्वारा अनुकरण किया जा सकता है None:

>>> map(None, [1, 2], [3, 4], [5, 6, 7])
[(1, 3, 5), (2, 4, 6), (None, None, 7)]

---

पायथन 3, 115 बाइट्स

L,d,*O=input(),0
for i,c in enumerate(L):b=c>"(";O+="",;O[d-b]=O[d-b].ljust(i)+c;d-=b*2-1
for l in O:l and print(l)

कोई ज़िपिंग, बस के साथ उचित रूप से गद्दी ljust। ऐसा लगता है कि कुछ गोल्फ की क्षमता है।

Answer 8

आर, 151 127 वर्ण

S=strsplit(scan(,""),"")[[1]];C=cumsum;D=c(C(S=="("),0)-c(0,C(S==")"));for(j in 1:max(D)){X=S;X[D!=j]=' ';cat(X,sep='',fill=T)}

इंडेंट और न्यूलाइन्स के साथ:

S=strsplit(scan(,""),"")[[1]]
C=cumsum
D=c(C(S=="("),0)-c(0,C(S==")"))
for(j in 1:max(D)){
    X=S
    X[D!=j]=' '
    cat(X,sep='',fill=T)
    }

उपयोग:

> S=strsplit(scan(,""),"")[[1]];C=cumsum;D=c(C(S=="("),0)-c(0,C(S==")"));for(j in 1:max(D)){X=S;X[D!=j]=' ';cat(X,sep='',fill=T)}
1: ()(())((()))(())()
2: 
Read 1 item
()(  )(    )(  )()
   ()  (  )  ()   
        ()        
> S=strsplit(scan(,""),"")[[1]];C=cumsum;D=c(C(S=="("),0)-c(0,C(S==")"));for(j in 1:max(D)){X=S;X[D!=j]=' ';cat(X,sep='',fill=T)}
1: ((()())()(()(())()))
2: 
Read 1 item
(                  )
 (    )()(        ) 
  ()()    ()(  )()  
             ()     

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

यह बहुत छोटा करने में मेरी मदद करने के लिए @ मिक्की का धन्यवाद!

Comments

+1 अच्छा और सुरुचिपूर्ण समाधान। के for(i in n)cat(ifelse(D[i]-j," ",S[i]));cat("\n")साथ बदलकर आप 6 बचा सकते हैं X=S;X[which(D!=j)]=' ';cat(X,sep='',fill=T)। फिर nवास्तव में आवश्यक नहीं है, लेकिन आपको कमसुम भाग को थोड़ा बदलना होगा। D=c(C(S=="("),0)-c(0,C(S==")"));इसे 135 तक नीचे लाना।

— मिकी

@ मिक्की वाह धन्यवाद! ऐसा नहीं सोचा था। whichहालांकि वास्तव में यहाँ आवश्यक नहीं है ( D!=jपहले से ही अनुक्रमित अनुमति देने वाले बूलियनों का एक वेक्टर है)। मैं तर्क के fillलिए नहीं जानता था cat, यह एक मुश्किल चाल है! एक आश्चर्यजनक 24 पात्रों द्वारा मुझे छोटा करने के लिए धन्यवाद !!

— प्लेनैपस

Answer 9

सी, 58 53 52 51 49 बाइट्स

कर्सर की स्थिति को स्थानांतरित करने के लिए एएनएसआई एस्केप सीक्वेंस का उपयोग करता है।

f(char*s){while(*s)printf(*s++&1?"\e[A)":"(\v");}

यदि gcc या किसी अन्य संकलक का उपयोग नहीं किया जाता है, \eतो इसे \x1Bकुल 2 अतिरिक्त बाइट्स के साथ प्रतिस्थापित किया जा सकता है । \e[Aकर्सर को एक पंक्ति ऊपर ले जाता है और कर्सर को एक पंक्ति \e[Bनीचे ले जाता है। यह उपयोग करने के लिए आवश्यक नहीं है \e[Bएक पंक्ति नीचे ले जाने के रूप में यह ASCII ऊर्ध्वाधर टैब वर्ण का उपयोग करने के दो बाइट्स छोटा है 0xBया \v।

इनपुट स्ट्रिंग को माना जाता है, प्रश्न से, केवल (संतुलित) कोष्ठक से मिलकर, इसलिए चरित्र की समता की जांच करना &1, के बीच अंतर करने के लिए पर्याप्त है (और )।

Answer 10

पिप, 53 बाइट्स

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

z:{aEQ'(?++v--v+1}MaW(o:{z@++v=i?as}Ma)RMs{Pov:-1++i}

कोष्ठक की स्ट्रिंग को एक कमांड-लाइन तर्क के रूप में अपेक्षा करता है।

"Ungolfed" संस्करण:

z:{
   a EQ '( ?
    ++v
    --v+1
  } M a
W (o:{
      z @ ++v = i ?
       a
       s
     } M a
  ) RM s
{
 P o
 v:-1
 ++i
}

स्पष्टीकरण:

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

प्रोग्राम पहले zइनपुट स्ट्रिंग के लिए एक फंक्शन मैप करके गहराई की एक सूची (इसे स्टोर करना ) बनाता है a। वैश्विक चर vवर्तमान स्तर को ट्रैक करता है। ( a-gपिप में वेरिएबल्स फंक्शन-लोकल वैरिएबल हैं, लेकिन h-zग्लोबल हैं। vयह आसान है क्योंकि यह 1 के लिए प्रांतीय है।)

अगला, हम Wप्रत्येक पंक्ति को उत्पन्न करने और प्रिंट करने के लिए एक हील लूप का उपयोग करते हैं, जब तक कि उत्पन्न लाइन में सभी रिक्त स्थान शामिल नहीं होंगे। vअब स्तंभों के लिए, और iपंक्तियों के लिए उपयोग किया जाता है । {z@++v=i?as}समारोह, बार-बार मूल इनपुट स्ट्रिंग से मैप किया गया, परीक्षण है कि मौजूदा लाइन iपंक्ति से मेल खाती वर्तमान कोष्ठक (में संग्रहीत के रूप में पर माना जाता है zसूची)। यदि ऐसा है, तो कोष्ठक ( a) का उपयोग करें ; यदि नहीं, तो प्रयोग करें s(अंतरिक्ष के लिए पूर्व-निर्मित)। अंतिम परिणाम यह है कि प्रत्येक पुनरावृत्ति पर, oआउटपुट की अगली पंक्ति के बराबर वर्णों की एक सूची सौंपी जाती है।

यह जांचने के लिए कि क्या हमें लूपिंग जारी रखना चाहिए, हम जांचते हैं कि oसभी रिक्त स्थान RMरिक्त हैं या नहीं। यदि नहीं, तो इसे प्रिंट करें (जो डिफ़ॉल्ट रूप से CJam के रूप में सब कुछ एक साथ मिलाता है), कॉलम नंबर -1 को रीसेट करें, और पंक्ति संख्या बढ़ाएँ।

(मजेदार तथ्य: मेरे पास पहले एक 51-बाइट समाधान था ... जो काम नहीं करता था क्योंकि यह दुभाषिया में एक बग बन गया था।)

Answer 11

पायथ, 31 बाइट्स

VzJs.e?YqN-/<zk\(/<zhk\)dzI-JdJ

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

-/<zk\(/<zhk\): वर्तमान चरित्र स्थिति के लिए उपयुक्त स्तर ढूँढता है।

?YqN-/<zk\(/<zhk\)d: एक स्थान यदि उपयुक्त स्तर वर्तमान स्तर नहीं है, तो वर्तमान वर्ण अन्यथा।

Js.e?YqN-/<zk\(/<zhk\)dz: स्ट्रिंग उत्पन्न करें, इसे सहेजें J।

I-JdJ: यदि Jसभी स्थान नहीं हैं, तो इसे प्रिंट करें।

Vz: लूप zसमय।

Answer 12

GNU बैश + कोरुटिल्स + इंडेंट, 135

eval paste "`tr '()' {}|indent -nut -i1 -nbap|sed 's/.*/<(fold -1<<<"&")/'|tr '
' \ `"|expand -t2|sed 'y/{}/()/;s/\(.\) /\1/g;s/ \+$//'

STDIN / STDOUT के माध्यम से इनपुट / आउटपुट:

$ ./telescopic.sh <<< "(()(()())()((())))(())"
(                )(  )
 ()(    )()(    )  ()
    ()()    (  )
             ()
$ 

indentअधिकांश भारी उठाने का काम करता है, लेकिन परेंसियों के बजाय ब्रेसिज़ के साथ काम करने की आवश्यकता होती है। बाकी इस जवाब में संशोधन है कि किस के उत्पादन को स्थानांतरित करना है indent।

Answer 13

अजगर 2, 92

def f(s,i=0,z=''):
 for x in s:b=x>'(';z+=[' ',x][i==b];i-=2*b-1
 if'('in z:print z;f(s,i-1)

प्रिंट लाइन द्वारा लाइन। किसी दिए गए लाइन नंबर i(वास्तव में, इसकी अवहेलना) के लिए, इनपुट स्ट्रिंग के माध्यम से जाता है s, और एक नया स्ट्रिंग बनाता है zजिसमें केवल sगहराई पर वर्ण होते हैं i। यह iवर्तमान गहराई को ट्रैक करने के लिए इंक्रीमेंट या डिक्रिमेंटिंग द्वारा किया जाता है , और वर्तमान वर्णों को जोड़ते हुए जब पार्न प्रकार के लिए समायोजित किया iजाता 0है, और अन्यथा एक स्थान जोड़ते हैं।

फिर, प्रिंट और अगले iतक पुनरावृत्ति करता है जब तक कि वर्तमान लाइन सभी रिक्त स्थान नहीं थी। ध्यान दें कि चूंकि पैरेंस संतुलित हैं, इसलिए iलूप के बाद शुरू में भी ऐसा ही है।

अजगर 3 के लिए एक चरित्र को छोड़कर एक ही होगा print(z)।

Answer 14

धोखा :( रेटिना + TeX, एन बाइट्स धोखा :(

यह केवल तभी काम करता है जब आप मथजैक्स या कुछ अन्य टीईएक्स का उपयोग करके आउटपुट (?) प्रदान करते हैं, जो वर्तमान में इस एसई के लिए अक्षम है: ...

\(
({
\)
})
\{\(
_{(

प्रत्येक पंक्ति एक अलग फ़ाइल में होनी चाहिए, लेकिन आप Retina -e "\(" -e "({" -e "\)" -e "})" -e "\{\(" -e "_{("(या समतुल्य sed कमांड sed -e "s/(/({/g;s/)/})/g;s/{(/_{(/g") का उपयोग करके इसका परीक्षण कर सकते हैं । इनपुट STDIN के माध्यम से पारित किया जाता है।

यह ब्रेसिज़ में प्रत्येक जोड़ी कोष्ठक की सामग्री को संलग्न करके काम करता है, और फिर उनके अंदर सभी वस्तुओं को सबस्क्रिप्ट करता है।

उत्पादन

(((())))
(_{(_{(_{({})})})})

()(())((()))(())()
({})(_{({})})(_{(_{({})})})(_{({})})({})

((()())()(()(())()))
(_{(_{({})({})})({})(_{({})(_{({})})({})})})

Comments

मैं चापलूसी कर रहा हूं कि आपने रेटिना का उपयोग किया है, और यह अच्छी सोच है-बाहर का बॉक्स है, लेकिन यह बिल्कुल नहीं है कि आउटपुट कैसा दिखता है। ;) विशेष रूप से यह वैकल्पिक सूत्रीकरण का उल्लंघन करता है "इसे देखने का एक और तरीका यह है कि गहराई n पर कोष्ठक को उनके क्षैतिज स्थिति को बनाए रखते हुए लाइन n पर ले जाया जाता है।" मैं हालांकि एक शुद्ध, नियम-संगत रेटिना समाधान से बहुत प्रभावित होऊंगा और इसके लिए एक इनाम दे सकता हूं । ;)

— मार्टिन एंडर

In total the lines must not be longer than twice the length of the input string। लाइन 2 से टू (\,{और लाइन 4 को बदलने का }\,)मतलब है कि आउटपुट इसे फिट करता है (हालाँकि ऊर्ध्वाधर गहराई अभी भी गलत है

— :)

खैर, मैं नियम-संगत समाधान बनाने में कामयाब रहा

— :)

अच्छी नौकरी। मुझे लगता है कि इसका मतलब है कि आप अब धोखा देने वाले उत्तर को हटा सकते हैं। ;)

— मार्टिन एंडर

Answer 15

जावा, 232 226 224 222 बाइट्स

गोल्फ संस्करण:

int i,j,k,l,m,a[];void f(String s){a=new int[s.length()];j=a.length;for(k=0;k<j;){a[k]=s.charAt(k++)<41?i++:--i;m=m<i?i:m;}for(k=0;k<m;k++)for(l=0;l<j;)System.out.print(k==a[l++]?i++%2<1?'(':l==j?")\n":')':l==j?'\n':' ');}

दीर्घ संस्करण:

int i, j, k, l, m, a[];
void f(String s) {
    a = new int[s.length()];
    j = a.length;
    for (k = 0; k < j;) {
        a[k] = s.charAt(k++) < 41 ? i++ : --i;
        m = m < i ? i : m;
    }
    for (k = 0; k < m; k++)
        for (l = 0; l < j;)
            System.out.print(k == a[l++] ? (i++ % 2 < 1 ? '(' : (l == j ? ")\n" : ')')) : (l == j ? '\n':' '));
}

इनपुट स्ट्रिंग का पहले विश्लेषण किया जाता है, एक काउंटर को जोड़ने / घटाने के लिए "(" और ")" की तलाश की जाती है और यह निर्धारित करते हुए अपने मूल्य को संग्रहीत किया जाता है कि कोष्ठक में कितनी दूर तक जाना चाहिए, साथ ही यह भी ध्यान रखना चाहिए कि गहराई कितनी गहरी है। फिर सरणी का विश्लेषण किया जाता है; कम मान वाले कोष्ठक पहले मुद्रित होते हैं, और अधिकतम तक पहुंचने तक लाइन द्वारा मुद्रण रेखा जारी रखेंगे।

मैं शायद इसे आगे बाद में गोल्फ करने के तरीके खोजूंगा।

Answer 16

जावास्क्रिप्ट / ईएस 6, 97 वर्ण

f=s=>{for(n in s){m=o=d='';for(c of s)o+=n==(c<')'?d++:--d)?c:' ',m=m<d?d:m;n<m&&console.log(o)}}

प्रयोग

f("(()(()())()((())))(())")

व्याख्या

fn=str=>{                          // accepts string of parenthesis
  for(line in str){                // repeat process n times where n = str.length
    max=output=depth='';           // max: max depth, output: what to print, depth: current depth
    for(char of str)               // iterate over chars of str
      output+=
        line==(char<')'?depth++:--depth)? // update depth, if line is equal to current depth
        char:' ',                  // append either '(', ')', or ' '
        max=max<depth?depth:max;   // update max depth
    line<max&&console.log(output)  // print if current line is less than max depth
  }
}

Comments

इसके बजाय n<m?console.log(o):0, आप उपयोग कर सकते हैं n<m&&console.log(o)जो 1 बाइट बचाता है।

— इस्माइल मिगुएल

Answer 17

CJam, 43 41 36 बाइट्स

बहुत अधिक गोल्फ नहीं (मुझे लगता है), लेकिन यहाँ मेरा पहला प्रयास है:

l:L,{)L<)_')=@~zS*\+}%_$0=,f{Se]}zN*

यह काम किस प्रकार करता है

मैं बहुत आसान तथ्य का उपयोग कर रहा हूं कि )और (CJam में क्रमशः वेतन वृद्धि और क्षय होता है। इस प्रकार, मैं गहराई प्राप्त करने के लिए बस कोष्ठक का मूल्यांकन करता हूं।

l:L,{)L<)_')=@~zS*\+}%_$0=,f{Se]}zN*
l:L,{                    }%                "Store input line in L and iterate over [0,L)";
     )L<                                   "substr(L, 0, iterator + 1)";
        )                                  "Slice off the last character to stack";
         _')=                              "Put 0 on stack if the sliced character is (,
                                            else 1 if sliced character is )";
             @~                            "bring forth the remaining
                                            brackets after slicing and evaluate them";
               zS*                         "Stack has negative depth number, take absolute
                                            value and get that many spaces";
                  \+                       "Prepend to the sliced character";
                      _$0=,                "Get the maximum depth of brackets";
                           f{Se]}          "Pad enough spaces after each string to match
                                            the length of each part";
                                 zN*       "Transpose and join with new lines";

इसे यहाँ ऑनलाइन आज़माएँ

Answer 18

ऑक्टेव, 85 वर्ण

function r=p(s)i=j=0;for b=s k=b==40;k&&++j;t(j,++i)=9-k;k||--j;r=char(t+32);end;end

यह भोले दृष्टिकोण का एक अनुकूलन है, जो वास्तव में मतलाब और ओक्टेव के लिए बहुत स्वाभाविक है:

function r=p(s)
i=j=1;
for b=s
 if b=='(' t(++j,i++)='(' else t(j--,i++)=')' end; end; t(~t)=' '; r=char(t);
end;

तालिका t अभी भी मौजूद नहीं हो सकती है, और हम अभी किसी भी तत्व को असाइन कर सकते हैं, और यह इस तत्व के अस्तित्व के लिए आवश्यक सबसे छोटे आयाम को पुन: आकार देता है जो कि काफी सुविधाजनक है।

Answer 19

पर्ल, 91 89 88 84 80 79 बाइट्स

$t=<>;{$_=$t;s/\((?{$l++})|.(?{--$l})/$^R==$c?$&:$"/ge;print,++$c,redo if/\S/}

• $ t इनपुट स्ट्रिंग है।
• $ c वह गहराई है जिसे हम वर्तमान लाइन पर प्रिंट करना चाहते हैं।
• $ l वह गहराई है जो हम एक मुठभेड़ के बाद उठाते हैं।
• $ l को regex एम्बेडेड कोड ब्लॉक में अपडेट किया गया है ।
• $ ^ R सबसे हालिया कोड ब्लॉक का परिणाम है।

Answer 20

हास्केल, 154 बाइट्स

f h('(':s)=h:f(h+1)s;f h(')':s)=(h-1):f(h-1)s;f _ _=[]
main=interact$ \s->unlines[[if i==h then c else ' '|(c,i)<-zip s l]|let l=f 0 s,h<-[0..maximum l]]

अन्य हास्केल समाधान के समान विचार, लेकिन कुछ हद तक कम। - उपयोग:

echo  '(((())())(()))' | runghc Golf.hs

Answer 21

जे, ४६

अन्य 'गोल्फ भाषाओं' के रूप में महान नहीं है, लेकिन मेरे बचाव में: जम्मू तार के साथ भयानक है।

[:|:(((,~(' '#~]))"0)(0,2%~[:+/\2+/\1-'(('i.]))~

एक फ़ंक्शन के लिए इनपुट के रूप में स्ट्रिंग लेता है। जे में इसे करने का एक बेहतर तरीका भी है।

उपयोग:

   f=:[:|:(((,~(' '#~]))"0)(0,2%~[:+/\2+/\1-'(('i.]))~
   f '(()(()())()((())))(())'
(                )(  )
 ()(    )()(    )  () 
    ()()    (  )      
             ()       

Comments

जे। में ऐसा करने के एक और तरीके के लिए मेरा जवाब देखें

— फ़ूजएक्सल

व्यक्तिगत रूप से, मुझे लगता है कि जम्मू स्ट्रिंग्स के लिए पूरी तरह से अनुकूल है। आपको केवल सरणियों के साथ सोचने की आवश्यकता है।

— फ़ूजएक्सएक्सएल

Answer 22

रूबी, 119 115 114

->s{r=[""]*s.size
d=0
s.chars.map{|l|r.map!{|s|s+" "}
b=l>"("?1:0
d-=b
r[d][-1]=l
d+=1-b}.max.times{|i|puts r[i]}}

स्पष्टीकरण:

->s{r=[""]*s.size  # Take an array of strings big enough
d=0                # This will contain the current depth
s.chars.map{|l|r.map!{|s|s+" "}  # Add a new space to every array
b=l>"("?1:0       # Inc/Dec value of the depth
d-=b               # Decrement depth if we are at a closing paren
r[d][-1]=l         # Set the corresponding space to the actual open/close paren
d+=1-b             # Increment the depth if we are at a opening paren
}.max.times{|i|puts r[i]}}  # Print only the lines up to the max depth

Answer 23

जावा, 233 214 बाइट्स

void f(String s){int p,x,d,l=s.length();char c,m[]=new char[l*l];java.util.Arrays.fill(m,' ');p=x=0;while(x<l){d=(c=s.charAt(x))==40?p++:--p;m[d*l+x++]=c;}for(x=0;x<l*l;x++)System.out.print((x%l==0?"\n":"")+m[x]);}

इंडेंट:

void f(String s){
    int p, x, d, l = s.length();
    char c, m[] = new char[l * l];
    java.util.Arrays.fill(m, ' ');
    p = x = 0;
    while (x < l){
        d = (c = s.charAt(x)) == 40
                ? p++
                : --p;
        m[d * l + x++] = c;
    }
    for (x = 0; x < l * l; x++)
        System.out.print((x % l == 0 ? "\n" : "") + m[x]);
}

मुझे लगता है कि अंतिम लूप को छोटा किया जा सकता है, लेकिन मैं इसे पाठक को एक अभ्यास के रूप में छोड़ दूँगा। ;-)

---

पुराना, 233 बाइट्स उत्तर:

void f(String s){int y=s.length(),x=0;char[][]m=new char[y][y];for(char[]q:m)java.util.Arrays.fill(q,' ');y=0;for(char c:s.toCharArray())if(c=='(')m[y++][x++]=c;else m[--y][x++]=c;for(char[]q:m)System.out.println(String.valueOf(q));}

इंडेंट:

static void f(String s) {
    int y = s.length(), x = 0;
    char[][] m = new char[y][y];
    for(char[] q : m)
        java.util.Arrays.fill(q, ' ');
    y = 0;
    for(char c : s.toCharArray())
        if(c == '(')
            m[y++][x++] = c;
        else
            m[--y][x++] = c;
    for(char[] q : m)
        System.out.println(String.valueOf(q));
}

Comments

मुझे पता है कि यह एक वर्ष से अधिक हो गया है, लेकिन मुझे लगता है कि अंतिम लूप को छोटा किया जा सकता है, लेकिन मैं इसे पाठक के लिए एक अभ्यास के रूप में छोड़ दूंगा; ;-) "। तुम वास्तव में सही हो। यह से बदला जा सकता है for(x=0;x<l*l;x++)System.out.print((x%l==0?"\n":"")+m[x]);के लिए for(x=0;x<l*l;)System.out.print((x%l==0?"\n":"")+m[x++]);-1 बाइट के लिए। इसके अलावा, आप हटाने के द्वारा 2 और बाइट्स बचा सकते हैं p=x=0और int p=0,x=0,इसके बजाय खेतों के आरंभीकरण पर उपयोग कर सकते हैं । कुल में यह 211 बाइट्स हो जाता है ।

— केविन क्रूज़सेन

Answer 24

सी #, 195 बाइट्स

अगर मैंने कुछ गलत किया है तो सबसे पहले गोल्फ - येल पर प्रयास करें।

वैकल्पिक C # संस्करण जो SetCursorPosition का उपयोग कर रहा है और कमांड लाइन आर्ग के रूप में इनपुट लेने के लिए दाएं से बाएं काम कर रहा है।

using System;class P{static void Main(string[] a){Action<int,int>p=Console.SetCursorPosition;int r=0,c=0;foreach(var x in a[0]){r+=x==')'?-1:0;p(c,r);Console.Write(x);r+=x=='('?1:0;p(c,r);c++;}}}

मुझे लगा कि खुले / नज़दीकी पैरेन के आधार पर लिखने की स्थिति को समायोजित करने में मज़ा आएगा और पूरी लाइनों पर नहीं। लिखने से पहले करीबी व्यक्ति स्थिति को ऊपर ले जाता है; लिखने के बाद खुले पैरेन इसे नीचे ले जाते हैं। क्रिया SetCursorPosition पाँच बाइट्स बचाता है। आउटपुट के बाद कर्सर को अगली पंक्ति में ले जाना काफी अतिरिक्त होगा।

using System;
class P
{
    static void Main(string[] a)
    {
        Action<int, int> p = Console.SetCursorPosition;
        int r = 0, c = 0;
        foreach (var x in a[0])
        {            
            r += x == ')' ? -1 : 0;
            p(c, r);
            Console.Write(x);
            r += x == '(' ? 1 : 0;
            p(c, r);
            c++;
        }
    }
}

Answer 25

बैच, 356 335 बाइट्स

मुझे पता है कि इस चुनौती के लिए पहले से ही एक बैच समाधान मौजूद है, लेकिन यह एक बहुत अधिक गोल्फ है और एक अलग दृष्टिकोण लेता है। सबसे महत्वपूर्ण बात, दूसरे बैच के समाधान में कम से कम एक शक्तियां शामिल हैं; यह समाधान नहीं करता है।

@echo off
setlocal enabledelayedexpansion
set p=%1
set p=%p:(="(",%
set p=%p:)=")",%
set c=0
for %%a in (%p%)do (if ")"==%%a set/ac-=1
set d=!d!,!c!%%~a
if "("==%%a set/ac+=1&if !c! GTR !m! set m=!c!)
set/am-=1
for /l %%a in (0,1,!m!)do (for %%b in (!d!)do (set t=%%b
if "%%a"=="!t:~0,-1!" (cd|set/p=!t:~-1!)else (cd|set/p=. ))
echo.)

U+0008डॉट (पंक्ति 12, कॉलम 57) के बाद दूसरी से अंतिम पंक्ति तक एक बैकस्पेस वर्ण ( ) है। यह यहां पोस्ट किए गए कोड में दिखाई नहीं देता है, लेकिन बाइट काउंट में शामिल है।

Comments

कोई और वास्तव में बैच में एक जवाब प्रस्तुत कर रहा है - अच्छा एक +1।

— चाचा

Answer 26

बैच, 424 बाइट्स

@echo off
setLocal enableDelayedExpansion
set s=%1
set a=1
:c
if defined s (set/ac+=1
set "z="
if "%s:~0,1%"=="(" (set "1=(")else (set/aa-=1
set "1=)")
for %%a in (!a!)do for /f usebackq %%b in (`powershell "'!l%%a!'".Length`)do (set/ay=!c!-%%b
for /l %%a in (1,1,!y!)do set z= !z!
set "l%%a=!l%%a!!z!!1!")
if "%s:~0,1%"=="(" set/aa+=1
if !a! GTR !l! set/al=!a!-1
set "s=%s:~1%"
goto c)
for /l %%a in (1,1,!l!)do echo !l%%a!

संयुक्त राष्ट्र के golfed:

@echo off
setLocal enableDelayedExpansion

set s=%1
set a=1
set c=0
set l=0

:c
if defined s (
    set /a c+=1
    set "z="
    if "%s:~0,1%"=="(" (
        set "1=("
    ) else (
        set /a a-=1
        set "1=)"
    )
    for %%a in (!a!) do for /f usebackq %%b in (`powershell "'!l%%a!'".Length`) do (
        set /a y=!c!-%%b
        for /l %%a in (1,1,!y!) do set z= !z!
        set "l%%a=!l%%a!!z!!1!"
    )
    if "%s:~0,1%"=="(" set /a a+=1
    if !a! GTR !l! set /a l=!a!-1
    set "s=%s:~1%"
    goto c
)

for /l %%a in (1,1,!l!) do echo !l%%a!

उदाहरण:

h:\>par.bat (((())())(()))
 (            )
  (      )(  )
   (  )()  ()
    ()

Answer 27

सी, 118 117 बाइट्स

सी में एक और जवाब, लेकिन मेरा छोटा है।

c;d;main(m,v)int**v;{while(d++<m){char*p=v[1];while(*p)c+=*p==40,putchar(c-d?*p:32),m=c>m?c:m,c-=*p++==41;puts("");}}

Ungolfed संस्करण:

c; /* current depth */
d; /* depth to print in current row */
main(m,v)int**v;{
    while(d++<m) {
        char*p=v[1];
        while(*p){
            c+=*p==40;           /* 40 = '(' */
            putchar(c-d?*p:32); /* 32 = ' ' (space) */
            m=c>m?c:m;           /* search maximum depth */
            c-=*p++==41;         /* 41 = ')' */
        }
        puts("");
    }
}

और यह काम करता है!

% ./telescope '()(())((()))(())()'
()(  )(    )(  )()
   ()  (  )  ()
        ()
% ./telescope '((()())()(()(())()))'
(                  )
 (    )()(        )
  ()()    ()(  )()
             ()

Comments

हालांकि, एक सुरुचिपूर्ण समाधान काफी putchar(c-d?32:*p)कम है putchar(c==d?*p:32)।

— pawel.boczarski

Answer 28

हास्केल, 227 बाइट्स

n _ []=[]
n h ('(':r)=('(',h):n(h+1)r
n d (')':r)=let h=d-1 in(')',h):n h r
m n []=n
m n ((_,h):r)=m(max h n)r
p s=let v=n 0 s;h=m 0 v;in map(\d->map(\(b,l)->if l==d then b else ' ')v)[0..h]
main=fmap p getLine>>=mapM_ putStrLn

Comments

आप ऑपरेटरों के साथ कुछ स्थान बचा सकते हैं: जैसे n#[]इसके बजाय m n []।

— फ्रेंकी

Answer 29

पर्ल, 76 बाइट्स

$a[/\(/?$l++:--$l][$i++]=$_ for split//,<>;print map{$_||' '}@$_,"\n"for@a

use strictयहाँ नहीं :)

Answer 30

लेक्स, 94 बाइट्स

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

%%
 int p[2]={0};
\( printf("(\33D");++p[!*p];
\) printf("\33M)");--*p;
\n while(p[1]--)ECHO;

संकलन और चलाने के लिए:

$ flex -o telescopic.c telescopic.l
$ gcc -o telecopic telescopic.c -lfl
$ ./telescopic
(()(()())()((())))(())
(                )(  )
 ()(    )()(    )  ()
    ()()    (  )
             ()
--- type ctrl-D ---