फिसलने वाली राजधानियाँ

Question

पृष्ठ - भूमि

पूँजी अक्षरों में एक पंक्ति में लिखी गई अंग्रेजी वर्णमाला की कल्पना कीजिए - ABCDEFGHIJKLMNOPQRSTUVWXYZ। मान लें कि हमारे पास एक विशेष चर-चौड़ाई वाला लेंस है, जिसे जब पंक्ति में रखा जाता है, तो यह वर्णमाला की एक निश्चित "विंडो" दिखाता है, जिसमें लेंस दृश्य से छिपा हुआ होता है। इसके अतिरिक्त, इस लेंस में एक ताना-बाना विशेषता है, ताकि लेंस के अंदर पहला अक्षर और उसके बाद हर दूसरा अक्षर कम-आवरण वाला हो, लेकिन शेष अक्षर अभी भी बड़े अक्षरों में दिखाई देते हैं।

उदाहरण के लिए, हम लंबाई 5 वर्णमाला के बीच में कहीं रखा का एक लेंस हो सकता था और हम केवल देखना होगा . jKlMnनोट - (यहाँ प्रमुख अवधि खाली स्थान के शो सुनिश्चित करने के लिए) Kऔर Mअभी भी बड़ा किया जाता है, जबकि j, lऔर nसभी कम कर रहे हैं -cased। जैसा कि हम इस लेंस को वर्णमाला के साथ बाएं-से-दाएं स्लाइड करते हैं, विभिन्न अक्षरों को दिखाया जाएगा और विभिन्न अक्षरों को कैपिटल किया जाएगा। यहाँ कार्य परिणामी अक्षरों को लेंस स्लाइड के रूप में आउटपुट करना है।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो एक इनपुट पूर्णांक लेता है 0 < n < 27और आउटपुट या स्ट्रिंग (एस) को लौटाता है जो वर्णमाला के पार स्लाइड्स के रूप में वर्णित लेंस के रूप में दिखाई देते हैं।

से nबड़े मूल्यों के लिए 1, लेंस वर्णमाला के बाईं ओर "लटका" द्वारा शुरू होता है, इसलिए केवल Aलेंस के दाएं-सबसे स्लॉट में दिखाया गया है। किसी भी आउटपुट की पहली पंक्ति इस प्रकार Aलेंस की लंबाई के आधार पर एकल या तो पूंजी या लोअरकेस होगी।

इसी तरह, लेंस तब फिसलता है जब लेंस Zके बाएं-सबसे स्लॉट में होता है (जिसका अर्थ है कि किसी भी आउटपुट में बहुत अंतिम पंक्ति हमेशा 25 स्थान पर होगी और उसके बाद एक लोअरकेस होगी z)।

उदाहरण

इनपुट: 1

आउटपुट:

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

इनपुट: 4

आउटपुट:

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

इनपुट: 26

आउटपुट:

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

नियम

• मानक इनपुट / आउटपुट नियम लागू होते हैं
• मानक खामियों को दूर किया
• मानक कोड-गोल्फ नियम लागू होते हैं
• दिखाए गए अनुसार प्रमुख व्हाट्सएप की आवश्यकता है, ताकि हम जान सकें कि हम वर्णमाला में कहां हैं।
• प्रत्येक पंक्ति में व्हॉट्सएप नहीं हो सकता (जैसा कि दिखाया गया है - आउटपुट आयत नहीं है)।
• एक एकल अनुगामी न्यूलाइन वैकल्पिक है।

Comments

संबंधित

— एलेक्स ए।

Answer 1

पायथ, 31 बाइट्स

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

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

जल्दी और गन्दी।

Answer 2

जावास्क्रिप्ट (ईएस 6), 130 बाइट्स

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`

जहां \nशाब्दिक न्यूलाइन चरित्र का प्रतिनिधित्व करता है। विकर्ण के बाहर आउटपुट आयत और आउटपुट रिक्त स्थान पर लूपिंग करके काम करता है, जबकि वर्ण कोड में 32 जोड़कर इसे वैकल्पिक वर्गों में कम करता है। प्रयोग replace1 बाइट से अधिक लंबा प्रतीत होता है:

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`

Answer 3

AWK, 160 बाइट्स

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

के रूप में तंग के रूप में मैं अंदर आ सकता है AWK। 3 अलग-अलग printएस होने और continueवास्तव में बाइट-गिनती में जोड़ें।