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!

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.

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

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!

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
]

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

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.

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

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

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.

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

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

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

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.

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

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!

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

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
                   }

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

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.

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

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

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

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

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.

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

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,")");

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.

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 (

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

Wypukły , 10 bajtów

_'(*\,(')*

Wypróbuj online!

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