Untuk "memfungsikan sarang" suatu string, Anda harus:

• Perlakukan karakter pertama sebagai fungsi, dan karakter berikut sebagai argumen untuk fungsi itu. Misalnya, jika string input adalah Hello, maka langkah pertama adalah:

  H(ello)
  

• Kemudian, ulangi langkah yang sama ini untuk setiap substring. Jadi kita dapatkan:

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

Tugas Anda adalah menulis sebuah program atau fungsi yang "berfungsi membuat" string. Misalnya, jika string input adalah Hello world!, maka Anda harus menampilkan:

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

Input hanya akan berisi ASCII yang dapat dicetak , dan Anda dapat mengambil input dan output dalam format yang masuk akal. Misalnya, STDIN / STDOUT, argumen fungsi dan nilai kembali, membaca dan menulis ke file, dll.

Demi kesederhanaan, Anda juga dapat berasumsi bahwa input tidak akan mengandung tanda kurung, dan tidak akan kosong.

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)

Seperti biasa, semua aturan dan celah default kami berlaku, dan jawaban terpendek yang dicetak dalam byte menang!

Python, 41 39 34 byte

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

Ide itu

Cukup jelas.

Ini menempatkan tanda kurung antara setiap karakter lain kemudian menambahkan satu kurang dari tanda kurung panjang sampai akhir.

File MS-DOS .com, 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

String dilewatkan ke executable menggunakan baris perintah. (Satu karakter spasi antara nama file .COM dan string).

Hasilnya ditulis ke output standar.

Pembongkaran ada di sini:

  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

Catatan: Anda dapat keluar dari file DOS .COM (tidak seperti file dengan header EXE) menggunakan instruksi "RET".

JavaScript (ES6), 40 34 33 byte

Disimpan 6 byte, berkat produk ETH

Fungsi rekursif.

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

Cobalah online!

Brainfuck, 42 40 byte

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

Cobalah online!

Tidak Terkumpul:

>+[-->+[<]>-]>+     # 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 byte

S'(ý¹g<')×J

Cobalah online!

Penjelasan:

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

Brainfuck, 44 byte

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

Membaca byte pada satu waktu, menempatkan paren terbuka sebelum masing-masing kecuali yang pertama, menempatkan jumlah parens yang sama di akhir.

Haskell, 30 byte

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

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

Ambil char berikutnya, diikuti oleh (, diikuti oleh panggilan rekursif dengan semua kecuali char pertama, diikuti oleh a ).

Jelly , 9 8 byte

-1 byte terima kasih kepada @Dennis (gunakan cetakan ṁ,, sebagai pengganti panjang L,, dan ulangi, x)

j”(³”)ṁṖ

TryItOnline

Bagaimana?

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 byte

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

Cobalah online!

Kalau tidak:

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

Penjelasan

Saya selalu lupa bahwa mungkin saja mencetak hal-hal di sepanjang jalan alih-alih mengubah segalanya menjadi hasil akhir dan menghasilkannya dalam sekali jalan ...

\1>`.
($&

Di sini \memberi tahu Retina untuk mencetak hasil tahap ini tanpa linefeed tambahan. Ini 1>adalah batas yang berarti bahwa pertandingan pertama regex harus diabaikan. Adapun panggung itu sendiri, itu hanya menggantikan masing-masing karakter ( .) kecuali yang pertama (diikuti oleh karakter itu. Dengan kata lain, itu menyisipkan (di antara setiap pasangan karakter. Untuk input abc, ini mengubahnya menjadi (dan mencetak)

a(b(c

Yang tersisa adalah mencetak tanda kurung penutup:

T`(p`)_

Hal ini dilakukan dengan transliterasi yang menggantikan (dengan )dan menghapus semua karakter ASCII printable lainnya dari string.

> <> , 19 18 byte

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

Cobalah online!

Penjelasan

Baris pertama adalah loop input yang mencetak semuanya hingga karakter terakhir dari input (termasuk semua () dan meninggalkan jumlah yang tepat )pada stack:

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.

Setelah kita menekan EOF, penunjuk instruksi berakhir di baris kedua dan kita hanya akan mengeksekusi odalam satu lingkaran, mencetak semua ), sampai tumpukan kosong dan program keluar.

J, 13 byte

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

J dieksekusi dari kanan ke kiri sehingga menggunakan adverbia insert /, kata kerja dapat digunakan untuk mengurangi huruf-huruf dari string input.

Pemakaian

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

Anda dapat mengamati output parsial antara setiap pengurangan.

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

Penjelasan

(,'(',,&')')/  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 byte

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

Lambda ini harus menjadi metode statis, apakah saya perlu menghitung byte tambahan untuk persyaratan itu? Biasanya saya tidak akan menggunakan lambda untuk rekursi dalam C #, tapi kemudian saya pikir akan lebih pendek untuk tidak menggunakan rekursi.

/*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 byte

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

Regex menemukan dan mengganti spasi antara karakter dengan "(". Kemudian catdan repmenambahkan ")" n-1 kali di akhir.

Java 7,81 79 byte

Disimpan 1byte. Terima kasih kevin.

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

PowerShell v2 +, 46 byte

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

Mengambil string input, char-array itu saja, -joins array bersama-sama dengan parens terbuka (, kemudian menggabungkan pada jumlah yang sesuai dari paren tertutup ).

APL, 19 byte

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

Penjelasan:

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

Solusi alternatif, juga 19 byte:

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

Penjelasan:

{              
              ⍵,⊂⍬  ⍝ 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 byte

t~40+v3L)7MQ3L)h

Cobalah online!

Penjelasan

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 byte

Tidak buruk untuk Turing turing ...

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
}

(Ya, semua spasi putih itu wajib.)

Catatan: karena keterbatasan input Acc !! , tidak mungkin untuk membaca serangkaian karakter acak tanpa pembatas akhir. Oleh karena itu, program ini mengharapkan input (pada stdin) sebagai string yang diikuti oleh karakter tab.

Acc !! ?

Ini adalah bahasa yang saya buat yang sepertinya tidak bisa digunakan . Satu-satunya tipe data adalah bilangan bulat, satu-satunya konstruksi aliran kontrol adalah Count x while yloop, dan satu-satunya cara untuk menyimpan data adalah akumulator tunggal _. Input dan output dilakukan satu karakter pada satu waktu, menggunakan nilai khusus Ndan Writepernyataan. Terlepas dari keterbatasan ini, saya cukup yakin bahwa Acc !! adalah Turing-complete.

Penjelasan

Strategi dasar dalam Acc !! pemrograman adalah dengan menggunakan mod %dan integer division /untuk secara konseptual mempartisi akumulator, memungkinkannya untuk menyimpan beberapa nilai sekaligus. Dalam program ini, kami menggunakan tiga bagian seperti itu: tujuh bit urutan terendah ( _%128) menyimpan kode ASCII dari input; bit berikutnya ( _/128%2) menyimpan nilai flag; dan bit yang tersisa ( _/256) menghitung jumlah parens dekat yang akan kita butuhkan.

Masukkan Acc !! berasal dari nilai khusus N, yang membaca satu karakter dan mengevaluasi kode ASCII-nya. Pernyataan apa pun yang hanya terdiri dari ekspresi memberikan hasil ekspresi itu ke akumulator. Jadi kita mulai dengan menyimpan kode karakter pertama di akumulator.

_%128akan menyimpan karakter yang terakhir dibaca. Jadi loop pertama berjalan sementara _%128-9adalah bukan nol - yaitu, sampai karakter saat ini adalah tab.

Di dalam loop, kami ingin mencetak ( kecuali kami berada di iterasi pertama. Sejak Acc !! tidak memiliki pernyataan if, kita harus menggunakan loop untuk conditional. Kami menggunakan bit 128 dari akumulator _/128%2,, sebagai nilai bendera. Pada pass pertama, satu-satunya hal dalam akumulator adalah nilai ASCII <128, jadi flagnya adalah 0 dan loop dilewati. Pada setiap operan berikutnya, kami akan memastikan bahwa benderanya 1.

Di dalam Count xloop (setiap kali flag adalah 1), kami menulis paren terbuka (ASCII 40) dan menambahkan 128 ke akumulator, dengan demikian mengatur flag ke 0 dan keluar dari loop. Ini juga terjadi untuk meningkatkan nilai _/256, yang akan kita gunakan sebagai penghitungan dari orang tua kita untuk menjadi output.

Terlepas dari nilai flag, kami menulis char input terbaru, yang sederhana _%128.

Tugas berikutnya ( _+128-_%128+N) melakukan dua hal. Pertama, dengan menambahkan 128, itu menetapkan bendera untuk waktu berikutnya melalui loop. Kedua, itu nol _%128slot, membaca karakter lain, dan menyimpannya di sana. Lalu kita mengulang.

Ketika Count iloop keluar, kami baru saja membaca karakter tab, dan nilai akumulator terurai seperti ini:

• _%128: 9(karakter tab)
• _/128%2: 1(bendera)
• _/256: jumlah karakter yang dibaca, minus 1

(Yang minus 1 adalah karena kita hanya menambahkan 128 ke akumulator sekali selama melewati pertama melalui loop utama.) Yang kita butuhkan sekarang adalah parens-dekat. Count j while _/256-jloop _/256kali, menulis close-paren (ASCII 41) setiap kali. Voila!

Perl, 25 byte

Terima kasih kepada @Ton Hospel untuk bermain golf 4 byte.

24 byte kode + -F.

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

Kebutuhan -Fdan -Ebendera:

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

Perhatikan bahwa jika Anda mencoba ini pada versi perl yang lama, Anda mungkin perlu menambahkan -aflag.

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

(Untuk menggunakannya, masukkan kode di dalam file dan panggil dengan echo -n "Hello" | perl nest.pl)

Ruby, 27 byte

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

Penjelasan

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

Termasuk +1 untuk -p

Berikan string pada STDIN tanpa baris baru (atau tambahkan -lopsi ke program)

echo -n Hello | nest.pl

nest.pl:

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

PHP, 63 Bytes

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

Versi sebelumnya 64 Bytes

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

GNU sed, 37 35 31 bytes (30 +1 untuk -rargumen)

Solusi sed linux murni

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

1. Memberi nama subsidi :; kemudian menyebutnya secara rekursif dengant
2. Membuat 2 grup regex:
   • Grup pertama adalah karakter pertama dari dua karakter berurutan yang bukan tanda kurung
   • Grup kedua adalah karakter kedua berturut-turut dan sisa string hingga akhir baris
3. Tambahkan tanda kurung di sekitar grup kedua \1 ( \2 )

Sunting : Terima kasih kepada @manatwork karena membantu menghapus 4 karakter!

Penguji online

Ubur-ubur , 19 18 byte

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

Karakter ␁adalah karakter kontrol yang tidak dapat dicetak dengan nilai byte 0x1. Cobalah online!

Penjelasan

Ini adalah program Ubur-ubur yang cukup rumit, karena banyak nilai digunakan di banyak tempat.

• I adalah input mentah, baca dari STDIN sebagai string.
• '(adalah karakter literal (.
• The {(kiri identitas) mengambil '(dan Isebagai masukan, dan kembali '(. Nilai pengembalian tidak pernah benar-benar digunakan.
• `adalah utas. Ini memodifikasi {untuk mengembalikan karakter (untuk setiap karakter I, menghasilkan string (s dengan panjang yang sama dengan I.
• >adalah ekor; dibutuhkan string (s sebagai input dan memotong karakter pertama.
• +mengambil argumen argumen (s dan byte yang tidak dapat dicetak, dan menambahkan nilai byte (1) ke setiap karakter. Ini memberikan string sama panjang )s. Menggunakan karakter ␁menjamin bahwa nilai kembali adalah string, dan bukan daftar bilangan bulat.
• Di sudut kiri bawah, /ambil byte yang tidak dapat dicetak, dan mengembalikan fungsi yang membutuhkan dua argumen, dan bergabung dengan argumen kedua dengan argumen pertama sekali (karena nilai byte adalah 1).
• _mengambil fungsi ini, meraih argumen yang lebih rendah {(yang dulu '(dan I), dan memanggil funtion dengan mereka. Ini menyisipkan karakter (antara setiap pasangan karakter di I.
• ,menyatukan string ini dengan string )s, dan Pmencetak hasilnya.

05AB1E , 22 21 19 18 byte

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

Cobalah online!

Penjelasan:

¤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 byte

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

Beranjak dari ujung ke awal, karena kalau tidak Anda tersandung )huruf yang sudah Anda tulis. Penggunaan habukannya igagal ketika mencapai awal.

Biasanya, Anda tidak akan melakukan dua sisipan terpisah seperti ini; Anda akan melakukan sesuatu seperti C()<Esc>Pmenyimpan stroke. Tetapi positioning tidak berfungsi dengan baik saat ini.

Cembung , 10 byte

_'(*\,(')*

Cobalah online!

> <> , 37 byte

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

Baris demi baris

1. Mendorong setiap char dari input dengan tanda kurung buka setelah masing-masing
2. Menghapus EOF dan tanda kurung pembuka terakhir dan mendorong panjang tumpukan
3. Menggunakan perbandingan dengan setengah panjang tumpukan untuk mendorong kurung tutup
4. Mencetak isi tumpukan

Cobalah online!

Brain-Flak 103 97 Bytes

Termasuk +3 untuk -c

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

Cobalah secara Online!

Penjelasan:

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

Faktor, 81 byte

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