Alice , 28 바이트

/mY. zm~wZ.k;
\I;'!*?RR.OY@/

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

입력 길이가 홀수이면 선형화 된 프로그램의 끝에 패딩 공간이 생겨 출력의 첫 문자가됩니다.

Leo는 며칠 전에 Alice에서 Ordinal formatter를 작성했습니다 . 홀수 길이의 입력에 대한 지원을 추가 한 다음이 과제에 필요하지 않은 일부 항목을 제거한 후 28 바이트가되었습니다 . 나는 약간 다른 접근법을 시도하고 싶었습니다.이 답변입니다. 불행히도 방금 28 바이트를 묶었 지 만 적어도이 방법으로 내 솔루션을 게시하고 Leo가 원래 알고리즘을 게시하도록 할 수 있습니다.

이것은 Leo의 정말 영리한 아이디어를 사용하여 문자열을 반으로 나눕니다 ..Y;m;.!z?~.

설명

입력의 길이가 짝수라고 가정합시다 (그렇지 않으면 공백으로 채울 것이므로). 패턴을 0123456789코드로 사용하는지보다 쉽게 ​​알 수 있습니다. 필요한 출력은 다음과 같습니다.

91735
08264

따라서 첫 번째 줄에는 입력의 모든 홀수 위치가 포함되고 두 번째 줄에는 모든 짝수 입력이 포함됩니다. 또한 홀수 위치를 반대로하면 선 자체가 전반부 (아마도 더 길어질 수 있음)와 후반부 반전으로 인터리브됩니다.

기본 아이디어는 다음과 같습니다.

• 홀수 및 짝수 위치로 입력을 분리하십시오.
• 필요한 경우 홀수 위치를 공백으로 채 웁니다.
• 홀수 위치를 뒤집습니다.
• 그런 다음 두 번 : 현재 문자열을 반으로 줄이고 후반부를 뒤집고 두 절반을 인터리브하고 후행 줄 바꿈으로 인쇄합니다.

코드에 관해서는, 이것은 우리가이 챌린지에서 생성하는 일종의 레이아웃과 비슷해 보이지만 미묘하게 다릅니다. IP가 /코드의 끝에 도달하면 남쪽이 아닌 동쪽 에 반영됩니다 . 그런 다음 카디널 모드에서 IP는 첫 번째 열로 줄 바꿈됩니다. 는 \거기에 다시 진입 서수 모드, 그래서 코드의 두 번째 절반은 오른쪽에서 이동하지 않는 것을 여기 남아 있지만에서 오른쪽뿐만 아니라 왼쪽. 이것은 리턴 주소 스택으로 작업 할 때 유용합니다. IP 방향에 대한 정보를 저장하지 않기 때문입니다. 는 IP가 모두 동일 (수평) 방향으로 이동하기 때문에이 작업은 몇 바이트 저장 우리를 할 수 있습니다 w와 k.

선형화 된 코드는 다음과 같습니다.

IY' *mRw..Y;m;.!z?~RZOk@

살펴 보겠습니다 :

I       Read one line of input.
Y       Unzip. Separates the string into even and odd positions.
' *     Append a space to the odd half.
m       Truncate: discards characters from the longer of the two
        strings until they're the same length. So if the input
        length was even, appending a space will make the odd half
        longer and this discards the space again. Otherwise, the
        space just padded the odd half to the same length as the
        even half and this does nothing.
R       Reverse the odd half.
w       Push the current IP address to the return address stack.
        The purpose of this is to run the following section
        exactly twice.

          This first part splits the current line in half, based
          on an idea of Leo's:
  ..        Make two copies of the current half.
  Y         Unzip one of the copies. The actual strings are irrelevant
            but the important part is that the first string's length
            will be exactly half the original string's length (rounded up).
  ;         Discard the potentially shorter half.
  m         Truncate on the original string and its even half. This shortens
            the original string to the first half of its characters.
  ;         Discard the even half, because we only needed its length.
  .!        Store a copy of the first half on the tape.
  z         Drop. Use the first half to discard it from the original string.
            This gives us the the second (potentially shorter half).
  ?         Retrieve the first half from the tape.
  ~         Swap it so that the second half is on top.
          The string has now been split in half.
  R       Reverse the second half.
  Z       Zip. Interleave the two halves.
  O       Print the result with a trailing linefeed.

k       Pop an address from the return address stack and jump back there.
        The second time we reach this, the return address stack is empty,
        and this does nothing.
@       Terminate the program.

답변

LḂ⁶ẋ;µṚ,µm2œs2U0¦ż/µ€Y

LḂ⁶ẋ;µṚ,µm2œs2U0¦ż/µ€Y - Main link: list of characters
L                      - length
 Ḃ                     - modulo 2
  ⁶                    - literal space character
   ẋ                   - repeat
    ;@                 - concatenate (swap @rguments) (appends a space if the input's length is odd)
      µ                - monadic chain separation, call that s
       Ṛ               - reverse s
        ,              - pair with s
         µ         µ€  - for €ach:
          m2           -   modulo 2 slice (take every other character)
            œs2        -   split into two "equal" chunks (first half longer if odd)
               U0¦     -   upend index 0 (reverse the second chunk)
                   /   -   reduce by:
                  ż    -     zip
                     Y - join with newlines (well just the one in this case)
                       - implicit print (mushes the sublists together)

f=
s=>s.replace(/./g,(c,i)=>a[1&~i][i+i>l?l-i:i]=c,a=[[` `],[]],l=s.length-1|1)&&a.map(a=>a.join``).join`
`

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