Para "anidar funciones" una cadena, debe:

• Trate el primer carácter como una función, y los siguientes caracteres como argumentos para esa función. Por ejemplo, si la cadena de entrada era Hello, entonces el primer paso sería:

  H(ello)
  

• Luego, repita este mismo paso para cada subcadena. Entonces obtenemos:

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

Su tarea es escribir un programa o función que "anide" una cadena. Por ejemplo, si la cadena de entrada era Hello world!, entonces debería generar:

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

La entrada solo contendrá ASCII imprimible , y puede tomar la entrada y la salida en cualquier formato razonable. Por ejemplo, STDIN / STDOUT, argumentos de función y valor de retorno, lectura y escritura en un archivo, etc.

En aras de la simplicidad, también puede suponer que la entrada no contendrá paréntesis y no estará vacía.

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 de costumbre, se aplican todas nuestras reglas y lagunas predeterminadas, ¡y gana la respuesta más corta obtenida en bytes!

Python, 41 39 34 bytes

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

Ideone

Bastante autoexplicativo.

Pone un paréntesis entre cada otro carácter y luego agrega uno menos que el paréntesis de longitud al final.

Archivo .com de 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

La cadena se pasa al ejecutable usando la línea de comando. (Un carácter de espacio entre el nombre del archivo .COM y la cadena).

El resultado se escribe en la salida estándar.

El desmontaje está aquí:

  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: Puede salir de un archivo DOS .COM (a diferencia de los archivos con encabezados EXE) utilizando una instrucción "RET".

JavaScript (ES6), 40 34 33 bytes

Guardado 6 bytes, gracias a ETHproductions

Una función recursiva.

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

Pruébalo en línea!

Brainfuck, 42 40 bytes

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

Pruébalo en línea!

Sin golf:

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

Pruébalo en línea!

Explicación:

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

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

Lee un byte a la vez, coloca un par abierto antes de cada uno, excepto el primero, coloca el mismo número de parentescos cercanos al final.

Haskell, 30 bytes

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

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

Tome el siguiente carácter, seguido de un (, seguido de una llamada recursiva con todos menos el primer carácter, seguido de un ).

Jalea , 9 8 bytes

-1 byte gracias a @Dennis (use molde ṁ, en lugar de longitud L, y repita x)

j”(³”)ṁṖ

TryItOnline

¿Cómo?

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

Pruébalo en línea!

Alternativamente:

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

Explicación

Siempre olvido que es posible imprimir cosas en el camino en lugar de transformar todo en el resultado final y sacarlo de una vez ...

\1>`.
($&

Aquí \le dice a Retina que imprima el resultado de esta etapa sin un salto de línea final. El 1>es un límite que significa que la primera coincidencia de la expresión regular debe ignorarse. En cuanto a la etapa en sí, simplemente reemplaza cada carácter ( .) excepto el primero con (seguido de ese carácter. En otras palabras, se inserta (entre cada par de caracteres. Para la entrada abc, esto lo transforma en (e imprime)

a(b(c

Todo lo que queda es imprimir los paréntesis de cierre:

T`(p`)_

Esto se hace con una transliteración que sustituye (con )y elimina todos los demás caracteres ASCII imprimibles de la cadena.

> <> , 19 18 bytes

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

Pruébalo en línea!

Explicación

La primera línea es un bucle de entrada que imprime todo hasta el último carácter de la entrada (incluyendo todos los () y deja la cantidad correcta )en la pila:

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.

Una vez que llegamos a EOF, el puntero de instrucción termina en la segunda línea y simplemente ejecutaremos oen un bucle, imprimiendo todo ), hasta que la pila esté vacía y el programa falle.

J, 13 bytes

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

J se ejecuta de derecha a izquierda, por lo que, usando el adverbio de inserción /, se puede usar un verbo para reducir las letras de la cadena 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))))))))

Puede observar las salidas parciales entre cada reducción.

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

Explicación

(,'(',,&')')/  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)})":"");

Este lambda debe ser un método estático, ¿necesitaría contar bytes adicionales para ese requisito? Normalmente no usaría una lambda para la recursión en C #, pero luego creo que sería más corto no usar la recursión.

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

Regex encuentra y reemplaza espacios entre caracteres con "(". Luego caty repagrega ")" n-1 veces al final.

Java 781 79 bytes

1Byte guardado. Gracias a 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)

Toma la cadena de entrada, char-array's it, -joins the array junto con los pares abiertos (, luego se concatena en el número apropiado de pares cerrados ).

APL, 19 bytes

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

Explicación:

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

Solución alternativa, también 19 bytes:

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

Explicación:

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

Pruébalo en línea!

Explicación

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

No está mal para un tarpit de Turing bastante detallado ...

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
}

(Sí, todo ese espacio en blanco es obligatorio).

Nota: debido a las limitaciones de entrada de Acc !! , es imposible leer una cadena arbitraria de caracteres sin algún delimitador final. Por lo tanto, este programa espera una entrada (en stdin) como una cadena seguida de un carácter de tabulación.

Acc !! ?

Es un lenguaje que creé que solo parece inutilizable . El único tipo de datos son los enteros, la única construcción de flujo de control es el Count x while ybucle, y la única forma de almacenar datos es un único acumulador _. La entrada y la salida se realizan un carácter a la vez, utilizando el valor especial Ny la Writedeclaración. A pesar de estas limitaciones, estoy bastante seguro de que Acc !! está Turing completo.

Explicación

La estrategia básica en Acc !! La programación consiste en utilizar la %división de mods y enteros /para particionar conceptualmente el acumulador, lo que le permite almacenar múltiples valores a la vez. En este programa, utilizamos tres de estas secciones: los siete bits de orden más bajo ( _%128) almacenan un código ASCII desde la entrada; el siguiente bit ( _/128%2) almacena un valor de bandera; y los bits restantes ( _/256) cuentan el número de parentescos cercanos que necesitaremos.

Entrada en Acc !! proviene del valor especial N, que lee un solo carácter y evalúa su código ASCII. Cualquier declaración que consista únicamente en una expresión asigna el resultado de esa expresión al acumulador. Entonces, comenzamos almacenando el código del primer personaje en el acumulador.

_%128almacenará el personaje leído más recientemente. Entonces, el primer ciclo se ejecuta mientras _%128-9no es cero, es decir, hasta que el carácter actual sea una pestaña.

Dentro del bucle, queremos imprimir a ( menos que estemos en la primera iteración. Desde Acc !! no tiene una declaración if, tenemos que usar bucles para condicionales. Usamos el bit del acumulador de 128 _/128%2, como un valor de bandera. En la primera pasada, lo único en el acumulador es un valor ASCII <128, por lo que el indicador es 0 y se omite el bucle. En cada pase posterior, nos aseguraremos de que la bandera sea 1.

Dentro del Count xbucle (siempre que la bandera sea 1), escribimos un par abierto (ASCII 40) y agregamos 128 al acumulador, estableciendo así la bandera en 0 y saliendo del bucle. Esto también aumenta el valor de _/256, que usaremos como nuestro recuento de parentescos cercanos para la salida.

Independientemente del valor de la bandera, escribimos el carácter de entrada más reciente, que es simplemente _%128.

La siguiente asignación ( _+128-_%128+N) hace dos cosas. Primero, al agregar 128, establece la bandera para la próxima vez a través del ciclo. En segundo lugar, pone a cero la _%128ranura, lee otro personaje y lo almacena allí. Luego hacemos un bucle.

Cuando se Count icierra el ciclo, acabamos de leer un carácter de tabulación y el valor del acumulador se desglosa así:

• _%128: 9(el carácter de tabulación)
• _/128%2: 1(la bandera)
• _/256: número de caracteres leídos, menos 1

(El menos 1 se debe a que solo agregamos 128 al acumulador una vez durante la primera pasada a través del bucle principal). Todo lo que necesitamos ahora son los parentescos cercanos. Count j while _/256-jbucles _/256veces, escribiendo un close-paren (ASCII 41) cada vez. Voila!

Perl, 25 bytes

Gracias a @Ton Hospel por jugar 4 bytes.

24 bytes de código + -F.

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

Necesidades -Fy -Ebanderas:

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

Tenga en cuenta que si prueba esto en una versión anterior de perl, es posible que deba agregar un -aindicador.

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

(Para usarlo, coloque el código dentro de un archivo y llámelo con echo -n "Hello" | perl nest.pl)

Rubí, 27 bytes

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

Explicación

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

Incluye +1 para -p

Dar cadena en STDIN sin nueva línea (o agregar una -lopción al 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,")‌​");

Versión anterior 64 Bytes

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

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

Solución pura de linux sed

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

1. Nombrar la subvención :; luego llamándolo recursivamente cont
2. Hacer 2 grupos de expresiones regulares:
   • El primer grupo es el primer carácter de dos caracteres consecutivos que no son paréntesis
   • El segundo grupo es el segundo carácter consecutivo y el resto de la cadena hasta el final de la línea.
3. Agregar paréntesis alrededor del segundo grupo \1 ( \2 )

Editar : ¡Gracias a @manatwork por ayudar a eliminar 4 personajes!

Probador en línea

Medusa , 19 18 bytes

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

El carácter ␁es el carácter de control no imprimible con valor de byte 0x1. Pruébalo en línea!

Explicación

Este es un programa Jellyfish bastante complejo, ya que muchos valores se utilizan en varios lugares.

• I es una entrada sin formato, leída de STDIN como una cadena.
• '(Es el carácter literal (.
• La {(identidad izquierda) toma '(y Icomo entradas, y regresa '(. El valor de retorno nunca se usa realmente.
• `es hilo. Se modifica {para devolver el carácter (para cada carácter de I, dando como resultado una cadena de (s con la misma longitud que I.
• >es cola toma la cadena de (s como entrada y corta el primer carácter.
• +toma como argumentos la cadena de (sy el byte no imprimible, y agrega el valor de byte (1) a cada carácter. Esto da una cadena de igual longitud de )s. Usando el personaje␁ garantiza que el valor de retorno es una cadena y no una lista de enteros.
• En la esquina inferior izquierda, /toma el byte no imprimible y devuelve una función que toma dos argumentos, y une el segundo argumento con el primero una vez (ya que el valor del byte es 1).
• _toma esta función, toma los argumentos de la parte inferior {(que eran '(y I), y llama a la función con ellos. Esto inserta el carácter (entre cada par de caracteres en I.
• ,concatena esta cadena con la cadena de )s e Pimprime el resultado.

05AB1E , 22 21 19 18 bytes

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

Pruébalo en línea!

Explicación:

¤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

Va de principio a fin, porque de lo contrario te tropiezas con los )mensajes que ya has escrito. Utiliza en halugar de ifallar cuando llega al principio.

Por lo general, no haría dos inserciones separadas como esta; harías algo como C()<Esc>Psalvar un derrame cerebral. Pero el posicionamiento no funciona tan bien esta vez.

Convexo , 10 bytes

_'(*\,(')*

Pruébalo en línea!

> <> , 37 bytes

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

Fila por fila

1. Empuja cada carácter de entrada con un paréntesis de apertura después de cada
2. Elimina EOF y el último paréntesis de apertura y empuja la longitud de la pila
3. Utiliza una comparación con la mitad de la longitud de la pila para empujar el paréntesis de cierre
4. Imprime el contenido de la pila.

Pruébalo en línea!

Brain-Flak 103 97 Bytes

Incluye +3 para -c

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

Pruébalo en línea!

Explicación:

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

Factor, 81 bytes

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