विकर्ण वर्णमाला

66

बिना किसी इनपुट के, आपका कार्य निम्नलिखित को उत्पन्न करना है:

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

गैर-कानूनी रूप से, आपका कार्य वर्णमाला के प्रत्येक अक्षर को उत्पन्न करना है, इससे पहले कि वह वर्णमाला के शून्य से एक स्थान के बराबर है।

यदि आप इसे प्रिंट करते हैं, तो यह ऊपर की तरह दिखाई देगा। बाहरी व्हाट्सएप जो उपस्थिति को प्रभावित नहीं करता है, साथ ही साथ एक अनुगामी न्यूलाइन की अनुमति है। आप सभी लोअरकेस, या सभी अपरकेस का उपयोग कर सकते हैं।

आप इसे सामान्य नियमों के अनुसार एक फ़ंक्शन से भी वापस कर सकते हैं, या तो नई सूचियों के साथ एक स्ट्रिंग या स्ट्रिंग की सूची के रूप में।

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!

code-golf  kolmogorov-complexity  alphabet 
— स्टीफन
स्रोत
क्या रिक्त स्थान को वास्तविक ASCII स्थान होना चाहिए, या क्या मैं जैसे आउटपुट दे सकता हूं a<VERTICAL-TAB>b<VERTICAL-TAB>c...? कैसे के बारे में अगर वहाँ भी कुछ बैकस्पेस वर्ण हैं? जब तक दृश्य परिणाम समान है?
— डिजिटल ट्रामा
@DigitalTrauma जब तक यह एक ही प्रतीत होता है, मुझे परवाह नहीं है कि आप किस तरह के व्हाट्सएप का उपयोग करते हैं।
— स्टीफन
क्या मैं रिक्त स्थान के बजाय टैब का उपयोग कर सकता हूं?
@ yamboy1 हम्म, शायद नहीं। अधिकांश टैब बड़ी संख्या में रिक्त स्थान पर सेट किए जाते हैं - यदि आपका विकर्ण ऐसा दिखता है कि इसमें 4रिक्त स्थान हैं b, तो यह बहुत विकर्ण नहीं दिखेगा। यदि यह ढलान की तरह लग रहा है ~ -1तो यह ठीक है।
— स्टीफन
उपस्थिति को प्रभावित नहीं करता है जिसमें एक अतिरिक्त अग्रणी स्थान या 2 शामिल हैं?
— माइल्डलीवेटकॉस्ट

जवाबों:

87

चारकोल , 2 बाइट्स

↘β

इसे ऑनलाइन आज़माएं!

कैसे?

 β - the lowercase alphabet
↘  - direction

बिल्कुल उसी तरह की चुनौती जिसके लिए मूल रूप से चारकोल डिजाइन किया गया था।

— जोनाथन एलन
स्रोत
4
सही भाषा :)
— स्टीफन
2
यह मुझे याद दिलाता है, मुझे शायद क्रेयॉन पर कुछ और काम करना चाहिए ... मेरा मानना ​​है ↘"abc ... xyz"qकि यह सबसे कम काम करने वाला कार्यक्रम होगा। ( इसे ऑनलाइन आज़माएं! ) ↘``26O;)qकाम करना चाहिए (एक बैकटिक के साथ शुरू करें; प्रत्येक I के लिए 0 ... 25 में, निहितार्थ पॉप करें, बैकटिक और आउटपुट बढ़ाएँ), लेकिन यह किसी कारण के लिए "खाली स्टैक" त्रुटि फेंकता है .. ।
— ETHproductions
2
2 बाइट्स ?! SOUTH EAST ARROW एक सिंगल बाइट किस एन्कोडिंग में है?
— व्येक
6
@Wyck चारकोल (नोट: अटकलें) एक कस्टम कोड पृष्ठ का उपयोग करता है, जिसे 1 बाइट निर्देशों के लिए संकुचित किया जा सकता है। यह कोड गोल्फ के लिए वैध है। codegolf.meta.stackexchange.com/questions/9428/…
— ड्रेको 18s
14
@StephenS, मुझे लगता है कि आप नीचे-दाईं भाषा का मतलब है :)
— Wossname
18

सी, 45 बाइट्स

f(i){for(i=0;++i<27;)printf("%*c\n",i,i+96);}

5 बाइट बचाने के लिए @ डेनिस को धन्यवाद !

— Doorknob
स्रोत
9
मेरी मशीन पर काम करता है ™
— विनाशकारी नींबू
मुझे लगता है कि आपको iकिसी बिंदु पर आरंभ या रीसेट करना होगा। कम से कम TIO पर, f()केवल एक बार काम करता है ।
— डेनिस
@ डेनिस आह, आप सही कह रहे हैं। तय किया कि
— दोर्कनोब
f(i){for(i=0;++i<27;printf("%*c\n",i,i+96));}कुछ बाइट्स बचाता है।
— डेनिस
3
f(i){for(i=96;i<122;)printf("%c\v",++i);}41 बाइट्स के लिए - इसे वास्तविक टर्मिनल पर चलाना सुनिश्चित करें (हाँ, यह अनुमति है )
— NieDzejkob
13

05AB1E , 14 8 6 बाइट्स

-2 बाइट्स @Emigna की बदौलत

AvyNú»

यह काम किस प्रकार करता है

A      # lowercase alphabet
 v     # for letter in alphabet
  y    # push letter
   N   # push index of letter
    ú  # Pad letter with index of letter spaces
     » # Join with stack on newline.

इसे ऑनलाइन आज़माएं!

मूल संस्करण, 14 बाइट्स

26FNð×N65+ç«}»
— नील ए।
स्रोत
आप के साथ एक और 2 बाइट्स बचा सकते हैं AvyNú»।
— इमीना
@Emigna: धन्यवाद! में संपादित करेंगे।
— नील ए।
ƶबहुत सही लगता है, लेकिन यह नहीं है :(।
— मैजिक ऑक्टोपस Urn
Λशायद समय पर अभी तक उपलब्ध नहीं था, लेकिन 26A3Λएक बाइट बचाता है।
— केविन क्रूज़सेन
1
@MagicOctopusUrn और ₂A3Λभी छोटा होता।
— केविन क्रूज़सेन
12

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

f=(n=10)=>n-36?" ".repeat(n-10)+n.toString(++n)+`
`+f(n):""

एक पुनरावर्ती कार्य जो एक अनुगामी न्यूलाइन के साथ एक स्ट्रिंग लौटाता है।

— ETHproductions
स्रोत
1
वाह, यह बहुत डरपोक है। एक संख्या को 10 से 36 की संख्या में एक अजीब आधार में परिवर्तित करना। अभी तक समझ में नहीं आया कि आधार को हालांकि बढ़ाना है।
— स्टीव बेनेट
2
@SteveBennett सही है, लेकिन n.toString(++n)+f(n)बाइट से कम है n.toString(36)+f(n+1)।
— ETHproductions
1
आप f=(n=10,s='')=>n-36?s+n.toString(++n)+'\n'+f(n,s+' '):""55 के लिए कर सकते हैं ।
— अरनुलद
1
कुछ ईएस 8 के साथ एक बाइट सहेजें "".padEnd(n-10)+n.toString(++n):।
— झबरा
1
@ अर्नुलड, अनुमन्य f=(n=10,s='')=>n-36?s+n.toString(++n)+'\n'+f(n,s+' '):sप्रतीत होगा।
— झबरा
12

रूबी , 28 बाइट्स

26.times{|a|puts" "*a<<97+a}

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

रूबी में एक स्ट्रिंग पर << ऑपरेटर चाल है, जैसा कि प्रलेखन में समझाया गया है

  • str << पूर्णांक → str

  • str << obj → str

परिशिष्ट - दिए गए ऑब्जेक्ट को str से समेटता है। यदि ऑब्जेक्ट एक इंटेगर है, तो इसे एक कोडपॉइंट के रूप में माना जाता है, और कॉन्सेटेशन से पहले एक चरित्र में परिवर्तित किया जाता है।

— जीबी
स्रोत
12

आर, 38 37 36 बाइट्स

write(intToUtf8(diag(65:90),T),1,26)

(का उपयोग @ ग्यूसेप के उत्तरwrite से प्रेरित है ।)

— स्वेन होहेंस्टीन
स्रोत
3
मैं कसम खाता हूँ कि मैं कोशिश की, लेकिन यह काम करने के लिए नहीं मिल सकता है! बहुत बढ़िया। 65:90 का उपयोग करके आप 1 बाइट बचा सकते हैं, क्योंकि ऊपरी मामले की अनुमति है।
— user2390246
@ user2390246 इशारा करने के लिए धन्यवाद!
— स्वेन हेनस्टीन
आप किसी अन्य बाइट को शेव करने के 1बजाय उपयोग कर सकते हैं ""।
— ग्यूसेप
@Giuseppe इंगित करने के लिए धन्यवाद!
— स्वेन होइनस्टीन
11

विम, 29 बाइट्स

:h<_↵↵↵y$ZZ25o <Esc>{qqpblD+q25@q

इसे ऑनलाइन आज़माएं!

↵ का अर्थ है रिटर्न कुंजी दबाएं

<Esc> मतलब एस्केप कुंजी दबाएं

यह कैसे काम करता है?

:h<_↵↵↵                             Open the help and navigate to the alphabet
       y$ZZ                         Copy the alphabet and close the help
           25o <Esc>                Abuse auto-indent and create a whitespace diagonal
                    gg              Go to the beginning of the file
                      qq            Record a macro
                        pb          Paste the alphabet and go to the first letter
                          lD        Go to the second letter and cut the rest of the alphabet
                            +       Go to the first non-blank character in the next line
                             q      Stop recording the macro
                              25@q  Run the macro for the remaining letters
— jmriego
स्रोत
इसे ऑनलाइन आज़माएं! आप इसे प्रदर्शित करने के लिए इसका उपयोग कर सकते हैं (वी विम पर आधारित है और ज्यादातर पीछे की ओर संगत है जो स्पष्ट रूप से ऑटोइंडेंट डिफॉल्ट को छोड़कर)। इसके अलावा, कम महत्वपूर्ण, आप +अपने स्पष्टीकरण में चूक गए जिसने मुझे एक सेकंड के लिए फेंक दिया।
— nmjcman101
धन्यवाद @ nmjcman101! मैं ऑनलाइन
— वीम
आप उपयोग कर सकते हैं ␛के बजाय <Esc>। मेरी राय में यह थोड़ा बेहतर है।
— गेहूं जादूगर
आप एक बाइट बचा सकता है यदि आप ऐसा {करने के बजायgg
— DJMcMayhem
आप $ 6 के बजाय of और शायद Y के बजाय 2 of का उपयोग कर सकते हैं
— GB
11

पायथन 2 , 36 बाइट्स

n=65;exec"print'%*c'%(n,n);n+=1;"*26

यह बाहरी व्हाट्सएप का लाभ उठाता है जो उपस्थिति नियम को प्रभावित नहीं करता है ।

इसे ऑनलाइन आज़माएं!

वैकल्पिक संस्करण, 38 बाइट्स

n=1;exec"print'%*c'%(n,n+96);n+=1;"*26

यह चुनौती की कल्पना से सटीक उत्पादन का उत्पादन करता है।

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत
कैसे %*cभी काम करता है ?
— लीक नून
%*<identifier>दो तर्क लेता है: यह करने के लिए पैड और विकल्प के लिए वास्तविक बात करने के लिए। कुछ printfकार्यान्वयन में और भी अस्पष्ट विशेषताएं हैं, जैसे कि %1$<identifier>मैंने यहां उपयोग किया था ।
— डेनिस
8

शुद्ध बैश, १३

echo {a..z}^K^H

यहाँ ^Kऔर ^Hशाब्दिक ऊर्ध्वाधर टैब और बैकस्पेस ASCII नियंत्रण वर्ण हैं। xxdका उपयोग करें - इस स्क्रिप्ट का डंप इस प्रकार है xxd -r: वास्तविक स्क्रिप्ट को पुनर्जीवित करने के

00000000: 6563 686f 207b 612e 2e7a 7d0b 08         echo {a..z}..
  • {a..z}उत्पादन के लिए एक मानक बैश ब्रेस विस्तार है a b c ... z(अंतरिक्ष अलग)
  • ^Kऊर्ध्वाधर टैब एक ही स्थिति के लिए एक पंक्ति नीचे कर्सर चला जाता है
  • ^Hबैकस्पेस कर्सर वापस ले जाता है एक विभाजक अंतरिक्ष को मिटाने के लिए

इसे ऑनलाइन आज़माएं । colऔर tacब्राउज़र विंडो में सही तरीके से रेंडर करने के लिए इसे पाने के लिए पाद लेख में उपयोग किया जाता है, लेकिन नियमित टर्मिनल में यह अनावश्यक है।

यदि आउटपुट में उपरोक्त अपरंपरागत नियंत्रण वर्ण आपके लिए बहुत अधिक खिंचाव के हैं, तो आप ऐसा कर सकते हैं:

बैश + आम उपयोगिताओं, 24

echo {a..z}^K^H|col -x|tac

यहाँ ^Kऔर ^Hशाब्दिक ऊर्ध्वाधर टैब और बैकस्पेस ASCII नियंत्रण वर्ण हैं। xxdका उपयोग करें - इस स्क्रिप्ट का डंप इस प्रकार है xxd -r: वास्तविक स्क्रिप्ट को पुनर्जीवित करने के

00000000: 6563 686f 207b 612e 2e7a 7d0b 087c 636f  echo {a..z}..|co
00000010: 6c20 2d78 7c74 6163                      l -x|tac

इसे ऑनलाइन आज़माएं । ऊर्ध्वाधर टैब और बैकस्पेस को आपके ब्राउज़र द्वारा अदृश्य रूप से प्रस्तुत किया जा सकता है, लेकिन वे वहां हैं (क्रोम पर अदृश्य, फ़ायरफ़ॉक्स पर दिखाई दे रहे हैं)।

  • col -x इस तरह के इनपुट को फिर से प्रस्तुत करता है कि एक ही दृश्य परिणाम देने के लिए मजेदार नियंत्रण वर्णों को रिक्त स्थान और नई लाइनों के साथ बदल दिया जाता है
  • किसी कारण colसे रिवर्स ऑर्डर में लाइनों को आउटपुट करता है। tacसही करता है।
— डिजिटल आघात
स्रोत
यह बहुत ही मस्त है :) (और मेटा और @ डेनिस को थैंक्स के बजाय कोडगुल्फ पर जवाब देने के लिए स्कोर के बजाय गतिविधि द्वारा बेहतर उत्तर देने के लिए, (बहुत उबाऊ) कोडगॉल्फ ने बिल्डिंग्स वाले लोगों के बजाय बेहतर जवाब दिया है): कोडगॉल्फ .meta.stackexchange। com / प्रश्न / 10127 /… )
— ओलिवियर
कई टर्मिनलों ^Kको कर्सर के रूप में प्रस्तुत किया जाता है, जो कि व्यवहार है colजो यहां अनुकरण करना चाहिए।
— नील
@ नील हां, यह समझ में आता है - colमैनपेज वीटी को "रिवर्स लाइन फीड" कहता है। xterm, सूक्ति-टर्मिनल और OSX टर्मिनल सभी एक लाइन से नीचे
— डिजिटल ट्रॉमा
8

ब्रेन-फ्लैक , 124, 116 , 106 बाइट्स

((((()))))(((([][]){}){})[[]()]<>){(({})<(({})<({}<>({})({})<>)>)
{({}<(<>({})<>)>[()])}{}(<>[][]<>)>[()])}

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

यह उत्तर स्टैक हाइट निलाद को गाली देता है , लेकिन एक नए तरीके से, जिसका मैंने पहले कभी उपयोग नहीं किया है, जिस पर मुझे बहुत गर्व है। इसके अलावा, जवाब बहुत चालाक नहीं है।

तो इस ASCII कला में प्रयुक्त पात्रों का विश्लेषण, वास्तव में तीन मूल्य हैं जो अक्सर उपयोग किए जाते हैं:

  • 32 (स्थान),

  • 64 (वर्णमाला के एन अक्षर को पाने के लिए 64 से एन जोड़ें), और

  • 10 (नई पंक्ति)

साथ ही साथ 26. (लूप की संख्या) और इन नंबरों को अलग-अलग स्थानों में धकेल दिया जाता है, इसलिए हम बड़ी संख्या को छोटा बनाने के लिए वास्तव में मध्यवर्ती मूल्यों का पुन: उपयोग नहीं कर सकते हैं। और इन सभी नंबरों के लिए धक्का अकेले 86 बाइट्स है:

10:
((()()()()()){})

26:
((((()()()){}){}()){})

32:
((((()()()()){}){}){})

64:
(((((()()()()){}){}){}){})

यह भयानक है। तो यहाँ है कि हम इसे और अधिक सुविधाजनक कैसे बनाते हैं। स्पष्ट दृष्टिकोण 32वैकल्पिक स्टैक पर धक्का देना है , जिससे हमारा 32स्निपेट बन जाता है: (<>({})<>)और हमारा 64स्निपेट बन जाता है (<>({})({})<>)। यदि हम अपने प्रारंभिक गठबंधन धक्का 32 हमारी प्रारंभिक साथ धक्का 26 , हम 8 बाइट्स मोटे तौर पर बचा सकता है। (मेरा पहला गोल्फ)।

लेकिन यहाँ वह चाल है जहाँ मैं वास्तव में गर्व महसूस करता हूँ। चूंकि हम किसी और चीज़ के लिए वैकल्पिक स्टैक का उपयोग नहीं कर रहे हैं, इसलिए हम 10 के नीचे गोल्फ भी खेल सकते हैं। ऐसा करने के लिए, हम कार्यक्रम की शुरुआत में स्टैक पर 4 मनमानी संख्याओं को आगे बढ़ाएंगे। चूंकि हम 32 को भी धक्का देते हैं [], इससे निलाद का मान 5 तक बढ़ जाता है , जो हमारे 10स्निपेट को बहुत अधिक सुविधाजनक बनाता है । और हमारे लिए भाग्यशाली है, यह वास्तव में हमें 32 और 26 स्निपेट को नीचे धकेलने की अनुमति देता है !

#Push 32, 26
(((((()()()()){}){}){})<>[(()()()){}])

#Push 10
((()()()()()){})

हो जाता है

#Push 32, 26 (-2 bytes)
(((((())))))((([][][]){}()())[[]]<>)

#Push 10 (-6 bytes)
(<>[][]<>)

तो यहाँ एक विस्तृत विवरण है:

# Push 1 four times
((((()))))

# Push 32 to main stack (to reuse later)...
((([][][]){}()())

# And then 26 to the alternate stack
[[]()]<>)

#While true
{

    # Keep track of the current TOS
    (({})<

        # Push [TOS, TOS + 64] (To get uppercase characters)
        (({})<({}<>({})({})<>)>)

        # TOS times...
        {
            # Decrement the loop counter, while pushing a space underneath it
            ({}<(<>({})<>)>[()])

        # Endwhile, pop zeroed counter
        }{}

        # Push 10 (newline)
        (<>[][]<>)

    # Push TOS - 1 back one
    >[()])

# Endwhile
}
— DJMcMayhem
स्रोत
7

Google पत्रक, 67 65 बाइट्स

=ArrayFormula(IF(ROW(A1:Z)=COLUMN(A1:Z26),CHAR(96+ROW(A1:Z26)),))

= ArrayFormula (IF (आरओडब्ल्यू (A1: जेड) = स्तंभ (A1: Z26), CHAR (96 + पंक्ति (A1: Z26)), ""))

किसी भी व्हाट्सएप द्वारा किए गए स्पष्टीकरण को बंद करने के बाद, मैंने नेत्रहीन खाली कोशिकाओं का उपयोग किया है

उत्पादन

मुझे पता है अगर यह गिनती नहीं है, अगर मैं बाइट गिनती गलत समझा है या अगर मैं कुछ शिष्टाचार खराब कर दिया है के रूप में यह मेरी पहली पोस्ट यहाँ है।

संपादित करें: यह पता चलता है कि मैं 2 बाइट्स को "" छोड़ कर बचा सकता हूं क्योंकि Google शीट एक खाली मान मानेंगे।

— Mr.Parivir
स्रोत
1
PPCG में आपका स्वागत है :) अच्छा लग रहा है! अन्य Google शीट जवाब देने के लिए अच्छा काम!
— स्टीफन
7

एपीएल (Dyalog) , 9 7 बाइट्स SBCS

-2 बाइट्स ngn के संकेत के लिए धन्यवाद।

↑⍨∘-⌸⎕A

[इसे ऑनलाइन आज़माएं!] [TIO-j3o0ipjy]

⎕A अपरकेस एक वर्णमाला

⌸ प्रत्येक (तत्व, सूचकांकों की सूची) जोड़ी के बीच, निम्नलिखित टैसिट फ़ंक्शन डालें:

 ↑⍨ तत्व (पत्र) से…

 ∘ ...

 - नकारात्मक-वर्णों की संख्या, यानी पीछे से कई वर्ण, रिक्त स्थान के साथ सामने की ओर।

इसे ऑनलाइन आज़माएं!

— एडम
स्रोत
अच्छा लगा। मेरा जे प्रयास काफी अधिक क्रियात्मक था। क्या इन क्रियाओं का अनुवाद J में है?
— जोनाह
@Jonah क्रिया: ↑है {.और ⍳है i.क्रियाविशेषण: ¨है "0और ⍨है ~।
— अदम
धन्यवाद। ऐसा लगता है कि J अनुवाद कुछ संक्षिप्तता खो देता है:(a.{~97+i.26){."0~-1+i.26
— योना
@ उत्पादन अपेक्षित नहीं दिखता; संकेत: ⌸एक उचित मैट्रिक्स का उत्पादन करने के लिए और 2 बाइट्स बचाने के लिए
— ngn
@ng आप स्ट्रिंग्स की सूची (…) भी लौटा सकते हैं। लेकिन मैं जांच करूंगा। संपादित करें: ओह हाँ, बिल्कुल!
— 21
6

ऑक्टेव, 25 19 या 12? बाइट्स

[diag(65:90)+32 '']

इसे ऑनलाइन आज़माएं!

अन्य समाधान @LuisMendo (12 बाइट्स) द्वारा प्रस्तावित है कि मैंने इसे ऑक्टेव के विंडोज़ संस्करण में परीक्षण किया है:

diag('a':'z')

स्पष्टीकरण:

के विकर्ण मैट्रिक्स उत्पन्न करता है a:z।

— rahnema1
स्रोत
@LuisMendo टियो में मैं एक ही परिणाम नहीं दे सकता। यह एक अभिव्यक्ति है, जिसका मूल्यांकन किया जा सकता है, जो वांछित परिणाम पैदा करता है :)
— rahnema1
लुइस द्वारा प्रस्तावित समाधान अब TIO पर काम करने लगता है ... ऑक्टेव का नया संस्करण शायद?
— स्टीवी ग्रिफिन
या टियो का नया संस्करण !?
— rahnema1
6

जावा 8, 72 71 70 61 बाइट्स

o->{for(int a=0;a++<26;)System.out.printf("%"+a+"c%n",a+96);}

-1 बाइट को लोअरकेस के बजाय अपरकेस वर्णमाला से आउटपुट करके।
मल्टीलाइन स्ट्रिंग्स को वापस करने के बजाय सीधे प्रिंट करके बाइट करें।
-8 बाइट्स से छुटकारा पाने के लिए सीधे उपयोग करके @ ऑलिवरग्रेयर के लिए धन्यवाद । और यह भी -1 बदलकर बाइट के लिए ।printfString s="";()->o->

इसे यहाँ आज़माएँ।

— केविन क्रूज़सेन
स्रोत
भोली कार्यान्वयन जितना मैंने सोचा होगा उससे कम है। आप c=65(या 64वास्तव में) के साथ एक बाइट बचा सकते हैं ताकि आपको 3 अंकों की संख्या की आवश्यकता न हो। स्ट्रिंग के बजाय एक सरणी वापस करने से आप किसी भी बाइट को बचा सकते हैं क्योंकि आप सेंट निकाल सकते हैं +"\n"?
— द लीथलकोडर
@LethalCoder आह, हमें नहीं पता था कि हमें अपरकेस वर्णमाला के उत्पादन की अनुमति है। उस पर स्किम्ड। धन्यवाद। और एक सरणी के आउटपुट का क्या मतलब है? सरणियों के एक सरणी की तरह?
— केविन क्रूज़सेन
1
@LethalCoder किसी भी टिप का स्वागत है, इसलिए धन्यवाद। लेकिन इस मामले में यह कम नहीं होगा। :)
— केविन क्रूज़सेन
1
@ अपने पहले सुझाव के बारे में, जो अभी भी इस मेटा-पोस्ट में चर्चा में है , लेकिन वोटों को देखते हुए मुझे लगता है कि यह वास्तव में अभी से अनुमति है। दूसरे के रूप में मुझे यकीन नहीं है .. यह थोथा लगता है कि नियमों को धोखा देना / झुकना, विशेष रूप से इस मेटा पोस्ट की टिप्पणियों में इन गर्म चर्चाओं के बाद और उत्तर ।
— केविन क्रूज़सेन
1
62 बाइट्स: ()->{for(int a=0;a++<26;)System.out.printf("%"+a+"c%n",a+96);}एक ही विचार का उपयोग करके दूसरी चुनौती के रूप में ।
— ओलिवियर ग्रेगोइरे
5

जेली ,  10  9 बाइट्स

डेस के लिए -1 बाइट धन्यवाद (निचली Jसीमा का उपयोग करके गिरावट से बचें 26Ḷ, सीधे,)

26Ḷ⁶ẋżØaY

एक पूर्ण कार्यक्रम जो परिणाम प्रिंट करता है।

इसे ऑनलाइन आज़माएं!

( ØaJ’⁶ẋż7 के लिए एक विवादास्पद लिंक है जो वर्णों की सूचियों की सूची की एक सूची देता है, लेकिन यह ऐसा है [["a"],[" ","b"],[" ","c"],...]जो संभवतः अस्वीकार्य है।)

हालाँकि, अगर कोई छोटा तरीका नहीं है जिसके बारे में मैंने नहीं सोचा है, तो मुझे आश्चर्य नहीं होगा!

कैसे?

26Ḷ⁶ẋżØaY - Main link: no arguments
26        - literal 26
  Ḷ       - lowered range = [0,1,2,...,26]
   ⁶      - literal space character
    ẋ     - repeat          [ [],      [' '],      [' ',' '],    ...,  [' ',' ',...,' ']]
      Øa  - yield lowercase alphabet
     ż    - zip             [[[],'a'],[[' '],'b'],[[' ',' '],'c'],...,[[' ',' ',...,' '],'z']]
        Y - join with newlines  [[],'a','\n',[' '],'b',\n',[' ',' '],'c','\n',...,'\n',[' ',' ',...,' '],'z']
          - implicit print (smashes the above together, printing the desired output)
— जोनाथन एलन
स्रोत
मैं [["a"],[" ","b"],[" "," ","c"],...]तब भी अनुमति देता हूँ जब से वर्णों की एक सूची एक स्ट्रिंग के लिए एक वैकल्पिक परिभाषा है, लेकिन एक ट्यूपल फिट नहीं लगता है :)
— स्टीफन
हां मैंने भी यही सोचा था।
— जोनाथन एलन
1
... ध्यान दें कि ऊपर प्रत्येक "..."में वर्णों की एक सूची है, इसलिए वास्तव में यह [[['a']],[[[' '],['b']],[[' ',' '],['c']],...]तब से है जब जेली में कोई तार नहीं है, बस सूचियां हैं।
— जोनाथन एलन
26Ḷ⁶ẋżØaYएक बाइट बचाता है।
— डेनिस
ØaJ’⁶ẋżके लिए 7, अपने वैकल्पिक संस्करण के लिए।
— लीक नून
5

पॉवरशेल, 29 बाइट्स

0..25|%{' '*$_+[char]($_+97)}
— TessellatingHeckler
स्रोत
मुझे अच्छा लगता है कि कैसे आप 97 जोड़ते हैं $_जैसे आप जाते हैं, अच्छा है।
— रूट
5

ऐलिस , 22 20 बाइट्स

52E&waq'a+q&' d&o]k@

इसे ऑनलाइन आज़माएं!

भले ही आउटपुट एक स्ट्रिंग है, लेकिन यह इस चुनौती के लिए जाने का तरीका नहीं है।

व्याख्या

52E&w             k@     do 26 times
     a                   push 10 (LF)
      q                  push current tape position (initially zero)
       'a+               add the ASCII code for "a"
          q&'            push 32 (space) a number of times equal to tape position
              d&o        output entire stack
                 ]       move tape position one space to the right

पिछला समाधान

["za/?rO&
' !]\"ohkw@/

इसे ऑनलाइन आज़माएं!

इससे पहले कि मैं यह पता लगा पाता मैं लगभग दस 23 बाइट समाधानों से गुजरता।

व्याख्या

यह प्रोग्राम आउटपुट के लिए रिक्त स्थान की संख्या को ट्रैक करने के लिए टेप का उपयोग करता है। कार्डिनल और ऑर्डिनल मोड एक ही टेप का उपयोग करते हैं, लेकिन उनके पास अलग-अलग टेप प्रमुख हैं। दो मोड की अलग-अलग व्याख्याएं हैं जो वे टेप पर देखते हैं, और कार्यक्रम पूरी तरह से उस अंतर का फायदा उठाता है।

आदेशों को निम्नलिखित क्रम में निष्पादित किया जाता है:

[                   move cardinal tape position left
 "za"               push this string (as a string, since the final " is in ordinal mode)
     r              interpolate to entire range (i.e., the lowercase alphabet backward)
      h             split first character from string
       &            for each character in string: push that character and...
        w                                         push current address onto return address stack
         ' !        (cardinal mode) place 32 (space) at current cardinal tape position
            ]       (cardinal mode) move cardinal tape position right
             ?      (back to ordinal mode) read string from tape starting at ordinal tape position
                    this string will consist of n-1 spaces.
              o     output string of spaces
               O    output top of stack (current letter) followed by newline
                k   return to pushed return address. 
                    after 26 times through this loop, the return address stack will be empty and this is a no-op.
                 @  terminate
— Nitrodon
स्रोत
5

ब्रेनफक, 103 बाइट्स

>-<-----[[<+>->>+++>-<<<]>++]<<<<<<<<<[-]>>>-[<[-]<[-]<[>+>+<<-]>>[<<+>>-]<[>>>>.<<<<-]<+>>>>.+>>.<<<-]

इसे ऑनलाइन आज़माएं!

चर का स्थान किसी भी तरह से कामचलाऊ है।

व्याख्या

>-<-----[[<+>->>+++>-<<<]>++]   Initializes the tape.
<<<<<<<<<[-]>[-]>>-             Resets variables that
                                need to be at 0.
[                               For loop (25 to 0).
 <[-]<<[>+>+<<-]>>[<<+>>-]      Copy the spaces count in
                                order to use it in a loop.
 <[>>>>.<<<<-]                  Prints the spaces.
                                Prints the character followed
 <+>>>>.+>>.<<<-                by a new line. Also decrements
                                the main loop counter.
]
— 6infinity8
स्रोत
5

Google शीट, 69 बाइट्स

=ArrayFormula(JOIN("
",REPT(" ",ROW(A1:A26)-1)&CHAR(96+ROW(A1:A26))))

यहां कुछ भी जटिल नहीं है। केवल चाल का उपयोग कर रहा है ArrayFormulaऔर फ़ंक्शन के ROW(A1:A26)लिए 26 विभिन्न मान वापस करने के लिए JOIN। आउटपुट इस तरह दिखता है:

उत्पादन

मुझे लगता है कि एक्सेल 2016 भी ऐसा ही कर सकता है, TEXTJOINलेकिन मैं ऑनलाइन संस्करण में सरणी सूत्र दर्ज नहीं कर सकता हूं और केवल 2013 में ही हूं। सूत्र यह होना चाहिए:

=TEXTJOIN("
",FALSE,REPT(" ",ROW(A1:A26)-1)&CHAR(96+ROW(A1:A26)))

इसे एक सरणी सूत्र के रूप में दर्ज करना ( Ctrl+ Shift+ Enter) { }दोनों पक्षों पर घुंघराले कोष्ठक जोड़ता है , इसे 67 बाइट्स में लाता है। जो कोई भी इसे सत्यापित कर सकता है, वह अपने जवाब के रूप में इसका उपयोग करने के लिए स्वागत करता है।

— इंजीनियर टोस्ट
स्रोत
5

बीज , 6014 बाइट्स

मुझे नहीं लगता कि यह कोई पुरस्कार जीतेगा, लेकिन सिर्फ मनोरंजन के लिए, यहां बीज में एक समाधान है।

86 11103250503694729158762257823050815521568836599011209889044745493166180250197633623839266491438081837290079379263402288506775397211362446108152606095635373134468715450376738199004596861532212810083090232034321755895588102701453625219810339758989366211308223221344886043229936009486687653111291562495367476364760255760906228050130847228170228716790260998430434027546345063918859356161024202180254514539438087787769611000320430464740566450402368450792375043801526494811596087812709169139468697779440918934518195843690439213251884693846598754642076364755341359062651237754916053099089619667382845958005035392458577634784453744876558142057256976895330859887974064083588368087014591508237946214519271550243549214199679364098489146944338807874570414584343165070707969101892779772740177526390597395955859236589308394889243501541206981604661264930842784772121710695027991351718061777696274815931123342985242351444203296855501870888626347939456384376808446806093364176576945969539054970975848477876079897476093353730443488664472826635815956526890935049081522728044807877072639829234224838977148057506785320443165975265560224605597481381188291535996775480326796788286452216432605854564432262547835415260058472165825285438444435690700488258778785613363062417500848996527077259315494936037544655054620369560227407957368700650031346856230643646273909094915618471799926504192999361174763592054723307855670381682927214117502862645460031555724588536036895597768493827964819026940533784490457441244859937078155137620826821294513857153097135094397278852300032685608169642137925241118197368192392427097109982751185030229544527638686131131545529690698706313745703838144933923021851042677941879847025167921010148923860660695145106913052517930707522151230705792709484338746351589089180137363986003757314611932324492978098101655359729841878862276799317010824753645947659706175083519817734448003718088115457982394423932136760435046136644679525408371158980833993157988971884061469882136904103033944270884697456159261033500286722891139158500027351042265757431184139617566089023339480051231776345929815102059539844917563709940188668873305602146506284075271989710388430531233185164106985265575418252638186398535149202928422854319253947591044830747981534342833040219194969504971457701296402664807369043224201667623773161453335066484102800249947322601702575025462427139266561015140950621152993027466758026351218924607290766894274223554418125824416921899080393405328694235821466034161071834073874727856768719898425047229002772806527172294625623026601313091815217479540688812203850300478145319935479599086534606210099372526810614742385909275512758349679098012967475393301857434507012875239092688018536028125644341148882858752275129016876257290205949225918496182271679312996010157634568807332616541938310641844258434083838017690572891417189135014450484203635258935943095637185443145042430274553211816422809756194554145177421779800554334935224073734034988935790096239926730047370699006392111034056662661567902477446646680125183082979598538506383502737734442490068661537425714549752783861222862366340979663873475326752237893690641570287341027097775099918958849864419430754493042534812120486345363285167685811903366691676146427476942948696624274431993989133835880516551024369474029197791751838810883302415448112237526350703063618171739262753474029252659418383385834751808940073804107171146665382663467460066719556797639176747423279761528061219482681051780434845070421974558638870988408449698678976622755518024906714421419806347234183574860655249471877105716127767795785164699804819127058322715857697491583787449703283625085118896433923054087238479453964363805045497229148813441732912067120594705269402106426011497763749556561398150139686331615167139081591537739333533146667211063179804707883556569241294269430626179579760506971066676011512530066694518309930078451295032445835025178124213221937594928472509588116557231122849491576207720183829735710200290762251904109318007206980645946249679357907549498615310165588678201768095297568708803842208357473777731751349499510116345704811971207818719582793964185192140178454948686109674659005978400204479072321714207828018696339659886683414074211823497880135255138161141724546221354224299071581607979907417508104234534779573666933024250229754952685174194168516481670999039048675109878524061868078078216337487277443941946961426121900907734301692962783139932352047932263834773963592317279425421954035566305805348109175553209815893678595198155962166838761859540063188209014774346841267440789072833797121217961797443744676162541668802226500817146368372390178287945076657776275930590173768326046610094573983886099504933977126798348879838826160714899283593774855907724617352862079916515034033299006419237012240730789008999523238851913897908225482003661109026061857228300111070725651744312468140016983078297938157227595743419983763920290850801438187869169473456288283458163865462359588316419331445070232596307970490434468929587726795603069137946085898481642595124580643542063564880389350236902538522311931690905858973696558714577085714396738993556273941292496636824719451697631982422926675238248502170501569627556395875619564600587531422890212003952929325067813498958390095519100963598626450443103780781917045489137526377521695121594716424797216910752252094749957224424042047863869830458287114846161217532552045343745235776511344577755412402833175338541217548987687334493461236111032661075185714361252784989689657180878190058132112701323898697673356854132286586129946906160482715702618768869398700713988301485421822519104930442450343377920756456344715552821899659777521739288202633751258303637433110490141551780764889912485271829265224821750882760152112536985349681370761157202793523201156381835717321637420939424473215237574260806475544972321933149796156065126465186203580256364372579422208318560608817806013462242728082475787319168695978160861791054731154820533251279706873332364894538291172324730671914083193733203570060223897442373172904974570329139578763294810924815364789498523721281918680145538278976651264

यह निम्नलिखित Befunge प्रोग्राम का अनुवाद करता है:

vaa{       @>
v#      g02<v
>30g20g`   |
10g-:!v!: < >#<
v,:g02_40g,1- ^
>1+20p$91+, v
— TehPers
स्रोत
4

++ , 1069 बाइट्स जोड़ें

+97
&
-87
&
+22
&
+66
&
-88
&
+22
&
&
+67
&
-89
&
+22
&
&
&
+68
&
-90
&
+22
&
&
&
&
+69
&
-91
&
+22
&
&
&
&
&
+70
&
-92
&
+22
&
&
&
&
&
&
+71
&
-93
&
+22
&
&
&
&
&
&
&
+72
&
-94
&
+22
&
&
&
&
&
&
&
&
+73
&
-95
&
+22
&
&
&
&
&
&
&
&
&
+74
&
-96
&
+22
&
&
&
&
&
&
&
&
&
&
+75
&
-97
&
+22
&
&
&
&
&
&
&
&
&
&
&
+76
&
-98
&
+22
&
&
&
&
&
&
&
&
&
&
&
&
+77
&
-99
&
+22
&
&
&
&
&
&
&
&
&
&
&
&
&
+78
&
-100
&
+22
&
&
&
&
&
&
&
&
&
&
&
&
&
&
+79
&
-101
&
+22
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
+80
&
-102
&
+22
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
+81
&
-103
&
+22
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
+82
&
-104
&
+22
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
+83
&
-105
&
+22
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
+84
&
-106
&
+22
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
+85
&
-107
&
+22
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
+86
&
-108
&
+22
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
+87
&
-109
&
+22
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
+88
&
-110
&
+22
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
+89
&
-111
&
+22
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
+90
&
P

इसे ऑनलाइन आज़माएं!

हां। यह हार्डकोड है। मुझे यकीन है कि एक बेहतर तरीका है, और यदि आप इसे ढूंढना चाहते हैं, तो आगे बढ़ें, लेकिन यह तरीका सबसे अच्छा काम करता है क्योंकि Add ++ मेमोरी के साथ काम करना मुश्किल है।

— केर्ड सिक्काहिरिंग
स्रोत
4

आर , 59 49 47 बाइट्स

-10 बाइट्स djhurio के लिए धन्यवाद

-2 बाइट्स स्वेन होहेंस्टीन की बदौलत 

write("diag<-"(matrix("",26,26),letters),"",26)

प्रिंट करने के लिए प्रिंट। User2390246 द्वारा बहिष्कृत

इसे ऑनलाइन आज़माएं!

— ग्यूसेप
स्रोत
आप एक बाइट को बचाने के 26^2साथ बदल सकते हैं 676।
— दरवाज़े
2
m=matrix("",26,26);diag(m)=letters;write(m,'',26)(49 बाइट्स)
— djhurio
बाइट्स की समान मात्रा के लिए, आप मैट्रिक्स का उपयोग करके प्रिंट कर सकते हैंcat(m,fill=27)
— JAD
1
@djhurio "बाइट्स की समान राशि के लिए"
— JAD
1
@Giuseppe कमांड "diag<-"(x, y)के समान है diag(x) <- y। मान को एक चर में नहीं सौंपा गया है लेकिन वापस लौटा दिया गया है।
— स्वेन हेनस्टीन
4

> <> , 46 44 42 बाइट्स

"A"0::?!v" "o1-40.
*(?!;30.>~$:oao1+$1+:d2

इसे ऑनलाइन आज़माएं!

व्याख्या

Line 1:
"a"0::?!v" "o1-40.
"a"0                       :Initialize the stack items (print char and space count)
    ::?!v                  :Duplicate the space count, check if 0, go down if 0
         " "o1-            :Print a space then take 1 from the space count
               40.         :Jump to codepoint row 0 col 4 (this restarts the loop)
Line 2:
*(?!;30.>~$:oao1+$1+:d2
        >~                 :Remove the zeroed space counter off the stack
          $:oao1+          :Place our print char on the top of the stack, duplicate and print it, print a new line, increase it by 1; a->b->c etc
                 $1+       :Place our space count on the top of the stack and increase it by 1
*                   :d2    :Duplicate the space counter, add 26 to the stack
 (?!;                      :Add 0 to the stack, less than compare 0, if the counter is above 0 it terminates
     30.                   :Jump to the first line, (back to printing spaces)

यह मेरे पिछले 46 बाइट्स से पूरी तरह से अलग है, इसलिए मैंने TIO को केवल एक के लिए भी शामिल किया है। 46 बाइट्स इसे ऑनलाइन आज़माएं!

नीचे एमिग्ना की सबमिशन का लिंक दिया गया है, यह पहला> <> जवाब था लेकिन मेरा मानना ​​है कि मेरा काफी अलग है (और कुछ बाइट्स बचाता है) एक दूसरे को वारंट करने के लिए।

एमिग्ना का जवाब

— पेल पेलिकन
स्रोत
और अब हम बंधे हुए हैं। सबसे अच्छा यदि आप एक बाइट को बंद करते हैं या दो को सुनिश्चित करते हैं;)
— Emigna
@ एग्निमा, मुझे लगा कि 3 बचाए गए बाइट्स पर्याप्त होंगे: ओ अंदाजा है कि मुझे कुछ और काम करना है :)
— चैले पेलिकन
4

हास्केल , 66 65 58 57 45 43 बाइट्स

12 14 बाइट बचाने के लिए @nimi और @maple_shaft को धन्यवाद । 

unlines[(' '<$['b'..n])++[n]|n<-['a'..'z']]

इसे ऑनलाइन आज़माएं!

— vroomfondel
स्रोत
1
आपको एक ही स्कोर मिलेगा लेकिन कभी-कभी आप <$प्रतिकृति के बजाय उपयोग कर सकते हैं :(' '<$[1..(fromEnum n-97)])
— मेपल_शफ्ट
2
आप @ maple_shaft के सुझाव को बदल सकते हैं (' '<$['b'..n])।
— नमि
अनाम कार्यों की अनुमति है, के लिए कोई आवश्यकता नहीं है f=।
— nimi
2
Btw, एक ही बाइट गिनती ['a'..'z']>>= \n->(' '<$['b'..n])++[n,'\n']:।
— nimi
4

PHP, 23 बाइट्स

नोट: IBM-850 एन्कोडिंग का उपयोग करता है।

<?=join(~¶,range(a,z));

इस तरह से चलाएं:

echo '<?=join(~¶,range(a,z));' | php -n;echo
# With default (utf8) terminal:
echo '<?=join("\v",range(a,z));' | php -n;echo

व्याख्या

वर्णमाला के सभी वर्णों की एक सरणी बनाएं, इसे एक ऊर्ध्वाधर टैब के साथ गोंद के रूप में मिलाएं।

— aross
स्रोत
4

ब्रेनफक , 80 बाइट्स

++++++++[>+>++++>++++++++>+++<<<<-]>++>>+>++[->[<<<.>>>->+<]>+[-<+>]<<<.+<<.>>>]

इसे ऑनलाइन आज़माएं!

प्रारूपित:

++++++++[>+>++++
>++++++++>+++<<<
<-]>++>>+>++[->[
<<<.>>>->+<]>+[-
<+>]<<<.+<<.>>>]

एक सरल गुणक पीढ़ी समारोह का उपयोग करता है स्मृति में कुछ स्थिरांक डाल करने के लिए है, तो उसके बाद मुद्रण एन रिक्त स्थान की प्रक्रिया को दोहराता 'A' + Nके लिए N = 0..25।

एनोटेट:

INITIALIZE TAPE: 10 32 65 >26< 0 0
C_NEWLINE: 10
C_SPACE: 32
V_ALPHA: 65
V_COUNTER: 26
V_PREFIX: 0
V_PREFIX_TEMP: 0
++++++++[>+>++++>++++++++>+++<<<<-]>++>>+>++

WHILE V_COUNTER != 0  [-
   "PRINT C_SPACE REPEATED V_PREFIX TIMES"
   "V_PREFIX_TEMP = V_PREFIX"
     V_PREFIX TIMES  >[-
       PRINT C_SPACE <<<.>>>
       INCREMENT V_PREFIX_TEMP >+<
     ]
   "V_PREFIX = V_PREFIX_TEMP PLUS 1"
     V_PREFIX_TEMP PLUS 1 TIMES  >+[-
       INCREMENT V_PREFIX <+>
     ]
   PRINT C_ALPHA <<<.
   INCREMENT C_ALPHA +
   PRINT C_NEWLINE <<.
>>>]
— कोनोर ओ ब्रायन
स्रोत
4

RProgN 2 , 5 बाइट्स

aS`\x0B.

\ x0B एक वर्टिकल टैब लिटरल है

यह सिर्फ लोअरकेस वर्णमाला लेता है, इसे विभाजित करता है, और इसे ऊर्ध्वाधर टैब के साथ जोड़ता है। यह कुछ बैश टर्मिनलों पर इच्छित प्रभाव पैदा करता है।

स्क्रिप्ट चल रही है

— Ataco
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.