이 도전 을 도와 주신 @KritixiLithos에게 감사드립니다 !

V 는 코드 골프 과제에 vim을 사용하고 확장 할 수 있도록 작성한 프로그래밍 언어입니다. 첫 번째 커밋 은 2016 년 3 월 3 일에 이루어졌으며, 오늘날 V는 1 살이되었습니다. 우후

V의 첫해에 걸쳐 4 명의 다른 기여자로부터 176 개의 커밋이 있었고, 12 명의 다른 사용자로부터 140 개의 답변이 있으며 , 너무 많은 깨진 중복 연산자로 계산할 수 없습니다 . @Dennis가 관대하게 호스팅 하는 온라인 통역사 가 12 월 이후 거의 8,000 회 운영되었습니다 .

V의 생일을 축하하기 위해 도전합시다! V의 대부분의 기능은 문자열 조작과 아스키 아트 를 염두에두고 설계되었으므로 V를 축하하는 모든 과제는 아스키 아트에 관한 것이어야합니다. 따라서 오늘 당면 과제는 단어를 입력으로 받아 해당 단어를 V 모양으로 바꾸는 것입니다. 예를 들어 입력 "Hello"는 다음 V를 제공해야합니다.

Hello         olleH
 Hello       olleH
  Hello     olleH
   Hello   olleH
    Hello olleH
     HellolleH
      HellleH
       HeleH
        HeH
         H

V의 모양에 대한 자세한 내용은 다음과 같습니다. 입력 문자열의 길이 가 n 자인 경우 V의 n*2행은 커야합니다. 첫 번째 줄은 다음으로 구성되어야합니다.

<input string><(n*2) - 1 spaces><input string reversed>

각각의 줄 바꿈에서 한 칸의 공백이 시작 부분에 추가되고 문자열의 양쪽이 서로를 향해 이동하여 겹치는 문자를 제거합니다. 입력의 첫 문자 인 마지막 줄까지. 각 줄의 후행 공백은 허용되며 후행 줄 바꿈도 허용됩니다.

공백이없는 입력은 항상 인쇄 가능한 ASCII 라고 가정 할 수 있으며 합리적인 방법으로 입력 및 출력 할 수 있습니다. 다음은 더 많은 샘플 입력입니다.

Happy:

Happy         yppaH
 Happy       yppaH
  Happy     yppaH
   Happy   yppaH
    Happy yppaH
     HappyppaH
      HapppaH
       HapaH
        HaH
         H

Birthday:

Birthday               yadhtriB
 Birthday             yadhtriB
  Birthday           yadhtriB
   Birthday         yadhtriB
    Birthday       yadhtriB
     Birthday     yadhtriB
      Birthday   yadhtriB
       Birthday yadhtriB
        BirthdayadhtriB
         BirthdadhtriB
          BirthdhtriB
           BirthtriB
            BirtriB
             BiriB
              BiB
               B

V!:

V!   !V
 V! !V
  V!V
   V

~:

~ ~
 ~

물론 이것은 코드 골프 이기 때문에 표준 허점은 금지되어 있으며 목표는이 작업을 완료하기 위해 가능한 가장 짧은 프로그램을 작성하는 것입니다. 행복한 골프!

가치가있는 것은 vim 답변을위한 소프트 스팟이 있으므로 vim 또는 V 사용에 대한 가상 보너스 포인트는 있지만 모든 언어가 허용됩니다. :)

MATL , 21 14 바이트

MATL은 생일 축하합니다!

tnEXyY+c3MZvZ)

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

설명

입력을 고려하십시오

'Hello'

길이 n=5. 코드는 size의 항등 행렬을 사용하여이 문자열의 2D 컨벌루션을 계산합니다 2*n.

[1 0 0 0 0 0 0 0 0 0;
 0 1 0 0 0 0 0 0 0 0;
 0 0 1 0 0 0 0 0 0 0;
 0 0 0 1 0 0 0 0 0 0;
 0 0 0 0 1 0 0 0 0 0;
 0 0 0 0 0 1 0 0 0 0;
 0 0 0 0 0 0 1 0 0 0;
 0 0 0 0 0 0 0 1 0 0;
 0 0 0 0 0 0 0 0 1 0;
 0 0 0 0 0 0 0 0 0 1]

문자로 변환되고 문자 0이 공백으로 표시된 회선의 결과는 다음과 같습니다.

['Hello         ';
 ' Hello        ';
 '  Hello       ';
 '   Hello      ';
 '    Hello     ';
 '     Hello    ';
 '      Hello   ';
 '       Hello  ';
 '        Hello ';
 '         Hello']

그런 다음 [1, 2, ..., 2*n-1, 2*n, 2*n-1, ..., 2, 1]이 char 행렬에서 열 이 선택되어 원하는 결과가 생성됩니다.

['Hello         olleH';
 ' Hello       olleH ';
 '  Hello     olleH  ';
 '   Hello   olleH   ';
 '    Hello olleH    ';
 '     HellolleH     ';
 '      HellleH      ';
 '       HeleH       ';
 '        HeH        ';
 '         H         ']

주석이 달린 코드

t      % Implicitly input string. Duplicate
nE     % Length, say n. Multiply by 2
Xy     % Identity matrix of that size
Y+     % 2D convolution. This converts chars to ASCII codes
c      % Convert to char
3M     % Push 2*n, again
Zv     % Push symmetric range [1, 2, ..., 2*n, 2*n-1, ..., 1]
Z)     % Apply as column indices. This reflects the first 2*n columns
       % symmetrically, and removes the rest. Implicitly display

V , 24, 23 , 20 바이트

3Ù2Ò Íî
Xæ$òâÙHãêxx>

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

V에 '역'연산자가 있으므로 훨씬 짧아졌습니다 .

대답 한 다른 골프 언어에 비해 인상적이지는 않지만 수행해야했습니다. 16 진 덤프 :

00000000: 33d9 32d2 20cd ee0a 58e6 24f2 e2d9 48e3  3.2. ...X.$...H.
00000010: ea78 783e                                .xx>

설명:

3Ù                  " Make three extra copies of this current line
  2Ò                " Replace each character on this line and the next line with spaces
     Íî             " Join all lines together
X                   " Delete one space
 æ$                 " Reverse the word under the cursor

이 시점에서 버퍼는 다음과 같습니다.

Happy         yppaH

아니요, 우리는 삼각형을 재귀 적으로 만들 것입니다.

ò                   " Recursively:
 â                  "   Break if there is only one non-whitespace character on this line
  Ù                 "   Make a copy of this line
   H                "   Move to the first line
    ã               "   Move to the center of this line
     ê              "   Move to this column on the last line
      xx            "   Delete two characters
        >           "   Indent this line

여기서 V의 가장 좋아하는 기능 중 하나를 보여줄 수 있습니다. 많은 명령에는 인수가 필요합니다. 예를 들어, >명령은 인수에 따라 가변 수의 행을 들여 씁니다.

>>    " Indent this line (this command is actually a synonym for '>_')
>j    " Indent this line and the line below
>k    " Indent this line and the line above
6>>   " Indent 6 lines
>}    " Indent to the end of this paragraph
>G    " Indent to the last line
...   " Many many many more

그러나 대부분의 명령은 프로그램의 끝에 있고 지정되지 않은 경우 기본 인수 (일반적으로 현재 줄)로 끝나게됩니다. 예를 들어, V가 실제로 실행하는 것 재귀 루프에서 하는 것은 다음과 같습니다.

òâÙHãêxx>>ò

두 번째 ò는 암시 적으로 채워져 있습니다. 멋진 점은 암시 적으로 종료 된 명령이 여러 계층에 깊이를 적용한다는 것입니다. 따라서 우리가 썼지 만 >V는 암시 적으로 _인수를 제공 하고 현재 행을 들여 쓰기합니다.

Brainfuck , 152 바이트

이것은 아주 중대한 기회입니다. 저는 올 BF 통역사를 파기하고 이것을 돌리기로 결정했습니다.

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

주석으로

++++++++++
[->+>+++<<] Insert 0 into the first buffer (Which we don't care about) 10 into the second and 30 into the thrd
>>++    Raise the third buffer to 32 making us our space
>   This buffer is reserved for the Insertable spaces counter
>
+>>>    Raise our incrementer This will be used to fill the other half of the string with spaces
,[  Read a byte
    [<]<<   Move to the back of the string buffer which is our incrementer
    +       increment it
    >>>[>]      And move to the next space of the string
    ,       And then read a new byte
]
<[<]<<-     Decrement the incrementer and begin to add spaces
[
    -       Decrement the incrementer
    >+      Raise the incrementer in the padding
    >>[>]   Move to a new part of the string buffer
    >++++[-<++++++++>]< Write a space
    [<]<<   Move all the way back to the string counter
]
BEGIN WRITING!!
>
[->++<]>[-<+>]<Double the incrementer
[
    <[  Move to the space counter
        -<+<.>> Decrement the space counter increment the temporary one to the left of it then print the space we stored to the left of that then return
    ]<[->+<]>+> Move the temporary space counter back
    -   Decrement the incrementer
    >>[.>]  Print every character from left to right
    <[-]    Snip the end off this
    <[.<]   Print every character from right to left
    <   Move back ot the incrementer
    <<<<.>>>> Print a newline aswell
]

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

> <> 221 바이트

내가 보낸 방법 이에 너무 많은 시간을. 생일 축하해, V!

l:2*01           p84*/v
 !@:$-1         /!?:$<
  1.v/ ^       v\~~>a
   vv\}o<     >ao  /
    1\/84/   :}o:$-
     \\!?<: l;!?\v
      p10-1:g10r\
       >  :>?\vv
        v:$-1/~
         </r+*
          </~
           l

온라인으로 시도 할 수 있지만 이 인터프리터 를 가져 와서 --play플래그를 사용하여 실행하는 것이 훨씬 더 재미 있습니다.

python3 fish.py v.fish -s "ppcg" --tick 0.05 --play

아래 애니메이션이 생성됩니다.

예

(2 분이 조금 걸립니다)

설명

이 답변의 흥미로운 부분은 V모양으로 감싸는 것이므로 여기에 맞는 설명이 있습니다. 우리는 참조를 위해 다음 라인 번호 버전을 사용합니다.

1. l:2*01           p84*/v
2.  !@:$-1         /!?:$<
3.   1.v/ ^       v\~~>a
4.    vv\}o<     >ao  /
5.     1\/84/   :}o:$-
6.      \\!?<: l;!?\v
7.       p10-1:g10r\
8.        >  :>?\vv
9.         v:$-1/~
10.         </r+*
11.          </~
12.           l

때때로 스 니펫에 도달하는 방향을 나타 내기 위해 화살표 (→ ↓ ←)가 사용됩니다.

1. 초기화

      1.→l:2*01           p84*/v
      2.  !@:$-1   X     /!?:$<
      3.   1.            \~~>a
   

   첫 번째 줄은 2n 을 [0,1]로 밀고 , 스택에 n 을 남겨두고 하나의 공백을 추가합니다. 다음으로 오른쪽에서 두 번째 줄로 넘어 가서 왼쪽으로갑니다. n + 1 공백 을 추가하기위한 루프가 있습니다. 이것은 다음과 같이 작동합니다.

                   Initial:                 "ppcg4 "
   !@:$-1 /!?:$<
              $     Swap.                   "ppcg 4"
             :      Duplicate.              "ppcg 44"
            ?       If more spaces to add:
       -1            Subtract 1.            "ppcg 3"
      $              Swap.                  "ppcg3 "
     :               Duplicate.             "ppcg3  "
    @                Rotate top 3.          "ppcg 3 "
   !                 Jump over stored value
                            and wrap around.
                   Else:
           /         Go to next part.
   

   이 작업이 완료되면 3 행으로 바운스됩니다. 맨 위 두 개의 스택 요소 (0 및 공백)가 제거되고 ( ~~) 오른쪽 X위치에서 [10,1] ( a1.) 위치로 점프합니다 . 우리는 /7 번 라인을 감싸고 메인 프로그램 루프를 시작한다.

2. 메인 루프 ( 2n 회)

    6.              ;!?\
    7.       p10-1:g10r\   ←
   

   이것이 루프 조건입니다. 처음에는 인쇄를 위해 스택이 뒤집 힙니다. 그런 다음 [1,0] ( 01g) 에서 카운터를 가져 와서 감소 된 버전 ( :1-01p)을 저장합니다 . 우리는 감싸고 위아래로 충돌함으로써 프로그램 종료 조건을 만난다. 종료하지 않으면 첫 번째 인쇄 루프로 넘어갑니다.

   • 첫 번째 인쇄 루프 (왼쪽 절반)

     5.    1\   /   :}o:$-
     6.     \\!?<: l         ←
     

     스택 상단의 길이로 시작하여 상단 요소가 0이 아닌 한 다음 코드를 실행합니다.

     1-$:o}
     
     1-        Subtract 1.    "ppcg3"
       $       Swap.          "ppc3g"
        :      Duplicate.     "ppc3gg"
         o     Output.        "ppc3g"
          }    Rotate right.  "gppc3"
     

     스택을 버리지 않고 인쇄합니다. 루프가 종료되면 5 번 라인에서 오른쪽으로 점프하여 다음 인쇄 루프를 준비합니다.

   • 오른쪽 절반의 준비

     5.  →    /84/   
     6.       \     
     7.            :    
     8.            >
     9.         v:$-1/~
     10.         </r+*
     11.          </~
     12.           l
     

     이것은 가장 어려운 부품 중 하나였습니다. 아래는 모든 방향 래핑이 제거 된 버전으로 어떤 일이 발생하는지 나타냅니다.

                  Initial stack:   "    gcpp0"
     84*+r~
     84*          Push 32 == " ".  "    gcpp0 "
        +         Add 32 and 0.    "    gcpp "
         r        Reverse.         " gcpp    "
          ~       Remove top.      " gcpp   "
     

     그런 다음 인쇄 할 내용의 길이를 누르고 두 번째 인쇄 루프를 시작합니다 (루프의 일부가 아닌 초기 복제본 사용).

   • 두 번째 인쇄 루프 (오른쪽 절반)

     3.     / ^ 
     4.     \}o<
     5.    
     6.           ↓   
     7.           
     8.       >  :>?\vv
     9.        v:$-1/~ 
     

     실행되는 코드는 첫 번째 인쇄 루프와 완전히 동일하며 o}사용 가능한 위치가 있기 때문에 조금 더 배치됩니다. 마무리가 끝나면 메인 루프 불변성을 다시 확인하기 전에해야 할 일이 몇 가지 있습니다. ~온라인 9 번이 실행 된 후, 우리는 수직으로 둘러 싸고 다음 코드에서 끝납니다.

                     ↓
     2.          X     / 
     3.  1.v/             >a
     4.              >ao  /
     

     먼저 ao줄 바꿈을 인쇄합니다. 그런 다음 초기화 후 똑같은 지점에 튀어 오르고 도착합니다 X.

Brain-Flak , 486 + 1 = 489 바이트

Brain-Flak의 생일 축하합니다!

또한 이 답변에 사용 된 코드 중 일부를 제공 한 0 에게 감사합니다.

-cASCII 입력 및 출력에 필요한 플래그 로 인해 +1

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

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

이것은 내가 Brain-Flak에서 한 것 중 가장 어려운 일입니다.

Brain-Flak은 현을 복제하고 뒤집는 것이 끔찍한 것으로 악명 높으며이 과제는 현을 복제하고 뒤집는 것만으로 구성됩니다.

나는 이것을 얻을 수 있었다 단지 노력의 시간에서 거의 작업 조각을하지만, 지난 몇 공간에 추가하면 내가 뇌 - 플랙에서 수행 한 가장 어려운 일 중 하나가 될 것으로 밝혀졌다.

설명

기본 아이디어는 V의 상단을 먼저 만들고 각 반복은 중간에서 두 문자를 제거하고 시작 부분에 공백을 추가한다는 것입니다.

실제로 이것은 상당히 어려워집니다.

기존 알고리즘은 복사 및 반전을 위해 존재하므로 그 중 하나를 사용하여 오프 스택에서 코드의 반전 된 사본을 작성했습니다. 일단 완료 2n-1하면 원래 스택 위에 공백을 놓고 오프 스택을 다시 스택 위로 이동하여 샌드위치를 ​​만듭니다.

이제 우리는 최상위 행을가집니다. 이제 처음부터 두 문자를 제거하고 공백을 앞에 추가하려고합니다. 이것은 가장 어려운 부분으로 판명되었습니다. 그 이유는 현재 스 니펫의 깊이에 대한 값과 삭제가 발생하는 V의 중심에 대한 깊이에 대한 값을 본질적으로 저장해야하기 때문입니다.

이것은 어렵다.

두 스택 모두에서 진행되는 모든 중복 및 반전으로 인해 항상 사용됩니다. 이 스택에는 아무것도 넣을 곳이 없습니다. 세계의 모든 Third Stack Magic을 사용하더라도이 문제를 해결하는 데 필요한 액세스 유형을 얻을 수 없습니다.

어떻게 고치나요? 요컨대 우리는 실제로 그렇지 않습니다. 우리는 지금 공백을 무시하고 나중에 패치합니다. 공백이 어디로 가고 싶은지 표시하기 위해 코드에 0을 추가하지만 실제로는 아무것도하지 않을 것입니다.

따라서 각 반복마다 마지막 반복의 사본을 만들어 오프 스택에 넣습니다. 우리는 저장 한 깊이를 사용하여 이것을 절반으로 나누고 오른쪽 스택에 V의 왼쪽 절반을 왼쪽 스택에 V의 오른쪽 절반을 갖습니다. 우리는 두 요소를 제거하고 두 요소를 다시 패치합니다. 좋은 측정을 위해 줄 바꿈을 추가하고 다음 반복을 시작합니다. V의 중심까지의 깊이는 1 씩 감소하고 0에 도달하면 루프를 멈 춥니 다.

이제 우리는 V의 대부분을 구성했습니다. 그러나 우리는 적절한 공간이 부족하고 V는 현재 약간 거꾸로되어 있습니다 (읽기 : 완전히).

그래서 뒤집습니다. 다른 스택으로 뒤집으려면 각 요소를 하나씩 이동해야합니다. 요소를 이동하면서 0을 확인합니다. 우리가 하나를 만나면 공간을 그들이 속한 곳에 다시 배치해야합니다. 우리는 0을 척킹하고 많은 공간을 추가합니다. 우리는 얼마나 많은지 어떻게 알 수 있습니까? 우리는 계속 추적합니다. 스택을 복제하거나 뒤집는 것과 달리 스택을 뒤집는 것은 매우 집중적이지 않은 작업이므로 실제로 추가 카운터를 저장하고 액세스하여 추가 할 공간 수를 추적 할 메모리가 있습니다. 공백을 추가 할 때마다 카운터가 하나씩 줄어 듭니다. 마지막 줄 바꿈 (V의 상단)에서 카운터가 0이되어야하므로 인쇄 할 준비가되었습니다.

마지막으로 몇 가지를 정리하고 암시 적 출력을 위해 프로그램을 종료합니다.

젤리 , 15 12 바이트

⁶ṁ⁸;;\Uz⁶ŒBY

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

작동 원리

⁶ṁ⁸;;\Uz⁶ŒBY  Main link. Argument: s (string)

⁶ṁ            Mold ' ' like s, creating a string of len(s) spaces.
  ⁸;          Prepend s to the spaces.
    ;\        Cumulative concatenation, generating all prefixes.
      U       Upend; reverse each prefix.
       z⁶     Zip/transpose, filling empty spots with spaces.
         ŒB   Bounce; map each string t to t[:-1]+t[::-1].
           Y  Join, separating by linefeeds.

파이썬 3 , 65 바이트

s=input();s+=' '*len(s)
for _ in s:s=' '+s[print(s+s[-2::-1]):-1]

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

파이썬 2 , 65 바이트

s=input();s+=' '*len(s)
for _ in s:print s+s[-2::-1];s=' '+s[:-1]

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

자바 스크립트 (ES6) 108 106 98 94 바이트

f=
s=>s.repeat((j=l=s.length*4)*2).replace(/./g,_=>--j?s[j+j<l?j-i:l-i-j]||` `:(j=l,++i,`
`),i=1)

<input oninput=o.textContent=f(this.value)><pre id=o>

레티 나 , 51 47 바이트

동료 문자열 처리 언어에서 생일 축하합니다!

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

$
$.`$* 
$
¶$`
O$^r`.\G

;{*`.¶

(\S.*).¶.
 $1¶

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

설명

$
$.`$* 

이렇게 하면 문자열의 끝을 일치시키고 문자열의 길이를로 검색하고 공백을 반복하여 n공백 ( n문자열 길이)을 추가 합니다 .$.`$*

$
¶$`

문자열의 끝을 다시 일치시키고 문자열 자체를로 삽입하여 전체 문자열 (줄 바꿈으로 구분)을 복제합니다 $`.

O$^r`.\G

오른쪽에서 왼쪽으로 ( r) 일치 한 다음 한 번에 한 문자를 일치시켜 ( ) 두 번째 줄을 반대로하면서 .모두 인접 해 있는지 확인합니다 ( \G). 이렇게하면 일치 항목이 줄 바꿈을 통과 할 수 없습니다. 그런 다음 정렬 단계에서 사용됩니다. 정렬 기준 모드 ( $)를 사용하지만 각 일치 항목을 빈 문자열로 바꾸면 실제 정렬이 수행되지 않습니다. 그러나 ^옵션 으로 인해 마지막 두 번째 줄을 반전시켜 경기가 끝납니다.

;{*`.¶

이 단계는 출력 단계이며 나머지 프로그램에도 영향을줍니다. {루프에서 나머지 스테이지를 랩핑하여 해당 스테이지가 문자열을 변경하지 못할 때까지 반복됩니다 (마지막 스테이지가 더 이상 일치하지 않기 때문에 발생 함). ;프로그램의 끝 비활성화 출력. *회전 스테이지가 처리되고 결과가 출력되지만, 그 후 이전의 문자열이 복원되는 것을 의미 건식으로 실행이 단계.

스테이지 자체는 단순히 줄 바꿈과 선행 문자를 제거합니다. 원하는 출력의 한 줄을 제공합니다 (첫 번째 줄부터 시작).

(\S.*).¶.
 $1¶

마지막으로이 단계는 각 줄을 다음 줄로 바꿉니다. 첫 번째 공백이 아닌 문자 앞에 공백을 삽입하고 첫 번째 행의 마지막 문자와 두 번째 행의 첫 번째 문자를 제거하면됩니다. 첫 번째 행에 공백이 아닌 문자가 하나만 남아 있으면 출력의 마지막 행에 해당하면이 프로세스가 중지됩니다.

05AB1E , 12 바이트

Dgð×J.p€ûR.c

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

설명

D             # duplicate input
 g            # length of copy
  ð×J         # append that many spaces to input
     .p       # get a list of all prefixes
       €û     # turn each into a palindrome
         R    # reverse the list
          .c  # pad each line until centered

또는 다른 방향에서 같은 바이트 수를 계산하십시오.

Âsgú.sí€ûR.c

설명

             # push a reversed copy of input
 s            # swap the input to the top of the stack
  g           # get its length
   ú          # prepend that many spaces
    .s        # get a list of all suffixes
      í       # reverse each
       €û     # turn each into a palindrome
         R    # reverse the list
          .c  # pad each line until centered

apt, 22 20 16 14 + 2 바이트

Japt는 V가 더욱 성공적인 골프를 기원합니다!

²¬£²îU²ç iYU)ê

-R깃발이 필요합니다 . 온라인으로 테스트하십시오!

설명

이것은 며칠 전에 추가 한 ç및 î기능 을 사용합니다 .

²¬£²îU²ç iYU)ê    Implicit: U = input string
²                 Double the input string.
 ¬                Split into chars.
  £               Map each char X and index Y by this function:
     U²             Take the input doubled.
       ç            Fill this with spaces.
         iYU        Insert the input at index Y.
    î       )       Mask: repeat that string until it reaches the length of
   ²                the input doubled.
                    This grabs the first U.length * 2 chars of the string.
             ê      Bounce the result ("abc" -> "abcba").
                  Implicit: output result of last expression, joined by newlines (-R flag)

Dennis의 기술 은 1 바이트 더 깁니다.

U+Uç)å+ mw y mê

GNU 나오지 , 110 100 + 1 (R 플래그) = 101 바이트

편집 : Riley 덕분에 9 바이트 단축

다른 문자열 조작 언어로서, sed 는 V 가 가장 좋기를 바랍니다 !

h;G
:;s:\n.: \n:;t
h;:r;s:(.)(\n.*):\2\1:;tr
H;x
s:\n\n ::
:V
h;s:\n::p;g
s:^: :;s:.\n.:\n:
/\n$/!tV

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

설명 : 입력이 마지막 테스트 케이스 ( 'V!')라고 가정합니다. 각 단계마다 패턴 공간을 명확하게 표시하고 공백을 'S'로 바꿉니다.

h;G                       # duplicate input to 2nd line: V!\nV!
:;s:\n.: \n:;t            # shift each char from 2nd line to 1st, as space: V!SS\n
h;:r;s:(.)(\n.*):\2\1:;tr # save pattern space, then loop to reverse it: \nSS!V
H;x                       # append reversed pattern to the one saved V!SS\n\n\nSS!V
s:\n\n ::                 # convert to format, use \n as side delimiter: V!SS\nS!V
:V                        # start loop 'V', that generates the remaining output
h;s:\n::p;g               # temporarily remove the side delimiter and print pattern
s:^: :;s:.\n.:\n:         # prepend space, delete char around both sides: SV!S\n!V
/\n$/!tV                  # repeat, till no char is left on the right side
                          # implicit printing of pattern left (last output line)

파이썬, 110 바이트

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

나는 이것이 최적이 아니라고 확신하지만 적어도 Pythonic입니다.

def f(s):n=len(s)*2-1;return''.join(i*' '+s[:n+1-i]+(n-2*i)*' '+s[n-i-1::-1]+'\n'for i in range(n))+n*' '+s[0]

줄프, 31 바이트

Jolf는 V에게 행복한 생일을 기원합니다!

RΜwzΒώlid+γ_pq_ l+*␅Hi0ΒΒ␅ L_γ1S

여기 사용해보십시오! ␅0x05 여야합니다.

설명

RΜzΒώlid+γ_pq_ l+*␅Hi0ΒΒ␅ L_γ1S  i = input
     li                                  i.length
    ώ                                2 * 
   Β                             Β =
  z                              range(1, Β + 1)
 Μ     d                         map with: (S = index, from 0)
                +                 add:
                 *␅H               S spaces
                    i              and the input
               l                  slice (^) from
                     0Β            0 to Β
           pq_         Β␅         pad (^) with spaces to the right
         γ_                       γ = reverse (^)
        +                 L_γ1    γ + behead(γ)
R                             S  join with newlines

숯 , 29 바이트

아쉽게도 오랫동안 도전 해 왔던 ASCII 아트 언어의 동료 생일 축하합니다!

ＳσＦ…·¹Ｌσ«Ｆι§σκＭι←↖»Ｆσ«Ｐσ↖»‖Ｏ→

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

설명

우리의 전략 : V의 왼쪽 절반을 아래에서 시작하여 왼쪽 상단으로 이동하십시오. 그리고 그것을 반영하십시오.

Ｓσ                                    Input σ as string
                                       The bottom len(σ) half-rows:
   Ｆ…·¹Ｌσ«           »               For ι in inclusive range from 1 to length(σ):
            Ｆι                          For κ in range(ι):
               §σκ                         Print character of σ at index κ
                  Ｍι←                   Move cursor ι spaces leftward
                      ↖                  Move cursor one space up and left
                                       The top len(σ) half-rows:
                        Ｆσ«    »      For each character ι in σ:
                            Ｐσ          Print σ without moving the cursor
                               ↖         Move cursor one space up and left
                                 ‖Ｏ→  Reflect the whole thing rightward, with overlap

(Charcoal 만 문자열 슬라이싱을 가지고 있다면 ... 아직 구현되지 않은 것으로 보입니다.)

핍 , 32 25 바이트

a.:sX#aL#a{OaDQaPRVaaPUs}

입력 문자열을 명령 줄 인수로 사용합니다. 온라인으로 사용해보십시오!

설명

                           a is 1st cmdline arg, s is space (implicit)
     #a                    Len(a)
   sX                      Space, string-multiplied by the above
a.:                        Concatenate that to the end of a
       L#a{             }  Loop len(a) times (but NB, a is now twice as long as it was):
           Oa                Output a (no trailing newline)
             DQa             Dequeue one character from the end of a
                PRVa         Print reverse(a) (with trailing newline)
                    aPUs     Push one space to the front of a

stringi 패키지가있는 R, 225 바이트

library(stringi)
f=function(){
s=scan(,'',1,sep="\n")
m=2*nchar(s)
l=stri_pad(sapply(1:m-1,function(x)substr(paste(paste(rep(" ",x),collapse=""),s),1,m)),m,"right")
r=substr(stri_reverse(l),2,m)
message(paste0(l,r,"\n"))}
f()

대화 형 코드에서 R을 실행하면 내 대답을 붙여 넣은 후에 아무것도 입력하십시오. stringi R 패키지를 설치해야합니다 (규칙에 위배되지 않기를 바랍니다).

설명:

기본 아이디어는 왼쪽에 공백을 추가 한 다음 올바른 길이로 자르는 것입니다. 그런 다음 반대 버전을 오른쪽으로 붙여 넣습니다. 사람이 읽을 수있는 더 긴 버전의 함수는 다음과 같습니다.

library(stringi)
make_V <- function(){                  # declaring the function
  string <- scan(, '', n=1, sep="\n")  # reading input
  max_length <- 2*nchar(string)        # number of chars in each half row

  # creating the left side of the V

  left <- stri_pad(                    
            sapply(1:max_length-1,     # for each row
                   function(x){     
                    substr(            
                      paste0(
                        paste0(rep(" ", x),
                               collapse=""), string), # add spaces to left side
                           1,
                           max_length) # cut the unneeded end
                    }),
            width=max_length,
            side="right")              # add spaces to the right side

  # creating the right side of the V

  right <- substr(stri_reverse(left), 2, max_length)

  # print it without any symbols before the strings 
  message(paste0(left, right, "\n"))
}

# run the function
make_V()

루비, 92 89 85 바이트

s=gets.chomp
s<<" "*n=s.size*2
n.times{s=s[0..(n-1)]
puts s+s.reverse[1..-1]
s=" "+s}

내 프로세스는 전반을 반전시킨 후 각 줄의 오른쪽 절반에서 첫 번째 문자를 제거하는 것이 었습니다. 이처럼 :

Hello     |    olleH
 Hello    |   olleH 
  Hello   |  olleH  
   Hello  | olleH   
    Hello |olleH    
     Hello|lleH     
      Hell|leH      
       Hel|eH       
        He|H        
         H|         

나는 골프를 타는 데 익숙하지 않기 때문에 더 짧게하기 위해 할 수있는 일이 있으면 알려주십시오.

배치, 186 185 바이트

@set e=@set 
%e%/ps=
%e%t=%s%
%e%r=
:l
%e%s=%s% 
%e%r= %r%%t:~-1%
%e%t=%t:~,-1%
@if not "%t%"=="" goto l
:g
%e%r=%r:~1%
@echo %s%%r%
%e%s= %s:~,-1%
@if not "%r%"=="" goto g

1 행과 6 행에는 후행 공백이 있습니다. 편집 : @ ConorO'Brien 덕분에 1 바이트가 절약되었습니다.

하스켈 , 76 바이트

v주요 기능으로 String인수를 취하고 String결과를 제공합니다 .

v i=unlines.r$i++(' '<$i)
r""=[]
r s|t<-init s=(s++reverse t):map(' ':)(r t)

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

노트:

• i 초기 인수 / 입력입니다.
• s처음 i에는 length i공백이 추가됩니다.
• v i를 호출 r s한 다음 결과 라인에 참여합니다.
• rString줄 목록을 반환합니다 .
• t이다 s잘려 마지막 문자로.
• 재귀 r t는 첫 번째 줄을 제외하고 각 줄의 초기 공간을 뺀 줄을 만듭니다.

젤리 , 13 바이트

⁶ṁ;@µḣJUz⁶ŒBY

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

어떻게?

⁶ṁ;@µḣJUz⁶ŒBY - Main link: string s
⁶             - space character
 ṁ            - mould like s: len(s) spaces
  ;@          - concatenate s with that
    µ         - monadic chain separation (call that t)
      J       - range(length(t))
     ḣ        - head (vectorises): list of prefixes from length to all
       U      - upend: reverse each of them
        z     - transpose with filler:
         ⁶    -     space: now a list of the left parts plus centre
          ŒB  - bounce each: reflect each one with only one copy of the rightmost character
            Y - join with line feeds
              - implicit print

루비, 85 83 바이트

편집 : 여분의 공백 제거

s=ARGV[0];s+=' '*s.length;s.length.times{|i|puts s+s[i..-2].reverse;s=' '+s[0..-2]}

실제로 루비에서 골프를하는 것은 꽤 어렵다는 것을 알았습니다. 공백을 추가 한 후에는 꽤 읽을 수있는 코드 스 니펫으로 확장됩니다.

s = ARGV[0]
s+=' ' * s.length

s.length.times do |i|
  puts s + s[i..-2].reverse
  s = ' ' + s[0..-2]
end

MATLAB (R2016b), 223 183 바이트

r=input('');l=nnz(r)*2;for i=1:l;m=l+1-2*i;c={' '};s=cell(1,i-1);s(:)=c;x=cell(1,m);x(:)=c;e=r;y=flip(r);if(m<1);e=r(1:2*end-i+1);y=r(l/2+end-i:-1:1);end;disp(cell2mat([s e x y]));end

처음으로 코드 골프. 팁은 환영합니다!

프로그램 출력 :

편집하다:

Luis Mendo 덕분에 40 바이트를 절약했습니다.

PHP, 95 92 85 80 78 77 바이트

참고 : IBM-850 인코딩 사용

for($s.=strtr($s^$s=$argn,~ ,~▀);~$s[$i++];)echo$s,strrev($s=" $s"^$s^$s),~§;
          # Note that this ^ char is decimal 255 (negating it yields "\0")

다음과 같이 실행하십시오.

echo "Hello" | php -nR 'for($s.=strtr($s^$s=$argn,"\0",~▀);~$s[$i++];)echo$s,strrev($s=" $s"^$s^$s),~§;'
> Hello         olleH 
>  Hello       olleH  
>   Hello     olleH   
>    Hello   olleH    
>     Hello olleH     
>      HellolleH      
>       HellleH       
>        HeleH        
>         HeH         
>          H          

설명

for(
  $s.=strtr(             # Set string to the input, padded with spaces.
    $s^$s=$argn,         # Input negated with itself, leads to string with
                         # only null bytes with the same length.
    ~ ,                  # Replace null bytes...
    ~▀                   # ... with spaces.
  );
  ~$s[$i++];             # Iterate over the string by chars, works because 
                         # there are just as many lines as the padded
                         # string has chars.
)
  echo                   # Output!
    $s,                  # The string.
    strrev(              # The reverse of the string.
      $s=" $s"^$s^$s     # After each iteration, prefix string with a
    ),                   # space, and trim the last character.
    ~§;                  # Newline.

조정

• 패드 문자를 제거하여 3 바이트 str_pad를 절약했습니다 ( 기본값은 공백으로, 필요한 것입니다)
• 문자열에서 이진 연산을 사용하여 문자열을 자르는 대신 7 바이트를 절약했습니다. substr
• 반전 인쇄시 문자열을 회전하여 5 바이트를 절약했습니다. 백 스페이스를 인쇄 할 필요는 없지만 각 줄에 후행 공백이 생깁니다.
• 보다 복잡하지만 짧은 방법을 사용하여 문자열을 채워 2 바이트를 절약했습니다.
• ~"0"모든 입력을 인쇄 가능한 ASCII (Thx @Titus)로 가정 할 수 있으므로 사례 를 설명 할 필요가 없기 때문에 바이트를 절약했습니다 (ASCII 207).

자바 스크립트 (ES6), 169 157 바이트

(Conor O'Brien 덕분에 10 바이트)

V=(j,i=0,p="")=>i<(f=j.length)*2?V(j,-~i,p+" ".repeat(i)+j.slice(0,f-i*(i>f))+" ".repeat(i<f?(f-i)*2-1:0)+[...j.slice(0,f+~i*(i>=f))].reverse().join``+`
`):p

재귀 솔루션. 저는 JavaScript를 처음 사용하므로 조심하십시오! 모든 골프 팁을 높이 평가합니다. :)

그리고 물론, 당신에게 아주 행복한 생일입니다 V!

테스트 스 니펫

V=(j,i=0,p="")=>i<(f=j.length)*2?V(j,-~i,p+" ".repeat(i)+j.slice(0,f-i*(i>f))+" ".repeat(i<f?(f-i)*2-1:0)+[...j.slice(0,f+~i*(i>=f))].reverse().join``+`
`):p

<input oninput=o.textContent=V(this.value)><pre id=o>

CJam , 26 바이트

당신의 오래된 친구 CJam에서 생일 축하합니다!

q_,2*:L,\f{LS*+m>L<_W%(;N}

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

설명

q                           Push the input
 _,2*:L                     Push 2 times the length of the input, store it in L
       ,                    Take the range from 0 to L-1
        \                   Swap top stack elements
         f{                 Map over the range, using the input as an extra parameter
           LS*+               Append L spaces to the input
               m>             Rotate the resulting string right i positions (where i is the
                               current number being mapped)
                 L<           Take the first L characters of the string
                   _W%        Duplicate it and reverse it
                      (;      Remove the first character from the copy
                        N     Add a newline
                         }  (end of block)
                            (implicit output)

PowerShell, 126 바이트 124 바이트

$l=($s="$args")|% Le*;$r=-join$s[-1..-$l];0..($l*2-1)|%{' '*$_+($s+' '*$l).substring(0,$l*2-$_)+(' '*$l+$r).substring($_+1)}

와 같은 단일 매개 변수로 호출하십시오 .\V.ps1 Hello.

편집 : AdmBorkBork의 팁으로 2 바이트 저장

파이크 , 14 바이트

l}j Fd*R+j^j<s

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

자바 스크립트 (ES6), 94 바이트

f=(s,y=0,x=0,l=s.length*2-1)=>(s[(x>l?l*2-x:x)-y]||' ')+(x<l*2?f(s,y,x+1):y<l?`
`+f(s,y+1):'')

테스트 사례

f=(s,y=0,x=0,l=s.length*2-1)=>(s[(x>l?l*2-x:x)-y]||' ')+(x<l*2?f(s,y,x+1):y<l?`
`+f(s,y+1):'')

console.log(f('Happy'))
console.log(f('Birthday'))
console.log(f('V!'))
console.log(f('~'))

J, 44 바이트

(([(,}.@|.)@{."1-@i.@[|."0 1(,#&' ')~)~+:@#)