N (e (s (t))) une chaîne

77

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!

DJMcMayhem
la source
21
Ahem: Est- ce que ce message a quelque chose à voir avec le défi? :-)
wizzwizz4
12
T I L 4 2 = 8
ETHproductions
Quelle est la longueur maximale pour la chaîne d'entrée? Cas des méthodes récursives
Ferrybig
1
@ kamoroso94 You may take the input and the output in any reasonable format.Une liste de personnages me semble parfaitement raisonnable.
DJMcMayhem
1
Voilà donc à quoi ressemble le code Lisp
caird coinheringaahing

Réponses:

63

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.

Assistant de blé
la source
13
Ce truc est cool, je vais devoir m'en souvenir.
Skyler
comment fonctionne le ~ -trick?
ShadowFlame
1
@ShadowFlame -rend le nombre négatif et le ~retourne. Vous pouvez en lire un peu plus à ce sujet sur la page de conseils .
Wheat Wizard
1
@ ShadowFlame. La mécanique de celui-ci est comme WheatWidard a dit. Cela fonctionne sur les systèmes qui utilisent le mode deux-complément pour stocker les nombres négatifs (ce qui est la plupart des systèmes de nos jours).
Mad Physicist
1
@MadPhysicist Avec Python, cela fonctionne toujours, car ~ est défini comme -x-1
Mega Man
45

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

Martin Rosenau
la source
Puisque je ne trouve pas de documentation ou d’informations satisfaisantes, pourquoi call 0xfoff? Le programme est chargé en mémoire à l'adresse 0, autant que je sache (ou 0x100sur CP / M-DOS mais il semble que ce soient des instructions x86), pourquoi recursiveFunctionse trouve- t-il soudainement à 0xffof? Il semble commencer 9 octets après le début du programme et il n'y a pas de virtualisation ni de métadonnées dans l'exécutable.
chat
6
DOS charge les fichiers .COM à adresser, 0x100mais ce programme pourrait même s’exécuter sur n’importe quelle adresse: e8 f0 ffc’est une instruction d’appel relative : il saute à l’adresse de l’instruction qui suit l’ callinstruction moins 0x10.
Martin Rosenau
32

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!

Arnauld
la source
1
Belle astuce avec 1/s.
ETHproductions
Super bon tour avec ([c,...s])vous devriez écrire un conseil
edc65
@ edc65 Juste pour des raisons de clarté, celle-ci a été suggérée par ETHproductions.
Arnauld
o bon, quelqu'un doit quand même écrire un pourboire
edc65
1
@ jmingov merci, je sais. Le point ici est d'utiliser DA pour couper une chaîne de façon très courte (très courte que. Slice)
edc65
27

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
]
Alex Howansky
la source
1
Il existe généralement un moyen plus rapide d'obtenir une constante que la multiplication évidente à 2 facteurs.
Martin Ender
Ah bien, merci. C’était ma première soumission BF (mon tout premier programme BF, vraiment), alors je suis sûr qu’il existe de nombreuses autres améliorations possibles.
Alex Howansky
vous avez une paire de supports pour beaucoup!?
Vloxxity
Cela met une paire de parenthèses vide après le dernier caractère de la chaîne. Je ne sais pas s'il existe un moyen d'éviter cela sans ajouter ",". avant la boucle et la commutation de l'ordre de sortie à l'intérieur de la boucle, ce qui rallonge le programme de deux octets.
user59468
Ah, mon pote, tu as raison. Je n'ai pas lu assez attentivement et j'ai fait de la dernière lettre un appel de fonction comme les autres.
Alex Howansky
23

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
acrolithe
la source
18

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.

utilisateur59468
la source
+++++[->++++++++<],.,[>.>+<<.,]>+>[-<.>]est légèrement plus court.
Tesseract
17

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

nimi
la source
2
Si nous interprétons les réponses comme étant Haskell, nous pouvons le résoudre simplement f=Data.List.intersperse '$'! Cela nous donne f "Nest a string"-> "N$e$s$t$ $a$ $s$t$r$i$n$g".
dimanche
Je voulais juste vous faire savoir que @fornit (il n’a pas assez de représentants pour commenter) a suggéré de l’utiliser f[]=[]comme base de votre cas f[x]=[x]. Je ne connais pas Haskell, donc je ne sais pas si c'est légitime ou non, je vous laisse juger.
Dada
@Dada: ça ne marchera pas, car cela mettrait un autre ()derrière la dernière lettre, par exemple f "abc"-> "a(b(c()))".
nimi
Cela ne gère pas non plus les entrées vides. La version la plus courte correcte que je pourrais trouver est 44, avec une technique différente: f=(++).intersperse '('<*>drop 1.map(\_->')').
Jon Purdy
@JonPurdy: nous n'avons pas à gérer les entrées vides. interspersenécessite import Data.List17 autres octets.
nimi
16

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))))))))
Jonathan Allan
la source
3
, BTW ³provoque en fait Jelly pour imprimer la valeur de retour de courant, de sorte que vous n'avez deux listes de caractères.
Dennis
13

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.

Martin Ender
la source
Dangit. Si vite ...
mbomb007
@ mbomb007 ... et loin d'être optimal. ;)
Martin Ender
13

> <> , 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é.

Martin Ender
la source
12

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
milles
la source
12

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
    )
;
Lait
la source
la définition doit fonctionner comme annoncé et compter
cat
9

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.

jmartindill
la source
Peut effectivement soustraire 1 octet ici en éliminant le F, comme c'est le cas , cela est dû au fait que chaque entrée a déjà un paramètre par défaut. Ainsi, laisser un caractère vide entre deux virgules fera que l'option ignore.case utilisera sa valeur par défaut. Mais vous saviez probablement que ... Travail bien fait!
Sumner18
9

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;}
Numéro numéroté
la source
Belle approche récursive. Plus court que le for-loop que j'étais sur le point de poster. +1 Deux choses que vous pouvez l!=a.lengthl<a.lengthb=b+'('+a[l],++l)+')'b+="("+a[l],++l)+")"
jouer au
@KevinCruijssen b+="("+a[l],++l)+")"vous donne 144141148))), et BTW b+"("+a[l],++l)+")"est correct. et ce fut une erreur très stupide de ma part ( !=).
Numéro numéroté
Non, b+='('+a[l],++l)+')'donne 144141148, mais b+="("+a[l],++l)+")"pas. Les parenthèses sont entourées de guillemets au lieu de guillemets.
Kevin Cruijssen
Je publie ma version (82 octets dans Java 7) en utilisant uniquement la chaîne d'entrée comme paramètre. Verbose mais pas si mal;) Si vous trouvez quelque chose à changer: codegolf.stackexchange.com/a/96745/59739
AxelH
8

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

AdmBorkBork
la source
8

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
                   }
marinus
la source
6
Où achetez-vous les claviers pour un tel langage !!!
Ronan Dejhero
@RonanDejhero Peut-être simplement remapper les clés en utilisant CLTR, Maj, Alt, Capslock, NumLock, etc.
Ariana
8

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
Luis Mendo
la source
8

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!

DLosc
la source
7

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.


Un autre moyen intéressant (un peu plus long cependant: 28 octets):
Merci encore à Ton Hospel de m'avoir aidé à réussir celui-ci.

#!/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)

Dada
la source
Vous n'avez pas besoin de l' ""après -F. Vous n'avez pas non plus besoin de la -lsi vous exigez que la chaîne d'entrée soit entrée sans echo -n Hello | program
saut de
@TonHospel Oui, j'ai oublié (ou je ne savais pas, je ne suis pas sûr) de ce comportement -F, merci. (Je me demandais comment obtenir l'entrée sans la nouvelle ligne finale, merci pour cela aussi)
Dada
perl -F -E '$"="(";say"@F".")"x$#F'
Ton Hospel
Votre autre idée peut fonctionner avec quelque chose comme s/.(?=.)/s%$'%($&)%/reg, mais elle ne prend bien sûr pas en charge les chaînes contenant des métacaractères regex
Ton Hospel
@TonHospel Merci beaucoup pour tout ça! (À propos du second, j'ai ajouté \Qpour supporter les métacaractères regex) :-)
Dada
6

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
m-chrzan
la source
6

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
Ton Hospel
la source
6

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,")");
Jörg Hülsermann
la source
1
Vous pouvez enregistrer deux octets en utilisant à la <?=place de echo et un autre si vous définissez $ s comme résultat de l' str_splitappel à la place de $argv[1], puis à la count($s)place destrlen($s)
Alex Howansky
2
63 octets: <?=str_pad(join("(",$s=str_split($argv[1])),count($s)*3-2,")");- wordwrapvaincrait la combinaison scission / jointure, mais échouera malheureusement si l'entrée contient des espaces.
Titus
1
@Titus nice alternative merci
Jörg Hülsermann
6

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

jour du Jugement dernier
la source
2
Utiliser seulement 2 groupes semble être suffisant. Capturez les 2ème et 3ème ensemble.
Manatwork
Oh, et désolé, mais les options de ligne de commande nécessaires pour modifier le comportement par défaut de l'interpréteur pour que votre code fonctionne doivent être incluses dans le nombre de tailles. Le peu nécessaire -ede passer le code à l'interprète est gratuit. (Ok, sedest heureux sans elle aussi.) Donc pour sed -re '…'vous comptez +1.
Manatwork
1
Les étiquettes vierges sont une fonctionnalité / un bogue GNU sed, alors peut-être que le titre devrait être GNU sed.
Riley
6

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.
Zgarb
la source
5

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
Luke
la source
5

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.

udioica
la source
Vous pouvez utiliser la <End>touche en mode insertion au lieu de quitter le mode insertion et de le faireA
BlackCap
@ BlackCap Ce n'est pas un octet. J'aurais besoin de compter les traits au lieu d'octets. (Et Vimgolf est un meilleur jeu lorsque vous interdisez les touches du curseur, bien que la différence soit triviale.)
dimanche
4

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

Emigna
la source
4

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 (
Riley
la source
Me battre à elle. +1
DJMcMayhem
Hmm. Je pensais que réutiliser le 40 pour éviter de repousser un grand entier permettrait de gagner beaucoup d'octets, mais le mieux que je puisse trouver, {({}<><(((((()()){}()){}){}){})>)<>}<>({}<(({})<>())><>)([]){({}[()()]<(<>({})<>)>)}{}{}{({}<>)<>}<>{}c'est de deux octets de plus ...
DJMcMayhem
Merci de me donner l’idée de réutiliser le 40. Je l’ai descendue à 95 + 3. Pourquoi est-ce que c'est 3 octets -adans Brain-Flak quand même?
Riley
Oh, beau travail! Les +3octets sont standard pour les indicateurs de ligne de commande spéciaux . Ce qui est regrettable, mais que je peux supporter. En fait, j'ai réfléchi aux moyens de réduire cela, mais je ne sais pas encore comment.
DJMcMayhem
N'est-ce pas normalement 2 octets? un pour le -et un pour le drapeau? Vous pouvez avoir un drapeau pour une exécution normale, comme le fait Perl -e. De cette façon, il ne s'agirait que d'un octet supplémentaire.
Riley
4

Facteur, 81 octets

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