O fundo

Imagine o alfabeto inglês escrito em letras maiúsculas - ABCDEFGHIJKLMNOPQRSTUVWXYZ. Suponha que tenhamos uma lente especial de largura variável, que, quando colocada sobre a linha, mostre uma certa "janela" do alfabeto, com letras fora da lente ocultas da vista. Além disso, essa lente possui uma característica de distorção, de modo que a primeira letra dentro da lente e a cada segunda letra posteriormente é em letras minúsculas, mas as letras restantes ainda aparecem em maiúsculas.

Por exemplo, poderíamos ter uma lente de comprimento 5 colocado em algum lugar no meio do alfabeto e nós só iria ver . jKlMn(período que antecedeu aqui para garantir espaços em branco mostra) - nota o Ke Mainda são capitalizados, enquanto a j, le nsão todos menores -caso. À medida que deslizamos essa lente da esquerda para a direita ao longo do alfabeto, diferentes letras serão mostradas e diferentes em maiúsculas. A tarefa aqui é produzir as letras resultantes conforme a lente desliza ao longo do alfabeto.

O desafio

Escreva um programa ou função que utilize um número inteiro de entrada 0 < n < 27e produza ou retorne as strings visíveis quando a lente descrita acima desliza pelo alfabeto.

Para valores nmaiores que 1, a lente começa "pendurando" no lado esquerdo do alfabeto, portanto, apenas o Aé mostrado no slot mais à direita da lente. A primeira linha de qualquer saída será, portanto, uma única A, maiúscula ou minúscula, dependendo do comprimento da lente.

Da mesma forma, a lente termina de deslizar quando Zestá no slot mais à esquerda da lente (o que significa que a última linha em qualquer saída será sempre 25 espaços seguidos por uma minúscula z).

Os exemplos

Entrada: 1

Resultado:

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

Resultado:

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

Resultado:

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

As regras

• Aplicam- se regras de entrada / saída padrão
• Lacunas padrão não permitidas
• Aplicam- se regras de código-golfe padrão
• O espaço em branco à esquerda, conforme mostrado, é necessário, para que possamos saber onde estamos no alfabeto.
• Cada linha não pode ter espaços em branco à direita (como mostrado - a saída não é um retângulo).
• Uma única nova linha à direita é opcional.

Pitão, 31 bytes

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

Experimente online. Suíte de teste.

Rapido e sujo.

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`

Onde \nrepresenta o caractere literal de nova linha. Funciona fazendo um loop sobre o retângulo de saída e produzindo espaços fora da diagonal enquanto adiciona 32 ao código de caractere para minúscula em quadrados alternativos. O uso replaceparece ter 1 byte a mais:

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""}}

Isso é o mais apertado possível AWK. Ter 3 se diferente printe continuerealmente adicionar à contagem de bytes.