Introdução

Alice é uma linguagem 2D de Martin Ender que possui dois modos de execução diferentes, cardinal e ordinal . Quando o ponteiro de instrução passa através de um espelho (um /ou \), ele alterna de um modo para o outro.

Neste desafio, focaremos no modo ordinal , onde os comandos operam nas seqüências de caracteres e o ponteiro da instrução se move na diagonal, batendo nas bordas do código.

Programas simples que operam apenas no modo ordinal podem ser escritos em um estilo bastante compacto, como no exemplo a seguir:

/fbd/
@aec\

Aqui, o IP é iniciado no modo cardinal da primeira célula indo para o leste, passa pelo primeiro espelho e começa a se mover na diagonal e saltar, executar comandos a, be c. Em seguida, ele encontra o espelho Nordeste que torna vá para o sul em direção ao outro espelho e, em seguida, começar a saltar de volta para o oeste, encontrando comandos d, e, f, e, finalmente @, que termina o programa.

Esse tipo de estrutura é bastante compacto, mas não é fácil escrever e manter (adicionar um único comando pode nos forçar a reordenar a maior parte do código!), Portanto, gostaria que você me ajudasse na formatação.

A tarefa

Dada uma sequência de comandos, em que cada comando é um único caractere ASCII imprimível, reordene-os em duas linhas para que a primeira metade da sequência possa ser lida iniciando no primeiro caractere da segunda linha e depois movendo-se sempre na diagonal para a direita, enquanto a segunda metade pode ser lida, levando os caracteres restantes da direita para a esquerda. Não se preocupe com espelhos e o símbolo de terminação, eu mesmo os adicionarei.

Então, por exemplo, dada a entrada que abcdefvocê deve gerar

fbd
aec

Caso a entrada seja de tamanho ímpar, você deve adicionar um único espaço (que é um noop em Alice) em qualquer lugar, desde que a sequência de comandos encontrados permaneça a mesma. Você também pode optar por imprimir duas linhas com comprimento diferente por um caractere; nesse caso, a menor é considerada como tendo um único espaço no final.

Regras

Isso é código-golfe , a resposta mais curta, em bytes, vence!

• Você pode entrada / saída através de qualquer um dos métodos de entrada / saída padrão
• A entrada consiste em uma única linha de caracteres ASCII imprimíveis
• Uma única nova linha à direita é permitida na saída
• Algumas saídas do seu programa podem não ter um comportamento completamente correto quando executadas como programas da Alice (por exemplo, se o espaço de preenchimento for inserido dentro de uma string literal). Você não precisa se preocupar com essas situações
• As brechas padrão são proibidas

Casos de teste

--Input
abcdef
--Output
fbd
aec

--Input
123
--Output
 2
13
OR
31
 2
OR
3
12
OR
32
1

--Input
O
--Output
O

OR

O

--Input
"Hello, World!"o
--Output
oH!lloo 
""edlr,W

--Input
i.szR.szno
--Output
o.zz.
inssR

--Input
"  ^^} .~[}.~~[}{~~{}[^^^^.""!}"r.h~;a*y'~i.*So
--Output
o *^i}'.*[;.h~r}}~"{.[^
"S .^~ y~a}~~.["{!~"}^^^
(Odd length, your solution may be different)

Gelatina , 15 bytes

œs2U2¦ṚZUJḤ$¦ZY

Experimente online!

Leva a entrada citada.

Explicação:

œs2U2¦ṚZUJḤ$¦ZY Main link, monadic
œs2             Split into 2 chunks of similar lengths, last might be shorter
   U2¦          Reverse the 2nd chunk
      Ṛ         Swap the chunks
       Z        Transpose into chunks of length 2
        UJḤ$¦   Reverse the chunks at even indices (1-indexed)
             Z  Transpose into 2 chunks again
              Y Join by a newline

Alice , 28 bytes

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

Experimente online!

Se o comprimento da entrada for ímpar, isso coloca o espaço de preenchimento no final do programa linearizado, que acaba sendo o primeiro caractere da saída.

Leo escreveu um formatador Ordinal em Alice alguns dias atrás. Depois de adicionar suporte para entradas de tamanho ímpar e remover algumas coisas que não eram necessárias para esse desafio, acabamos com 28 bytes . Eu queria tentar uma abordagem um pouco diferente, que é essa resposta. Infelizmente, ele acabou vinculando 28 bytes, mas pelo menos dessa maneira eu posso postar minha própria solução e deixar Leo postar seu algoritmo original.

Isso usa a idéia realmente inteligente de Leo para dividir uma corda ao meio ..Y;m;.!z?~.

Explicação

Vamos supor que a entrada tenha um comprimento uniforme (porque apenas a preencheremos com um espaço, se não houver). O padrão é um pouco mais fácil de ver se usamos 0123456789como código. A saída necessária seria:

91735
08264

Portanto, a primeira linha contém todas as posições ímpares da entrada e a segunda linha todas as entradas pares. Além disso, se invertermos as posições ímpares, as próprias linhas serão ambas a primeira metade (possivelmente mais longas) intercaladas com o reverso da segunda metade.

Portanto, a ideia básica é:

• Separe a entrada em posições ímpares e pares.
• Preencher as posições ímpares com um espaço, se necessário.
• Inverta as posições ímpares.
• Depois, duas vezes: corte pela metade a sequência atual, inverta a segunda metade, intercale as duas metades, imprima com avanço de linha à direita.

Quanto ao código, isso se parece muito com o tipo de layout que estamos produzindo neste desafio, mas é sutilmente diferente: quando o IP atinge /o final do código, ele é refletido no leste , não no sul. Então, enquanto estiver no modo Cardinal, o IP será contornado para a primeira coluna. O \lá entra novamente no modo Ordinal, para que a segunda metade do código não vá da direita para a esquerda aqui, mas da esquerda para a direita também. Isso é benéfico ao trabalhar com a pilha de endereços de retorno, porque não armazena informações sobre a direção do IP. Isso nos permite salvar alguns bytes, porque o IP se moverá na mesma direção (horizontal) em ambos we k.

O código linearizado é este:

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

Vamos passar por isso:

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.

Geléia , 23 22 bytes

-1 byte graças a Leo (canto inferior esquerdo pode ser o preenchimento)

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

Um programa completo imprimindo o resultado (o link monádico retorna uma lista de listas de caracteres).

Experimente online!ou veja uma suíte de testes .

Como?

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)

JavaScript (ES6), 104 bytes

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>

Funciona emulando o caminho de execução e preenchendo os comandos conforme ele é executado.