Introducción

Alice es un lenguaje bidimensional de Martin Ender que tiene dos modos de ejecución diferentes, cardinal y ordinal . Cuando el puntero de instrucciones pasa a través de un espejo (ya sea /o \), cambia de un modo a otro.

En este desafío, nos centraremos en el modo ordinal , donde los comandos operan en cadenas y el puntero de instrucciones se mueve en diagonal, rebotando contra los bordes del código.

Los programas simples que operan solo en modo ordinal se pueden escribir en un estilo bastante compacto, como en el siguiente ejemplo:

/fbd/
@aec\

Aquí el IP se inicia en modo cardinal de la primera célula hacia el este, pasa por el primer espejo y comienza a moverse en diagonal y rebotando, la ejecución de comandos a, by c. A continuación, se encuentra con el espejo noreste, que hace que se vaya al sur hacia el otro espejo y luego empezar a rebotar hacia el oeste, encontrándose con los comandos d, e, f, y, por último @, que termina el programa.

Este tipo de estructura es bastante compacta, pero no es fácil de escribir y mantener (¡agregar un solo comando podría obligarnos a reordenar la mayor parte del código!), Por lo que me gustaría que me ayudara con el formateo.

La tarea

Dada una secuencia de comandos, donde cada comando es un único carácter ASCII imprimible, reordenarlos en dos líneas para que la primera mitad de la secuencia pueda leerse comenzando desde el primer carácter de la segunda línea y luego moviéndose siempre diagonalmente hacia la derecha, mientras que la segunda mitad se puede leer tomando los caracteres restantes de derecha a izquierda. No se preocupe por los espejos y el símbolo de terminación, los agregaré yo mismo.

Entonces, por ejemplo, dada la entrada abcdefque debe generar

fbd
aec

En caso de que la entrada sea de longitud impar, debe agregar un solo espacio (que es un noop en Alice) en cualquier lugar, siempre que la secuencia de comandos encontrados permanezca igual. También puede optar por generar dos líneas que difieran en longitud por un carácter, en cuyo caso se considera que la más corta tiene un solo espacio al final.

Reglas

Este es el código de golf , la respuesta más corta, en bytes, gana.

• Puede ingresar / salir a través de cualquiera de los métodos de entrada / salida predeterminados
• La entrada consiste en una sola línea de caracteres ASCII imprimibles
• Se permite una nueva línea final en la salida
• Algunas salidas de su programa pueden no tener un comportamiento completamente correcto cuando se ejecutan como programas de Alice (por ejemplo, si el espacio de relleno se inserta dentro de un literal de cadena). No tiene que preocuparse por estas situaciones.
• Las lagunas estándar están prohibidas

Casos de prueba

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

Jalea , 15 bytes

œs2U2¦ṚZUJḤ$¦ZY

Pruébalo en línea!

Toma la entrada citada.

Explicación:

œ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@/

Pruébalo en línea!

Si la longitud de entrada es impar, esto coloca el espacio de relleno al final del programa linealizado, que termina siendo el primer carácter de la salida.

Leo escribió un formateador ordinal en Alice hace unos días. Después de agregar soporte para entradas de longitud impar y luego eliminar algunas cosas que no eran necesarias para este desafío, terminamos en 28 bytes . Quería probar un enfoque ligeramente diferente, que es esta respuesta. Desafortunadamente, terminó empatando 28 bytes, pero al menos de esta manera puedo publicar mi propia solución y dejar que Leo publique su algoritmo original.

Esto usa la idea realmente inteligente de Leo para dividir una cadena por la mitad ..Y;m;.!z?~.

Explicación

Supongamos que la entrada tiene una longitud uniforme (porque la rellenaremos con un espacio si no es así). El patrón es un poco más fácil de ver si lo usamos 0123456789como código. El resultado requerido sería:

91735
08264

Entonces, la primera línea contiene todas las posiciones impares de la entrada y la segunda línea todas las entradas pares. Además, si invertimos las posiciones impares, entonces las líneas en sí son la primera mitad (posiblemente más larga) intercaladas con el reverso de la segunda mitad.

Entonces la idea básica es:

• Entrada separada en posiciones pares e impares.
• Rellene las posiciones impares con un espacio si es necesario.
• Invierta las posiciones impares.
• Luego dos veces: reducir a la mitad la cadena actual, invertir la segunda mitad, intercalar ambas mitades, imprimir con salto de línea final.

En cuanto al código, se parece mucho al tipo de diseño que estamos produciendo en este desafío, pero es sutilmente diferente: cuando la IP llega /al final del código, se refleja al este , no al sur. Luego, mientras está en modo Cardinal, la IP se ajustará a la primera columna. El \no vuelve a entrar en el modo ordinal, por lo que la segunda mitad del código no va de derecha a izquierda aquí, pero de izquierda a derecha también. Esto es beneficioso cuando se trabaja con la pila de dirección de retorno, ya que no almacena información sobre la dirección de la IP. Esto nos permite guardar algunos bytes porque la IP se moverá en la misma dirección (horizontal) en ambos wy k.

El código linealizado es este:

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

Vamos a verlo:

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.

Jalea , 23 22 bytes

-1 byte gracias a Leo (la parte inferior izquierda puede ser el relleno)

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

Un programa completo que imprime el resultado (el enlace monádico devuelve una lista de listas de listas de caracteres).

Pruébalo en línea! o ver un conjunto de pruebas .

¿Cómo?

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 la ruta de ejecución y completando los comandos a medida que avanza.