문자열을 "함수 중첩"하려면 다음을 수행해야합니다.

• 첫 번째 문자를 함수로, 다음 문자를 해당 함수의 인수로 취급하십시오. 예를 들어 입력 문자열이 Hello인 경우 첫 번째 단계는 다음과 같습니다.

  H(ello)
  

• 그런 다음 모든 하위 문자열에 대해 동일한 단계를 반복하십시오. 그래서 우리는 얻는다 :

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

당신의 임무는 문자열을 "함수 중첩"하는 프로그램이나 함수를 작성하는 것입니다. 예를 들어 입력 문자열이 인 Hello world!경우 다음을 출력해야합니다.

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

입력은 인쇄 가능한 ASCII 만 포함 하며 입력과 출력을 합리적인 형식으로 가져올 수 있습니다. 예를 들어 STDIN / STDOUT, 함수 인수 및 반환 값, 파일 읽기 및 쓰기 등

간단하게하기 위해 입력에 괄호가없고 비어 있지 않은 것으로 가정 할 수도 있습니다.

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)

평소와 같이 모든 기본 규칙과 허점이 적용되며 가장 짧은 답은 바이트로 표시됩니다!

파이썬, 41 39 34 바이트

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

그것을 취소

꽤 자명하다.

다른 모든 문자 사이에 괄호를 넣은 다음 길이 괄호보다 하나를 끝에 추가합니다.

MS-DOS .com 파일, 30 바이트

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

문자열은 명령 행을 사용하여 실행 파일로 전달됩니다. .COM 파일 이름과 문자열 사이에 공백이 하나 있습니다.

결과는 표준 출력에 기록됩니다.

분해는 여기 있습니다 :

  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

참고 : "RET"명령을 사용하여 EXE 헤더가있는 파일과 달리 DOS .COM 파일을 종료 할 수 있습니다.

자바 스크립트 (ES6), 40 34 33 바이트

ETH 프로덕션 덕분에 6 바이트 절약

재귀 함수

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

온라인으로 사용해보십시오!

Brainfuck, 42 40 바이트

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

온라인으로 사용해보십시오!

언 골프 드 :

>+[-->+[<]>-]>+     # 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 바이트

S'(ý¹g<')×J

온라인으로 사용해보십시오!

설명:

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

Brainfuck, 44 바이트

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

한 번에 바이트를 읽고 첫 번째를 제외하고 각각의 앞에 열려있는 paren을두고 끝에 같은 수의 close-parens를 씁니다.

하스켈, 30 바이트

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

사용 예 : f "Nest a string"-> "N(e(s(t( (a( (s(t(r(i(n(g))))))))))))".

다음 문자를 가져온 다음 (, 첫 번째 문자를 제외한 모든 문자를 사용한 재귀 호출, 다음에 ).

젤리 , 9 8 바이트

바이트 -1 @Dennis에 감사 (이용 금형 ṁ의 길이 대신에 L, 및 반복 x)

j”(³”)ṁṖ

TryItOnline

어떻게?

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

망막 , 22 17 바이트

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

온라인으로 사용해보십시오!

또는

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

설명

나는 모든 것을 최종 결과로 변환하고 한 번에 출력하는 대신 길을 따라 물건을 인쇄하는 것이 가능하다는 것을 항상 잊어 버립니다 ...

\1>`.
($&

여기 \뒤에 줄 바꿈하지 않고이 단계의 결과를 인쇄하는 망막을 알려줍니다. 이 1>제한은 정규식의 첫 번째 일치를 무시해야 함을 의미합니다. 스테이지 자체 .는 첫 번째 문자를 제외한 각 문자 ( )를 해당 문자로 대체합니다 (. 즉, (각 문자 쌍 사이에 삽입 됩니다. input의 경우 abc,이를 변환하고 인쇄합니다.

a(b(c

남은 것은 닫는 괄호를 인쇄하는 것입니다.

T`(p`)_

이것은 대체하는 음역으로 이루어집니다 (로 )하고, 문자열에서 다른 모든 인쇄 가능한 ASCII 문자를 삭제합니다.

> <> , 19 18 바이트

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

온라인으로 사용해보십시오!

설명

첫 번째 줄은 입력 루프로 입력의 마지막 문자까지 모든 것을 인쇄하고 (모두 포함 () )스택에 올바른 양을 남깁니다 .

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에 도달하면 명령 포인터가 두 번째 줄에서 끝나고 스택이 비어 있고 프로그램 오류가 발생할 때까지 o모든을 인쇄하여 루프로 실행 )합니다.

C #, 32 바이트

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

이 람다는 정적 방법이어야합니다. 요구 사항에 대한 추가 바이트를 계산해야합니까? 일반적으로 C #에서는 재귀에 람다를 사용하지 않지만 재귀를 사용하지 않는 것이 더 짧을 것이라고 생각합니다.

/*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 바이트

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

J는 오른쪽에서 왼쪽으로 실행되므로 insert adverb /를 사용하면 동사를 사용하여 입력 문자열의 문자를 줄일 수 있습니다.

용법

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

각 감소 사이의 부분 출력을 관찰 할 수 있습니다.

   |. f\. 'Hello'
o            
l(o)         
l(l(o))      
e(l(l(o)))   
H(e(l(l(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

R, 61 바이트

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

정규식을 찾아 "(". 다음과 문자 사이의 공백을 대체 cat하고 rep마지막에 N-1 회 추가 ")".

PowerShell v2 +, 46 바이트

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

입력 문자열을 취하고 char-array가 다야 -join열린 괄호 함께 배열 S는 (다음 닫힌 괄호의 해당 번호에 연접 ).

Acc !! 129 바이트

상당히 장황한 Turing tarpit에 나쁘지 않습니다 ...

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
}

(예, 모든 공백은 필수입니다.)

참고 : Acc !! 의 입력 제한으로 인해 끝 구분 기호없이 임의의 문자열을 읽을 수 없습니다. 따라서이 프로그램은 stdin의 입력을 문자열과 탭 문자로 예상합니다.

Acc !! ?

내가 사용할 수없는 것처럼 보이는 언어 입니다. 유일한 데이터 유형은 정수이고, 유일한 제어 흐름 구성은 Count x while y루프이며, 데이터를 저장하는 유일한 방법은 단일 누산기 _입니다. 입력 및 출력은 특수 값 N과 Write명령문을 사용하여 한 번에 한 문자 씩 수행됩니다 . 이러한 제한에도 불구하고, 나는 Acc! 튜링 완료입니다.

설명

Acc 의 기본 전략 !! 프로그래밍은 mod %및 integer 나누기 를 사용 /하여 누산기를 개념적으로 분할하여 여러 값을 한 번에 저장할 수 있습니다. 이 프로그램에서는 다음과 같은 세 가지 섹션을 사용합니다. 최하위 7 비트 ( _%128)는 입력에서 ASCII 코드를 저장합니다. 다음 비트 ( _/128%2)는 플래그 값을 저장하고; 나머지 비트 ( _/256)는 우리가 필요로하는 close-parens의 수를 센다.

Acc로 입력 !! N단일 문자를 읽고 ASCII 코드로 평가 하는 특수 값에서 가져옵니다 . 식으로 만 구성된 모든 명령문은 해당 식의 결과를 누산기에 할당합니다. 첫 번째 문자 코드를 누산기에 저장하는 것으로 시작합니다.

_%128가장 최근에 읽은 문자를 저장합니다. 따라서 첫 번째 루프 _%128-9는 0이 아닌 동안 , 즉 현재 문자가 탭이 될 때까지 실행됩니다 .

루프 내에서 첫 번째 반복이 ( 아닌 한 인쇄하고 싶습니다 . Acc 이후로 !! if 문이 없으면 조건문에 루프를 사용해야합니다. 128 비트 누산기를 _/128%2플래그 값으로 사용합니다. 첫 번째 패스에서 누산기의 유일한 것은 ASCII 값 <128이므로 플래그는 0이고 루프는 건너 뜁니다. 이후 모든 패스에서 플래그가 1인지 확인합니다.

Count x루프 내에서 (플래그가 1 일 때마다) 열린 paren (ASCII 40)을 작성하고 누산기에 128을 추가하여 플래그를 0으로 설정하고 루프를 종료합니다. 이것은 또한 값을 증가 _/256시키는데,이 값 은 근접 패런의 집계로 출력됩니다.

플래그 값에 관계없이 가장 최근의 입력 문자를 작성합니다 _%128.

다음 과제 ( _+128-_%128+N)는 두 가지 일을합니다. 먼저 128을 추가하여 루프를 통해 다음에 플래그를 설정합니다. 둘째, _%128슬롯을 0으로 만들고 다른 문자를 읽고 거기에 저장합니다. 그런 다음 반복합니다.

Count i루프가 종료 되면 탭 문자를 읽었으며 누산기 값이 다음과 같이 분류됩니다.

• _%128:( 9탭 문자)
• _/128%2:( 1깃발)
• _/256: 읽은 문자 수-1 빼기

마이너스 1은 메인 루프를 통과하는 첫 번째 패스 동안 누산기에 128을 한 번만 추가하기 때문입니다. 이제 필요한 것은 클로즈 패런입니다. 매번 클로즈-패런 (ASCII )을 작성하여 Count j while _/256-j반복 합니다. 짜잔!_/25641

자바 7,81 79 바이트

1바이트를 저장 했습니다. kevin에게 감사합니다.

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

APL, 19 바이트

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

설명:

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

대체 솔루션, 19 바이트 :

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

설명:

{              
              ⍵,⊂⍬  ⍝ 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 바이트

t~40+v3L)7MQ3L)h

온라인으로 사용해보십시오!

설명

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

펄, 25 바이트

4 바이트 를 골라 낸 @Ton Hospel 에게 감사 합니다.

24 바이트의 코드 + -F.

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

요구 -F와 -E깃발 :

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

이전 버전의 perl에서이 작업을 시도하면 -a플래그 를 추가해야 할 수도 있습니다 .

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

(사용하려면 코드를 파일 안에 넣고로 호출하십시오 echo -n "Hello" | perl nest.pl)

루비, 27 바이트

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

설명

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

펄, 24 23 바이트

에 +1 포함 -p

줄 바꿈 없이 STDIN에 문자열을 제공하십시오 (또는 -l프로그램에 옵션을 추가하십시오 )

echo -n Hello | nest.pl

nest.pl:

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

GNU sed, 37 35 31 바이트 ( -r인수의 경우 30 +1 )

순수한 리눅스 sed 솔루션

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

1. 대체 이름 지정 :; 그런 다음 재귀 적으로 호출t
2. 정규식 그룹 2 개 만들기 :
   • 첫 번째 그룹은 괄호 가 아닌 두 개의 연속 문자 중 첫 번째 문자입니다.
   • 두 번째 그룹은 두 번째 연속 문자이며 줄 끝까지 문자열의 나머지 부분입니다.
3. 두 번째 그룹 주위에 괄호를 추가하십시오 \1 ( \2 )

편집 : 4 개의 문자를 제거하는 데 도움을 주신 @manatwork에게 감사합니다!

온라인 테스터

해파리 , 19 18 바이트

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

문자 ␁는 바이트 값을 가진 인쇄 할 수없는 제어 문자입니다 0x1. 온라인으로 사용해보십시오!

설명

여러 장소에서 많은 값이 사용되기 때문에 이것은 매우 복잡한 해파리 프로그램입니다.

• I STDIN에서 문자열로 읽은 원시 입력입니다.
• '(문자 리터럴 (입니다.
• {(왼쪽 정체성) 소요 '(및 I입력, 반환 등 '(. 리턴 값은 실제로 사용되지 않습니다.
• `스레드입니다. 의 각 문자에 대한 {문자를 반환하도록 수정 하여와 길이가 같은의 문자열을 만듭니다.(I(I
• >꼬리입니다. (s 문자열을 입력으로 받아 첫 번째 문자를 잘라냅니다.
• +(s 의 문자열 과 인쇄 할 수없는 바이트 를 인수로 취하여 각 문자에 바이트 값 (1)을 추가합니다. 이것은 같은 길이의 문자열을 제공합니다 ). 문자를 사용하면 ␁반환 값이 정수 목록이 아닌 문자열이됩니다.
• 왼쪽 하단 /에서 인쇄 할 수없는 바이트 를 가져 와서 두 개의 인수를 취하는 함수 를 리턴하고 두 번째 인수를 첫 번째 인수와 결합합니다 (바이트 값이 1이므로).
• _이 함수를 사용하여 하한 {( '(및 I) 의 인수를 잡고 함수를 호출합니다. 그러면의 (모든 문자 쌍 사이 에 문자 가 삽입 됩니다 I.
• ,이 문자열을 )s 문자열과 연결 P하고 결과를 인쇄합니다.

05AB1E , 22 21 19 18 바이트

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

온라인으로 사용해보십시오!

설명:

¤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 바이트

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

이전 버전 64 바이트

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

Vim, 17 바이트

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

그렇지 않으면 )이미 작성한 것을 넘어서 넘어 가기 때문에 끝에서 처음으로갑니다 . 처음에 도달 할 때 실패하는 ha대신 사용 합니다 i.

일반적으로 이와 같이 두 개의 별도 인서트를 수행하지 않습니다. C()<Esc>P스트로크를 저장하는 것과 같은 작업을 수행합니다 . 그러나 이번에는 포지셔닝이 제대로 작동하지 않습니다.

Brain-Flak 103 97 바이트

-c에 +3 포함

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

온라인으로 사용해보십시오!

설명:

#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 바이트

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

이것은 꼭대기 에 ⊃있고{ }/

⊃( { }/람다의 감소) 후에 ( 첫번째 요소를 얻음)이 적용됩니다.

⍺,1⌽')(',⍵- 왼쪽 인자 ( ⍺(와 연결) ,)를 좌측으로 하나 개의 원소에 의해 회전 ( 1⌽문자열) ')('(와 연결된 ,오른쪽 인자 () ⍵)

여기에서 필요에 따라 오른쪽에서 왼쪽으로 APL 접기 감소

볼록형 , 10 바이트

_'(*\,(')*

온라인으로 사용해보십시오!

> <> , 37 바이트

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

행마다

1. 입력 후 각 문자를 여는 괄호로 밀어냅니다.
2. EOF와 마지막 여는 괄호를 제거하고 스택 길이를 푸시합니다
3. 스택 길이의 절반과 비교하여 닫는 괄호를 사용합니다.
4. 스택의 내용을 인쇄합니다

온라인으로 사용해보십시오!