Bối cảnh

Hãy tưởng tượng bảng chữ cái tiếng Anh được viết thành một hàng bằng chữ in hoa - ABCDEFGHIJKLMNOPQRSTUVWXYZ. Giả sử chúng ta có một ống kính có chiều rộng thay đổi đặc biệt sao cho khi đặt trên hàng, nó sẽ hiển thị một "cửa sổ" nhất định của bảng chữ cái, với các chữ cái bên ngoài ống kính bị che khuất khỏi tầm nhìn. Ngoài ra, ống kính này có đặc tính cong vênh, sao cho chữ cái đầu tiên bên trong ống kính và mỗi chữ cái thứ hai sau đó được đặt thấp hơn, nhưng các chữ cái còn lại vẫn hiển thị viết hoa.

Ví dụ, chúng ta có thể có một ống kính có độ dài 5 đặt ở đâu đó ở giữa của bảng chữ cái và chúng tôi sẽ chỉ nhìn thấy . jKlMn(kỳ hàng đầu ở đây để đảm bảo khoảng trắng show) - lưu ý các Kvà Mvẫn đang được vốn, trong khi j, lvà ntất cả đều thấp hơn theo đuổi. Khi chúng ta trượt ống kính này từ trái sang phải dọc theo bảng chữ cái, các chữ cái khác nhau sẽ được hiển thị và các chữ cái khác nhau được viết hoa. Nhiệm vụ ở đây là xuất các chữ cái kết quả khi ống kính trượt dọc theo bảng chữ cái.

Các thách thức

Viết chương trình hoặc hàm lấy số nguyên đầu vào 0 < n < 27và xuất hoặc trả về (các) chuỗi có thể nhìn thấy khi ống kính được mô tả ở trên các trang trình bày trên bảng chữ cái.

Đối với các giá trị nlớn hơn 1, ống kính bắt đầu bằng cách "treo" bên trái bảng chữ cái, do đó, chỉ có giá trị Ađược hiển thị ở khe ngoài cùng bên phải của ống kính. Do đó, dòng đầu tiên của bất kỳ đầu ra nào sẽ là một Achữ cái in hoa hoặc viết thường tùy thuộc vào độ dài của ống kính.

Tương tự, ống kính kết thúc trượt khi Znằm ở khe ngoài cùng bên trái của ống kính (có nghĩa là dòng cuối cùng trong bất kỳ đầu ra nào sẽ luôn là 25 khoảng trắng theo sau là chữ thường z).

Các ví dụ

Đầu vào: 1

Đầu ra:

Đầu vào: 4

Đầu ra:

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

Đầu vào: 26

Đầu ra:

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

Những quy định

Quy tắc đầu vào / đầu ra tiêu chuẩn được áp dụng
Sơ hở tiêu chuẩn không được phép
Luật golf tiêu chuẩn được áp dụng
Khoảng trắng hàng đầu như được hiển thị là bắt buộc, để chúng tôi biết chúng ta đang ở đâu trong bảng chữ cái.
Mỗi dòng không thể có khoảng trắng ở cuối (như được hiển thị - đầu ra không phải là hình chữ nhật).
Một dòng mới duy nhất là tùy chọn.

code-golf string subsequence

— AdBorkBork
nguồn

1

Liên quan

— Alex A.

2

Bình thường, 31 byte

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

Hãy thử trực tuyến. Bộ thử nghiệm.

Nhanh chóng và hèn hạ.

— PurkkaKoodari
nguồn

2

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`

Trường hợp \nđại diện cho nhân vật dòng chữ mới. Hoạt động bằng cách lặp qua hình chữ nhật đầu ra và xuất ra các khoảng trắng bên ngoài đường chéo trong khi thêm 32 vào mã ký tự để viết thường nó trong các ô vuông thay thế. Việc sử dụng replacedường như dài hơn 1 byte:

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
nguồn

1

AWK, 160 byte

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

Đó là khoảng chặt chẽ như tôi có thể đến với AWK. Có 3 prints khác nhau và continuethực sự thêm vào số byte.

— Robert Benson
nguồn

Thủ đô trượt

Bối cảnh

Các thách thức

Các ví dụ

Những quy định

Bình thường, 31 byte

JavaScript (ES6), 130 byte

AWK, 160 byte