Étant donné un numéro d'entrée nde 1à 26(ou 0à 25), sortez l'alphabet de gauche à droite jusqu'à et y compris la lettre correspondante, avec a=1, b=2, c=3, .... La torsion est que les lettres doivent également être répétées verticalement correspondant à leur position dans l'alphabet. Les nombres impairs (lorsqu'ils sont 1indexés) doivent être équilibrés sur la ligne horizontale, tandis que les nombres pairs doivent alterner entre favoriser le haut ou le bas (vous pouvez choisir la direction à suivre en premier). Si vous indexez 0, échangez impair / pair dans la phrase précédente.

Autrement dit - si la valeur alphabétique d'une lettre ?est #, alors il devrait y avoir des #copies de cette lettre dans la sortie, toutes dans la #e colonne. Ces lettres doivent être également équilibrées au-dessus et au-dessous de la ligne horizontale qui a le a. Si les lettres ne peuvent pas être équilibrées de manière égale, alterner avec la lettre "extra" au-dessus et en dessous de cette ligne.

Voici les six premières sorties ( n = 1,2,3,4,5,6, indexées 1, choisissant d'alterner en bas en premier), séparées par des retours à la ligne, afin que vous puissiez voir le motif. Les commentaires expliquant le modèle commencent par #.

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

(sauter quelques-uns pour 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

Règles

• Vous pouvez choisir de sortir en majuscules ou en minuscules, mais cela doit être cohérent.
• La sortie ne peut pas avoir d'espaces blancs superflus, à l'exception d'une nouvelle ligne de fin facultative.
• Un programme complet ou une fonction sont acceptables.
• Le numéro d'entrée peut être pris via n'importe quel format approprié .
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Gelée ,2018 octets

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

Port de ma réponse Python. Essayez-le en ligne.

EDIT: Dennis a économisé deux octets en utilisant Ụ(grade up) au lieu de Þ(trier par)!

Python 2, 101 99 octets

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 a économisé deux octets en réalisant des x*-(x&2)suffixes comme clé de tri - la moitié inférieure de l'image résultante n'est pas affectée car elle sortedgarantit un tri stable.

Pyth , 26 octets

Un score parfait pour un défi sur l'alphabet.

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

Essayez-le en ligne!

Gelée , 25 octets

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

Essayez-le en ligne! ou vérifiez tous les cas de test .

JavaScript (ES6), 127 126 octets

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

Utilise le truc de tri de @ Lynn. Écrire l'alphabet entier coûtait deux octets moins cher que de le calculer. Edit: sauvé 1 octet grâce à @ETHproductions car j'ai oublié de noter que cela \nreprésente en fait le caractère littéral de la nouvelle ligne. (Je n'aime pas mettre de nouvelles lignes littérales dans ma réponse quand la ligne est si longue.)