Bir dizgiyi "işlev yuvasına" eklemek için şunları yapmalısınız:

• İlk karaktere bir işlev olarak ve aşağıdaki karakterlere o işlevin argümanları gibi davranın. Örneğin, giriş dizgisi Helloöyleyse, ilk adım şöyle olacaktır:

  H(ello)
  

• Ardından, bu aynı adımı her alt dize için tekrarlayın. Yani biz alırız:

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

Görevin bir dize "işlevi yuvalayan" bir program veya işlev yazmaktır. Örneğin, girdi dizesi Hello world!öyleyse, çıktı vermelisiniz:

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

Giriş yalnızca yazdırılabilir ASCII içerecektir ve girişi ve çıkışı herhangi bir makul formatta alabilirsiniz. Örneğin, STDIN / STDOUT, fonksiyon argümanları ve dönüş değeri, bir dosyayı okuma ve yazma vb.

Basitlik uğruna, girişin parantez içermeyeceğini ve boş olmayacağını da varsayabilirsiniz.

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)

Her zaman olduğu gibi, tüm varsayılan kurallarımız ve boşluklarımız geçerlidir ve bayt cinsinden atılan en kısa cevap kazanır!

Python, 41 39 34 bayt

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

Ideone

Oldukça kendini açıklayıcı.

Diğer her karakterin arasına bir parantez koyar, daha sonra sonuna uzunluk parantezinden bir küçük harf ekler.

MS-DOS .com dosyası, 30 bayt

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

Dize, komut satırını kullanarak yürütülebilir dosyaya iletilir. (.COM dosya adı ile dize arasında bir boşluk karakteri).

Sonuç standart çıktıya yazılır.

Sökme burada:

  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

Not: Bir "RET" talimatı kullanarak bir DOS .COM dosyasından (EXE başlıklarına sahip dosyaların aksine) çıkabilirsiniz.

JavaScript (ES6), 40 34 33 bayt

ETHproductions sayesinde 6 byte kurtarıldı

Özyinelemeli bir işlev.

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

Çevrimiçi deneyin!

Brainfuck, 42 40 bayt

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

Çevrimiçi deneyin!

Ungolfed:

>+[-->+[<]>-]>+     # count to 40 (ASCII for open paren)
>>                  # move to the input holder
,.                  # input the first byte and output it
,                   # input the next byte
[                   # while it's not zero
  <+                # move to the input counter and increment it
  <.                # move to the open paren and output it
  >>.               # move to the input holder and output it
  ,                 # input the next byte
]
<<+                 # move to the open paren and increment it to a close
>                   # move to the input counter
[                   # while it's not zero
  -                 # decrement it
  <.                # move to the close paren and output it
  >                 # move to the input counter
]

05AB1E , 11 bayt

S'(ý¹g<')×J

Çevrimiçi deneyin!

Açıklama:

S'(ý         join input by "("
    ¹g<      push length of input - 1, call it n
       ')×   push a string with char ")" n times
          J  concatenate

Brainfuck, 44 bayt

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

Her seferinde bir bayt okur, birincisi hariç her birinin önüne bir açık-paren koyar, sonuna aynı yakın-parenleri koyar.

Haskell, 30 bayt

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

Kullanım örneği: f "Nest a string"-> "N(e(s(t( (a( (s(t(r(i(n(g))))))))))))".

Bir sonraki karaktere geçin, ardından a (, ardından ilk karakter hariç tümü ile özyinelemeli bir çağrı yapın, ardından a ).

Jöle , 9 8 bayt

@Dennis sayesinde -1 bayt (kalıp kullanın ṁ, uzunluk yerine Lve tekrarlayın x)

j”(³”)ṁṖ

TryItOnline

Nasıl?

j”(³”)ṁṖ - Main link: s     e.g. "code-golf"           printed output:
j        - join s with
 ”(      - literal '('           "c(o(d(e(-(g(o(l(f"
    ”)   - literal ')'
      ṁ  - mould like
   ³     - first input, s        ")))))))))"
         - causes print with no newline of z:          c(o(d(e(-(g(o(l(f
       Ṗ - pop (z[:-1])          "))))))))"            c(o(d(e(-(g(o(l(f
         - implicit print                              c(o(d(e(-(g(o(l(f))))))))

Retina , 22 17 bayt

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

Çevrimiçi deneyin!

Alternatif:

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

açıklama

Her şeyi nihai sonuca dönüştürmek ve bir defada çıkarmak yerine, yol boyunca malzeme basmanın mümkün olduğunu her zaman unutuyorum ...

\1>`.
($&

Burada \, Retina'ya bu aşamanın sonucunu izleyen bir satır beslemesi olmadan basmasını söyler. 1>Regex ilk maçı göz ardı edilmesi anlamına gelir bir sınırdır. Sahnenin kendisine gelince, onu izleyen .ilk karakter hariç, her bir karakteri ( ) değiştirir (. Başka bir deyişle, (her karakter çifti arasına girer . Giriş için abc, bu onu dönüştürür (ve yazdırır)

a(b(c

Geriye kalan tek şey kapanış parantezlerini yazdırmaktır:

T`(p`)_

Bu yerini alan bir transliteration ile yapılır (ile )ve ipten diğer tüm yazdırılabilir ASCII karakterleri siler.

> <> , 19 18 bayt

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

Çevrimiçi deneyin!

açıklama

İlk satır, her şeyi girişin son karakterine kadar (tümü de dahil olmak üzere () basan )ve istifin üzerine doğru miktarda bırakan bir giriş döngüsüdür :

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.

EOF'a bastığımızda, komut işaretçisi ikinci satırda sona erer ve yığın boş olana ve program bitene kadar, ohepsini basan basitçe bir döngüde )yürütürüz.

C #, 32 bayt

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

Bu lambda statik bir yöntem olmalı, bu gereksinim için fazladan bayt saymam gerekir mi? Normalde C # 'da özyineleme için bir lambda kullanmazdım, ama sonra özyinelemeyi kullanmamanın daha kısa olacağını düşünüyorum.

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

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

J sağdan sola yürütülür /, böylece insert zarfını kullanarak , giriş dizesinin harflerini azaltmak için bir fiil kullanılabilir.

kullanım

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

Her azaltma arasındaki kısmi çıktıları gözlemleyebilirsiniz.

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

açıklama

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

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

Regex, karakterleri arasındaki boşlukları bulur ve değiştirir (". Sonra da catve repsonunda") "ile 1 kez ekler.

PowerShell v2 +, 46 bayt

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

Giriş dizesini alır - dizi, açık charparenler -joinile birlikte dizidir (, ardından uygun sayıda kapalı paren üzerinde birleştirilir ).

Acc !! , 129 bayt

Oldukça ayrıntılı bir Turing tarpit için fena değil ...

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
}

(Evet, bütün bu boşluklar zorunludur.)

Not: çünkü giriş sınırlamaları Acc !! , bazı sınırlayıcılar olmadan rastgele bir karakter dizisi okumak mümkün değildir. Bu nedenle, bu program girişi (stdin'de) bir sekme karakteri izleyen bir dizge olarak bekler.

Acc !! ?

Oluşturduğum bir dil sadece kullanılamaz görünüyor . Sadece veri tipi tamsayılar, tek kontrol akışı yapısı Count x while ydöngüdür ve veri depolamanın tek yolu tek bir akümülatördür _. Giriş ve çıkış, özel değer Nve Writedeyim kullanılarak bir defada bir karakter yapılır . Bu sınırlamalara rağmen, eminim ki Acc !! Turing tamamlandı.

açıklama

Acc temel strateji ! programlama, akümülatörü kavramsal olarak bölümlere ayırmak için mod %ve tamsayı bölmesini kullanmak ve /aynı anda birden fazla değeri saklamasını sağlamaktır. Bu programda, bu tür üç bölüm kullanıyoruz: en düşük dereceli yedi bit ( _%128) girdiden bir ASCII kodu depolar; sonraki bit ( _/128%2) bir bayrak değeri saklar; ve kalan bitler ( _/256) ihtiyaç duyacağımız yakın-ebeveynlerin sayısını.

Acc Giriş !! Ntek bir karakter okuyan ve ASCII kodunu değerlendiren özel değerden gelir . Yalnızca bir ifadeden oluşan herhangi bir ifade, bu ifadenin sonucunu akümülatöre atar. Böylece ilk karakterin kodunu aküde saklayarak başlıyoruz.

_%128En son okunan karakteri saklar. Bu yüzden ilk döngü _%128-9sıfır değilken , yani geçerli karakter bir sekme olana kadar çalışır .

İlk döngüde ( olmadıkça döngü içinde yazdırmak istiyoruz . Acc beri ! if deyimi yok, koşullamalar için döngüler kullanmalıyız. Akünün 128 bitini _/128%2bayrak değeri olarak kullanırız. İlk geçişte, akümülatördeki tek şey bir ASCII değeri <128'dir, bu nedenle bayrak 0'dır ve döngü atlanır. Sonraki her pasta, bayrağın 1 olduğundan emin olacağız.

İçinde Count xdöngü (bayrak olduğunda 1), açık bir parantez (ASCII yazma 40) ve böylece 0'a bayrağını ayarlama ve döngüsünden çıkar, akümülatör için 128 ekleyin. Bu aynı zamanda _/256, çıkacak olan yakın-parilerimiz olarak kullanacağımızın değerini de arttırır.

Bayrağın değeri ne olursa olsun, basitçe en son girdi karakterini yazıyoruz _%128.

Bir sonraki atama ( _+128-_%128+N) iki şey yapar. İlk olarak, 128 ekleyerek, bayrağını bir sonraki kez döngüden geçirir. İkincisi, _%128yuvayı sıfırlar , başka bir karakter okur ve orada saklar. Ardından döngü.

Ne zaman Count idöngüden çıkılır, biz sadece bir sekme karakteri okudum ve akümülatör değeri böyle yıkar:

• _%128: 9(sekme karakteri)
• _/128%2: 1(bayrak)
• _/256: okunan karakter sayısı, eksi 1

(Eksi 1, ana döngüden ilk geçişte aküye sadece bir kez 128 eklediğimiz için.) Şimdi tek ihtiyacımız olan yakın parenler. her seferinde bir yakın-paren (ASCII ) yazan zamanlar, Count j while _/256-jdöngüler . İşte bu kadar!_/25641

Java 7,81 79 bayt

1Bayt kaydedildi. Kevin'e teşekkürler.

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

APL, 19 bayt

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

Açıklama:

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

Alternatif çözüm, ayrıca 19 bayt:

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

Açıklama:

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

t~40+v3L)7MQ3L)h

Çevrimiçi deneyin!

açıklama

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 bayt

@Ton Hospel'e teşekkürler4 byte'lık golf .

Kod + 24 bayt -F.

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

İhtiyaçlar -Fve -Ebayraklar:

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

Bunu eski bir perl sürümünde denerseniz, eklemeniz gerekebilir. -a bayrak .

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

(Kullanmak için, kodu bir dosyanın içine koyun ve arayın echo -n "Hello" | perl nest.pl)

Ruby, 27 bayt

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

açıklama

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

İçin +1 içerir -p

Yeni bir satır olmadan STDIN'de dize verin (veya -lprograma bir seçenek ekleyin )

echo -n Hello | nest.pl

nest.pl:

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

GNU sed, 37 35 31 bayt ( -rbağımsız değişken için 30 +1 )

Saf linux sed çözümü

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

1. Taahhüdün isimlendirilmesi : ; sonra yinelemeli olarak arayarakt
2. 2 regex grubu oluşturma:
   • Birinci grup, parantez olmayan iki ardışık karakterin ilk karakteridir.
   • İkinci grup, art arda ikinci karakter ve satırın sonuna kadar dizenin geri kalanıdır.
3. İkinci grubun etrafına parantez ekle \1 ( \2 )

Düzenleme : 4 karakterin kaldırılmasına yardımcı olduğu için @ manatwork'e teşekkürler!

Çevrimiçi test

Denizanası , 19 18 bayt

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

Karakter ␁bayt değeri Yazdırılamaz kontrol karakteridir 0x1. Çevrimiçi deneyin!

açıklama

Bu oldukça karmaşık bir Denizanası programıdır, çünkü birçok değer birçok yerde kullanılır.

• I ham girdi, STDIN'den bir dize olarak okunur.
• '(karakter değişmezidir (.
• {(Sol özdeşlik) alır '(ve Igirişler ve döner gibi '(. Dönüş değeri asla kullanılmaz.
• `iş parçacığı. Her {karakteri (için bir karakter döndürmek üzere değiştirilir ve aynı uzunlukta bir s Idizesiyle sonuçlanır .(I
• >kuyruk; (s dizesini girdi olarak alır ve ilk karakteri keser.
• +argüman olarak (s dizesini ve yazdırılamaz baytı alır ve her karaktere bayt değerini (1) ekler. Bu eşit uzunlukta bir )s dizisi verir . Karakterin kullanılması, ␁dönüş değerinin bir tamsayı listesi değil bir dize olduğunu garanti eder.
• Sol alt köşede, /yazdırılamayan baytı alır ve iki argüman alan bir işlev döndürür ve ikinci argümanı birinciyle birleştirir (bayt değeri 1 olduğundan).
• _bu işlevi alır, aşağı olanın argümanlarını alır {(hangisi '(ve I) ve onlarla birlikte işlevsellik çağırır. Bu, karakteri (her karakterin arasına ekler I.
• ,bu dizeyi )s dizesiyle birleştirir Pve sonucu yazdırır.

05AB1E , 22 21 19 18 bayt

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

Çevrimiçi deneyin!

Açıklama:

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

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

Önceki sürüm 64 Bayt

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

Vim, 17 bayt

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

Baştan sona gider, çünkü aksi halde )zaten yazdığınız s üzerinde gezersiniz. Başına ulaştığında başarısız olmak hayerine kullanır i.

Genellikle, bunun gibi iki ayrı ek yapmazsınız; C()<Esc>PBir vuruş kaydetmek gibi bir şey yapardın . Ancak konumlandırma bu seferde işe yaramıyor.

Brain-Flak 103 97 Bayt

-C için +3 içerir

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

Çevrimiçi Deneyin!

Açıklama:

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

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

Bu bir olduğunu tepesine arasında ⊃ve{ }/

⊃(ilk eleman alın) sonra uygulanacaktır { }/(bir lambda'nın azaltılması)

⍺,1⌽')(',⍵- sol argümanı ( ⍺) ( ) ile birleştirilmiş, ,bir elemanın döndürdüğü , ( ) ile sağ argüman ( ) ile birleştirilen 1⌽dizenin soluna ( )')(',⍵

APL'deki azalma burada gerektiği gibi sağdan sola kıvrılıyor

Dışbükey , 10 bayt

_'(*\,(')*

Çevrimiçi deneyin!

> <> , 37 bayt

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

Sıra sıra

1. Her bir char'i her birinden sonra açıklık paranteziyle girdiden iter
2. EOF ve son açılış parantezini kaldırır ve istif uzunluğunu iter
3. Kapatma parantezini itmek için istif uzunluğunun yarısı ile bir karşılaştırma yapar
4. Yığının içeriğini yazdırır

Çevrimiçi deneyin!