ในการ "function ซ้อน" สตริงคุณต้อง:

• ปฏิบัติต่ออักขระตัวแรกเป็นฟังก์ชันและอักขระต่อไปนี้เป็นอาร์กิวเมนต์ของฟังก์ชันนั้น ตัวอย่างเช่นถ้าสตริงอินพุตเป็นHelloดังนั้นขั้นตอนแรกจะเป็น:

  H(ello)
  

• จากนั้นทำซ้ำขั้นตอนเดียวกันนี้สำหรับทุกสตริงย่อย ดังนั้นเราจึงได้รับ:

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

งานของคุณคือการเขียนโปรแกรมหรือฟังก์ชั่นที่ "ฟังก์ชั่นรัง" สตริง ตัวอย่างเช่นถ้าสตริงอินพุตเป็นHello world!ดังนั้นคุณควรส่งออก:

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

อินพุตจะมีASCII ที่พิมพ์ได้เท่านั้นและคุณสามารถรับอินพุตและเอาต์พุตในรูปแบบที่เหมาะสม ตัวอย่างเช่น STDIN / STDOUT อาร์กิวเมนต์ของฟังก์ชันและค่าส่งคืนการอ่านและการเขียนไปยังไฟล์ ฯลฯ

เพื่อความเรียบง่ายคุณอาจสมมติว่าอินพุตจะไม่มีวงเล็บและจะไม่ว่างเปล่า

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)

ตามปกติแล้วกฎเริ่มต้นและช่องโหว่ทั้งหมดของเราจะมีผลบังคับใช้และคำตอบที่สั้นที่สุดจะชนะเป็นไบต์!

Python 41 39 34 ไบต์

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

ไอดีโอมัน

สวยด้วยตนเองอธิบาย

มันทำให้วงเล็บระหว่างตัวละครทุกตัวแล้วเพิ่มหนึ่งวงเล็บที่น้อยกว่าความยาวไปยังจุดสิ้นสุด

ไฟล์ MS-DOS .com ขนาด 30 ไบต์

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

สตริงถูกส่งผ่านไปยังไฟล์สั่งการโดยใช้บรรทัดคำสั่ง (อักขระเว้นวรรคหนึ่งตัวระหว่างชื่อไฟล์. COM กับสตริง)

ผลลัพธ์ถูกเขียนลงในเอาต์พุตมาตรฐาน

ถอดแยกชิ้นส่วนอยู่ที่นี่:

  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

หมายเหตุ: คุณสามารถออกจากไฟล์ DOS .COM (ไม่เหมือนกับไฟล์ที่มีส่วนหัว EXE) โดยใช้คำสั่ง "RET"

JavaScript (ES6), 40 34 33 ไบต์

บันทึกแล้ว 6 ไบต์ขอบคุณ ETHproductions

ฟังก์ชั่นวนซ้ำ

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

ลองออนไลน์!

Brainfuck, 42 40 ไบต์

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

ลองออนไลน์!

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 ไบต์

S'(ý¹g<')×J

ลองออนไลน์!

คำอธิบาย:

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

Brainfuck, 44 ไบต์

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

อ่านทีละครั้งวาง open-paren ไว้หน้าแต่ละอันยกเว้นอันแรกวาง parens ใกล้เคียงจำนวนเท่ากันในตอนท้าย

Haskell 30 ไบต์

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

ตัวอย่างการใช้งาน: ->f "Nest a string""N(e(s(t( (a( (s(t(r(i(n(g))))))))))))"

ใช้ถ่านต่อไปตามด้วย(ตามด้วยโทร recursive กับทุก )แต่ถ่านแรกตามมาด้วย

เยลลี่ , 9 8 ไบต์

-1 ไบต์ขอบคุณ @Dennis (ใช้รา, ṁแทนที่L, และทำซ้ำ, x)

j”(³”)ṁṖ

TryItOnline

อย่างไร?

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))))))))

Retina , 22 17 ไบต์

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

ลองออนไลน์!

อีกวิธีหนึ่งคือ:

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

คำอธิบาย

ฉันมักจะลืมว่ามันเป็นไปได้ที่จะพิมพ์สิ่งต่าง ๆ ไปพร้อมกันแทนที่จะเปลี่ยนทุกอย่างให้เป็นผลลัพธ์สุดท้ายและแสดงผลในครั้งเดียว ...

\1>`.
($&

ที่นี่\บอกให้ Retina พิมพ์ผลลัพธ์ของระยะนี้โดยไม่ต้องป้อนบรรทัดต่อท้าย 1>ขีด จำกัด ซึ่งหมายความว่าการแข่งขันครั้งแรกของ regex ควรจะละเว้น สำหรับสเตจนั้นมันจะแทนที่อักขระแต่ละตัว ( .) ยกเว้นอักขระแรก(ตามด้วยอักขระนั้น กล่าวอีกนัยหนึ่งมันแทรก(อยู่ระหว่างตัวละครแต่ละคู่ สำหรับอินพุตabcสิ่งนี้จะแปลงเป็น (และพิมพ์)

a(b(c

สิ่งที่เหลืออยู่คือการพิมพ์วงเล็บปิด:

T`(p`)_

สิ่งนี้ทำกับการทับศัพท์ซึ่งแทนที่(ด้วย)และลบอักขระ ASCII ที่พิมพ์ได้อื่นทั้งหมดออกจากสตริง

> <> , 19 18 ไบต์

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

ลองออนไลน์!

คำอธิบาย

บรรทัดแรกคืออินพุตวนซึ่งพิมพ์ทุกอย่างจนถึงอักขระตัวสุดท้ายของอินพุต (รวมถึงทั้งหมด() และปล่อยให้อยู่ในจำนวนที่เหมาะสม)บนสแต็ก:

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.

เมื่อเรากด EOF ตัวชี้คำสั่งจะจบลงที่บรรทัดที่สองและเราจะทำการoวนซ้ำพิมพ์ทั้งหมด)จนกว่าสแต็กจะว่างเปล่าและข้อผิดพลาดของโปรแกรมจะหมดไป

C #, 32 ไบต์

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

แลมบ์ดานี้ต้องเป็นวิธีคงที่ฉันจะต้องนับไบต์พิเศษใด ๆ สำหรับความต้องการนั้นหรือไม่? ปกติฉันจะไม่ใช้แลมบ์ดาในการเรียกซ้ำใน C # แต่ฉันคิดว่ามันจะสั้นกว่าที่จะไม่ใช้การเรียกซ้ำ

/*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 ไบต์

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

J ดำเนินการจากขวาไปซ้ายเพื่อใช้คำวิเศษณ์แทรกคำ/กริยาสามารถใช้เพื่อลดตัวอักษรของสตริงป้อนเข้า

การใช้

   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))))))))

คุณสามารถสังเกตเห็นผลลัพธ์บางส่วนระหว่างการลดแต่ละครั้ง

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

คำอธิบาย

(,'(',,&')')/  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 ไบต์

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

Regex ค้นหาและแทนที่ช่องว่างระหว่างอักขระด้วย "(" จากนั้นcatและrepเพิ่ม ")" n-1 ครั้งในตอนท้าย

PowerShell v2 +, 46 ไบต์

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

นำสายป้อน, char-array มัน-joins อาร์เรย์ร่วมกับ parens เปิด(แล้วเชื่อมกับจำนวนที่เหมาะสมของ )parens

Acc !! , 129 ไบต์

ไม่เลวสำหรับ tarpit ทัวริงที่ค่อนข้างละเอียด ...

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
}

(ใช่ช่องว่างทั้งหมดนั้นเป็นข้อบังคับ)

หมายเหตุ:เนื่องจากข้อ จำกัด การป้อนข้อมูลของAcc !! มันเป็นไปไม่ได้ที่จะอ่านสตริงของตัวละครโดยไม่ต้องมีตัวคั่นที่สิ้นสุด ดังนั้นโปรแกรมนี้คาดว่าอินพุต (บน stdin) เป็นสตริงตามด้วยอักขระแท็บ

Acc !! ?

เป็นภาษาที่ฉันสร้างขึ้นซึ่งดูเหมือนจะใช้ไม่ได้เท่านั้น เพียงชนิดข้อมูลเป็นจำนวนเต็มเท่านั้นสร้างการควบคุมการไหลเป็นห่วงและวิธีเดียวที่จะเก็บข้อมูลเป็นสะสมเดียวCount x while y _อินพุทและเอาท์พุททำได้ครั้งละหนึ่งตัวอักษรโดยใช้ค่าพิเศษNและWriteคำสั่ง แม้จะมีข้อ จำกัด เหล่านี้ฉันค่อนข้างแน่ใจว่าAcc !! ทัวริงเสร็จสมบูรณ์

คำอธิบาย

กลยุทธ์พื้นฐานในAcc !! การเขียนโปรแกรมคือการใช้ mod %และการหารจำนวนเต็มในการแบ่ง/พาร์ติชั่นของคอนเซปต์ช่วยให้สามารถเก็บค่าได้หลายค่าในครั้งเดียว ในโปรแกรมนี้เราใช้สามส่วนดังกล่าวลำดับที่เจ็ดบิตต่ำสุด ( _%128) เก็บรหัส ASCII จากอินพุต; บิตถัดไป ( _/128%2) เก็บค่าแฟล็ก และบิตที่เหลืออยู่ ( _/256) นับจำนวนโคลสอัพที่เราต้องการ

อินพุตในACC !! มาจากค่าพิเศษNซึ่งอ่านตัวเดียวและประเมินเป็นรหัส ASCII คำสั่งใด ๆ ที่ประกอบด้วยการแสดงออกเพียงอย่างเดียวจะกำหนดผลลัพธ์ของการแสดงออกนั้นให้กับผู้สะสม ดังนั้นเราเริ่มจากการเก็บรหัสตัวละครตัวแรกไว้ในตัวสะสม

_%128จะจัดเก็บอักขระที่อ่านล่าสุด ดังนั้นลูปแรกจะทำงานในขณะที่_%128-9ไม่ใช่ศูนย์ - นั่นคือจนกระทั่งอักขระปัจจุบันเป็นแท็บ

ภายในวงเราต้องการพิมพ์( เว้นแต่ว่าเราจะทำซ้ำครั้งแรก ตั้งแต่ACC !! ถ้าไม่มีคำสั่งเราต้องใช้ลูปสำหรับเงื่อนไข เราใช้ตัวสะสม 128 บิต_/128%2เป็นค่าสถานะ ในรอบแรกสิ่งเดียวในแอคคูมูเลเตอร์คือค่า ASCII <128 ดังนั้นการตั้งค่าสถานะจึงเป็น 0 และข้ามการวนซ้ำ ในทุก ๆ รอบที่ผ่านมาเราจะทำให้แน่ใจว่าการตั้งค่าสถานะเป็น 1

ภายในCount xลูป (เมื่อใดก็ตามที่ตั้งค่าสถานะเป็น 1) เราเขียน paren แบบเปิด (ASCII 40) และเพิ่ม 128 ลงในแอคคิวมูเลเตอร์เพื่อตั้งค่าสถานะเป็น 0 และออกจากลูป สิ่งนี้ยังเกิดขึ้นกับการเพิ่มค่าของ_/256ซึ่งเราจะใช้เป็นจำนวนของ parens ใกล้เคียงของเราที่จะส่งออก

_%128โดยไม่คำนึงถึงความคุ้มค่าของธงที่เราเขียนถ่านป้อนข้อมูลล่าสุดซึ่งเป็นเพียง

การมอบหมายครั้งต่อไป ( _+128-_%128+N) ทำสองสิ่ง ขั้นแรกโดยการเพิ่ม 128 จะตั้งค่าสถานะสำหรับครั้งต่อไปผ่านการวนซ้ำ ประการที่สองมันเป็นศูนย์ออกจาก_%128สล็อตอ่านตัวละครอื่นและเก็บไว้ที่นั่น จากนั้นเราวนซ้ำ

เมื่อCount iวงออกมาเราเพิ่งอ่านอักขระแท็บและค่าแอคคูเลเตอร์จะแยกออกเป็นดังนี้

• _%128: 9(อักขระแท็บ)
• _/128%2: 1(ธง)
• _/256: จำนวนตัวอักษรที่อ่านลบ 1

(ลบ 1 เป็นเพราะเราเพิ่ม 128 เพียงตัวสะสมหนึ่งครั้งในระหว่างการส่งผ่านครั้งแรกผ่านลูปหลัก) สิ่งที่เราต้องการในตอนนี้คือการปิดภาพ Count j while _/256-jลูป_/256หลายครั้งเขียนคำสั่งปิด (ASCII 41) ในแต่ละครั้ง Voila!

Java 781 79 ไบต์

1ไบต์ที่บันทึกไว้ขอขอบคุณเควิน

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

APL, 19 ไบต์

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

คำอธิบาย:

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

ทางเลือกอื่น ๆ เช่น 19 ไบต์:

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

คำอธิบาย:

{              
              ⍵,⊂⍬  ⍝ 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 ไบต์

t~40+v3L)7MQ3L)h

ลองออนไลน์!

คำอธิบาย

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 ไบต์

ขอบคุณ@Ton Hospelสำหรับการตีกอล์ฟขนาด 4 ไบต์

24 ไบต์ของรหัสเมือง -F+

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

ความต้องการ-Fและ-Eธง:

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

โปรดทราบว่าหากคุณลองใช้ Perl เวอร์ชันเก่าคุณอาจต้องเพิ่มการ-aตั้งค่าสถานะ

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

(หากต้องการใช้งานให้วางรหัสไว้ในไฟล์และเรียกใช้ด้วยecho -n "Hello" | perl nest.pl)

Ruby, 27 ไบต์

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

คำอธิบาย

->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 ไบต์

รวม +1 สำหรับ -p

ให้สตริงที่ STDIN โดยไม่ต้องขึ้นบรรทัดใหม่ (หรือเพิ่ม-lตัวเลือกให้กับโปรแกรม)

echo -n Hello | nest.pl

nest.pl:

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

GNU sed, 37 35 31 bytes ( -rอาร์กิวเมนต์30 +1 )

โซลูชัน linux sed ที่บริสุทธิ์

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

1. การตั้งชื่อ subsitution :; จากนั้นเรียกมันซ้ำด้วยt
2. สร้าง 2 กลุ่ม regex:
   • กลุ่มแรกเป็นอักขระตัวแรกของอักขระต่อเนื่องสองตัวที่ไม่ใช่วงเล็บ
   • กลุ่มที่สองคืออักขระตัวที่สองติดต่อกันและส่วนที่เหลือของสตริงจนกระทั่งสิ้นสุดบรรทัด
3. เพิ่มวงเล็บล้อมรอบกลุ่มที่สอง \1 ( \2 )

แก้ไข : ขอบคุณ @manatwork ที่ช่วยในการลบ 4 ตัวอักษร!

ผู้ทดสอบออนไลน์

แมงกะพรุนขนาด19 18 ไบต์

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

ตัวละครตัวนี้␁เป็นตัวละครที่ควบคุม unprintable 0x1มีมูลค่าไบต์ ลองออนไลน์!

คำอธิบาย

นี่เป็นโปรแกรมแมงกะพรุนที่ค่อนข้างซับซ้อนเนื่องจากมีการใช้หลายค่าในหลาย ๆ ที่

• I เป็นข้อมูลดิบอ่านจาก STDIN เป็นสตริง
• '((เป็นตัวละครที่แท้จริง
• {(ตัวตนซ้าย) ใช้เวลา'(และเป็นปัจจัยการผลิตและผลตอบแทนI '(ไม่ส่งคืนค่าที่ใช้จริง
• `เป็นด้าย มันปรับเปลี่ยน{เพื่อกลับตัวละคร(ตัวละครของแต่ละIผลในสตริงของ(S Iกับยาวเช่นเดียวกับ
• >เป็นหาง มันใช้สตริงของ(s เป็นอินพุตและตัดอักขระตัวแรกออก
• +รับอาร์กิวเมนต์เป็นสตริงของ(s และไบต์ที่ไม่สามารถพิมพ์ได้และเพิ่มค่าไบต์ (1) ให้กับอักขระแต่ละตัว นี้จะช่วยให้สตริงเท่ากับความยาวของ)s การใช้อักขระ␁รับประกันว่าค่าส่งคืนเป็นสตริงและไม่ใช่รายการจำนวนเต็ม
• ที่มุมซ้ายล่าง/ใช้ไบต์ที่ไม่สามารถพิมพ์ได้และส่งคืนฟังก์ชันที่รับสองอาร์กิวเมนต์และรวมอาร์กิวเมนต์ที่สองกับหนึ่งในครั้งแรก (ตั้งแต่ค่าไบต์คือ 1)
• _รับฟังก์ชั่นนี้คว้าข้อโต้แย้งของคนล่าง{(ซึ่งเป็น'(และI) และเรียกใช้ funtion กับพวกเขา แทรกตัวอักษรระหว่างคู่ของตัวละครในทุก(I
• ,เชื่อมสตริงนี้กับ string ของ)s และPพิมพ์ผลลัพธ์

05AB1E , 22 21 19 18 ไบต์

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

ลองออนไลน์!

คำอธิบาย:

¤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 ไบต์

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

รุ่นก่อนหน้า 64 ไบต์

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

เป็นกลุ่ม, 17 ไบต์

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

ไปตั้งแต่ต้นจนจบเพราะไม่เช่นนั้นคุณจะเดินทางข้ามสิ่ง)ที่คุณเขียนไปแล้ว ใช้haแทนที่จะiล้มเหลวเมื่อถึงจุดเริ่มต้น

โดยปกติแล้วคุณจะไม่ทำเม็ดมีดสองแบบแยกกันเช่นนี้ คุณต้องการทำบางสิ่งC()<Esc>Pเพื่อประหยัด แต่ตำแหน่งนี้ใช้งานไม่ได้ในครั้งนี้

Brain-Flak 103 97 Bytes

รวม +3 สำหรับ -c

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

ลองออนไลน์!

คำอธิบาย:

#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 ไบต์

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

นี่คือส่วนบนของ⊃และ{ }/

⊃(รับองค์ประกอบแรก) จะถูกนำไปใช้หลังจาก{ }/(ลดแลมบ์ดา)

⍺,1⌽')(',⍵- อาร์กิวเมนต์ด้านซ้าย ( ⍺) ต่อกันกับ ( ,) การหมุนโดยองค์ประกอบหนึ่งไปทางซ้าย ( 1⌽) ของสตริงที่')('ต่อกับ ( ,) อาร์กิวเมนต์ที่ถูกต้อง ( ⍵)

การลดลงของ APL จะลดลงจากขวาไปซ้ายตามต้องการที่นี่

นูน 10 ไบต์

_'(*\,(')*

ลองออนไลน์!

> <> , 37 ไบต์

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

ทีละแถว

1. ผลักอักขระแต่ละตัวจากอินพุตโดยใช้วงเล็บเปิดหลังจากแต่ละอักขระ
2. ลบ EOF และวงเล็บเปิดล่าสุดและผลักความยาวสแต็ก
3. ใช้การเปรียบเทียบกับครึ่งความยาวสแต็กเพื่อดันวงเล็บปิด
4. พิมพ์เนื้อหาของสแต็ก

ลองออนไลน์!