( 이 도전에서 영감을 얻음 )

두 개의 입력 문자열 중 하나가 다른 문자보다 정확히 하나의 문자보다 길면 문자열이 반쯤 지퍼가 달린 지퍼의 두 반쪽 인 것처럼 ASCII 아트로 문자열을 정렬하십시오. 더 긴 단어는 지퍼의 바닥을 형성하며 결합 된 지퍼 부분의 첫 번째이자 마지막 문자입니다. 그 단락을 이해하기 어렵 기 때문에 몇 가지 예를 살펴보십시오.

zippered
paragraph

 z
   i
     p
       p
        gerraepdh
      a
    r
  a
p

참고 방법 paragraph(긴 워드) 하단 지퍼를 형성하고, g r a p h일부는 캡슐 e r e d의 일부를 zippered, 상기 z i p p와 p a r a부분들은 서로 오프셋된다.

입력

• 편리한 형식의 두 ASCII 문자열 로 , 하나는 길이가 길고 다른 하나는 정확히 한 문자 더 길어야합니다.
• 문자열은 공백을 포함하지 않지만 인쇄 가능한 다른 ASCII 값을 포함 할 수 있습니다.
• 어느 순서로든 입력을받을 수 있습니다. 제출시 입력 순서를 알려주십시오.

산출

위에 설명 된대로 압축 된 단어의 ASCII 아트 표현은 편리한 형식으로 다시 표시됩니다.

규칙

• 문자 자체가 올바르게 정렬되는 한 줄 바꿈 또는 공백은 모두 선택 사항입니다.
• 전체 프로그램 또는 기능이 허용됩니다. 함수 인 경우 출력하지 않고 출력을 반환 할 수 있습니다.
• 가능하면 다른 사람들이 귀하의 코드를 시험해 볼 수 있도록 온라인 테스트 환경에 대한 링크를 포함하십시오!
• 표준 허점 은 금지되어 있습니다.
• 이것은 코드 골프 이므로 모든 일반적인 골프 규칙이 적용되며 가장 짧은 코드 (바이트)가 이깁니다.

예

ppcg
tests

 p
   p
    sctgs
  e
t

string
strings

 s
   t
     r
      iinnggs
    r
  t
s

Japt , 31 28 바이트

N®¬£ç iXYm½*Ul
uUo mw
y c ·y

온라인으로 테스트하십시오! 짧은 문자열을 먼저 가져옵니다.

설명

N®¬£ç iXYm½*Ul    First line: Set U to the result.
N®                Map each item (there's exactly 2 of them) in the input to
  ¬                 the item split into chars,
   £                with each item X and index Y mapped to
    ç                 the first input filled with spaces,
      iX              with X inserted at index
        Ym½*Ul          min(Y, 0.5 * U.length).
                  At the end each input is an array like
                  ["p    ", " p   ", "  c  ", "  g  "]
                  ["t    ", " e   ", "  s  ", "  t  ", "  s  "]

uUo mw    Second line: Set V to the result (though that's not important).
 Uo       Pop the last item (the array representing the second string) from U.
    m     Map each item by
     w      reversing.
u         Push the result to the beginning of U.
          At the end we have e.g.
          ["    t", "   e ", "  s  ", "  t  ", "  s  "]
          ["p    ", " p   ", "  c  ", "  g  "]

y c ·y    Last line: Output the result of this line.
y         Transpose: map [[A,B,C,...],[a,b,c,...]] to [[A,a],[B,b],[C,c],...].
  c       Flatten into one array. [A,a,B,b,C,c,...]
    ·     Join on newlines. Now we have the output transposed.
     y    Transpose rows with columns.

숯 , 33 31 바이트

→Ｆ²«ＦＬ諧θκ→¿‹κ÷Ｌθ²¿ι↑↓»Ｊ⁰ＬθＡηθ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 짧은 문자열을 먼저 가져옵니다. 편집 : 중간 점 감지를 조정하여 2 바이트를 절약했습니다. 설명:

→Ｆ²«

각 줄을 차례로 반복합니다.

ＦＬθ«

문자열의 각 문자를 차례로 반복합니다.

§θκ→

문자를 인쇄하고 여분의 사각형을 오른쪽으로 이동하십시오.

¿‹κ÷Ｌθ²¿ι↑↓»

문자열의 처음 절반에 대해서도 커서를 적절하게 위 또는 아래로 이동하십시오.

Ｊ⁰ＬθＡηθ

첫 번째 문자열을 인쇄 한 후 두 번째 문자열의 시작점으로 건너 뛰고 첫 번째 문자열을 두 번째 문자열로 바꾸면 두 번째 루프에 대해 인쇄됩니다. (코드는 두 루프에서 실행되지만 두 번째는 작동하지 않습니다.)

Pyth , 35 바이트

AQj.t.e+*d+lG*<klH*^_1k/h-lGk2b.iHG

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

젤리 ,  27  26 바이트

-1 Outgolfer 에릭에 바이트 감사 (사용의 반복은 ¡, 경우, 교체 ?및 통과 else 절 ¹)

JCḂ¡€ṚH
żµL⁶ẋ;ЀFṙ"ÇZṙÇṀ$Y

질문에 허용 된대로 공백을 선행하여 결과를 인쇄하는 전체 프로그램 (또는 문자 목록을 반환하는 2 진 링크).

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

방법?

JCḂ¡€ṚH - Link 1, get rotations: list p        e.g.: ["a1","b2","c3","d4","e5","f6","g"]
J       - range of length of p                       [ 1, 2, 3, 4, 5, 6, 7]
    €   - for €ach:
   ¡    -   repeat link:
  Ḃ     - ...# of times: modulo 2                      1  0  1  0  1  0  1
 C      - ...link: complement (1-x)                    0  2 -2  4 -4  6 -6
     Ṛ  - reverse                                    [-6, 6,-4, 4,-2, 2, 0]
      H - halve                                      [-3, 3,-2, 2,-1, 1, 0]

żµL⁶ẋ;ЀFṙ"ÇZṙÇṀ$Y - Main link: longer (odd length); shorter (even length)
                   -                           e.g.: "abcdefg", "123456"
ż                  - zip them together               ["a1","b2","c3","d4","e5","f6","g"]
 µ                 - monadic chain separation, call that p
  L                - length of p                     7
   ⁶               - literal space character         ' '
    ẋ              - repeat                          "       "
        F          - flatten p                       "a1b2c3d4e5f"
      Ѐ           - map with:
     ;             -   concatenation                 ["       a","       1","       b","       2","       c","       3","       d","       4","       e","       5","       f","       6","       g"]
           Ç       - call last link (1) as a monad with argument p
          "        - zip with (no action on left by trailing values of right):
         ṙ         -   rotate left by                ["  a     ","    1   "," b      ","     2  ","c       ","      3 ","       d","       4","       e","       5","       f","       6","       g"]
            Z      - transpose                       ["    c        ","  b          ","a            ","             "," 1           ","   2         ","     3       ","      d4e5f6g"]
                $  - last two links as a monad:
              Ç    -   call last link (1) as a monad with argument p
               Ṁ   -   maximum                       3
             ṙ     - rotate left by                  ["             "," 1           ","   2         ","     3       ","      d4e5f6g","    c        ","  b          ","a            "]
                 Y - join with newlines            '''             \n
                                                       1           \n
                                                         2         \n
                                                           3       \n
                                                            d4e5f6g\n
                                                          c        \n
                                                        b          \n
                                                      a            '''
                   - as full program: implicit print

파이썬 2 , 128 119 바이트

f=lambda a,b,n=0:n/2<len(a)and' '*-~n+a[0]+'\n'+f(a[1:],b[1:],n+2)+'\n'+' '*n+b[0]or' '*n+''.join(sum(zip(b,a+' '),()))

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

V , 47 38 30 27 26 25 바이트

마지막으로 현재 젤리 답변을 이겼다.

긴 단어를 맨 위에 입력하십시오.

골프장에 더 많은 것이 있다고 생각하지 마십시오.

òGxplòxãòd|>HÏpd|>GGÏphl

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

설명

ò     ò      ' <M-r>ecursively
             |abc
             def
 Gx          ' (G)oto the last line and (x) the first character
             abc
             |ef
            ' <C-O> Go back to the previous location
             |abc
             ef
    p        ' (p)aste the character cut
             a|dbc
             ef
     l       ' move one character right
             ad|bc
             ef

x                  ' (x) the last extraneous character from the previous loop
 ã                 ' <M-c>enter the cursor
  ò                ' <M-r>ecursively
   d|              ' (d)elete to the first co(|)umn
     >H            ' (>) Indent every line from here to (H)ome (first line)
                   ' this leaves the cursor on the first line
       Ïp          ' <M-O>n a newline above this (the first) (p)aste the deleted section
                   ' this leaves the cursor on the last character
         d|        ' (d)elete to the first co(|)umn
           >G      ' (>) Indent every line from here to the end (G)
                   ' unfortunately the cursor stays on the first line
             G     ' (G)oto the last line
              Ïp   ' <M-O>n a newline above this (the last) (p)aste the deleted section
                hl ' move left and then right (break the loop at the end)

V , 79 바이트

ãl}dÍ./ &
XòYf D"0Pr -Y;D"0pr +òGï"1pÓ./&ò
}dGÓ/&ò
{jpògJòÓó
|DÇ./d
MÙ"-pBr 

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

다음은 풍자 및 인용구 가 많을 때 읽어야 합니다 .

내 골프 언어 의 대답은 문자열 기반 및 ASCII 예술 과제에 대한 짧은 대답에 좋습니다 . .

왜 나 자신에게 이것을 계속합니까?

16 진 덤프 :

00000000: e36c 167d 64cd 2e2f 2026 0a58 f259 6620  .l.}d../ &.X.Yf 
00000010: 4422 3050 7220 2d59 3b44 2230 7072 202b  D"0Pr -Y;D"0pr +
00000020: f247 ef22 3170 d32e 2f26 f20a 0f16 7d64  .G."1p../&....}d
00000030: 47d3 2f26 f20a 7b6a 70f2 674a f2d3 f30a  G./&..{jp.gJ....
00000040: 7c44 c72e 2f64 0a4d d922 2d70 4272 20    |D../d.M."-pBr 

젤리 , 28 바이트

HĊ©«Rµ®Ḥ_,Ṗ
ZLÇṬ€a"¥"o⁶ZẎz⁶Y

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

우 젤리는 사실에 경쟁 문자열 및 아스키 기술 에 도전! \영형/

05AB1E , 26 23 바이트

øS2ä`JIθ«¸«vyNúr})2äR˜»

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

설명

예를 들어 입력 = ppcg, tests

ø                           # zip the input strings
                            # STACK: ['tp', 'ep', 'sc', 'tg']
 S                          # split to a list of characters
                            # STACK: ['t', 'p', 'e', 'p', 's', 'c', 't', 'g'
  2ä                        # divide the list into 2 parts
    `                       # push them as separate to stack
                            # STACK: ['t', 'p', 'e', 'p'], ['s', 'c', 't', 'g']
     J                      # join the second part to a single string
      Iθ«                   # append the tail of the second input
         ¸«                 # concatenate the 2 lists
                            # STACK: ['t', 'p', 'e', 'p', 'sctgs']
           v                # for each y,N (element, index) in the list
            yNú             # prepend N spaces to y
               r            # reverse the stack
                })          # end loop and wrap the stack in a list
                            # STACK: ['    sctgs', '  e', 't', ' p', '   p']
                  2ä        # split the list into 2 parts
                    R       # reverse the list
                            # STACK: [[' p', '   p'], ['    sctgs', '  e', 't']]
                     ˜»     # flatten the list and join on newlines

C # (. NET 코어) 163 바이트

(l,s)=>{var o="";int i=0,k=s.Length;for(;i<k;)o+=i<k/2?s[i++]+"\n"+"".PadLeft(i):l[i]+""+s[i++];o+=l[i]+"\n";for(i=k/2;i>0;)o+="".PadLeft(--i)+l[i]+"\n";return o;}

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

아마도 여기에는 많은 골프가 있지만, 초기 비 LINQ 시도가 있습니다. 더 긴 단어를 먼저 사용하고 출력과 함께 문자열을 반환하는 Lambda 함수.

자바 8, 216 바이트

커리 람다 : 소요 String와에서 람다를 반환 String하는 String. 외부 람다에 대한 매개 변수는 더 짧은 문자열입니다.

String배열 구문 으로 s 에 색인을 생성 할 수 없다는 것은 불행한 일입니다.

s->t->{int l=s.length(),i=l/2;String o="",p=o,n="\n";for(;i<l;p+="  ")o=o+t.charAt(i)+s.charAt(i++);o=p+o+t.charAt(i)+n;for(;i-->0;)o=p.substring(l-i--)+s.charAt(i/2)+n+o+p.substring(l-i)+t.charAt(i/2)+n;return o;}

언 골프 람다

s ->
    t -> {
        int
            l = s.length(),
            i = l / 2
        ;
        String
            o = "",
            p = o,
            n = "\n"
        ;
        for (; i < l; p += "  ")
            o = o + t.charAt(i) + s.charAt(i++);
        o = p + o + t.charAt(i) + n;
        for (; i-- > 0; )
            o =
                p.substring(l-i--)
                + s.charAt(i / 2)
                + n
                + o
                + p.substring(l-i)
                + t.charAt(i / 2)
                + n
            ;
        return o;
    }

설명

l더 짧은 입력의 길이이며 더 짧은 입력 i의 두 번째 절반의 첫 번째 문자를 참조하도록 초기화 된 다목적 색인입니다. o결과를 누적하고 p궁극적으로 패딩을위한 공간을 저장하며 n에 대한 별명입니다."\n" .

첫 번째 루프는 두 문자열의 두 번째 절반을 인터리브하고 (더 긴 입력의 마지막 문자 제외) p 가운데 줄에 적절한 양의 패딩을 .

다음 줄은 중간 줄의 출력을 완료합니다.

James Gosling에게 두 번째 루프에 대해 사과하고 싶습니다. 안쪽에서 바깥쪽으로 중간 선 위와 아래에 선을 추가합니다. 루프를 입력하면 iis l - 1이므로 짧은 문자열의 첫 번째 절반의 마지막 문자와 함께 하나의 패딩 문자가 앞에 붙습니다.i다음 패딩 (결과에 추가됨)이 더 짧은 문자가되도록 감소됩니다. 정수 나누기에 의해 더 긴 문자열의 동일한 위치 문자가 추가됩니다. 반복되고 완성 된 결과가 반환됩니다.

멋진 것

13 번 줄

o+=t.charAt(i)+""+s.charAt(i++);

빈 문자열이 없으면 +문자 값을 더하고 숫자 문자열을 추가 했기 때문 입니다. 복합 할당을 확대함으로써,의 연결 o및 t.charAt(i)2 바이트를 저장, 빈 문자열에 대한 필요없이 원하는 결과를 얻을 수있는 첫번째 평가된다. 복합 할당이 확장과 다르게 동작하는 것을 처음으로 보았습니다.

자바 (ES6), 140 (137) 133 바이트

A=(a,b,c=0)=>a[c/2]?` `[d=`repeat`](c+1)+a[0]+`
`+A(a.slice(1),b.slice(1),c+2)+`
`+` `[d](c)+b[0]:` `[d](c)+[...a].map((e,f)=>e+b[f])

이것이 더 골프를 칠 수 있다는 것을 확신하십시오.

Mathematica, 174 바이트

(a=(c=Characters)@#;b=c@#2;T=Table;Column[Join[T[T["  ",i]<>a[[i]],{i,g=Length@a/2}],{T["  ",g+1]<>Riffle[b[[-g-1;;]],a[[-g;;]]]},Reverse@T[T["  ",i]<>b[[i+1]],{i,0,g-1}]]])&

입력

[ "지퍼", "문단"]

TXR 리스프 , 126 바이트

(defun f(a b :(n 0))(if(<(/ n 2)(length a))` @{""n}@[a 0]\n@(f(cdr a)(cdr b)(+ n 2))\n@{""n}@[b 0]``@{""n}@{(zip b`@a `)""}`))

PHP, 149129 바이트

for($r=" ";$x+1<$w=2*$e=strlen($argv[2]);++$x&1||$r[++$i*$w-1]="
")$r[$w*($x&1?$y-1:$e-$y+=$y<$e/2)+$x]=$argv[2-$x%2][$i];echo$r;

온라인으로 실행 -nr하거나 사용해보십시오 .

펄 5 , 163 바이트

@a=map{$s=.5*length;[/./g]}<>;say(($"x(2*$_)).$a[0][$_])for 0..$s-1;print$"x(2*$s);print$a[0][$_].$a[1][$_]for$s..@{$a[1]};print$/.($"x(1+2*$s)).$a[1][$s]while$s--

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

더 긴 문자열을 먼저받습니다.