El fondo

Imagine el alfabeto inglés escrito en una fila en mayúsculas - ABCDEFGHIJKLMNOPQRSTUVWXYZ. Supongamos que tenemos una lente especial de ancho variable de tal manera que, cuando se coloca sobre la fila, muestra una cierta "ventana" del alfabeto, con letras fuera de la lente ocultas a la vista. Además, esta lente tiene una característica de deformación, de modo que la primera letra dentro de la lente, y cada segunda letra a partir de entonces, está en minúscula, pero las letras restantes aún aparecen en mayúscula.

Por ejemplo, podríamos tener una lente de longitud 5 colocado en algún lugar en medio del alfabeto y sólo nos veríamos . jKlMn(período previo para garantizar espacios en blanco espectáculos) - Nota del Ky Mtodavía estamos mayúscula, mientras que el j, ly ntodos somos más baja en estuche A medida que deslizamos este lente de izquierda a derecha a lo largo del alfabeto, se mostrarán diferentes letras y se capitalizarán diferentes letras. La tarea aquí es generar las letras resultantes a medida que la lente se desliza a lo largo del alfabeto.

El reto

Escriba un programa o función que tome un número entero de entrada 0 < n < 27y produzca o devuelva las cadenas que son visibles a medida que la lente descrita anteriormente se desliza por el alfabeto.

Para valores nmayores que 1, la lente comienza colgando del lado izquierdo del alfabeto, por lo que solo Ase muestra en la ranura más a la derecha de la lente. La primera línea de cualquier salida será, por lo tanto A, mayúscula o minúscula, dependiendo de la longitud de la lente.

Del mismo modo, la lente termina de deslizarse cuando Zestá en la ranura más a la izquierda de la lente (lo que significa que la última línea en cualquier salida siempre será 25 espacios seguidos de una minúscula z).

Los ejemplos

Entrada: 1

Salida:

a
 b
  c
   d
    e
     f
      g
       h
        i
         j
          k
           l
            m
             n
              o
               p
                q
                 r
                  s
                   t
                    u
                     v
                      w
                       x
                        y
                         z

Entrada: 4

Salida:

A
aB
AbC
aBcD
 bCdE
  cDeF
   dEfG
    eFgH
     fGhI
      gHiJ
       hIjK
        iJkL
         jKlM
          kLmN
           lMnO
            mNoP
             nOpQ
              oPqR
               pQrS
                qRsT
                 rStU
                  sTuV
                   tUvW
                    uVwX
                     vWxY
                      wXyZ
                       xYz
                        yZ
                         z

Entrada: 26

Salida:

A
aB
AbC
aBcD
AbCdE
aBcDeF
AbCdEfG
aBcDeFgH
AbCdEfGhI
aBcDeFgHiJ
AbCdEfGhIjK
aBcDeFgHiJkL
AbCdEfGhIjKlM
aBcDeFgHiJkLmN
AbCdEfGhIjKlMnO
aBcDeFgHiJkLmNoP
AbCdEfGhIjKlMnOpQ
aBcDeFgHiJkLmNoPqR
AbCdEfGhIjKlMnOpQrS
aBcDeFgHiJkLmNoPqRsT
AbCdEfGhIjKlMnOpQrStU
aBcDeFgHiJkLmNoPqRsTuV
AbCdEfGhIjKlMnOpQrStUvW
aBcDeFgHiJkLmNoPqRsTuVwX
AbCdEfGhIjKlMnOpQrStUvWxY
aBcDeFgHiJkLmNoPqRsTuVwXyZ
 bCdEfGhIjKlMnOpQrStUvWxYz
  cDeFgHiJkLmNoPqRsTuVwXyZ
   dEfGhIjKlMnOpQrStUvWxYz
    eFgHiJkLmNoPqRsTuVwXyZ
     fGhIjKlMnOpQrStUvWxYz
      gHiJkLmNoPqRsTuVwXyZ
       hIjKlMnOpQrStUvWxYz
        iJkLmNoPqRsTuVwXyZ
         jKlMnOpQrStUvWxYz
          kLmNoPqRsTuVwXyZ
           lMnOpQrStUvWxYz
            mNoPqRsTuVwXyZ
             nOpQrStUvWxYz
              oPqRsTuVwXyZ
               pQrStUvWxYz
                qRsTuVwXyZ
                 rStUvWxYz
                  sTuVwXyZ
                   tUvWxYz
                    uVwXyZ
                     vWxYz
                      wXyZ
                       xYz
                        yZ
                         z

Las normas

• Aplican reglas estándar de entrada / salida
• Lagunas estándar no permitidas
• Aplican reglas estándar de código de golf
• Se requiere el espacio en blanco inicial como se muestra, para que sepamos dónde estamos en el alfabeto.
• Cada línea no puede tener espacios en blanco al final (como se muestra, la salida no es un rectángulo).
• Una nueva línea final es opcional.

Pyth, 31 bytes

Vr_tQ26s.erb%+Nk2+*Nd:GeS,0N+NQ

Pruébalo en línea. Banco de pruebas.

Rápido y sucio.

JavaScript (ES6), 130 bytes

n=>[...Array(n+25)].map(_=>[...Array(26)].map(_=>String.fromCharCode(j++<i|i+n<j?32:j+(j-i)%2*32),++i,j=64).join``,i=64-n).join`\n`

Donde \nrepresenta el carácter de nueva línea literal. Funciona girando sobre el rectángulo de salida y generando espacios fuera de la diagonal mientras agrega 32 al código de caracteres para minúsculas en cuadrados alternos. El uso replaceparece ser 1 byte más largo:

n=>[...Array(n+25)].map(_=>' '.repeat(26).replace(/./g,s=>j++<i|i+n<j?s:String.fromCharCode(j+(j-i)%2*32),++i,j=64),i=64-n).join`\n`

AWK, 160 bytes

{d=-$1
m=25
for(;i<m+$1;i++){f="%"(++d<0?0:d<m?d:m)"s"
c=u=65
l=97
printf f,""
for(j=++E-$1;j<E&&j<26;j++){c=c==u?l:u
if(j<0)continue
printf("%c",j+c)}print""}}

Eso es lo más ajustado que se me ocurre AWK. Tener 3 printsy diferentes y continuerealmente agregar al conteo de bytes.