Para "aninhar a função" uma sequência, você deve:

• Trate o primeiro caractere como uma função e os seguintes caracteres como argumentos para essa função. Por exemplo, se a sequência de entrada fosse Hello, o primeiro passo seria:

  H(ello)
  

• Em seguida, repita esta mesma etapa para cada substring. Então temos:

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

Sua tarefa é escrever um programa ou função que "a função aninhe" uma string. Por exemplo, se a sequência de entrada foi Hello world!, você deve gerar:

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

A entrada sempre conterá apenas ASCII imprimível e você poderá levar a entrada e a saída em qualquer formato razoável. Por exemplo, STDIN / STDOUT, argumentos de função e valor de retorno, leitura e gravação em um arquivo, etc.

Por uma questão de simplicidade, você também pode assumir que a entrada não conterá parênteses e não estará vazia.

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)

Como sempre, todas as nossas regras e brechas padrão se aplicam e a resposta mais curta registrada em bytes vence!

Python, 41 39 34 bytes

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

Ideone it

Bastante auto-explicativo.

Ele coloca um parêntese entre todos os outros caracteres e depois adiciona um a menos que o comprimento dos parênteses ao final.

Arquivo .com do MS-DOS, 30 bytes

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

A cadeia é passada para o executável usando a linha de comando. (Um caractere de espaço entre o nome do arquivo .COM e a sequência).

O resultado é gravado na saída padrão.

A desmontagem está aqui:

  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

Nota: Você pode sair de um arquivo .COM do DOS (diferente dos arquivos com cabeçalhos EXE) usando uma instrução "RET".

JavaScript (ES6), 40 34 33 bytes

Economizou 6 bytes graças a ETHproductions

Uma função recursiva.

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

Experimente online!

Brainfuck, 42 40 bytes

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

Experimente online!

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 bytes

S'(ý¹g<')×J

Experimente online!

Explicação:

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

Brainfuck, 44 bytes

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

Lê um byte de cada vez, coloca um ponto aberto antes de cada um, exceto o primeiro, coloca o mesmo número de pontos próximos no final.

Haskell, 30 bytes

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

Exemplo de uso: f "Nest a string"-> "N(e(s(t( (a( (s(t(r(i(n(g))))))))))))".

Pegue o próximo caractere, seguido de a (, seguido de uma chamada recursiva com todos, exceto o primeiro, seguido de a ).

Geléia , 9 8 bytes

-1 byte graças a @Dennis (use molde,, ṁno lugar do comprimento L, e repita x)

j”(³”)ṁṖ

TryItOnline

Quão?

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 bytes

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

Experimente online!

Alternativamente:

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

Explicação

Eu sempre esqueço que é possível imprimir coisas ao longo do caminho, em vez de transformar tudo no resultado final e produzi-lo de uma só vez ...

\1>`.
($&

Aqui, \diz ao Retina para imprimir o resultado desse estágio sem avanço de linha à direita. O 1>limite é o que significa que a primeira correspondência da regex deve ser ignorada. Quanto ao próprio palco, ele simplesmente substitui cada caractere ( .), exceto o primeiro, por (seguido por esse caractere. Em outras palavras, ele insere (entre cada par de caracteres. Para entrada abc, isso a transforma em (e imprime)

a(b(c

Tudo o que resta é imprimir os parênteses de fechamento:

T`(p`)_

Isto é feito com uma transliteração que substitui (com )e exclui todos os outros caracteres ASCII imprimíveis do string.

> <> , 19 18 bytes

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

Experimente online!

Explicação

A primeira linha é um loop de entrada que imprime tudo até o último caractere da entrada (incluindo todos os () e deixa a quantidade certa )na pilha:

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.

Quando pressionamos o EOF, o ponteiro da instrução termina na segunda linha e simplesmente executamos oum loop, imprimindo tudo ), até que a pilha esteja vazia e o programa com erros.

J, 13 bytes

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

J é executado da direita para a esquerda, portanto, usando o advérbio de inserção /, um verbo pode ser usado para reduzir as letras da sequência de entrada.

Uso

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

Você pode observar as saídas parciais entre cada redução.

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

Explicaçã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 bytes

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

Esse lambda deve ser um método estático. Preciso contar bytes extras para esse requisito? Normalmente, eu não usaria um lambda para recursão em C #, mas acho que seria mais curto não usar recursão.

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

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

O Regex localiza e substitui os espaços entre os caracteres por "(". Então cate repadicione ")" n-1 vezes no final.

Java 7,81 79 bytes

Salvo 1byte.Thanks para kevin.

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

PowerShell v2 +, 46 bytes

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

Pega a string de entrada, chare -joina matriz é junto com as parênteses abertas (e concatena o número apropriado de parênteses fechadas ).

APL, 19 bytes

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

Explicação:

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

Solução alternativa, também 19 bytes:

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

Explicação:

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

t~40+v3L)7MQ3L)h

Experimente online!

Explicação

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 bytes

Nada mal para um tarpit de Turing bastante detalhado ...

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
}

(Sim, todo esse espaço em branco é obrigatório.)

Nota: devido às limitações de entrada do Acc !! , é impossível ler uma sequência arbitrária de caracteres sem um delimitador final. Portanto, este programa espera entrada (no stdin) como uma sequência seguida por um caractere de tabulação.

Acc !! ?

É uma linguagem que criei que parece apenas inutilizável . O único tipo de dados são números inteiros, a única construção de fluxo de controle é o Count x while yloop, e a única maneira de armazenar dados é um único acumulador _. A entrada e a saída são executadas um caractere de cada vez, usando o valor especial Ne a Writeinstrução Apesar dessas limitações, tenho certeza de que Acc !! é Turing completo.

Explicação

A estratégia básica em Acc !! A programação é usar a %divisão mod e número inteiro /para particionar conceitualmente o acumulador, permitindo que ele armazene vários valores ao mesmo tempo. Neste programa, usamos três seções: os sete bits de ordem mais baixa ( _%128) armazenam um código ASCII da entrada; o próximo bit ( _/128%2) armazena um valor de flag; e os bits restantes ( _/256) contam o número de parênteses necessárias.

Entrada em Acc !! vem do valor especial N, que lê um único caractere e avalia seu código ASCII. Qualquer declaração que consiste apenas em uma expressão atribui o resultado dessa expressão ao acumulador. Então, começamos armazenando o código do primeiro caractere no acumulador.

_%128irá armazenar o caractere lido mais recentemente. Portanto, o primeiro loop é executado enquanto _%128-9é diferente de zero - ou seja, até o caractere atual ser uma guia.

Dentro do loop, queremos imprimir, a ( menos que estejamos na primeira iteração. Desde Acc !! não tem declaração if, temos que usar loops para condicionais. Usamos o bit 128 do acumulador _/128%2, como valor de flag. Na primeira passagem, a única coisa no acumulador é um valor ASCII <128, portanto, o sinalizador é 0 e o loop é ignorado. Em cada passe subsequente, garantiremos que a bandeira seja 1.

Dentro do Count xloop (sempre que o sinalizador é 1), escrevemos um paren aberto (ASCII 40) e adicionamos 128 ao acumulador, configurando o sinalizador para 0 e saindo do loop. Isso também aumenta o valor de _/256, que usaremos como registro de proximidade a ser produzido.

Independentemente do valor da flag, escrevemos o char de entrada mais recente, que é simplesmente _%128.

A próxima tarefa ( _+128-_%128+N) faz duas coisas. Primeiro, adicionando 128, ele define o sinalizador para a próxima vez no loop. Segundo, zera o _%128slot, lê outro caractere e o armazena lá. Então nós fazemos um loop.

Quando o Count iloop termina, acabamos de ler um caractere de tabulação, e o valor do acumulador se divide assim:

• _%128: 9(o caractere de tabulação)
• _/128%2: 1(a bandeira)
• _/256: número de caracteres lidos, menos 1

(O menos 1 é porque nós adicionamos 128 ao acumulador apenas uma vez durante a primeira passagem pelo loop principal.) Tudo o que precisamos agora são os parênteses. Count j while _/256-jloops _/256vezes, escrevendo um parêntese (ASCII 41) a cada vez. Voila!

Perl, 25 bytes

Agradecemos a @Ton Hospel por jogar fora 4 bytes.

24 bytes de código + -F.

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

Necessidades -Fe -Esinalizadores:

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

Observe que, se você tentar fazer isso em uma versão antiga do perl, poderá ser necessário adicionar um -asinalizador.

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

(Para usá-lo, coloque o código dentro de um arquivo e chame-o com echo -n "Hello" | perl nest.pl)

Ruby, 27 bytes

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

Explicação

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

Inclui +1 para -p

Atribua string ao STDIN sem nova linha (ou adicione uma -lopção ao programa)

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

Versão anterior 64 Bytes

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

GNU sed, 37 35 31 bytes (30 +1 para -rargumento)

Solução linux sed pura

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

1. Nomeando a subscrição :; então chamando recursivamente comt
2. Fazendo 2 grupos regex:
   • Primeiro grupo é o primeiro caractere de dois caracteres consecutivos que não estão entre parênteses
   • Segundo grupo é o segundo caractere consecutivo e o restante da sequência até o final da linha
3. Adicionar parênteses ao redor do segundo grupo \1 ( \2 )

Edit : Obrigado a @manatwork por ajudar a remover 4 caracteres!

Testador online

Água-viva , 19 18 bytes

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

O caractere ␁é o caractere de controle não imprimível com valor de bytes 0x1. Experimente online!

Explicação

Este é um programa Jellyfish bastante complexo, pois muitos valores são usados ​​em vários lugares.

• I é uma entrada bruta, leia STDIN como uma sequência.
• '(é o caractere literal (.
• A {(identidade à esquerda) assume '(e Icomo entradas e retorna '(. O valor de retorno nunca é realmente usado.
• `é fio. Ele modifica {para retornar o caractere (para cada caractere de I, resultando em uma sequência de (s com o mesmo comprimento que I.
• >é cauda; pega a sequência de (s como entrada e corta o primeiro caractere.
• +toma como argumento a sequência de (s e o byte não imprimível e adiciona o valor do byte (1) a cada caractere. Isso fornece uma seqüência de comprimento igual de )s. O uso do caractere ␁garante que o valor de retorno seja uma sequência e não uma lista de números inteiros.
• No canto inferior esquerdo, /pega o byte não imprimível e retorna uma função que aceita dois argumentos e junta o segundo argumento ao primeiro uma vez (já que o valor do byte é 1).
• _pega essa função, pega os argumentos dos inferiores {(que eram '(e I) e chama a função com eles. Isso insere o caractere (entre cada par de caracteres em I.
• ,concatena essa sequência com a sequência de )s e Pimprime o resultado.

05AB1E , 22 21 19 18 bytes

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

Experimente online!

Explicação:

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

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

Vai do fim ao começo, porque, caso contrário, você tropeça nos )s que já escreveu. Usa em havez de ifalhar quando chega ao início.

Normalmente, você não faria duas inserções separadas como esta; você faria algo como C()<Esc>Psalvar um derrame. Mas o posicionamento não funciona tão bem desta vez.

Convexo , 10 bytes

_'(*\,(')*

Experimente online!

> <> , 37 bytes

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

Linha por linha

1. Empurra cada caractere da entrada com um parêntese de abertura após cada
2. Remove EOF e o último parêntese de abertura e empurra o comprimento da pilha
3. Usa uma comparação com metade do comprimento da pilha para empurrar o parêntese de fechamento
4. Imprime o conteúdo da pilha

Experimente online!

Brain-Flak 103 97 Bytes

Inclui +3 para -c

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

Experimente Online!

Explicação:

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

Fator, 81 bytes

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