Stolice przesuwne

11

Tło

Wyobraź sobie angielski alfabet pisany wielkimi literami - ABCDEFGHIJKLMNOPQRSTUVWXYZ. Załóżmy, że mamy specjalną soczewkę o zmiennej szerokości, która po umieszczeniu nad rzędem pokazuje pewne „okno” alfabetu, z literami na zewnątrz soczewki ukrytym. Dodatkowo, ta soczewka ma charakterystykę wypaczania, dzięki czemu pierwsza litera wewnątrz soczewki, a następnie co druga litera, ma małe litery, ale pozostałe litery wciąż są wielkie.

Na przykład, możemy mieć obiektyw o długości 5 umieszczonego gdzieś w środku alfabetu i chcielibyśmy tylko zobaczyć . jKlMn(okres wiodącym tutaj, aby upewnić się pokazy białymi znakami) - Zanotuj Ki Mnadal są kapitalizowane, natomiast j, li nsą niższe w pudełku Gdy przesuwamy tę soczewkę od lewej do prawej wzdłuż alfabetu, wyświetlane będą różne litery i różne wielkie litery. Tutaj zadaniem jest wyprowadzenie powstałych liter, gdy soczewka przesunie się wzdłuż alfabetu.

Wyzwanie

Napisz program lub funkcję, która przyjmuje całkowitą liczbę wejściową 0 < n < 27i wyświetla lub zwraca ciąg (ciągi), które są widoczne, gdy soczewka opisana powyżej przesuwa się po alfabecie.

W przypadku wartości nwiększych niż 1, obiektyw zaczyna się od „zawieszenia” lewej strony alfabetu, więc tylko Aprawidłowa szczelina jest wyświetlana. Pierwsza linia dowolnego wyniku będzie zatem pojedynczą A, wielką lub małą literą, w zależności od długości obiektywu.

Podobnie, obiektyw kończy przesuwanie, gdy Zznajduje się w lewym skraju szczeliny obiektywu (co oznacza, że ​​ostatnia linia na dowolnym wyjściu będzie zawsze miała 25 spacji, po których następuje mała litera z).

Przykłady

Wejście: 1

Wynik:

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

Wejście: 4

Wynik:

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

Wejście: 26

Wynik:

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

Zasady

  • Standardowe zasady wejścia / wyjścia zastosowanie
  • Standardowe luki zabronione
  • Standardowe zasady code-golf zastosowanie
  • Wymagana jest wiodąca biała spacja, tak jak pokazano, abyśmy wiedzieli, gdzie jesteśmy w alfabecie.
  • Każda linia nie może mieć końcowych białych znaków (jak pokazano - wynik nie jest prostokątem).
  • Pojedyncza nowa linia jest opcjonalna.
code-golf string subsequence AdmBorkBork
źródło
1
Powiązane
Alex A.

Odpowiedzi:

2

JavaScript (ES6), 130 bajtów

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`

Gdzie \nreprezentuje dosłowny znak nowej linii. Działa poprzez zapętlanie prostokąta wyjściowego i wyprowadzanie spacji poza przekątną, dodając 32 do kodu znaku, aby małe litery były wyświetlane na przemian w kwadratach. Używanie replacewydaje się dłuższe o 1 bajt:

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`
Neil
źródło
1

AWK, 160 bajtów

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

To jest tak ciasne, jak tylko mogę wymyślić AWK. Posiadanie 3 różnych prints i continuenaprawdę dodaje do liczby bajtów.

Robert Benson
źródło