Щоб "функціонувати гніздо" рядка, необхідно:

• Трактуйте перший символ як функцію, а наступні символи - як аргументи цієї функції. Наприклад, якщо рядок введення був 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)

Як завжди, застосовуються всі наші правила та лазівки за замовчуванням, і найкоротша відповідь, набрана у байтах, виграє!

Пітон, 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

Примітка. Ви можете вийти з файлу .COM DOS (на відміну від файлів із заголовками EXE), використовуючи інструкцію "RET".

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

Скористайтеся наступним знаком, за яким слідує a (, після чого - рекурсивний дзвінок із усіма, крім першого знака, за яким слід a ).

Желе , 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))))))))

Сітківка , 22 17 байт

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

Спробуйте в Інтернеті!

Як варіант:

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

Пояснення

Я завжди забуваю, що можна друкувати речі попутно, а не перетворювати все на кінцевий результат і виводити його за один раз ...

\1>`.
($&

Тут \наказує Retina друкувати результат цього етапу без зворотного підведення. Це 1>межа, що означає, що першу відповідність регулярного вираження слід ігнорувати. Що стосується самого етапу, то він просто замінює кожен символ ( .), крім першого, (після якого йде цей символ. Іншими словами, він вставляється (між кожною парою символів. Для введення 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-raray це, -joinмасив разом з відкритими паролями (, а потім об'єднується у відповідну кількість закритих паролів ).

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заяву. Незважаючи на ці обмеження, я цілком впевнений, що Acc !! є Тьюрінгом.

Пояснення

Основна стратегія в Acc !! Програмування полягає у використанні мод %і цілого поділу /для концептуального розподілу акумулятора, що дозволяє йому зберігати відразу декілька значень. У цій програмі ми використовуємо три такі розділи: сім біт нижчого порядку ( _%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, яке ми будемо використовувати як наш підрахунок близько закритих парен для виведення.

Незалежно від значення прапора, ми пишемо останню графіку введення, що просто _%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 7,81 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)

Рубін, 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 байт (30 +1 за -rаргумент)

Чистий розчин 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).
• _приймає цю функцію, захоплює аргументи нижчих {(які були '(і 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

Йде від кінця до початку, тому що в іншому випадку ви подорожуєте над )уже написаними. Використовує haзамістьi щоб вийти з ладу, коли досягне початку.

Зазвичай ви б не робили двох окремих вставок, як це; ви зробите щось на кшталт, C()<Esc>Pщоб врятувати інсульт. Але на цей раз позиціонування не працює.

Мозок-Флак 103 97 байт

Включає +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 (

Діалог APL , 14 байт

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

це на вершині з ⊃і{ }/

⊃(отримати перший елемент) буде застосовано після { }/(зменшення лямбда)

⍺,1⌽')(',⍵- лівий аргумент ( ⍺), об'єднаний з (, ) обертанням одного елемента вліво ( 1⌽) рядка, ')('з'єднаного з ( ,) правим аргументом ( ⍵)

зменшення складок APL справа наліво, як вимагається тут

Опукла , 10 байт

_'(*\,(')*

Спробуйте в Інтернеті!

> <> , 37 байт

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

Рядок за рядом

1. Висуває кожну таблицю із вхідних даних із відкриваючими дужками після кожного
2. Видаляє EOF та останні дужки, що відкриваються, і висуває довжину стека
3. Використовує порівняння з половиною довжини стека для виштовхування дужок, що закриваються
4. Друкує вміст стеку

Спробуйте в Інтернеті!