Der Hintergrund

Stellen Sie sich das englische Alphabet vor, das in Großbuchstaben hintereinander geschrieben ist ABCDEFGHIJKLMNOPQRSTUVWXYZ. Angenommen, wir haben ein spezielles Objektiv mit variabler Breite, so dass beim Platzieren über der Reihe ein bestimmtes "Fenster" des Alphabets angezeigt wird, wobei Buchstaben außerhalb des Objektivs nicht sichtbar sind. Zusätzlich hat diese Linse eine Verzerrungseigenschaft, so dass der erste Buchstabe innerhalb der Linse und jeder zweite Buchstabe danach in Kleinbuchstaben geschrieben wird, die verbleibenden Buchstaben jedoch weiterhin groß geschrieben werden.

Zum Beispiel könnten wir eine Linse mit einer Länge von 5 irgendwo in der Mitte des Alphabets haben platziert und wir würden nur sehen . jKlMn(was Zeit hier , um die Leerzeichen zeigen zu gewährleisten) - man beachte die Kund Msind nach wie vor groß geschrieben, während die j, lund nall niedriger -gehüllt. Wenn wir diese Linse von links nach rechts entlang des Alphabets schieben, werden verschiedene Buchstaben angezeigt und verschiedene Buchstaben groß geschrieben. Die Aufgabe hier besteht darin, die resultierenden Buchstaben auszugeben, während das Objektiv entlang des Alphabets gleitet.

Die Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die eine Eingabe-Ganzzahl verwendet 0 < n < 27und die Zeichenfolge (n) ausgibt oder zurückgibt, die sichtbar sind, wenn das oben beschriebene Objektiv über das Alphabet gleitet.

Bei Werten ngrößer als 1"hängt" das Objektiv zunächst an der linken Seite des Alphabets "ab", sodass nur Adas Objektiv ganz rechts im Objektiv angezeigt wird. Die erste Zeile einer Ausgabe ist daher eine einzelne Zeile A, entweder in Groß- oder Kleinbuchstaben, abhängig von der Länge der Linse.

In ähnlicher Weise wird das Objektiv nicht mehr verschoben, wenn sich das Objektiv ganz Zlinks im Objektiv befindet (was bedeutet, dass die allerletzte Zeile in einer Ausgabe immer 25 Leerzeichen gefolgt von einem Kleinbuchstaben enthält z).

Die Beispiele

Eingang: 1

Ausgabe:

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

Eingang: 4

Ausgabe:

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

Eingang: 26

Ausgabe:

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

Die Regeln

• Standard Eingabe / Ausgabe - Regeln gelten
• Standard Lücken nicht zulässig
• Standard Code-Golfregeln gelten
• Das führende Leerzeichen wie gezeigt ist erforderlich, damit wir wissen, wo wir uns im Alphabet befinden.
• Jede Zeile darf kein nachfolgendes Leerzeichen enthalten (wie gezeigt - die Ausgabe ist kein Rechteck).
• Eine einzelne nachfolgende Newline ist optional.

Pyth, 31 Bytes

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

Probieren Sie es online aus. Testsuite.

Schnell und dreckig.

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`

Wobei \ndas wörtliche Zeilenumbruchzeichen steht. Funktioniert, indem Sie das Ausgaberechteck durchlaufen und Leerzeichen außerhalb der Diagonale ausgeben, während Sie dem Zeichencode 32 hinzufügen, um ihn in alternativen Quadraten in Kleinbuchstaben zu schreiben. Die Verwendung replacescheint 1 Byte länger zu sein:

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

Das ist ungefähr so ​​eng, wie ich es mir vorstellen kann AWK. Mit 3 verschiedenen prints und einem continuewirklich zur Byte-Anzahl hinzufügen.