N (e (s (t))) uma sequência

77

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!

DJMcMayhem
fonte
21
Ahem: Esta mensagem tem algo a ver com o desafio? :-)
wizzwizz4
12
T I L 4 2 = 8
ETHproductions 18/10/16
Qual é o comprimento máximo para a sequência de entrada? Caso de métodos recursivos
Ferrybig 23/10
1
@ kamoroso94 You may take the input and the output in any reasonable format.Uma lista de caracteres me parece perfeitamente razoável.
DJMcMayhem
1
Então é isso que o código Lisp se parece
caird coinheringaahing

Respostas:

63

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.

Assistente de Trigo
fonte
13
Esse truque é legal, vou precisar me lembrar disso.
Skyler #
como o ~ -trick funciona?
ShadowFlame
1
@ShadowFlame -torna o número negativo e o ~bit o vira. Você pode ler um pouco mais sobre isso na página de dicas .
Assistente de trigo
1
@ShadowFlame. A mecânica é como WheatWidard disse. Ele funciona em sistemas que usam o modo de dois complementos para armazenar números negativos (que é a maioria dos sistemas atualmente).
Mad Físico
1
@MadPhysicist Com o Python, ele sempre funciona, porque ~ é definido como -x-1 #
Mega Man
45

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

Martin Rosenau
fonte
Como não consigo encontrar nenhuma documentação real ou informações satisfatórias: por quê call 0xfoff? O programa é carregado na memória no endereço 0, tanto quanto eu posso dizer (ou 0x100no CP / M-DOS, mas estas parecem ser instruções x86), por que está recursiveFunctionlocalizado repentinamente 0xffof? Parece começar 9 bytes após o início do programa e não há virtualização ou metadados no executável.
cat
6
O DOS carrega arquivos .COM para endereçar, 0x100no entanto, esse programa seria executado em QUALQUER endereço: e8 f0 ffé uma instrução de chamada relativa : Salta para o endereço da instrução após a callinstrução menos 0x10.
Martin Rosenau 21/10
32

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!

Arnauld
fonte
1
Bom truque com 1/s.
ETHproductions
Super bom truque com ([c,...s])você deve escrever uma dica
edc65
@ edc65 Apenas por uma questão de clareza, este foi sugerido pela ETHproductions.
Arnauld
o bem, alguém tem que escrever uma dica de qualquer maneira
edc65
1
@jmingov obrigado, eu sei. O ponto aqui é usar DA para cortar uma corda de uma forma muito curto (muito mais curto do que .slice)
edc65
27

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
]
Alex Howansky
fonte
1
Geralmente, há uma maneira mais curta de obter uma constante do que a multiplicação óbvia de 2 fatores.
Martin Ender
Ah legal, obrigado. Este foi o meu primeiro envio de BF (meu primeiro programa de BF, realmente), então tenho certeza de que há muitas outras melhorias possíveis também.
Alex Howansky
você tem um par de suportes a muito !?
Vloxxity
Isso coloca um par de parênteses vazio após o último caractere da sequência. Não sei se há uma maneira de evitar isso sem adicionar ",." antes do loop e alternando a ordem de saída dentro do loop, o que torna o programa dois bytes mais longo.
user59468
Ah, merda, você está certo. Não li o suficiente e fiz da última letra uma chamada de função como as outras.
Alex Howansky
23

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
acrólito
fonte
18

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.

user59468
fonte
+++++[->++++++++<],.,[>.>+<<.,]>+>[-<.>]é um pouco mais curto.
Tesseract
17

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

nimi
fonte
2
Se interpretarmos as respostas como Haskell, podemos resolvê-lo com apenas f=Data.List.intersperse '$'! Isso nos dá f "Nest a string"-> "N$e$s$t$ $a$ $s$t$r$i$n$g".
porglezomp
Só queria que você soubesse que o @fornit (ele não tem representante suficiente para comentar) sugeriu o uso f[]=[]como um caso básico instaurado por você f[x]=[x]. Não conheço Haskell, então não sei se é legítimo ou não, deixarei você julgar.
Dada
@ Dadá: isso não vai funcionar, porque colocaria um adicional ()atrás da última letra, por exemplo f "abc"- -> "a(b(c()))".
nimi
Isso também não lida com entrada vazia. A versão correta mais curta que eu poderia vir acima com é de 44, com uma técnica diferente: f=(++).intersperse '('<*>drop 1.map(\_->')').
Jon Purdy
@ JonPurdy: não precisamos lidar com entradas vazias. intersperserequer import Data.Listoutros 17 bytes.
nimi
16

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))))))))
Jonathan Allan
fonte
3
Aliás, ³na verdade , o Jelly imprime o valor de retorno atual, para que você nunca tenha duas listas de caracteres.
Dennis
13

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.

Martin Ender
fonte
Dangit. Tão rápido ...
mbomb007
@ mbomb007 ... e longe de ser o ideal. ;)
Martin Ender
13

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

Martin Ender
fonte
12

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
milhas
fonte
12

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
    )
;
leite
fonte
a definição deve ser executada como declarada e contada
cat
9

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.

jmartindill
fonte
Na verdade, é possível subtrair 1 byte aqui, eliminando F, assim , porque cada entrada já possui uma configuração padrão; portanto, deixar um caractere vazio entre vírgulas fará com que a opção ignore.case use seu padrão. Mas você provavelmente sabia disso ... Trabalho bem feito!
precisa saber é o seguinte
9

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;}
Numberknot
fonte
Boa abordagem recursiva. Mais curto que o loop for que eu estava prestes a postar. No entanto, duas coisas que você pode jogar no golfe: l!=a.length-> l<a.lengthe b=b+'('+a[l],++l)+')'-> b+="("+a[l],++l)+")"( -2 bytes )
Kevin Cruijssen
@KevinCruijssen b+="("+a[l],++l)+")"fornece 144141148)))) e o BTW b+"("+a[l],++l)+")"está correto. e esse foi um erro muito bobo meu ( !=).
Numberknot
Não, b+='('+a[l],++l)+')'144141148, mas b+="("+a[l],++l)+")"não. Os parênteses são colocados entre aspas em vez de aspas.
Kevin Cruijssen 19/10/16
Publico minha versão (82 bytes em Java 7) usando apenas a entrada String como parâmetro. Detalhado, mas não é tão ruim;) Se você encontrar algo para mudar: codegolf.stackexchange.com/a/96745/59739
AxelH
8

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

AdmBorkBork
fonte
8

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
                   }
marinus
fonte
6
Onde você compra os teclados para esse idioma !!!
21136 Ronan Dejhero
@RonanDejhero Talvez apenas remapeamento chaves usando Clutter, shift, alt, capslock, numlock etc.
Ariana
8

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
Luis Mendo
fonte
8

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!

DLosc
fonte
7

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.


Outra maneira interessante (embora um pouco mais longa: 28 bytes):
Agradeço a Ton Hospel mais uma vez por me ajudar a corrigir esse problema.

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

dada
fonte
Você não precisa do ""depois do -F. Você também não precisa -lse você exigir que a string de entrada seja inserida sem nova linha final:echo -n Hello | program
Ton Hospel 19/16/16
@TonHospel Certo, eu esqueci (ou não sabia, não tenho certeza) sobre esse comportamento -F, obrigado. (Eu estava querendo saber como obter a entrada sem a nova linha final, obrigado por isso também)
Dada
perl -F -E '$"="(";say"@F".")"x$#F'
Ton Hospel
Você pode obter a sua outra ideia de trabalhar com algo como s/.(?=.)/s%$'%($&)%/reg, mas é claro que não suporta strings contendo metacharacters regex
Ton Hospel
@TonHospel Muito obrigado por tudo isso! (Sobre a segunda, que adicionado \Qpara suportar metacharacters regex) :-)
Dada
6

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
m-chrzan
fonte
6

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
Ton Hospel
fonte
6

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,")");
Jörg Hülsermann
fonte
1
Você pode salvar dois bytes usando <?=em vez de echo e outra se você definir $ s para o resultado da str_splitchamada em vez de $argv[1], e então usar count($s)em vez destrlen($s)
Alex Howansky
2
63 bytes: <?=str_pad(join("(",$s=str_split($argv[1])),count($s)*3-2,")");- wordwrapvenceria a combinação de divisão / junção, mas infelizmente falha se a entrada contiver espaço em branco.
Titus
1
@Titus boa alternativa Obrigado
Jörg Hülsermann
6

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

Apocalipse
fonte
2
Usar apenas 2 grupos parece ser suficiente. Capture o 2º e o 3º juntos.
manatwork
Ah, desculpe, mas as opções de linha de comando necessárias para alterar o comportamento padrão do interpretador para que seu código funcione devem ser incluídas na contagem de tamanhos. O pouco necessário -epara passar o código para o intérprete é de graça. (Ok, também sedfica feliz sem ele.) Então, para sed -re '…'você contar +1.
manatwork
1
Os rótulos em branco são um recurso / bug do GNU sed, portanto, talvez o título deva ser GNU sed.
Riley
6

Á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.
Zgarb
fonte
5

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
Lucas
fonte
5

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.

udioica
fonte
Você pode usar a <End>chave no modo de inserção em vez de sair do modo de inserção e fazendoA
Cabeção
@BlackCap Isso não é um byte. Eu precisaria contar traços em vez de bytes. (E Vimgolf é um jogo melhor quando você proibir teclas do cursor, embora a diferença aqui é trivial.)
udioica
4

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

Emigna
fonte
4

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 (
Riley
fonte
Bata-me para isso. +1
DJMcMayhem
Hmm. Pensei que reutilizando a 40 para evitar empurrando um grande inteiro novamente lhe poupar uma grande quantidade de bytes, mas o melhor que eu posso vir acima com é {({}<><(((((()()){}()){}){}){})>)<>}<>({}<(({})<>())><>)([]){({}[()()]<(<>({})<>)>)}{}{}{({}<>)<>}<>{}que é de dois bytes mais tempo ...
DJMcMayhem
Obrigado por me dar a ideia de reutilizar os 40. Reduzi para 95 + 3. Por que são 3 bytes -ano Brain-Flak?
Riley #
Oh, bom trabalho! Os +3bytes são padrão para sinalizadores de linha de comando especiais . O que é lamentável, mas algo que eu posso suportar. Na verdade, estive pensando em maneiras de encurtar isso, mas ainda não sei exatamente até agora.
DJMcMayhem
Normalmente não são 2 bytes? um para o -e outro para a bandeira? Você pode ter um sinalizador para execução normal, como o Perl faz -e. Dessa forma, seria apenas 1 byte extra.
Riley #
4

Fator, 81 bytes

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