文字列を「関数の入れ子」にするには、以下を行う必要があります。

• 最初の文字を関数として扱い、後続の文字をその関数の引数として扱います。たとえば、入力文字列がの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)

イデオネそれ

かなり自明です。

1文字おきに括弧を挿入し、長さ括弧よりも1つ短い文字を最後に追加します。

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ファイル名と文字列の間の1つのスペース文字）。

結果は標準出力に書き込まれます。

分解はこちらです：

  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バイト

ETHproductionsのおかげで6バイトを節約

再帰関数。

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バイト

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

一度に1バイトを読み取り、最初のパレンを除く各パレンの前にオープンパレンを置き、最後に同じ数のクローズパレンを置きます。

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

次の文字を取得し、その後にa (が続き、最初の文字を除くすべての再帰呼び出しが続き、その後にaが続き)ます。

ゼリー、9 8 バイト

@Dennisのおかげで-1バイト（ṁ長さの代わりにmould、、Lおよびrepeatを使用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))))))))

網膜、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に到達すると、命令ポインターは2行目になり、スタックが空になりプログラムがエラーになるまで、oすべてを出力してループで実行します)。

J、13バイト

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

Jは右から左に実行するため、insert adverbを使用する/と、動詞を使用して入力文字列の文字を減らすことができます。

使用法

   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

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

R、61バイト

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

正規表現は、「（」。そして見つけ、と文字の間にスペースを置換catし、rep終了時にN-1回の加算します「）」。

Java 7、81 79バイト

1バイトを保存しました。ケビンに感謝します。

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

PowerShell v2 +、46バイト

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

入力文字列をchar取得し、-array's 、配列-joinを開いた括弧(と一緒に、次に適切な数の閉じた括弧で連結し)ます。

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

Acc !! 、129バイト

かなり冗長なチューリングターピットは悪くない...

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ステートメントを使用して、一度に1文字ずつ行われます。これらの制限にもかかわらず、Acc !! チューリング完全です。

説明

Accの基本戦略!! プログラミングでは、mod %と整数除算を使用/して概念的にアキュムレータを分割し、複数の値を一度に格納できるようにします。このプログラムでは、このようなセクションを3つ使用します。最下位7ビット（_%128）は、入力からのASCIIコードを保存します。次のビット（_/128%2）にはフラグ値が格納されます。そして、残りのビット（_/256）は、必要な親括弧の数をカウントします。

Accで入力!! はN、単一の文字を読み取り、そのASCIIコードに評価する特別な値から取得されます。式のみで構成されるステートメントは、その式の結果をアキュムレーターに割り当てます。そのため、最初の文字のコードをアキュムレーターに保存することから始めます。

_%128最後に読み込まれた文字を保存します。したがって、最初のループ_%128-9はゼロ以外の時間、つまり現在の文字がタブになるまで実行されます。

ループ内では、最初の反復で( ない限り印刷します。Acc以来!! if文がないため、条件にループを使用する必要があります。アキュムレータの128ビットを_/128%2フラグ値として使用します。最初のパスでは、アキュムレータ内の唯一のものはASCII値<128であるため、フラグは0であり、ループはスキップされます。後続のすべてのパスで、フラグが1であることを確認します。

内部Count xループ（フラグがあるときはいつでも1）、我々は、オープン括弧（ASCIIを書き込み40、それによって0にフラグを設定し、ループを出る）とアキュムレータ128を追加します。また_/256、これはの値をインクリメントするために発生します。これは、出力されるクローズパレンの集計として使用します。

フラグの値に関係なく、単にである最新の入力文字を記述し_%128ます。

次の割り当て（_+128-_%128+N）は2つのことを行います。最初に、128を追加することにより、ループの次回のフラグを設定します。次に、_%128スロットをゼロにし、別の文字を読み取り、そこに保存します。その後、ループします。

ときにCount iループが終了すると、私たちはタブ文字を読んでいると、アキュムレータ値は次のようにブレークダウン：

• _%128：（9タブ文字）
• _/128%2：（1フラグ）
• _/256：読み取られた文字数-1

（マイナス1は、メインループの最初のパス中にアキュムレータに128を追加するだけなので、）今すぐ必要なのは、かっこだけです。Count j while _/256-jループを_/256繰り返し、41毎回閉じ括弧（ASCII ）を書き込みます。出来上がり！

Perl、25バイト

4バイトのゴルフをしてくれた@Ton Hospelに感謝します。

コード+の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）

ルビー、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

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,")");

GNU sed、37 35 31バイト（-r引数で30 +1 ）

純粋なLinux sedソリューション

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

1. 置換の命名 : ; それから再帰的に呼び出すt
2. 2つの正規表現グループの作成：
   • 最初のグループは、括弧ではない 2つの連続した文字の最初の文字です
   • 2番目のグループは、2番目に連続する文字と、行末までの残りの文字列です。
3. 2番目のグループの周りに括弧を追加します \1 ( \2 )

編集：4文字の削除を支援してくれた@manatworkに感謝します！

オンラインテスター

クラゲ、19 18バイト

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

文字␁は、バイト値を持つ印刷できない制御文字です0x1。オンラインでお試しください！

説明

多くの値が複数の場所で使用されているため、これは非常に複雑なJellyfishプログラムです。

• I STDINから文字列として読み取られる生の入力です。
• '(は文字リテラル(です。
• {（左アイデンティティ）かかり'(とI入力し、リターンなど'(。戻り値が実際に使用されることはありません。
• `スレッドです。の各{文字(に対して文字を返すように変更し、と同じ長さのsのI文字列を生成します。(I
• >尾です; (s の文字列を入力として受け取り、最初の文字を切り取ります。
• +引数として(s の文字列と印刷できないバイトを取り、バイト値（1）を各文字に追加します。これにより、等しい長さの)sの文字列が得られます。文字を使用␁すると、戻り値が整数のリストではなく文字列であることを保証します。
• 左下隅で/、印刷できないバイトを取り、2つの引数を取り、2番目の引数を最初の引数と1回結合する関数を返します（バイト値が1であるため）。
• _この関数を取り、下位の引数{（'(および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

Vim、17バイト

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

それ以外)の場合は、すでに書いたsにつまずくので、最後から最初に行きます。のha代わりに使用i最初に到達したときに失敗するます。

通常、このような2つの個別の挿入は行いません。C()<Esc>Pストロークを保存するようなことをするでしょう。ただし、今回はポジショニングもうまくいきません。

凸、10バイト

_'(*\,(')*

オンラインでお試しください！

> <>、37バイト

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

行ごと

1. 入力から各文字をプッシュし、それぞれの後に開き括弧を付けます
2. EOFと最後の開き括弧を削除し、スタックの長さをプッシュします
3. スタック長の半分との比較を使用して、閉じ括弧をプッシュします
4. スタックの内容を印刷します

オンラインでお試しください！

Brain-Flak 103 97バイト

-cに+3を含む

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

オンラインでお試しください！

説明：

#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 (

ファクター、81バイト

[ [ >array [ 1string ] map "("join ] [ length 1 - [ 40 ] replicate >string ] bi ]