N (e (s))) ciąg

77

Aby „zagnieździć funkcję” ciągu, należy:

  • Traktuj pierwszy znak jako funkcję, a kolejne znaki jako argumenty tej funkcji. Na przykład, jeśli ciąg wejściowy był Hello, to pierwszym krokiem byłoby:

    H(ello)
    
  • Następnie powtórz ten sam krok dla każdego podciągu. Otrzymujemy więc:

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

Twoim zadaniem jest napisanie programu lub funkcji, która „funkcja zagnieżdża” ciąg znaków. Na przykład, jeśli ciąg wejściowy był Hello world!, to powinieneś wypisać:

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

Dane wejściowe zawsze będą zawierały tylko drukowalne ASCII , a dane wejściowe i wyjściowe można pobrać w dowolnym rozsądnym formacie. Na przykład STDIN / STDOUT, argumenty funkcji i zwracana wartość, odczyt i zapis do pliku itp.

Dla uproszczenia można również założyć, że dane wejściowe nie będą zawierać nawiasów i nie będą puste.

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)

Jak zwykle obowiązują wszystkie nasze domyślne zasady i luki, a najkrótsza odpowiedź w bajtach wygrywa!

DJMcMayhem
źródło
21
Ahem: Czy ta wiadomość ma coś wspólnego z wyzwaniem? :-)
wizzwizz4 18.10.16
12
T I L 4 2 = 8
ETHprodukcje 18.10.16
Jaka jest maksymalna długość ciągu wejściowego?
Zastosowanie
1
@ kamoroso94 You may take the input and the output in any reasonable format.Lista znaków wydaje mi się całkowicie rozsądna.
DJMcMayhem
1
Tak właśnie wygląda kod Lisp
caird coinheringaahing

Odpowiedzi:

63

Python, 41 39 34 bajtów

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

Ideone to

Dość oczywiste.

Umieszcza nawias między każdą inną postacią, a następnie dodaje jeden koniec mniejszy niż długość nawiasu na końcu.

Sriotchilism O'Zaic
źródło
13
Ta ~ sztuczka jest fajna, muszę o tym pamiętać.
Skyler
jak działa ~ -trick?
ShadowFlame,
1
@ShadowFlame -sprawia, że ​​liczba jest ujemna i ~bit ją odwraca. Możesz przeczytać więcej na ten temat na stronie porad .
Sriotchilism O'Zaic
1
@ShadowFlame. Mechanika tego jest taka, jak powiedział WheatWidard. Działa na systemach, które używają trybu uzupełniania dwójkowego do przechowywania liczb ujemnych (co jest obecnie większością systemów).
Mad Physicist
1
@MadPhysicist W Pythonie działa zawsze, ponieważ ~ jest zdefiniowane jako -x-1
Mega Man
45

Plik MS-DOS .com, 30 bajtów

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

Ciąg jest przekazywany do pliku wykonywalnego za pomocą wiersza polecenia. (Jeden znak spacji między nazwą pliku .COM a łańcuchem).

Wynik jest zapisywany na standardowe wyjście.

Demontaż jest tutaj:

  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

Uwaga: Możesz wyjść z pliku DOS .COM (w przeciwieństwie do plików z nagłówkami EXE) za pomocą instrukcji „RET”.

Martin Rosenau
źródło
Ponieważ nie mogę znaleźć żadnej faktycznej dokumentacji ani zadowalających informacji: dlaczego call 0xfoff? Program jest ładowany do pamięci pod adresem, 0o ile mogę powiedzieć (lub 0x100na CP / M-DOS, ale wydaje się, że są to instrukcje x86), dlaczego recursiveFunctionnagle znajduje się pod 0xffof? Wygląda na to, że zaczyna się 9 bajtów po uruchomieniu programu i nie ma wirtualizacji ani metadanych w pliku wykonywalnym.
kot
6
DOS ładuje pliki .COM do adresowania, 0x100jednak ten program działałby nawet na DOWOLNYM adresie: e8 f0 ffjest instrukcją wywołania względnego : przeskakuje na adres instrukcji po callinstrukcji minus 0x10.
Martin Rosenau
32

JavaScript (ES6), 40 34 33 bajtów

Oszczędność 6 bajtów dzięki produktom ETH

Funkcja rekurencyjna.

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

Wypróbuj online!

Arnauld
źródło
1
Niezła sztuczka z 1/s.
ETHproductions
Super fajna sztuczka z ([c,...s])tobą powinna napisać napiwek
edc65
@ edc65 Dla jasności, ten został zasugerowany przez ETHproductions.
Arnauld
no cóż, ktoś i tak musi napisać napiwek
edc65
1
@jmingov dziękuję, wiem. Chodzi o to, aby użyć DA do pocięcia łańcucha w bardzo krótki sposób (bardzo krótszy niż .slice)
edc65,
26

Brainfuck, 42 40 bajtów

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

Wypróbuj online!

Nie golfowany:

>+[-->+[<]>-]>+     # 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
źródło
1
Zwykle jest krótszy sposób na uzyskanie stałej niż oczywiste mnożenie 2-czynnikowe.
Martin Ender
Ach miło, dzięki. To było moje pierwsze zgłoszenie BF (mój pierwszy program BF, naprawdę), więc jestem pewien, że jest też wiele innych możliwych ulepszeń.
Alex Howansky
masz za dużo jedną nawias !?
Vloxxity
Spowoduje to umieszczenie pustej pary nawiasów po ostatnim znaku ciągu. Nie wiem, czy można tego uniknąć bez dodania „,”. przed pętlą i przełączanie kolejności wyjścia w pętli, co powoduje, że program jest dłuższy o dwa bajty.
user59468,
O rany, masz rację. Nie przeczytałem wystarczająco uważnie i uczyniłem ostatnią literę wywołaniem funkcji, tak jak inne.
Alex Howansky
22

05AB1E , 11 bajtów

S'(ý¹g<')×J

Wypróbuj online!

Wyjaśnienie:

S'(ý         join input by "("
    ¹g<      push length of input - 1, call it n
       ')×   push a string with char ")" n times
          J  concatenate
acrolith
źródło
17

Brainfuck, 44 bajty

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

Odczytuje bajt na raz, stawia przed otwartymi paren przed każdym oprócz pierwszego, umieszcza na końcu taką samą liczbę parens.

użytkownik59468
źródło
+++++[->++++++++<],.,[>.>+<<.,]>+>[-<.>]jest nieco krótszy.
Tesseract
16

Haskell, 30 bajtów

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

Przykład użycia: f "Nest a string"-> "N(e(s(t( (a( (s(t(r(i(n(g))))))))))))".

Weź następny znak, a następnie a (, a następnie rekurencyjne połączenie ze wszystkimi znakami oprócz pierwszego, a następnie ).

nimi
źródło
2
Jeśli interpretujemy odpowiedzi jako Haskell, możemy rozwiązać je za pomocą f=Data.List.intersperse '$'! To daje nam f "Nest a string"-> "N$e$s$t$ $a$ $s$t$r$i$n$g".
porglezomp,
Chciałem tylko poinformować, że @fornit (nie ma wystarczającej liczby przedstawicieli, aby skomentować) zaproponował, aby użyć go f[]=[]jako podstawowego przypadku f[x]=[x]. Nie znam Haskella, więc nie wiem, czy jest legalny, czy nie, pozwolę ci osądzić.
Dada
@Dada: to nie zadziała, ponieważ oznaczałoby to dodatkową ()literę za ostatnią literą, np. f "abc"-> "a(b(c()))".
nimi
To również nie obsługuje pustych danych wejściowych. Najkrótsza poprawna wersja mogłem wymyślić jest 44, z różną techniką: f=(++).intersperse '('<*>drop 1.map(\_->')').
Jon Purdy
@JonPurdy: nie musimy obsługiwać pustych danych wejściowych. interspersewymaga import Data.Listkolejnych 17 bajtów.
nimi
16

Galaretka , 9 8 bajtów

-1 bajt dzięki @Dennis (użyj formy, zamiast długości Li powtórz x)

j”(³”)ṁṖ

TryItOnline

W jaki sposób?

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
źródło
3
Btw, ³faktycznie powoduje , że Jelly wypisuje bieżącą wartość zwracaną, więc nigdy nie masz dwóch list znaków.
Dennis
13

Siatkówka , 22 17 bajtów

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

Wypróbuj online!

Alternatywnie:

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

Wyjaśnienie

Zawsze zapominam, że po drodze można drukować różne rzeczy zamiast przekształcać wszystko w końcowy wynik i drukować za jednym razem ...

\1>`.
($&

\Mówi tutaj Retina, aby wydrukowała wynik tego etapu bez podawania końcowego. 1>Jest limit, co oznacza, że pierwszy mecz regex powinny być ignorowane. Jeśli chodzi o sam etap, po prostu zastępuje on każdy znak ( .), z wyjątkiem pierwszego, (po którym następuje ten znak. Innymi słowy, wstawia (pomiędzy każdą parę znaków. W przypadku danych wejściowych abcprzekształca to w (i drukuje)

a(b(c

Pozostało tylko wydrukować nawiasy zamykające:

T`(p`)_

Odbywa się to za pomocą transliteracji która zastępuje (się )i usuwa wszystkie inne druku znaków ASCII z łańcucha.

Martin Ender
źródło
Cholera. Tak szybko ...
mbomb007
@ mbomb007 ... i dalekie od optymalnych. ;)
Martin Ender
13

> <> , 19 18 bajtów

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

Wypróbuj online!

Wyjaśnienie

Pierwszy wiersz to pętla wejściowa, która wypisuje wszystko do ostatniego znaku wejścia (w tym wszystkie () i pozostawia odpowiednią ilość )na stosie:

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.

Po trafieniu w EOF wskaźnik instrukcji kończy się na drugim wierszu i po prostu wykonamy opętlę, drukując wszystko ), aż stos będzie pusty i program się nie wyłączy.

Martin Ender
źródło
12

C #, 32 bajty

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

Ta lambda musi być metodą statyczną, czy musiałbym policzyć dodatkowe bajty dla tego wymagania? Zwykle nie używałbym lambda do rekurencji w C #, ale myślę, że krótsze byłoby nie używanie rekurencji.

/*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
    )
;
mleko
źródło
definicja powinna być zgodna z deklaracją i policzoną
cat
11

J, 13 bajtów

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

J wykonuje się od prawej do lewej, więc używając przysłówka wstawiania /, czasownik może być użyty do zmniejszenia liter ciągu wejściowego.

Stosowanie

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

Możesz obserwować częściowe wyniki między każdą redukcją.

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

Wyjaśnienie

(,'(',,&')')/  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
mile
źródło
9

R, 61 bajtów

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

Regex znajduje i zamienia spacje między znakami na „(”. Następnie cati repdodaje „)” n-1 razy na końcu.

jmartindill
źródło
Może faktycznie odjąć 1 bajt tutaj, eliminując F, podobnie jak dzieje się tak , ponieważ każda pozycja ma już ustawienie domyślne, więc pozostawienie pustego znaku między przecinkami spowoduje użycie domyślnej opcji ignore.case. Ale prawdopodobnie wiedziałeś, że ... Dobra robota!
Sumner18,
8

PowerShell v2 +, 46 bajtów

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

Pobiera ciąg wejściowy, char-array's it, -joins tablicę wraz z otwartymi parens (, a następnie konkatenuje odpowiednią liczbę zamkniętych parens ).

AdmBorkBork
źródło
8

Acc !! , 129 bajtów

Nieźle jak na dość gadatliwą Tarpit Turinga ...

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
}

(Tak, wszystkie te białe znaki są obowiązkowe).

Uwaga: z powodu ograniczeń wejściowych Acc !! , nie można odczytać dowolnego ciągu znaków bez ogranicznika końcowego. Dlatego ten program oczekuje, że wejście (standardowe wejście) jest ciągiem, po którym następuje znak tabulacji.

Acc !! ?

To język, który stworzyłem, który wydaje się być bezużyteczny . Jedynym typem danych są liczby całkowite, jedyną konstrukcją przepływu sterującego jest Count x while ypętla, a jedynym sposobem przechowywania danych jest pojedynczy akumulator _. Dane wejściowe i wyjściowe są wykonywane po jednym znaku za pomocą wartości specjalnej Ni Writeinstrukcji. Pomimo tych ograniczeń jestem pewien, że Acc !! jest ukończony przez Turinga.

Wyjaśnienie

Podstawowa strategia w Acc !! programowanie polega na użyciu %dzielenia mod i liczb całkowitych, /aby koncepcyjnie podzielić akumulator, umożliwiając mu przechowywanie wielu wartości jednocześnie. W tym programie wykorzystujemy trzy takie sekcje: siedem bitów najniższego rzędu ( _%128) przechowuje kod ASCII z wejścia; następny bit ( _/128%2) przechowuje wartość flagi; a pozostałe bity ( _/256) policzą liczbę potrzebnych skróconych części.

Wejście w Acc !! pochodzi ze specjalnej wartości N, która odczytuje pojedynczy znak i ocenia na kod ASCII. Każda instrukcja, która składa się wyłącznie z wyrażenia, przypisuje wynik tego wyrażenia do akumulatora. Zaczynamy więc od zapisania kodu pierwszego znaku w akumulatorze.

_%128zapisze ostatnio przeczytaną postać. Tak więc pierwsza pętla działa, gdy _%128-9jest niezerowa - to znaczy, dopóki obecny znak nie będzie tabulatorem.

Wewnątrz pętli chcemy drukować, ( chyba że wykonamy pierwszą iterację. Ponieważ Acc !! nie ma instrukcji if, musimy używać pętli dla warunkowych. Używamy bitu 128 akumulatora _/128%2, jako wartości flagi. Przy pierwszym przejściu jedyną rzeczą w akumulatorze jest wartość ASCII <128, więc flaga ma wartość 0, a pętla jest pomijana. Przy każdym kolejnym przejściu upewnimy się, że flaga ma wartość 1.

Wewnątrz Count xpętli (ilekroć flaga ma wartość 1), piszemy otwarty paren (ASCII 40) i dodajemy 128 do akumulatora, ustawiając w ten sposób flagę na 0 i wychodząc z pętli. Zdarza się to również, aby zwiększyć wartość _/256, której użyjemy jako naszą sumę przybliżeń do wygenerowania.

Bez względu na wartość flagi piszemy najnowszy znak wejściowy, który jest po prostu _%128.

Następne przypisanie ( _+128-_%128+N) robi dwie rzeczy. Po pierwsze, dodając 128, ustawia flagę po raz kolejny przez pętlę. Po drugie, wyzerowuje _%128miejsce, odczytuje inną postać i zapisuje ją tam. Potem zapętlamy.

Kiedy Count ipętla kończy pracę, właśnie odczytaliśmy znak tabulacji, a wartość akumulatora rozkłada się w następujący sposób:

  • _%128: 9(znak tabulacji)
  • _/128%2: 1(flaga)
  • _/256: liczba odczytanych znaków minus 1

(Minus 1 wynika z tego, że dodajemy 128 do akumulatora tylko raz podczas pierwszego przejścia przez główną pętlę.) Wszystko, czego teraz potrzebujemy, to zbliżenia. Count j while _/256-jpętle _/256razy, za 41każdym razem pisząc ścisły paren (ASCII ). Voila!

DLosc
źródło
8

Java 7,81 79 bajtów

Zapisane 1bajty. Dzięki Kevin.

String f(char[]a,String b,int l){return l<a.length?f(a,b+'('+a[l],++l)+')':b;}
Numberknot
źródło
Ładne podejście rekurencyjne. Krótszy niż for-loop, który miałem opublikować. +1 Dwie rzeczy, na które możesz grać w golfa: l!=a.length-> l<a.lengthi b=b+'('+a[l],++l)+')'-> b+="("+a[l],++l)+")"( -2 bajty )
Kevin Cruijssen
@KevinCruijssen b+="("+a[l],++l)+")"daje 144141148))), a BTW b+"("+a[l],++l)+")"ma rację. i to był bardzo głupi błąd mojego ( !=).
Numberknot
Nie, b+='('+a[l],++l)+')'daje 144141148, ale b+="("+a[l],++l)+")"nie robi. Nawiasy są otoczone cudzysłowami ciągowymi zamiast cudzysłowów znakowych.
Kevin Cruijssen
Publikuję swoją wersję (82 bajty w Javie 7), używając tylko parametru wejściowego String jako parametru. Pełne, ale nie takie złe;) Jeśli znajdziesz coś do zmiany: codegolf.stackexchange.com/a/96745/59739
AxelH
7

APL, 19 bajtów

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

Wyjaśnienie:

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

Alternatywne rozwiązanie, również 19 bajtów:

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

Wyjaśnienie:

{              
              ⍵,⊂⍬  ⍝ 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
źródło
6
Gdzie kupujesz klawiatury dla takiego języka !!!
Ronan Dejhero
@RonanDejhero Być może po prostu ponowne mapowanie klawiszy za pomocą klawiszy Ctrl, Shift, Alt, Capslock, Numlock itp.
Ariana
7

MATL , 16 bajtów

t~40+v3L)7MQ3L)h

Wypróbuj online!

Wyjaśnienie

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
źródło
7

Perl, 25 bajtów

Dzięki @Ton Hospel za grę w golfa na 4 bajty.

24 bajty kodu + -F.

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

Potrzeby -Fi -Eflagi:

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

Zauważ, że jeśli spróbujesz tego na starej wersji Perla, może być konieczne dodanie -aflagi.


Kolejny interesujący sposób (choć nieco dłuższy: 28 bajtów):
Jeszcze raz dziękuję Tonowi Hospelowi za pomoc w poprawieniu tego.

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

(Aby go użyć, umieść kod w pliku i wywołaj go za pomocą echo -n "Hello" | perl nest.pl)

Dada
źródło
Nie potrzebujesz ""po -F. Nie potrzebujesz również, -ljeśli echo -n Hello | program
żądasz,
@TonHospel Racja, zapomniałem (lub nie wiedziałem, nie jestem pewien) o tym zachowaniu -F, dzięki. (Zastanawiałem się, jak uzyskać dane wejściowe bez ostatniego nowego wiersza, również za to dziękuję)
Dada,
perl -F -E '$"="(";say"@F".")"x$#F'
Ton Hospel,
Możesz sprawić, by twój inny pomysł działał z czymś takim s/.(?=.)/s%$'%($&)%/reg, ale oczywiście nie obsługuje ciągów zawierających metaznaki wyrażenia regularnego
Ton Hospel,
@TonHospel Wielkie dzięki za to wszystko! (O drugim, dodałem \Qdo obsługi metaznaków wyrażeń regularnych) :-)
Dada,
6

Rubinowy, 27 bajtów

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

Wyjaśnienie

->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
źródło
6

Perl, 24 23 bajtów

Obejmuje +1 dla -p

Podaj ciąg znaków na STDIN bez znaku nowej linii (lub dodaj -lopcję do programu)

echo -n Hello | nest.pl

nest.pl:

#!/usr/bin/perl -p
$\=")"x s/.(?=.)/$&(/g
Ton Hospel
źródło
6

GNU sed, 37 35 31 bajtów (30 +1 za -rargument)

Czysty roztwór linux sed

:;s/([^(])([^()].*)$/\1(\2)/;t
  1. Nazywanie subskrybcji :; następnie nazywając to rekurencyjniet
  2. Tworzenie 2 grup wyrażeń regularnych:
    • Pierwsza grupa to pierwszy znak dwóch następujących po sobie znaków, które nie są nawiasami
    • Druga grupa to drugi z kolei znak i reszta ciągu do końca linii
  3. Dodaj nawias wokół drugiej grupy \1 ( \2 )

Edycja : Dzięki @manatwork za pomoc w usunięciu 4 znaków!

Tester online

Dzień Sądu Ostatecznego
źródło
2
Używanie tylko 2 grup wydaje się wystarczające. Zdobądź 2 i 3 razem.
manatwork
Och, przepraszam, ale opcje wiersza poleceń niezbędne do zmiany domyślnego zachowania interpretera, aby Twój kod działał, muszą być uwzględnione w liczniku wielkości. Prawie konieczne -edo przekazania kodu do tłumacza jest za darmo. (Ok, sedbez niego też jest szczęśliwy.) Więc za sed -re '…'liczyć +1.
manatwork
1
Puste etykiety są cechą / błędem GNU sed, więc może tytuł powinien być GNU sed.
Riley,
6

Meduza , 19 18 bajtów

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

Znak jest niedrukowalnym znakiem kontrolnym z wartością bajtu 0x1. Wypróbuj online!

Wyjaśnienie

Jest to dość złożony program Meduza, ponieważ wiele wartości jest używanych w wielu miejscach.

  • I jest surowym wejściem, odczytywanym ze STDIN jako ciąg.
  • '(jest dosłowny charakter (.
  • {(Lewa tożsamość) wykonuje '(i Ijak wejść i powraca '(. Zwracana wartość nigdy nie jest faktycznie używana.
  • `jest wątkiem. Zmienia, {aby zwracać znak (dla każdego znaku I, w wyniku czego powstaje ciąg (s o tej samej długości co I.
  • >jest ogonem; pobiera ciąg (s jako dane wejściowe i odcina pierwszy znak.
  • +przyjmuje jako argument ciąg (s i bajt niezadrukowany i dodaje wartość bajtu (1) do każdego znaku. To daje ciąg )s równej długości . Użycie znaku gwarantuje, że zwracana wartość jest łańcuchem, a nie listą liczb całkowitych.
  • W lewym dolnym rogu /pobiera niedrukowalny bajt i zwraca funkcję, która przyjmuje dwa argumenty i łączy drugi argument z pierwszym jeden raz (ponieważ wartość bajtu wynosi 1).
  • _przyjmuje tę funkcję, pobiera argumenty niższe {(które były '(i I) i wywołuje z nimi funkcję. To wstawia znak (między każdą parą znaków w I.
  • ,łączy ten ciąg z ciągiem )s i Pwypisuje wynik.
Zgarb
źródło
5

05AB1E , 22 21 19 18 bajtów

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

Wypróbuj online!

Wyjaśnienie:

¤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
Łukasz
źródło
5

PHP, 63 bajtów

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

Poprzednia wersja 64 bajtów

<?=join("(",$s=str_split($argv[1])).str_pad("",count($s)-1,")");
Jörg Hülsermann
źródło
1
Możesz zapisać dwa bajty, używając <?=zamiast echo i kolejny, jeśli ustawisz $ s na wynik str_splitpołączenia zamiast $argv[1], a następnie użyj count($s)zamiaststrlen($s)
Alex Howansky
2
63 bajty: <?=str_pad(join("(",$s=str_split($argv[1])),count($s)*3-2,")");- wordwrappobiłby kombinację podziału / łączenia, ale niestety nie udaje się, jeśli dane wejściowe zawierają spacje.
Tytus
@Titus fajna alternatywa Dziękujemy
Jörg Hülsermann
4

Vim, 17 bajtów

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

Przechodzi od końca do początku, ponieważ w przeciwnym razie potkniesz się o )napisane wcześniej. Używa hazamiast izawieść, gdy osiągnie początek.

Zwykle nie robiłbyś dwóch osobnych wstawek w ten sposób; zrobiłbyś coś, C()<Esc>Pby uratować udar. Tym razem pozycjonowanie nie działa tak dobrze.

udioica
źródło
Możesz używać <End>klawisza w trybie wstawiania zamiast wychodzić z trybu wstawiania i robićA
BlackCap
@BlackCap To nie jest bajt. Musiałbym liczyć uderzenia zamiast bajtów. (A Vimgolf jest lepszą grą, gdy banujesz klawisze kursora, choć różnica tutaj jest trywialna.)
udioica
4

Brain-Flak 103 97 bajtów

Zawiera +3 dla -c

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

Wypróbuj online!


Wyjaśnienie:

#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
źródło
Pokonaj mnie do tego. +1
DJMcMayhem
Hmm Myślałem, że ponowne użycie 40, aby uniknąć ponownego pchnięcia dużej liczby całkowitej, pozwoliłoby ci zaoszczędzić dużo bajtów, ale najlepsze, co mogę wymyślić, {({}<><(((((()()){}()){}){}){})>)<>}<>({}<(({})<>())><>)([]){({}[()()]<(<>({})<>)>)}{}{}{({}<>)<>}<>{}to dwa bajty dłuższe ...
DJMcMayhem
Dzięki, że wpadłeś na pomysł ponownego użycia 40. Zredukowałem go do 95 + 3. Dlaczego -aw Brain-Flak są to 3 bajty ?
Riley,
Dobra robota! +3Bajtów jest norma na specjalne flagi linii poleceń . Co jest niefortunne, ale mogę się z tym pogodzić. Właściwie zastanawiałem się, jak to skrócić, ale nie jestem jeszcze pewien, jak to zrobić.
DJMcMayhem
Czy zwykle nie są to 2 bajty? jeden za -i jeden za flagę? Możesz mieć flagę do normalnego wykonania, tak jak robi to Perl -e. W ten sposób będzie to tylko 1 dodatkowy bajt.
Riley,
4

Dyalog APL , 14 bajtów

⊃{⍺,1⌽')(',⍵}/

to jest na szczycie od i{ }/

(zdobądź pierwszy element) zostanie zastosowane po { }/(redukcji lambda)

⍺,1⌽')(',⍵- lewy argument ( ) połączony z ( ,) obrotem o jeden element w lewo ( 1⌽) ciągu ')('połączonego z ( ,) prawy argument ( )

zmniejszenie fałd APL od prawej do lewej, zgodnie z wymaganiami tutaj

ngn
źródło
3

> <> , 37 bajtów

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

Rząd po rzędzie

  1. Wypycha każdy znak z wejścia za każdym razem z nawiasem otwierającym
  2. Usuwa EOF i ostatni nawias otwierający i przesuwa długość stosu
  3. Wykorzystuje porównanie z połową długości stosu, aby przesunąć nawias zamykający
  4. Drukuje zawartość stosu

Wypróbuj online!

Emigna
źródło