Pour "imbriquer" une chaîne, vous devez:

• Traitez le premier caractère comme une fonction et les caractères suivants comme les arguments de cette fonction. Par exemple, si la chaîne d'entrée était Hello, alors la première étape serait:

  H(ello)
  

• Ensuite, répétez cette même étape pour chaque sous-chaîne. Nous obtenons donc:

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

Votre tâche consiste à écrire un programme ou une fonction qui "imbrique" une chaîne. Par exemple, si la chaîne d'entrée était Hello world!, vous devriez alors générer:

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

L'entrée ne contiendra jamais que l' ASCII imprimable , et vous pouvez prendre l'entrée et la sortie dans n'importe quel format raisonnable. Par exemple, STDIN / STDOUT, arguments de fonction et valeur de retour, lecture et écriture dans un fichier, etc.

Par souci de simplicité, vous pouvez également supposer que l'entrée ne contiendra pas de parenthèses et ne sera pas vide.

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)

Comme d'habitude, toutes nos règles et échappements par défaut s'appliquent, et la réponse la plus courte notée en octets est gagnante!

Python, 41 39 34 octets

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

Ideone

Assez explicite.

Il met une parenthèse entre tous les autres caractères puis en ajoute un de moins que la longueur des parenthèses à la fin.

Fichier .com MS-DOS, 30 octets

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 chaîne est transmise à l'exécutable à l'aide de la ligne de commande. (Un espace entre le nom du fichier .COM et la chaîne).

Le résultat est écrit sur la sortie standard.

Le démontage est ici:

  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

Remarque: vous pouvez quitter un fichier .COM DOS (contrairement aux fichiers avec en-tête EXE) à l’aide d’une instruction "RET".

JavaScript (ES6), 40 34 33 octets

6 octets sauvés, grâce à ETHproductions

Une fonction récursive.

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

Essayez-le en ligne!

Brainfuck, 42 à 40 octets

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

Essayez-le en ligne!

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 octets

S'(ý¹g<')×J

Essayez-le en ligne!

Explication:

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

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

Lit un octet à la fois, met un parent ouvert avant chacun sauf le premier, met le même nombre de parents proches à la fin.

Haskell, 30 octets

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

Exemple d'utilisation: f "Nest a string"-> "N(e(s(t( (a( (s(t(r(i(n(g))))))))))))".

Prenez le caractère suivant, suivi de a (, suivi d'un appel récursif avec tous les caractères sauf le premier, suivi de a ).

Gelée , 9 à 8 octets

-1 octet grâce à @Dennis (utilisez moule, ṁau lieu de longueur L, et répétez x)

j”(³”)ṁṖ

TryItOnline

Comment?

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 octets

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

Essayez-le en ligne!

Alternativement:

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

Explication

J'oublie toujours qu'il est possible d'imprimer des choses en cours de route au lieu de tout transformer en résultat final et de le sortir en une fois ...

\1>`.
($&

Ici, il \demande à Retina d’imprimer le résultat de cette étape sans saut de ligne. Le 1>est une limite qui signifie que la première correspondance de l'expression régulière doit être ignorée. Quant à la scène elle-même, elle remplace simplement chaque caractère ( .) sauf le premier (suivi de ce caractère. En d'autres termes, il insère (entre chaque paire de caractères. Pour l’entrée abc, cela le transforme en (et l’imprime)

a(b(c

Il ne reste plus qu'à imprimer les parenthèses fermantes:

T`(p`)_

Cela se fait avec une translittération qui remplace (avec )et supprime tous les autres caractères ASCII imprimables de la chaîne.

> <> , 19 18 octets

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

Essayez-le en ligne!

Explication

La première ligne est une boucle d’entrée qui affiche tout jusqu’au dernier caractère de l’entrée (y compris tous les () et laisse la quantité appropriée de )sur la pile:

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.

Une fois que nous atteignons EOF, le pointeur d’instruction se termine sur la deuxième ligne et nous exécuterons simplement oen boucle, en imprimant tout le ), jusqu’à ce que la pile soit vide et que le programme soit erroné.

J, 13 octets

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

J s’exécute de droite à gauche. Ainsi, en utilisant l’adverbe inséré /, un verbe peut être utilisé pour réduire les lettres de la chaîne de saisie.

Usage

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

Vous pouvez observer les sorties partielles entre chaque réduction.

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

Explication

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

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

Ce lambda doit être une méthode statique. Aurais-je besoin de compter des octets supplémentaires pour cette exigence? Normalement, je n'utiliserais pas un lambda pour la récursion en C #, mais je pense qu'il serait plus court de ne pas utiliser la récursivité.

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

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

Regex trouve et remplace les espaces entre les caractères par "(". Ensuite, catet repajoute ")" n-1 fois à la fin.

Java 7,81 79 octets

Sauvegardé 1byte.Merci à Kevin.

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

PowerShell v2 +, 46 octets

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

Prend la chaîne d'entrée, char-array's it, -joinle tableau avec les parenthèses ouvertes (, puis concatène sur le nombre approprié de parenthèses fermées ).

APL, 19 octets

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

Explication:

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

Solution alternative, également 19 octets:

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

Explication:

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

t~40+v3L)7MQ3L)h

Essayez-le en ligne!

Explication

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 octets

Pas mal pour un tarpit assez bavard de 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
}

(Oui, tout cet espace est obligatoire.)

Note: à cause des limitations d'entrée de Acc !! , il est impossible de lire une chaîne de caractères arbitraire sans un délimiteur de fin. Par conséquent, ce programme attend une entrée (sur stdin) sous la forme d'une chaîne suivie d'un caractère de tabulation.

Acc !! ?

C'est un langage que j'ai créé et qui semble seulement être inutilisable . Les seuls types de données sont des entiers, la seule construction de flux de contrôle est la Count x while yboucle et le seul moyen de stocker des données est un seul accumulateur _. L'entrée et la sortie sont effectuées caractère par caractère, à l'aide de la valeur spéciale Net de l' Writeinstruction. Malgré ces limitations, je suis à peu près sûr que Acc !! est Turing-complet.

Explication

La stratégie de base dans Acc !! la programmation consiste à utiliser la %division mod et integer /pour partitionner conceptuellement l'accumulateur, ce qui lui permet de stocker plusieurs valeurs à la fois. Dans ce programme, nous utilisons trois de ces sections: les sept bits les plus faibles ( _%128) stockent un code ASCII à partir d’une entrée; le bit suivant ( _/128%2) stocke une valeur de drapeau; et les bits restants ( _/256) comptent le nombre de parents proches dont nous aurons besoin.

Entrée dans Acc !! provient de la valeur spéciale N, qui lit un seul caractère et s’évalue en code ASCII. Toute instruction composée uniquement d'une expression affecte le résultat de cette expression à l'accumulateur. Nous commençons donc par stocker le code du premier caractère dans l'accumulateur.

_%128stockera le dernier caractère lu. Ainsi, la première boucle s'exécute avec une valeur autre que _%128-9zéro, c'est-à-dire jusqu'à ce que le caractère actuel soit un onglet.

À l'intérieur de la boucle, nous voulons imprimer ( sauf si nous en sommes à la première itération. Depuis Acc !! n'a pas de déclaration if, nous devons utiliser des boucles pour les conditions. Nous utilisons le bit 128 de l'accumulateur _/128%2, comme valeur d'indicateur. Lors du premier passage, la seule chose dans l'accumulateur est une valeur ASCII <128, donc le drapeau est 0 et la boucle est ignorée. Lors de chaque passage ultérieur, nous nous assurerons que le drapeau est à 1.

Dans la Count xboucle (chaque fois que le drapeau est à 1), nous écrivons un code ouvert (ASCII 40) et ajoutons 128 à l'accumulateur, ce qui met le drapeau à 0 et quitte la boucle. Cela arrive également à incrémenter la valeur de _/256, que nous utiliserons comme notre décompte de parents proches à afficher.

Indépendamment de la valeur du drapeau, nous écrivons le dernier caractère en entrée, qui est simplement _%128.

La prochaine affectation ( _+128-_%128+N) fait deux choses. Tout d'abord, en ajoutant 128, il active l'indicateur pour la prochaine fois dans la boucle. Deuxièmement, il met la _%128fente à zéro, lit un autre caractère et le stocke à cet endroit. Puis on boucle.

Lorsque la Count iboucle se termine, nous venons de lire un caractère de tabulation, et la valeur de l'accumulateur se décompose comme suit:

• _%128: 9(le caractère de tabulation)
• _/128%2: 1(le drapeau)
• _/256: nombre de caractères lus, moins 1

(Le moins 1 est dû au fait que nous n’ajoutons que 128 à l’accumulateur une fois lors du premier passage dans la boucle principale.) Count j while _/256-jeffectue des boucles en _/256écrivant un ASCII proche 41chaque fois. Voila!

Perl, 25 octets

Merci à @Ton Hospel pour avoir joué 4 octets.

24 octets de code + -F.

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

Besoins -Fet -Edrapeaux:

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

Notez que si vous essayez ceci sur une ancienne version de perl, vous devrez peut-être ajouter un -aindicateur.

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

(Pour l'utiliser, placez le code dans un fichier et appelez-le avec echo -n "Hello" | perl nest.pl)

Ruby, 27 octets

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

Explication

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

Inclut +1 pour -p

Donne une chaîne sur STDIN sans nouvelle ligne (ou ajoute une -loption au programme)

echo -n Hello | nest.pl

nest.pl:

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

PHP, 63 octets

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

Version précédente 64 octets

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

GNU sed, 37 35 31 octets (30 +1 pour l' -rargument)

Solution linux sed pure

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

1. Nommer la subsitution :; puis en l'appelant récursivement avect
2. Faire 2 groupes de regex:
   • Le premier groupe est le premier caractère de deux caractères consécutifs qui ne sont pas des parenthèses
   • Le deuxième groupe est le deuxième caractère consécutif et le reste de la chaîne jusqu'à la fin de la ligne.
3. Ajouter des parenthèses autour du deuxième groupe \1 ( \2 )

Edit : Merci à @manatwork pour avoir aidé à supprimer 4 caractères!

Testeur en ligne

Méduse , 19 à 18 octets

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

Le caractère ␁est le caractère de contrôle non imprimable avec une valeur d'octet 0x1. Essayez-le en ligne!

Explication

Il s'agit d'un programme Jellyfish assez complexe, car de nombreuses valeurs sont utilisées à plusieurs endroits.

• I est une entrée brute, lue à partir de STDIN en tant que chaîne.
• '(est le caractère littéral (.
• Le {(identité de gauche) prend '(et Icomme entrées, et retourne '(. La valeur de retour n'est jamais réellement utilisée.
• `est le fil. Il modifie {pour retourner le caractère (pour chaque caractère de I, résultant en une chaîne de (s avec la même longueur que I.
• >est la queue; il prend la chaîne de (s en entrée et coupe le premier caractère.
• +prend comme arguments la chaîne de (s et l'octet non imprimable, et ajoute la valeur d'octet (1) à chaque caractère. Cela donne une chaîne d'égale longueur de )s. L'utilisation du caractère ␁garantit que la valeur renvoyée est une chaîne et non une liste d'entiers.
• Dans le coin inférieur gauche, /prend l'octet non imprimable, retourne une fonction qui prend deux arguments et joint le deuxième argument au premier une fois (puisque la valeur de l'octet est 1).
• _prend cette fonction, saisit les arguments du plus bas {(qui étaient '(et I) et appelle la fonction avec eux. Cela insère le caractère (entre chaque paire de caractères dans I.
• ,concatène cette chaîne avec la chaîne de )s et Paffiche le résultat.

05AB1E , 22 21 19 18 octets

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

Essayez-le en ligne!

Explication:

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

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

Va de bout en bout, sinon vous trébuchez sur ce que )vous avez déjà écrit. Utilise haau lieu d' iéchouer quand on arrive au début.

Habituellement, vous ne feriez pas deux insertions distinctes comme celle-ci; vous feriez quelque chose comme C()<Esc>Psauver un coup. Mais le positionnement ne fonctionne pas aussi bien cette fois-ci.

Convexe , 10 octets

_'(*\,(')*

Essayez-le en ligne!

> <> , 37 octets

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

Rangée par rangée

1. Pousse chaque caractère de l'entrée avec une parenthèse ouvrante après chaque
2. Supprime EOF et la dernière parenthèse ouvrante et pousse la longueur de la pile
3. Utilise une comparaison avec la moitié de la longueur de la pile pour pousser la parenthèse fermante
4. Imprime le contenu de la pile

Essayez-le en ligne!

Brain-Flak 103 97 Bytes

Comprend +3 pour -c

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

Essayez-le en ligne!

Explication:

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

Facteur, 81 octets

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