要“函数嵌套”字符串，您必须：

• 将第一个字符视为函数，然后将后续字符视为该函数的参数。例如，如果输入字符串是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

注意：您可以使用“ RET”指令退出DOS .COM文件（与带有EXE头文件的文件不同）。

JavaScript（ES6），40 34 33字节

节省了6个字节，这要归功于ETHproductions

递归函数。

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

在线尝试！

Brainfuck，42 40字节

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

在线尝试！

取消高尔夫：

>+[-->+[<]>-]>+     # 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个字节

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

一次读取一个字节，在除第一个字节之外的每个字节之前放置一个开放括号，在末尾放置相同数量的封闭括号。

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

取下一个字符，后跟一个(，然后进行除第一个字符外的所有递归调用，再跟一个)。

果冻，9 8 字节

-1个字节，感谢@Dennis（使用模具，ṁ代替长度L，然后重复x）

j”(³”)ṁṖ

在线试用

怎么样？

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

视网膜，22 17字节

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

在线尝试！

或者：

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

说明

我总是忘记，有可能沿途打印内容，而不是将所有内容转换为最终结果并一次性输出。

\1>`.
($&

此处\告诉Retina打印此阶段的结果而没有尾随换行符。这1>是一个限制，这意味着应忽略正则表达式的第一个匹配项。至于舞台本身，它仅替换了每个字符（.），但第一个字符替换(为该字符。换句话说，它插入(在每对字符之间。对于input 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)})":"");

此lambda必须是静态方法，为此我需要计算任何额外的字节吗？通常我不会在C＃中使用lambda进行递归，但是我认为不使用递归会更短。

/*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从右到左执行，因此可以使用insert副词/，动词来减少输入字符串的字母。

用法

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

正则表达式查找和字符之间的空间代替用“（”，然后cat与rep添加“）”在端N-1次。

PowerShell v2 +，46个字节

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

接受输入字符串char-array，将其-join与打开的parens一起作为数组(，然后串联适当数量的closed parens )。

加速！，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上）作为字符串，后跟一个制表符。

加速！？

这是我创建的一种语言，似乎只是无法使用。唯一的数据类型是整数，唯一的控制流构造是Count x while y循环，并且唯一的数据存储方式是单个累加器_。输入和输出使用特殊值N和Write语句一次完成一个字符。尽管有这些限制，但我很确定Acc！是图灵完成的。

说明

Acc的基本策略！！编程是使用mod %和integer除法/在概念上对累加器进行分区，从而允许它一次存储多个值。在该程序中，我们使用三个这样的部分：最低位的7位（_%128）存储来自输入的ASCII码；下一位（_/128%2）存储标志值；其余的位（_/256）计算我们需要的关闭位数。

输入Acc ！！来自特殊值N，该特殊值读取单个字符并求值为其ASCII码。任何仅由表达式组成的语句都会将该表达式的结果分配给累加器。因此，我们首先将第一个字符的代码存储在累加器中。

_%128将存储最近读取的字符。因此，第一个循环的运行时间_%128-9为非零-即直到当前字符为制表符为止。

在循环内部，( 除非要进行第一次迭代，否则我们要打印。由于acc！没有if语句，我们必须对条件使用循环。我们将累加器的128位_/128%2用作标志值。在第一遍中，累加器中唯一的内容是ASCII值<128，因此标志为0，并且跳过了循环。在随后的每遍操作中，我们将确保标志为1。

在Count x循环内部（每当标志为1时），我们编写一个开放的paren（ASCII 40），然后将128加到累加器，从而将标志设置为0并退出循环。这也恰好使的值增加_/256，我们将其用作要输出的近距离计数的记数。

无论该标志的值如何，我们都会编写最新的输入char，即简单的_%128。

下一个作业（_+128-_%128+N）做两件事。首先，通过添加128，它将在下一次循环中设置标志。其次，它将_%128插槽清零，读取另一个字符，然后将其存储在该位置。然后我们循环。

当Count i循环退出时，我们刚刚读取了一个制表符，并且累加器值如下分解：

• _%128：（9制表符）
• _/128%2：（1标志）
• _/256：读取的字符数，减1

（负1是因为在第一次通过主循环时，我们仅将128加到累加器一次。）现在，我们所需要的只是封闭值。Count j while _/256-j循环_/256时间，41每次都写一个封闭括号（ASCII ）。瞧！

Java 781 79个字节

已保存的1字节。感谢kevin。

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字节（-r参数为30 +1 ）

纯Linux sed解决方案

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

1. 命名替换:; 然后用递归调用t
2. 制作2个正则表达式组：
   • 第一组是两个不带括号的连续字符的第一个字符
   • 第二组是第二个连续字符，字符串的其余部分直到行尾
3. 在第二组周围添加括号 \1 ( \2 )

编辑：感谢@manatwork帮助删除4个字符！

在线测试仪

水母，19 18字节

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

该字符␁是具有字节值的不可打印的控制字符0x1。在线尝试！

说明

这是一个非常复杂的水母程序，因为在多个地方都使用了许多值。

• I 是原始输入，从STDIN作为字符串读取。
• '(是字符字面量(。
• 的{（左身份）开'(和I作为输入，并返回'(。返回值从不实际使用。
• `是线程。修改后{会(针对的每个字符返回一个字符I，从而产生一个(s 字符串，其长度与相同I。
• >是尾巴 它以(s 字符串作为输入，并切掉第一个字符。
• +将(s 的字符串和不可打印的字节作为参数，并将字节值（1）添加到每个字符。这给出了)s 的等长字符串。使用字符␁保证返回值是一个字符串，而不是整数列表。
• 在左下角，/需要不可打印字节，并返回一个函数有两个参数，并加入与第一个，第二个参数一次（由于字节值是1）。
• _使用此函数，获取下位参数{（was '(和I），并使用它们调用函数。这会(在中的每对字符之间插入一个字符I。
• ,将这个字符串与)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,")");

Vim，17个字节

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

从头到尾进行操作，因为否则会绊倒)已经编写的s。在到达起点时使用ha而不是i失败。

通常，您不会像这样进行两个单独的插入；您可能会想C()<Esc>P保存笔画。但是这次定位不太好。

Brain-Flak 103 97字节

包括+3 for -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⌽')(',⍵}/

这是一个顶上的⊃和{ }/

⊃（获取第一个元素）将在{ }/（减少lambda）之后应用

⍺,1⌽')(',⍵-左自变量（⍺）与（）串联，,旋转一个元素到与（）右1⌽字符串')('（,）串联的字符串的左侧（⍵）

按此处要求从右到左减少APL折叠

凸，10字节

_'(*\,(')*

在线尝试！

> <>，37个字节

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

一行一行

1. 在每个输入之后用开括号将来自输入的每个字符推入
2. 删除EOF和最后一个括号，并推入堆栈长度
3. 使用一半堆栈长度的比较来推动右括号
4. 打印堆栈中的内容

在线尝试！