Dato un numero di input nda 1a 26(o 0a 25), visualizza l'alfabeto leggendo da sinistra a destra fino a e includendo quella lettera corrispondente, con a=1, b=2, c=3, .... Il colpo di scena è che le lettere devono anche essere ripetute in senso verticale corrispondente alla loro posizione nell'alfabeto. I numeri dispari (quando non 1indicizzati) devono essere bilanciati lungo la linea orizzontale, mentre i numeri pari devono alternarsi tra il favorire la parte superiore o inferiore (è possibile scegliere la direzione da seguire per prima). Se stai indicizzando 0, scambia pari / dispari nella frase precedente.

Formulato in altro modo: se il valore alfabetico di una lettera ?è #, allora dovrebbero esserci #copie di quella lettera nell'output, tutte nella #colonna. Queste lettere dovrebbero essere equamente bilanciate sopra e sotto la linea orizzontale che ha il simbolo a. Se le lettere non possono essere bilanciate in modo uniforme, si alternano le lettere "extra" sopra e sotto quella linea.

Ecco i primi sei output ( n = 1,2,3,4,5,6, 1-indicizzati, che scelgono di alternare per primi in fondo), separati da nuove righe, in modo da poter vedere lo schema. I commenti che spiegano lo schema iniziano 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

(salta alcuni a 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

Regole

• È possibile scegliere di stampare in maiuscolo o minuscolo, ma deve essere coerente.
• L'output non può avere spazi bianchi estranei, ad eccezione di una nuova riga finale facoltativa.
• È accettabile un programma completo o una funzione.
• Il numero di input può essere preso tramite qualsiasi formato adatto .
• Sono vietate le scappatoie standard .
• Si tratta di code-golf, quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Jelly ,2018 byte

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

Risposta di Port of my Python. Provalo online.

EDIT: Dennis ha salvato due byte usando Ụ(classifica) invece di Þ(ordina per)!

Python 2, 101 99 byte

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 ha salvato due byte realizzando i x*-(x&2)suffissi come chiave di ordinamento: la metà inferiore dell'immagine risultante non viene influenzata dalla sortedgaranzia di un ordinamento stabile.

Pyth , 26 byte

Un punteggio perfetto per una sfida sull'alfabeto.

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

Provalo online!

Gelatina , 25 byte

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

Provalo online! o verifica tutti i casi di test .

JavaScript (ES6), 127 126 byte

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

Usa il trucco di @ Lynn. Scrivere l'intero alfabeto costava due byte in meno rispetto al calcolo. Modifica: salvato 1 byte grazie a @ETHproductions perché ho dimenticato di notare che in \nrealtà rappresenta il carattere letterale di newline. (Non mi piace inserire nuove righe letterali nella mia risposta quando la linea è così lunga.)