L'arrière-plan

Imaginez l'alphabet anglais écrit consécutivement en majuscules - ABCDEFGHIJKLMNOPQRSTUVWXYZ. Supposons que nous ayons un objectif spécial à largeur variable tel que, placé au-dessus de la ligne, il montre une certaine "fenêtre" de l'alphabet, avec des lettres à l'extérieur de l'objectif cachées. De plus, cette lentille a une caractéristique de déformation, de sorte que la première lettre à l'intérieur de la lentille, et toutes les deux lettres par la suite, sont en minuscules, mais les lettres restantes sont toujours en majuscule.

Par exemple, nous pourrions avoir une lentille de longueur 5 placé quelque part au milieu de l'alphabet et nous ne verriez . jKlMn(leader période ici pour assurer espaces blancs spectacles) - Noter la Ket Msommes toujours en majuscule, tandis que le j, let nsont tous inférieurs -cased. Lorsque nous glissons cet objectif de gauche à droite le long de l'alphabet, différentes lettres sont affichées et différentes lettres en majuscule. La tâche ici est de sortir les lettres résultantes lorsque l'objectif glisse le long de l'alphabet.

Le défi

Écrivez un programme ou une fonction qui prend un entier en entrée 0 < n < 27et génère ou renvoie la ou les chaînes visibles lorsque l'objectif décrit ci-dessus glisse sur l'alphabet.

Pour des valeurs nsupérieures à 1, l'objectif commence par "accrocher" sur le côté gauche de l'alphabet, de sorte que seul As'affiche dans la fente la plus à droite de l'objectif. La première ligne de n'importe quelle sortie sera donc une seule A, en majuscule ou en minuscule selon la longueur de l'objectif.

De même, l'objectif finit de glisser lorsque le Zest dans la fente la plus à gauche de l'objectif (ce qui signifie que la toute dernière ligne de n'importe quelle sortie sera toujours de 25 espaces suivis d'un minuscule z).

Les exemples

Contribution: 1

Production:

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

Contribution: 4

Production:

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

Contribution: 26

Production:

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

Les règles

• Les règles d'entrée / sortie standard s'appliquent
• Failles standard non autorisées
• Les règles de code-golf standard s'appliquent
• Le premier espace comme indiqué est requis, afin que nous sachions où nous en sommes dans l'alphabet.
• Chaque ligne ne peut pas avoir d'espace blanc de fin (comme indiqué - la sortie n'est pas un rectangle).
• Une seule nouvelle ligne de fin est facultative.

Pyth, 31 octets

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

Essayez-le en ligne. Suite de tests.

Rapide et sale.

JavaScript (ES6), 130 octets

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`

Où \nreprésente le caractère de nouvelle ligne littéral. Fonctionne en faisant une boucle sur le rectangle de sortie et en sortant des espaces en dehors de la diagonale tout en ajoutant 32 au code de caractère pour le mettre en minuscules dans des carrés alternés. L'utilisation replacesemble être de 1 octet de plus:

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 octets

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

C'est à peu près aussi serré que possible AWK. Avoir 3 prints différents et continuevraiment ajouter au nombre d'octets.