Чтобы «вложить» строку, вы должны:

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

Ideone это

Довольно понятно.

Он ставит круглые скобки между всеми остальными символами, а затем добавляет на единицу меньше скобок длины.

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 байт

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

Попробуйте онлайн!

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 байта

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

Читает байт за раз, ставит перед каждым, кроме первого, открытый символ «парен», в конце ставит одинаковое количество «парэнс».

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цикл, печатая все ), пока стек не опустеет и программа не выдаст ошибку.

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

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

Regex находит и заменяет пробелы между символами на "(". Затем 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 it, -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

Точность !! 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) в виде строки, за которой следует символ табуляции.

Точность !! ?

Это язык, который я создал, который кажется непригодным для использования . Единственным типом данных являются целые числа, единственной конструкцией потока управления является Count x while yцикл, а единственным способом хранения данных является один аккумулятор _. Ввод и вывод выполняются по одному символу за раз, используя специальное значение Nи Writeоператор. Несмотря на эти ограничения, я вполне уверен, что Acc !! завершена по Тьюрингу.

объяснение

Основная стратегия в Acc !! программирование заключается в использовании модового %и целочисленного деления /для концептуального разбиения аккумулятора, что позволяет ему хранить несколько значений одновременно. В этой программе мы используем три таких раздела: семь битов младшего порядка ( _%128) хранят код ASCII из ввода; следующий бит ( _/128%2) хранит значение флага; а оставшиеся биты ( _/256) подсчитывают количество близких паренов, которые нам понадобятся.

Вход в Acc !! происходит от специального значения N, которое считывает один символ и оценивает его код ASCII. Любой оператор, который состоит исключительно из выражения, присваивает результат этого выражения аккумулятору. Итак, начнем с хранения кода первого символа в аккумуляторе.

_%128будет хранить последний прочитанный символ Таким образом, первый цикл выполняется, пока он не _%128-9равен нулю, то есть до тех пор, пока текущий символ не станет вкладкой.

Внутри цикла мы хотим печатать, ( если не будем на первой итерации. С Акк !! не имеет оператора if, мы должны использовать циклы для условных выражений. Мы используем 128-разрядный бит аккумулятора _/128%2как значение флага. На первом проходе единственное, что в аккумуляторе - это значение ASCII <128, поэтому флаг равен 0 и цикл пропускается. На каждом последующем проходе мы будем следить за тем, чтобы флаг был равен 1.

Внутри Count xцикла (всякий раз, когда флаг равен 1), мы записываем открытый код (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раз, запись близкого парня (ASCII 41) каждый раз. Вуаля!

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

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 байт (30 +1 для -rаргумента)

Чистый Linux lin решение

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

1. Наименование подстановки :; затем вызывая это рекурсивно сt
2. Создание 2 групп регулярных выражений:
   • Первая группа - это первый символ из двух последовательных символов, которые не являются скобками
   • Вторая группа - второй последовательный символ и остальная часть строки до конца строки.
3. Добавьте скобки вокруг второй группы \1 ( \2 )

Редактировать : Спасибо @manatwork за помощь в удалении 4 символов!

Онлайн тестер

Медуза , 19 18 байт

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

Символ ␁является непечатаемым управляющим символом с байтовым значением 0x1. Попробуйте онлайн!

объяснение

Это довольно сложная программа Jellyfish, так как многие значения используются в разных местах.

• 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

Vim, 17 байт

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

Идет от конца к началу, потому что в противном случае вы запутаетесь в )уже написанном. Использует haвместо iпровала, когда достигает начала.

Обычно вы бы не делали две отдельные вставки, подобные этой; Вы бы сделали что-то вроде, C()<Esc>Pчтобы сохранить удар. Но на этот раз позиционирование не работает.

Выпуклый , 10 байт

_'(*\,(')*

Попробуйте онлайн!

> <> , 37 байт

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

Ряд за рядом

1. Отталкивает каждый символ от ввода с открывающей скобкой после каждого
2. Удаляет EOF и последнюю открывающую скобку и увеличивает длину стека
3. Использует сравнение с половиной длины стека, чтобы вставить закрывающую скобку
4. Печатает содержимое стека

Попробуйте онлайн!

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 (

Фактор, 81 байт

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