Dado un número de entrada nde 1a 26(o 0to 25), genera la lectura del alfabeto de izquierda a derecha hasta e incluyendo esa letra correspondiente, con a=1, b=2, c=3, .... El giro es que las letras también deben repetirse verticalmente correspondientes a su posición en el alfabeto. Los números impares (cuando están 1indexados) deben equilibrarse a través de la línea horizontal, mientras que los números pares deben alternar entre favorecer la parte superior o inferior (puede elegir qué dirección ir primero). Si está indexando a 0, intercambie impar / par en la oración anterior.

Dicho de otra manera: si el valor alfabético de una letra ?es #, entonces debería haber #copias de esa letra en la salida, todas ellas en la #columna th. Estas letras deben estar equilibradas por encima y debajo de la línea horizontal que tiene el a. Si las letras no se pueden equilibrar de manera uniforme, alterne teniendo la letra "extra" encima y debajo de esa línea.

Aquí están las primeras seis salidas ( n = 1,2,3,4,5,6indexadas en 1, eligiendo alternar primero a la parte inferior), separadas por nuevas líneas, para que pueda ver el patrón. Los comentarios que explican el patrón comienzan con #.

a         # On a line by itself

ab
 b        # The "extra" letter is below the horizontal

  c
abc       # The 'c' splits evenly
 bc

   d      # Because the 'b' was below, the extra 'd' must be above
  cd
abcd
 bcd


   de
  cde
abcde     # The 'e' balances
 bcde
    e

   def
  cdef
abcdef
 bcdef
    ef
     f    # Since the 'd' was above, the extra 'f' must be below

(omita algunos para n=26)

                       xyz
                      wxyz
                   tuvwxyz
                  stuvwxyz
               pqrstuvwxyz
              opqrstuvwxyz
           lmnopqrstuvwxyz
          klmnopqrstuvwxyz
       hijklmnopqrstuvwxyz
      ghijklmnopqrstuvwxyz
   defghijklmnopqrstuvwxyz
  cdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz
 bcdefghijklmnopqrstuvwxyz
    efghijklmnopqrstuvwxyz
     fghijklmnopqrstuvwxyz
        ijklmnopqrstuvwxyz
         jklmnopqrstuvwxyz
            mnopqrstuvwxyz
             nopqrstuvwxyz
                qrstuvwxyz
                 rstuvwxyz
                    uvwxyz
                     vwxyz
                        yz
                         z

Reglas

• Puede elegir la salida en mayúsculas o minúsculas, pero debe ser coherente.
• La salida no puede tener espacios en blanco extraños, a excepción de una nueva línea final opcional.
• Un programa completo o una función son aceptables.
• El número de entrada se puede tomar a través de cualquier formato adecuado .
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

jalea ,2018 bytes

Ḷ&2’×ḶỤØaḣ⁸¤ṫW€UGU

Puerto de mi respuesta Python. Pruébalo en línea.

EDITAR: ¡Dennis guardó dos bytes usando Ụ(subir de grado) en lugar de Þ(ordenar por)!

Python 2, 101 99 bytes

r=range(input())
for x in sorted(r,key=lambda x:x*-(x&2)):print bytearray([97+i,32][i<x]for i in r)

xsot ahorró dos bytes al darse cuenta de que es x*-(x&2)suficiente como una clave de clasificación: la mitad inferior de la imagen resultante no se ve afectada debido a la sortedgarantía de una clasificación estable.

Pyth , 26 bytes

Una puntuación perfecta para un desafío sobre el alfabeto.

j_C.e<u_G/k2.[.|1Q*hkbdQ<G

Pruébalo en línea!

Jalea , 25 bytes

RØaxŒgz⁶W€;ṚL‘$¡¥/Ṛ⁸H¤¡j⁷

Pruébalo en línea! o verificar todos los casos de prueba .

Javascript (ES6), 127 126 bytes

n=>[...Array(n).keys()].sort((a,b)=>a*~-(a&2)-b*~-(b&2)).map(i=>` `.repeat(i)+`abcdefghijklmnopqrstuvwxyz`.slice(i,n)).join`\n`

Utiliza el truco de @ Lynn. Escribir el alfabeto completo era dos bytes más barato que calcularlo. Editar: guardado 1 byte gracias a @ETHproductions porque olvidé señalar que en \nrealidad representa el carácter de nueva línea literal. (No me gusta poner nuevas líneas literales en mi respuesta cuando la línea es tan larga).