Um einen String zu "verschachteln", müssen Sie:

• Behandeln Sie das erste Zeichen als Funktion und die folgenden Zeichen als Argumente für diese Funktion. Wenn die Eingabezeichenfolge beispielsweise lautet Hello, lautet der erste Schritt:

  H(ello)
  

• Wiederholen Sie diesen Schritt dann für jeden Teilstring. So bekommen wir:

  H(ello)
  H(e(llo))
  H(e(l(lo)))
  H(e(l(l(o))))
  

Ihre Aufgabe ist es, ein Programm oder eine Funktion zu schreiben, die einen String "verschachtelt". Wenn zum Beispiel die Eingabezeichenfolge war Hello world!, sollten Sie Folgendes ausgeben:

H(e(l(l(o( (w(o(r(l(d(!)))))))))))

Die Eingabe enthält immer nur druckbares ASCII , und Sie können die Eingabe und die Ausgabe in jedem vernünftigen Format vornehmen. Zum Beispiel STDIN / STDOUT, Funktionsargumente und Rückgabewert, Lesen und Schreiben in eine Datei usw.

Der Einfachheit halber können Sie auch davon ausgehen, dass die Eingabe keine Klammern enthält und nicht leer ist.

Input:
Nest a string
Output:
N(e(s(t( (a( (s(t(r(i(n(g))))))))))))

Input:
foobar
Output:
f(o(o(b(a(r)))))

Input:
1234567890
Output:
1(2(3(4(5(6(7(8(9(0)))))))))

Input:
code-golf
Output:
c(o(d(e(-(g(o(l(f))))))))

Input:
a
Output:
a

Input:
42
Output:
4(2)

Wie immer gelten alle unsere Standardregeln und Regelungslücken, und die kürzeste Antwort in Bytes gewinnt!

Python, 41 39 34 Bytes

lambda e:"(".join(e)+")"*~-len(e)

Ideone es

Ziemlich selbsterklärend.

Es setzt eine Klammer zwischen jedes andere Zeichen und fügt am Ende eine Klammer weniger als die Länge hinzu.

MS-DOS-.com-Datei 30 Byte

0000   fc be 82 00 b4 02 ac 88 c2 cd 21 ac 3c 0d 74 0d
0010   b2 28 50 cd 21 5a e8 f0 ff b2 29 cd 21 c3

Die Zeichenfolge wird über die Befehlszeile an die ausführbare Datei übergeben. (Ein Leerzeichen zwischen dem .COM-Dateinamen und der Zeichenfolge).

Das Ergebnis wird in die Standardausgabe geschrieben.

Die Demontage ist hier:

  fc          cld              ; Make sure DF is not set (lodsb!)
  be 82 00    mov    si,0x82   ; First character of command line args
  b4 02       mov    ah,0x2    ; AH=2 means output for INT 21h
  ac          lodsb            ; Load first character
  88 c2       mov    dl,al     ; Move AL to DL (DL is written to output)
recursiveFunction:
  cd 21       int    0x21      ; Output
  ac          lodsb            ; Get the next character
  3c 0d       cmp    al,0xd    ; If it is "CR" (end of command line) ...
  74 0d       je     doReturn  ; ... return from the recursive function
  b2 28       mov    dl,0x28   ; Output "(" next...
  50          push   ax        ; ... but save character read first
  cd 21       int    0x21      ; (Actual output)
  5a          pop    dx        ; Restore character (but in DL, not in AL)
  e8 f0 ff    call   recursiveFunction  ; Recursively enter the function
doReturn:
  b2 29       mov    dl,0x29   ; Output ")"
  cd 21       int    0x21
  c3          ret              ; Actually return

Hinweis: Sie können eine DOS .COM-Datei (im Gegensatz zu Dateien mit EXE-Headern) mit einer "RET" -Anweisung beenden.

JavaScript (ES6), 40 34 33 Bytes

6 Bytes gespart dank ETHproductions

Eine rekursive Funktion.

f=([c,...s])=>s+s?c+`(${f(s)})`:c

Probieren Sie es online!

Brainfuck, 42 40 Bytes

>+[-->+[<]>-]>+>>,.,[<+<.>>.,]<<+>[-<.>]

Probieren Sie es online!

Ungolfed:

>+[-->+[<]>-]>+     # count to 40 (ASCII for open paren)
>>                  # move to the input holder
,.                  # input the first byte and output it
,                   # input the next byte
[                   # while it's not zero
  <+                # move to the input counter and increment it
  <.                # move to the open paren and output it
  >>.               # move to the input holder and output it
  ,                 # input the next byte
]
<<+                 # move to the open paren and increment it to a close
>                   # move to the input counter
[                   # while it's not zero
  -                 # decrement it
  <.                # move to the close paren and output it
  >                 # move to the input counter
]

05AB1E , 11 Bytes

S'(ý¹g<')×J

Probieren Sie es online!

Erläuterung:

S'(ý         join input by "("
    ¹g<      push length of input - 1, call it n
       ')×   push a string with char ")" n times
          J  concatenate

Brainfuck, 44 Bytes

>+++++[-<++++++++>],.,[<.>.>+<,]<+>>[-<<.>>]

Liest ein Byte nach dem anderen, setzt vor jedes ein Open-Paren, mit Ausnahme des ersten, und setzt am Ende die gleiche Anzahl von Close-Parens.

Haskell, 30 Bytes

f[x]=[x]
f(a:b)=a:'(':f b++")"

Anwendungsbeispiel: f "Nest a string"-> "N(e(s(t( (a( (s(t(r(i(n(g))))))))))))".

Nehmen Sie das nächste Zeichen, gefolgt von einem (, gefolgt von einem rekursiven Aufruf mit allen bis auf das erste Zeichen, gefolgt von einem ).

Gelee , 9 8 Bytes

-1 Byte dank @Dennis (benutze mold ṁ, anstelle von length L, und wiederhole, x)

j”(³”)ṁṖ

TryItOnline

Wie?

j”(³”)ṁṖ - Main link: s     e.g. "code-golf"           printed output:
j        - join s with
 ”(      - literal '('           "c(o(d(e(-(g(o(l(f"
    ”)   - literal ')'
      ṁ  - mould like
   ³     - first input, s        ")))))))))"
         - causes print with no newline of z:          c(o(d(e(-(g(o(l(f
       Ṗ - pop (z[:-1])          "))))))))"            c(o(d(e(-(g(o(l(f
         - implicit print                              c(o(d(e(-(g(o(l(f))))))))

Netzhaut , 22 17 Bytes

\1>`.
($&
T`(p`)_

Probieren Sie es online!

Alternative:

S_`
\`¶
(
T`(p`)_

Erläuterung

Ich vergesse immer, dass es möglich ist, Dinge auf dem Weg zu drucken, anstatt alles in das Endergebnis umzuwandeln und es auf einmal auszugeben ...

\1>`.
($&

Hier \weist Retina an, das Ergebnis dieser Phase ohne nachfolgenden Zeilenvorschub zu drucken. Das 1>ist eine Grenze , was bedeutet , dass das erste Spiel des regulären Ausdrucks ignoriert werden soll. Die Bühne selbst ersetzt einfach jedes Zeichen ( .) mit Ausnahme des ersten durch (gefolgt von diesem Zeichen. Mit anderen Worten, es wird (zwischen jedes Zeichenpaar eingefügt. Bei der Eingabe abcwandelt sich dies in (und druckt)

a(b(c

Jetzt müssen Sie nur noch die schließenden Klammern drucken:

T`(p`)_

Dies wird mit einer Umschrift durchgeführt , die ersetzt (mit )und löscht alle anderen druckbaren ASCII - Zeichen aus der Zeichenfolge.

> <> , 19 18 Bytes

io8i:&0(.')('o&!
o

Probieren Sie es online!

Erläuterung

Die erste Zeile ist eine Eingabeschleife, die alles bis zum letzten Zeichen der Eingabe (einschließlich aller () druckt und die richtige Menge von )auf dem Stapel belässt :

io                 Read and print the first character.
  8                Push an 8 (the x-coordinate of the . in the program).
   i               Read a character. Pushes -1 at EOF.
    :&             Put a copy in the register.
      0(           Check if negative. Gives 1 at EOF, 0 otherwise.
        .          Jump to (8, EOF?). As long as we're not at EOF, this is
                   a no-op (apart from popping the two coordinates). At EOF
                   it takes us to the second line.
         ')('      Push both characters.
             o     Output the '('.
              &    Push the input character from the register.
               !   Skip the 'i' at the beginning of the line, so that the next
                   iteration starts with 'o', printing the last character.

Sobald wir EOF drücken, landet der Anweisungszeiger in der zweiten Zeile und wir werden einfach oin einer Schleife ausgeführt und drucken alles aus ), bis der Stapel leer ist und das Programm fehlerfrei ist.

C #, 32 Bytes

F=s=>*s+++(0<*s?$"({F(s)})":"");

Dieses Lambda muss eine statische Methode sein. Muss ich für diese Anforderung zusätzliche Bytes zählen? Normalerweise würde ich kein Lambda für die Rekursion in C # verwenden, aber dann denke ich, dass es kürzer wäre, keine Rekursion zu verwenden.

/*unsafe delegate string Function(char* s);*/ // Lambda signature
/*static unsafe Function*/ F = s =>
    *s++                               // Take first char and increment pointer to next one
    + (0 < *s                          // Check if any chars left
        ? $"({F(s)})"                  // If so concat surrounding parens around recursion
        : ""                           // Otherwise done
    )
;

J, 13 Bytes

(,'(',,&')')/

J wird von rechts nach links ausgeführt, sodass mit dem Einfügeadverb /ein Verb verwendet werden kann, um die Buchstaben der Eingabezeichenfolge zu reduzieren.

Verwendungszweck

   f =: (,'(',,&')')/
   f 'Nest a string'
N(e(s(t( (a( (s(t(r(i(n(g))))))))))))
   f 'foobar'
f(o(o(b(a(r)))))
   f '1234567890'
1(2(3(4(5(6(7(8(9(0)))))))))
   f 'code-golf'
c(o(d(e(-(g(o(l(f))))))))

Sie können die Teilleistungen zwischen den einzelnen Reduzierungen beobachten.

   |. f\. 'Hello'
o            
l(o)         
l(l(o))      
e(l(l(o)))   
H(e(l(l(o))))

Erläuterung

(,'(',,&')')/  Input: string S
(          )/  Insert this verb between each char and execute (right-to-left)
      ,&')'      Append a ')' to the right char
  '(',           Prepend a '(' to that
 ,               Append to the left char

R, 61 Bytes

cat(gsub("(?<=.)(?=.)","(",x,F,T),rep(")",nchar(x)-1),sep="")

Regex findet und ersetzt Leerzeichen zwischen den Zeichen mit „(“. Dann catund repfügen Sie „)“ n-1 mal am Ende.

PowerShell v2 +, 46 Byte

param([char[]]$a)($a-join'(')+')'*($a.count-1)

Nimmt die Eingabezeichenfolge, char-array ist es, -joins das Array zusammen mit offenen Parens (und verkettet dann die entsprechende Anzahl geschlossener Parens ).

Acc !! 129 Bytes

Nicht schlecht für eine ziemlich wortreiche Turing-Plane ...

N
Count i while _%128-9 {
Count x while _/128%2 {
Write 40
_+128
}
Write _%128
_+128-_%128+N
}
Count j while _/256-j {
Write 41
}

(Ja, das ganze Leerzeichen ist obligatorisch.)

Hinweis: Wegen der Eingabebeschränkungen von Acc !! Ist es nicht möglich, eine beliebige Zeichenfolge ohne Endbegrenzer zu lesen? Daher erwartet dieses Programm die Eingabe (in stdin) als Zeichenfolge, gefolgt von einem Tabulatorzeichen.

Acc !! ?

Es ist eine Sprache, die ich erstellt habe und die nur unbrauchbar zu sein scheint . Der einzige Datentyp ist Integer, das einzige Kontrollflusskonstrukt ist die Count x while ySchleife und die einzige Möglichkeit, Daten zu speichern, ist ein einzelner Akkumulator _. Die Ein- und Ausgabe erfolgt zeichenweise unter Verwendung des speziellen Werts Nund der WriteAnweisung. Trotz dieser Einschränkungen bin ich mir ziemlich sicher, dass Acc !! ist Turing-komplett.

Erläuterung

Die Grundstrategie in Acc !! Bei der Programmierung wird der Akkumulator konzeptionell durch Mod- %und Integer-Division /partitioniert, sodass mehrere Werte gleichzeitig gespeichert werden können. In diesem Programm werden drei solcher Abschnitte verwendet: Die sieben Bits ( _%128) niedrigster Ordnung speichern einen ASCII-Code von der Eingabe; das nächste Bit ( _/128%2) speichert einen Flag-Wert; und die verbleibenden Bits ( _/256) zählen die Anzahl der von uns benötigten engen Parens.

Eingabe in Acc !! kommt von dem speziellen Wert N, der ein einzelnes Zeichen liest und zu seinem ASCII-Code auswertet. Jede Anweisung, die nur aus einem Ausdruck besteht, weist das Ergebnis dieses Ausdrucks dem Akkumulator zu. Also speichern wir zunächst den Code des ersten Zeichens im Akkumulator.

_%128speichert das zuletzt gelesene Zeichen. Die erste Schleife läuft also solange _%128-9, bis das aktuelle Zeichen ein Tabulator ist.

Innerhalb der Schleife möchten wir drucken, es ( sei denn, wir befinden uns in der ersten Iteration. Seit Acc !! Wenn keine if-Anweisung vorhanden ist, müssen Schleifen für Bedingungen verwendet werden. Wir verwenden das 128-Bit des Akkumulators _/128%2als Flag-Wert. Beim ersten Durchlauf ist das einzige, was sich im Akkumulator befindet, ein ASCII-Wert <128, daher ist das Flag 0 und die Schleife wird übersprungen. Bei jedem weiteren Durchgang stellen wir sicher, dass das Flag 1 ist.

Innerhalb der Count xSchleife (wenn das Flag 1 ist) schreiben wir einen offenen Paren (ASCII 40) und addieren 128 zum Akkumulator. Dadurch setzen wir das Flag auf 0 und verlassen die Schleife. Dies geschieht auch, um den Wert von _/256zu erhöhen, den wir als unsere Liste der auszugebenden engen Parens verwenden werden.

Unabhängig vom Wert des Flags schreiben wir das neueste Eingabezeichen, was einfach ist _%128.

Die nächste Anweisung ( _+128-_%128+N) führt zwei Dinge aus. Durch Hinzufügen von 128 wird zunächst das Flag für den nächsten Durchlauf der Schleife gesetzt. Zweitens wird der _%128Slot auf Null gesetzt, ein anderes Zeichen gelesen und dort gespeichert. Dann schleifen wir.

Wenn die Count iSchleife beendet wird, haben wir gerade ein Tabulatorzeichen gelesen und der Akkumulatorwert bricht folgendermaßen zusammen:

• _%128: 9(das Tabulatorzeichen)
• _/128%2: 1(die Flagge)
• _/256: Anzahl der gelesenen Zeichen minus 1

(Das Minus 1 liegt daran, dass wir beim ersten Durchlauf durch die Hauptschleife nur einmal 128 zum Akku addieren.) Alles, was wir jetzt brauchen, sind die engen Parens. Count j while _/256-jSchleifen Sie die _/256Zeiten ab und schreiben Sie 41jedes Mal ein enges Paren (ASCII ). Voila!

Java 7,81 79 Bytes

Gespeichert 1byte.Thanks zu kevin.

String f(char[]a,String b,int l){return l<a.length?f(a,b+'('+a[l],++l)+')':b;}

APL, 19 Bytes

{∊('(',¨⍵),')'⍴⍨⍴⍵}

Erläuterung:

{
  ('(',¨⍵)          ⍝ join a ( to each character in ⍵          
          ,')'⍴⍨⍴⍵  ⍝ for each character in ⍵, add an ) to the end
 ∊                  ⍝ flatten the list 
                   }

Alternativlösung, auch 19 Bytes:

{⊃{∊'('⍺⍵')'}/⍵,⊂⍬}

Erläuterung:

{              
              ⍵,⊂⍬  ⍝ add an empty list behind ⍵ (as a base case)
  {         }/      ⍝ reduce with this function:
    '('⍺⍵')'        ⍝   put braces around input
   ∊                ⍝   flatten the list
 ⊃                  ⍝ take first item from resulting list
                   }

MATL , 16 Bytes

t~40+v3L)7MQ3L)h

Probieren Sie es online!

Erläuterung

t     % Implicit input. Duplicate
      % STACK: 'foobar', 'foobar'
~     % Negate. Transforms into an array of zeros
      % STACK: 'foobar', [0 0 0 0 0 0]
40+   % Add 40, element-wise. Gives array containing 40 repeated
      % STACK: 'foobar', [40 40 40 40 40 40]
v     % Concatenate vertically. Gives a two-row char array, with 40 cast into '('
      % STACK: ['foobar'; '((((((']
3L)   % Remove last element. Converts to row vector
      % STACK: 'f(o(o(b(a(r'
7M    % Push array containing 40 again
      % STACK: 'f(o(o(b(a(r', [40 40 40 40 40 40]
Q     % Add 1, element-wise 
      % STACK: 'f(o(o(b(a(r', [41 41 41 41 41 41]
h     % Concatenate horizontally, with 41 cast into ')'
      % STACK: 'f(o(o(b(a(r)))))'
      % Implicit display

Perl, 25 Bytes

Vielen Dank an @Ton Hospel für die Ausgabe von 4 Bytes.

24 Byte Code + -F.

$"="(";say"@F".")"x$#F

Bedürfnisse -Fund -EFlaggen:

echo -n "I love lisp" | perl -F -E '$"="(";say"@F".")"x$#F'

Beachten Sie, dass Sie möglicherweise -aflag hinzufügen müssen, wenn Sie dies auf einer alten Version von Perl versuchen .

#!/usr/bin/perl -p
s/.(?=.)/s%\Q$'%($&)%/reg

(Um es zu benutzen, geben Sie den Code in eine Datei ein und rufen Sie ihn mit auf. echo -n "Hello" | perl nest.pl)

Ruby, 27 Bytes

->s{s.chars*?(+?)*~-s.size}

Erläuterung

->s{                       # Declare anonymous lambda taking argument s
    s.chars                # Get the array of chars representing s
           *?(             # Join the elements back into a string using "("s as separators
              +?)*~-s.size # Append (s.size - 1) ")"s to the end

Perl, 24 23 Bytes

Beinhaltet +1 für -p

Geben Sie in STDIN einen String ohne Zeilenumbruch ein (oder fügen Sie -ldem Programm eine Option hinzu)

echo -n Hello | nest.pl

nest.pl:

#!/usr/bin/perl -p
$\=")"x s/.(?=.)/$&(/g

GNU sed, 37 35 31 Bytes (30 +1 für -rArgument)

Reine Linux-Lösung

:;s/([^(])([^()].*)$/\1(\2)/;t

1. Benennung der Substitution :; dann mit rekursiv aufrufent
2. 2 Regex-Gruppen bilden:
   • Die erste Gruppe ist das erste Zeichen zweier aufeinanderfolgender Zeichen, die nicht in Klammern stehen
   • Die zweite Gruppe ist das zweite aufeinanderfolgende Zeichen und der Rest der Zeichenfolge bis zum Zeilenende
3. Fügen Sie um die zweite Gruppe Klammern hinzu \1 ( \2 )

Edit : Danke an @manatwork für die Hilfe beim Entfernen von 4 Zeichen!

Online-Tester

Qualle , 19 18 Bytes

P
,+>`
_  {I
/'␁'(

Das Zeichen ␁ist das nicht druckbare Steuerzeichen mit Bytewert 0x1. Probieren Sie es online!

Erläuterung

Dies ist ein ziemlich komplexes Jellyfish-Programm, da viele Werte an mehreren Stellen verwendet werden.

• I ist eine unformatierte Eingabe, die aus STDIN als Zeichenfolge gelesen wird.
• '(ist das buchstäbliche Zeichen (.
• Die {(linke Identität) nimmt '(und Ials Eingaben und kehrt zurück '(. Der Rückgabewert wird nie verwendet.
• `ist Faden. Es ändert sich {, um das Zeichen (für jedes Zeichen von zurückzugeben I, was zu einer Zeichenfolge von (s mit der gleichen Länge wie führt I.
• >ist Schwanz; es nimmt den String von (s als Eingabe und schneidet das erste Zeichen ab.
• +(Nimmt als Argumente die Zeichenfolge von s und das nicht druckbare Byte und fügt jedem Zeichen den Bytewert (1) hinzu. Dies ergibt eine Zeichenkette gleicher Länge von )s. Die Verwendung des Zeichens ␁garantiert, dass der Rückgabewert eine Zeichenfolge und keine Liste von Ganzzahlen ist.
• /Nimmt in der unteren linken Ecke das nicht druckbare Byte und gibt eine Funktion zurück , die zwei Argumente annimmt und das zweite Argument einmal mit dem ersten Argument verbindet (da der Bytewert 1 ist).
• _Nimmt diese Funktion, greift die Argumente der niederen {(die waren '(und I) und ruft die Funktion mit ihnen auf. Dies fügt das Zeichen (zwischen jedes Zeichenpaar in ein I.
• ,Verkettet diesen String mit dem String von )s und gibt Pdas Ergebnis aus.

05AB1E , 22 21 19 18 Bytes

¤Ug<©FN¹è'(}X®')×J

Probieren Sie es online!

Erläuterung:

¤Ug<©FN¹è'(}X®')×J #implicit input, call it A                                 
¤U                 #push the last letter of A, save it to X
  g<©              #push the length of A, subtract 1, call it B and save it to register_c
     F     }       #repeat B times
      N¹è          #push the Nth char of A
         '(        #push '('
            X      #push X
             ®')×  #push ')' repeated B times
                 J #join together
                   #implicit print

PHP, 63 Bytes

<?=str_pad(join("(",$s=str_split($argv[1])),count($s)*3-2,")‌​");

Vorherige Version 64 Bytes

<?=join("(",$s=str_split($argv[1])).str_pad("",count($s)-1,")");

Vim, 17 Bytes

$qqha(<Esc>A)<Esc>%h@qq@q

Geht von Ende zu Anfang, weil du sonst über die )s stolperst, die du schon geschrieben hast. Verwendet, haanstatt izu versagen, wenn es den Anfang erreicht.

Normalerweise würden Sie nicht zwei separate Einfügungen wie diese durchführen. Sie würden etwas tun C()<Esc>P, um einen Schlaganfall zu retten. Aber die Positionierung funktioniert diesmal nicht so gut.

Brain-Flak 103 97 Bytes

Beinhaltet +3 für -c

{({}<><(((((()()){}()){}){}){})>)<>}<>({}<([][()]){({}[()()]<(({})()<>)<>>)}{}>){({}<>)<>}<>{}

Probieren Sie es online!

Erläuterung:

#reverse the stack and put a 40 between every number
{({}<><(((((()()){}()){}){}){})>)<>}<>
{                                  }   #repeat this until the stack is empty
 ({}                            )      #pop the top and push it after
    <>                                 #switching stacks and
      <(((((()()){}()){}){}){})>       #pushing a 40 (evaluated as 0) 
                                 <>    #switch back to the first stack
                                    <> #switch to the stack that everything is on now    

#put as many )s on the other stack as needed
({}                                      ) #pop the top letter and put it  back
                                           #after doing the following
                                           #This leaves ( on the top
   <                                    >  #evalute this part as 0
    ([][()])                               #push the height of the stack minus one
            {                        }    #repeat until the "height" is 0
             ({}[()()]              )     #pop the "height" and push is minus two
                      <            >      #evaluate to 0
                       (        )         #push:
                        ({})              #the top of the stack (putting it back on)
                            ()            #plus one onto
                              <>          #the other stack
                                 <>       #switch back to the other stack

                                      {}  #pop what was the height of the stack

#move the string of letters and (s back, reversing the order again
{        }     # repeat until all elements are moved
 (    )        # push:
  {}           # the top of the stack after
    <>         # switching stacks
       <>      # switch back to the other stack
          <>   # switch to the stack with the final string
            {} #pop the extra (

Dyalog APL , 14 Bytes

⊃{⍺,1⌽')(',⍵}/

Dies ist eine Spitze von ⊃und{ }/

⊃(erstes Element holen) wird angewendet nach { }/(Reduktion eines Lambda)

⍺,1⌽')(',⍵- das linke Argument ( ⍺) verknüpft mit ( ,) der Drehung um ein Element nach links ( 1⌽) der Zeichenfolge ')('verknüpft mit ( ,) dem rechten Argument ( ⍵)

Reduzierung der APL-Falten von rechts nach links, wie hier erforderlich

Konvex , 10 Bytes

_'(*\,(')*

Probieren Sie es online!

> <> , 37 Bytes

i:0(?\'('
$,2l~/~
/?(2:<-1$')'
>~ror:

Reihe für Reihe

1. Pusht jedes Zeichen von der Eingabe mit einer öffnenden Klammer nach jedem
2. Entfernt EOF und die letzte öffnende Klammer und verschiebt die Stapellänge
3. Verwendet einen Vergleich mit der halben Stapellänge, um die schließende Klammer zu drücken
4. Druckt den Inhalt des Stapels

Probieren Sie es online!