Lo sfondo

Immagina l'alfabeto inglese scritto in lettere maiuscole - ABCDEFGHIJKLMNOPQRSTUVWXYZ. Supponiamo di avere una lente a larghezza variabile speciale tale che, quando posizionata sopra la fila, mostri una certa "finestra" dell'alfabeto, con le lettere all'esterno della lente nascoste alla vista. Inoltre, questa lente ha una caratteristica di deformazione, in modo che la prima lettera all'interno della lente, e successivamente ogni seconda lettera, sia maiuscola, ma le lettere rimanenti mostrano ancora in maiuscolo.

Ad esempio, potremmo avere una lente di lunghezza di 5 posti qualche parte nel mezzo dell'alfabeto e vorremmo solo vedere . jKlMn(che conduce periodo qui per garantire spazi bianchi spettacoli) - nota il Ke Mancora maiuscola, mentre il j, le nsiamo tutti più bassa -cased. Mentre facciamo scorrere questa lente da sinistra a destra lungo l'alfabeto, verranno visualizzate lettere diverse e lettere maiuscole diverse. Il compito qui è di produrre le lettere risultanti mentre l'obiettivo scorre lungo l'alfabeto.

La sfida

Scrivi un programma o una funzione che accetta un numero intero di input 0 < n < 27e genera o restituisce le stringhe che sono visibili mentre l'obiettivo sopra descritto scorre attraverso l'alfabeto.

Per valori nsuperiori a 1, l'obiettivo inizia "appendendo" sul lato sinistro dell'alfabeto, quindi Anella parte più a destra dell'obiettivo viene visualizzato solo il simbolo. La prima riga di qualsiasi output sarà quindi una singola A, maiuscola o minuscola a seconda della lunghezza dell'obiettivo.

Allo stesso modo, l'obiettivo finisce di scivolare quando si Ztrova nello slot più a sinistra dell'obiettivo (il che significa che l'ultima riga in qualsiasi uscita sarà sempre di 25 spazi seguita da una minuscola z).

Gli esempi

Ingresso: 1

Produzione:

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

Ingresso: 4

Produzione:

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

Ingresso: 26

Produzione:

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

Le regole

• Si applicano le regole standard di input / output
• Scappatoie standard non consentite
• Si applicano le regole standard del code-golf
• È richiesto lo spazio bianco principale come mostrato, in modo da sapere dove siamo nell'alfabeto.
• Ogni riga non può avere spazi vuoti finali (come mostrato - l'output non è un rettangolo).
• Una nuova riga finale è facoltativa.

Pyth, 31 byte

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

Provalo online. Suite di test.

Veloce e sporco.

JavaScript (ES6), 130 byte

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`

Dove \nrappresenta il carattere letterale di newline. Funziona eseguendo il ciclo sul rettangolo di output e producendo spazi all'esterno della diagonale, aggiungendo 32 al codice carattere per minuscola in quadrati alternati. L'uso replacesembra essere più lungo di 1 byte:

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 byte

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

Questo è il più stretto possibile AWK. Avere 3 prints differenti e un valore continueaggiunto al conteggio dei byte.