अंग्रेजी वर्णमाला के एक अक्षर को देखते हुए, आपका कार्य इनपुट के लिए अर्ध-विकर्ण वर्णमाला का निर्माण करना है।

अर्ध-विकर्ण वर्णमाला का निर्माण कैसे करें?

संक्षिप्त विवरण : सबसे पहले, आप अक्षर की स्थिति को वर्णमाला में लेते हैं, P( Pयहाँ 1-अनुक्रमित है)। फिर, आप प्रत्येक पत्र को एक पंक्ति पर इनपुट (समावेशी) तक प्रिंट करते हैं, P-1जो उस पत्र Pसमय से पहले और दोहराते हैं , रिक्त स्थान के साथ इंटरलेयिंग करते हैं।

उदाहरण :

यह देखते हुए F, आपका कार्यक्रम आउटपुट होना चाहिए:
```
ए 
 बी बी 
  सीसीसी 
   dddd 
    EEEEE 
     FFFFFF 
```

यह देखते हुए K, आपका कार्यक्रम आउटपुट होना चाहिए:

ए
 बी बी 
  सीसीसी 
   dddd 
    EEEEE 
     FFFFFF 
      ggggggg 
       HHHHHHHH 
        IIIIIIIII 
         JJJJJJJJJJ 
          KKKKKKKKKKK

यह देखते हुए A, आपका कार्यक्रम आउटपुट होना चाहिए:
```
A
```

नियम

आप लोअरकेस या अपरकेस वर्ण चुन सकते हैं, लेकिन यह सुसंगत होना चाहिए।
आपके पास निम्नानुसार रिक्त स्थान हो सकते हैं:
- एक सुसंगत अग्रणी स्थान (प्रत्येक पंक्ति पर)।
- एक अनुगामी या अग्रणी न्यूलाइन (एस)।
- संबद्ध पिछले स्थान।
इनपुट और आउटपुट किसी भी मानक माध्य से लिया जा सकता है, और डिफ़ॉल्ट कमियां लागू होती हैं।
आपको इसके बजाय लाइनों की एक सूची का उत्पादन करने की अनुमति है, जब तक आप एएससीआई-कला संस्करण भी प्रदान करते हैं ।
यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीतता है!

^{इस चुनौती से प्रेरित है ।}

क्या आउटपुट स्ट्रिंग्स की सूची के रूप में ठीक है?

— अदम

2

क्यों होता है पतन? मैं क्या सुधार कर सकता हूं?

1

जब आप कहते हैं "P 1-अनुक्रमित यहाँ है", तो क्या यहाँ चुनौती या उदाहरण है?

— डेव

3

@pizzakingme नहीं, आप नहीं कर सकते।

1

मुझे अपना जवाब देते हुए गलती से एक दिलचस्प पैटर्न मिल गया: tio.run/##K0nO@f@/…

— sergiol

10

पायथन 3 , 59 बाइट्स

lambda l:[' '*i+'%c '%(i+65)*-~i for i in range(ord(l)-64)]

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

पायथन 3 , 61 बाइट्स

lambda l:[' '*i+-~i*(chr(i+65)+' ')for i in range(ord(l)-64)]

इसे ऑनलाइन आज़माएं! (सुंदर प्रिंट संस्करण के लिए लिंक)

— मिस्टर एक्सकोडर
स्रोत

8

मैं एक मंदी के लिए बिल्कुल कोई कारण नहीं देखता हूं। क्या @downvoter समझा सकता है?

— श्री Xcoder

1

मुझे लगता है कि यह सिर्फ एक गर्भपात है, या शायद कोई व्यक्ति स्पष्टीकरण की कमी पसंद नहीं कर रहा है (बाद वाला आईएमओ की संभावना नहीं है)

— कॉनर ओ'ब्रायन

मैं अजगर को नापसंद करता हूं और मैं अजगर के साथ लागू नहीं कर सकता, इसलिए जवाब मेरे लिए उपयोगी नहीं है? बस मजाक कर रहे हैं, लेकिन बटन टूलटिप्स शायद इस साइट के नियमों को फिट नहीं करते हैं

— थॉमस वेलर

यह सिर्फ मुझे है या यह कहना है कि श्री Xcoder 1 प्रतिनिधि है ...?

— स्टेन स्ट्रोम

9

पायथन 2 , 63 61 59 बाइट्स

-2 बाइट्स रॉड के लिए धन्यवाद। -2 बाइट्स फेलिप नारदी बतिस्ता को धन्यवाद।

i=1
exec"print' '*i+'%c '%(i+64)*i;i+=1;"*(ord(input())-64)

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

— totallyhuman
स्रोत

8

सी, 89 बाइट्स

i,j;f(l){for(i=64;i++<l&&printf("%*c ",i-64,i);puts(""))for(j=i-65;j--;)printf("%c ",i);}

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

— Steadybox
स्रोत

7

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

65..$args[0]|%{" "*$i+++"$([char]$_) "*$i}

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

इनपुट को शाब्दिक चार के रूप में लेता है, फिर कैपिटल के माध्यम से उस बिंदु तक लूप करता है, प्रत्येक पुनरावृत्ति उपयुक्त स्थान और फिर चार \ स्पेस हाइब्रिड को प्रस्तुत करता है।

3 बाइट्स TessellatingHeckler के लिए धन्यवाद बचा लिया।

— AdmBorkBork
स्रोत

@TessellatingHeckler वास्तव में। मैं "$args"इतना है कि यहाँ काम नहीं करेगा गोल्फ रहा हूँ, मैं [0]विधि के बारे में भूल गया था । Haha।

— AdmBorkBork

5

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

इनपुट और आउटपुट दोनों के लिए निचले मामले में काम करता है। एक प्रमुख स्थान और प्रत्येक पंक्ति पर एक अनुगामी स्थान को आउटपुट करता है।

f=(c,k=10,C=k.toString(36),r=s=>`${s} `.repeat(k-9))=>r``+r(C)+(C==c?'':`
`+f(c,k+1))

डेमो

कोड स्निपेट दिखाएं

f=(c,k=10,C=k.toString(36),r=s=>`${s} `.repeat(k-9))=>r``+r(C)+(C==c?'':`
`+f(c,k+1))

O.innerText = f('m')

<pre id=O>

Expand snippet

— Arnauld
स्रोत

`${s} `(s+"")एक बाइट की बचत के लिए प्रतिस्थापित किया जा सकता है

— ल्यूक

@ मुझे इस स्थान की आवश्यकता है। यह द्वारा प्रतिस्थापित किया जा सकता है (s+" "), लेकिन यह बस के रूप में लंबे समय है।

— अरनुलड

5

एपीएल (डायलॉग) , 26 बाइट्स

स्केलर चरित्र के लिए संकेत। लाइनों की सूची प्रिंट करता है।

(∊⍴∘'',' ',¨⍨⊢⍴⊃∘⎕A)¨⍳⎕A⍳⎕

इसे ऑनलाइन आज़माएं! (एक अतिरिक्त बाइट में ASCII कला संस्करण है)

⎕ इनपुट के लिए संकेत

⎕A⍳ लगता है ɩ ndex में एक lphabet

⍳ पहले कि कई gers ntegers

(… )¨ प्रत्येक के लिए निम्नलिखित tacit फ़ंक्शन लागू करें:

⊃∘⎕AA वर्णमाला से आर्ग्युमेंट लेटर अक्षर को चुनें

⊢⍴ चक्रीय रूप से इसे तर्क लंबाई में बदल देते हैं

' ',¨⍨ प्रत्येक के लिए एक स्थान जोड़ें

⍴∘'', तर्क लंबाई की एक स्ट्रिंग तैयार करें (रिक्त स्थान के साथ गद्देदार)

∊ ϵ nlist (समतल)

ASCII कला संस्करण अभी ↑बहुत बाईं ओर है; पात्रों की तालिका में स्ट्रिंग की मिक्स सूची।

— एडम
स्रोत

4

पर्ल 5 , 31 बाइट्स

30 बाइट्स कोड + 1 के लिए -l।

print$"x$-,"$_ "x++$-for A..<>

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

— डोम हेस्टिंग्स
स्रोत

आप इसे ध्वज के sayबजाय का उपयोग करके काट सकते हैं -l: इसे ऑनलाइन आज़माएं!

— Xcali

@Xcali मैं -E/ पर फटा हुआ हूँ -M5.01, मैंने sayअतीत में काफी इस्तेमाल किया है , और शायद इस तथ्य का दुरुपयोग करेगा जो एक प्रतिबंधित स्रोत चुनौती में या शायद इसी तरह का sayविकल्प है print, लेकिन -3 के लिए, मैं रखूंगा अभी के लिए है। निष्पक्ष तर्क के लिए इस मेटा पोस्ट को देखें । हालांकि इनपुट की सराहना!

— डोम हेस्टिंग्स

3

Dyalog एपीएल, 38 बाइट्स

{↑{(y/' '),(2×y←⎕A⍳⍵)⍴⍵,' '}¨⎕A↑⍨⎕A⍳⍵}

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

कैसे?

⎕A↑⍨ - जब तक वर्णमाला न लें

⎕A⍳⍵ - इनपुट चरित्र

¨ - प्रत्येक चार के लिए

⍵,' ' - चार और एक जगह ले लो

(...)⍴ - को नया आकार दें

2×y←⎕A⍳⍵ - वर्णमाला में चार का सूचकांक

(y/' ') - और इंडेक्स-ऑफ-द-चार रिक्त स्थान

↑ - फिर चपटा

— Uriel
स्रोत

3

एपीएल (डायलॉग क्लासिक) , 26 बाइट्स

{↑{(≠\⍵<⍳3×⍵)\⍵⊃⎕A}¨⍳⎕A⍳⍵}

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

व्याख्या

                      ⍳⎕A⍳⍵  generate indexes up to position of right arg ⍵
{                   }¨       on each index apply function
   (≠\⍵<⍳3×⍵)                generate boolean mask for expansion (each line has a length 3 times its index ⍵, starting with ⍵ blanks and then alternating letter blank)
             \⍵⊃⎕A          expand character in position ⍵
 ↑                            mix result into text matrix

— गिल
स्रोत

अच्छाई ... 4 APL-er एक ही समय में एक ही समस्या का समाधान! :) मैं codegolf में लगता है कि आप बाहरी दूर करने के लिए अनुमति हो {}, की जगह ⍵के साथ ⎕, और दावा यह एक "पूरा कार्यक्रम" के बजाय एक समारोह है। यह आपके समाधान को सबसे अच्छा (अब तक) बना देगा।

— ngn

एक अच्छा संकेत होना चाहिए :) सुझाव के लिए धन्यवाद। मैंने देखा है यह किया है, लेकिन यह सुनिश्चित नहीं था कि रेखा कहाँ खींचनी है। मुझे लगता है कि मैं 3 बाइट्स बचा सकता हूं अगर मैं कर्ल निकालता हूं और मिश्रण करता हूं।

— गिल

3

V , 28, 26, 25 , 23 बाइट्स ( प्रतिस्पर्धा )

¬A[/a
lDÓ./& ò
ò-Ûä$Û>

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

ध्यान दें कि हालांकि मैं कुछ सुविधाओं को जोड़ने की योजना बना रहा हूं लंबे समय से , लेकिन इस चुनौती ने मुझे आखिरकार ऐसा करने के लिए आश्वस्त किया।

आउटपुट में प्रत्येक पंक्ति पर एक अग्रणी स्थान और एक अनुगामी न्यूलाइन होती है।

Hexdump:

00000000: ac41 5b2f 1261 0a6c 44d3 2e2f 2620 f20a  .A[/.a.lD../& ..
00000010: f22d dbe4 24db 3e                        .-..$.>

स्पष्टीकरण:

¬A[         " Insert 'ABCDEFGHIJKLMNOPQRSTUVWXYZ['
   /        " Search for...
    <C-r>a  "   The input
l           " Move one character to the right
 D          " And delete every character after the cursor
  Ó         " Search for...
   .        "   Any character
    /       " And replace it with...
     & ò    "   That character followed by a space and a newline
ò           " Recursively...
 -          "   Move to the beginning of the next line up
  Ûä$       "   Make *line number* copies of the current line
     Û>     "   And indent this line by *line number* spaces

— DJMcMayhem
स्रोत

1

यह प्रतिस्पर्धा है। आप शीर्षक टिप्पणी निकाल सकते हैं।

यह उन लोगों के लिए उपयोगी है जो नए मेटा के बारे में नहीं जानते थे, जैसे कि खुद

— कॉनर ओ'ब्रायन

3

05AB1E , 10 बाइट्स

A¹¡н«ðâƶāú

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

-2 अदनान को धन्यवाद ।

»इसे अलग-अलग लाइनों में प्रिंट करने की अपील करें ।

— आउटग्रॉफर को एरिक करें
स्रोत

आप के <रूप में एक लगातार अग्रणी अंतरिक्ष ठीक है छोड़ सकते हैं ।

— एमिगा

@Emigna धन्यवाद!

— 14

A¹¡н«ðâƶāú10 बाइट्स के लिए काम करना चाहिए

— अदनान

@ अदनान मुझे लगता है कि ¹¡यह काम नहीं करेगा ... ओह, तो इसीलिए «वहाँ है। : p

— एरिक आउटोलॉफ़र

3

आर, 94 88 बाइट्स

-6 बाइट्स ग्यूसेप के लिए धन्यवाद

function(x,l=LETTERS)for(i in 1:match(x,l))cat(rep(' ',i-1),rep(paste(l[i],' '),i),'\n')}

Ungolfed:

f=function(x,l=letters){
  for(i in 1:which(l==x)){
    A=paste(l[i],' ')
    cat(rep(' ',i-1),rep(A,i),'\n')
  }
}

— एंड्रयू हेन्स
स्रोत

88 बाइट्स : एक अनाम फ़ंक्शन वापस करना ठीक है, आप ब्रेसरों से छुटकारा पा सकते हैं क्योंकि fएक-लाइनर है, और बाइट matchको whichबचाने के बजाय उपयोग कर रहा है ।

— Giuseppe

71 बाइट्स

— Giuseppe

६ by बाइट्स स्टड से इनपुट लेते हैं।

— Giuseppe

3

हास्केल, 52 44 बाइट्स

f k=[[" ",s:" "]>>=(['A'..s]>>)|s<-['A'..k]]

लाइनों की एक सूची देता है।

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

f k=                  -- main function is f, input parameter k
  [   |s<-['A'..k]]   -- for each s from ['A'..k]
     >>=              -- map (and collect the results in a single string) the function: 
         (['A'..s]>>) --  replace each element in ['A'..s] with
    [  ,  ]           --  over the list, containing
     " "              --   a single space to get the indent
        s:" "         --   s followed by space to get the letter sequence

संपादित करें: @jferard: तीन बाइट्स सहेजे गए। धन्यवाद!

— nimi
स्रोत

49 बाइट्स:f k=[tail$[" ",s:" "]>>=(['A'..s]>>)|s<-['A'..k]]

— जेफर्ड

@ जफरार्ड: बहुत बहुत धन्यवाद। चुनौती को पुन: प्रस्तुत करते हुए मैंने देखा कि प्रति पंक्ति एक प्रमुख स्थान की अनुमति है, इसलिए हमें इसकी आवश्यकता नहीं है tail$।

— nimi

2

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

c=>(g=n=>n>9?[...g(n-1),`${n.toString(36)} `.repeat(n-=9).padStart(n*3)]:[])(parseInt(c,36))

लोअरकेस अक्षरों का उपयोग करता है। लाइनों में एक अग्रणी और एक अनुगामी स्थान होता है। लाइनों की एक सरणी देता है।

टेस्ट स्निपेट

let f=

c=>(g=n=>n>9?[...g(n-1),`${n.toString(36)} `.repeat(n-=9).padStart(n*3)]:[])(parseInt(c,36))

;O.innerText=f("k").join`\n`

<pre id=O></pre>

स्निपेट का विस्तार करें

— जस्टिन मेरिनर
स्रोत

2

भूसी , 13 बाइट्स

z+ḣ∞øzRNC1…'A

कमांड लाइन तर्क के रूप में एकल उद्धरणों में एक चरित्र लेता है, परिणाम STDOUT को प्रिंट करता है। इसे ऑनलाइन आज़माएं!

व्याख्या

मैं उस तरह से शोषण कर रहा हूं जैसे कि स्ट्रिंग्स की सूचियों की हस्क प्रिंट करता है: रिक्त स्थान के साथ आंतरिक सूची में शामिल हों और नई सूचियों के साथ बाहरी सूची।

z+ḣ∞øzRNC1…'A  Implicit input, say 'C'
          …'A  Range from A: "ABC"
        C1     Cut into strings of length 1: ["A","B","C"]
     z N       Zip with positive integers
      R        using repetition: x = [["A"],["B","B"],["C","C","C"]]
   ∞ø          The empty string repeated infinitely: ["","","",...
  ḣ            Prefixes: [[],[""],["",""],["","",""],...
z+             Zip with x using concatenation: [["A"],["","B","B"],["","","C","C","C"]]
               Implicitly join each inner list with spaces, join the resulting strings with newlines and print.

— Zgarb
स्रोत

2

05AB1E , 15 14 13 बाइट्स

अदनान की बदौलत बचा 1 बाइट

A¹¡н«ƶ€S»¶¡āú»

इसे ऑनलाइन आज़माएं! या एससीआई कला संस्करण

व्याख्या

A                # push lowercase alphabet
 ¹¡              # split at input
   н             # get the first part
    «            # append the input
     ƶ           # repeat each a number of times corresponding to its 1-based index
      €S         # split each to a list of chars
        »        # join on spaces and newlines
         ¶¡      # split on newlines
           āú    # prepend spaces to each corresponding to its 1-based index
             »   # join on newlines

— Emigna
स्रोत

ऐसा लग रहा है कि हमने इसे थोड़ा अलग तरीके से संभाला : D

— Erik the Outgolfer

@EriktheOutgolfer: हमने इसे काफी हद तक वैसा ही किया है, लेकिन उठाने से पहले एक जगह को जोड़ने के लिए आपका बहुत अच्छा विचार है, इस जुड़ाव की आवश्यकता को दूर करते हुए आपको छोटा बना दिया। मैंने यह नहीं पढ़ा था कि अग्रणी / अनुगामी स्थान और न ही सूची के रूप में आउटपुट ठीक था, इसलिए कि उम्मीद है कि मुझे लागू करने से पहले पूरी चुनौती पढ़ने के लिए

— सिखाएंगे

tl;

— डॉआर

A¹¡н«इसके बजाय ADIk>£काम करना चाहिए

— अदनान

@ अदनान: धन्यवाद! मैंने किया था, A¹¡нलेकिन «अंतिम पत्र प्राप्त करने के लिए विचार नहीं किया था इसलिए यह पर्याप्त नहीं था: पी

— एमिग्ना

2

एपीएल (Dyalog यूनिकोड) , 22 बाइट्स ^SBCS

⍕⍪⊢∘⊂\2,.↑⍉⍴⍨⌸⎕a↑⍨⎕a⍳⍞

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

उपयोग करता है ⎕io←1। एक प्रमुख स्थान प्रिंट करता है, जिसकी अनुमति है।

— NGN
स्रोत

2

QBasic, 79 74 72 बाइट्स

बाइट बचत के लिए टेलर स्कॉट का धन्यवाद (दो बार!)

FOR i=1TO ASC(INPUT$(1))-64
?TAB(i)
FOR j=1TO i
?CHR$(64+i)" ";
NEXT j,i

अपरकेस का उपयोग करता है। इनपुट कीपर द्वारा है और स्क्रीन पर प्रतिध्वनित नहीं होता है।

व्याख्या

हम पाश iसे 1वर्णमाला में सीमित पत्र की स्थिति पर निर्भर (1-आधारित)। प्रत्येक के लिए i, हम iउपयोग करते हुए स्क्रीन के कॉलम पर जाते हैं TAB; तब, iबार, हम iवर्णमाला के बाद के अक्षर को एक स्थान से मुद्रित करते हैं।

— DLosc
स्रोत

जैसा कि यह पता चला है कि आप -2 बाइट्स के डेल्टा के लिए INPUT$(1)चर के z$लिए एक सीधे प्रतिस्थापन के रूप में कमांड का उपयोग कर सकते हैं

— टेलर स्कॉट

@TaylorScott अच्छा विचार है, धन्यवाद!

— DLosc

2

जाप `-R` , २४ २३ १ 17 15 बाइट्स

एक सरणी को आउटपुट करता है, जिसमें एक प्रमुख नईलाइन और प्रत्येक पंक्ति पर एक अग्रणी और अनुगामी स्थान शामिल होता है।

IòUc ÏçSiXd¹iYç

झसे आज़माओ

1 बाइट ऑलिवर की मदद से बचाई गई और एक और 6 धन्यवाद उसके लिए प्रारंभिक सरणी उत्पन्न करने का एक बेहतर तरीका इंगित करता है।

— झबरा
स्रोत

1

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

Ｆ⁺⌕αθ¹«Ｐ×⁺§αι ⁺ι¹↘

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

— आउटग्रॉफर को एरिक करें
स्रोत

नहीं, आप 05AB1E को चारकोल को हरा नहीं दे सकते ...: पी

— पूरी तरह से

@totallyhuman बदला: p

— एरिक द आउटगॉल्फ

अफसोस की बात है कि प्रमुख व्हाट्सएप को Ｅ…·?θ⁺× κ⪫× κι14 बाइट्स में नौकरी करने की अनुमति नहीं है ।

— नील

@ नील एक प्रमुख व्हाट्सएप की अनुमति है, लेकिन मुझे यकीन नहीं है कि ?वहां कैसे पहुंचा । यह Aमेरे विचार से होना चाहिए । ओह रुको, ओह्ह्ह्ह मैं देखती हूँ कि तुम्हारा क्या मतलब है।

— आउटगोल्फर

1

ब्रिंगोल्फ , 65 बाइट्स

a#a-# 7-,-~vc<!?>[$_]:$_|&,(.#a-!?.>[# M]1+>[.M# M]:$_!@|v#
&@R);

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

छोटे।

प्रत्येक पंक्ति पर 1 अनुगामी स्थान और आउटपुट के अंत में एक अनुगामी नई रेखा समाहित करता है।

— Skidsdev
स्रोत

1

सी # (.NET कोर) , 103 बाइट्स

n=>{var i='`';var l="";for(;i<n;l+='\n'){l+="".PadLeft(i++-96);for(int s=96;s++<i;)l+=i+" ";}return l;}

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

— jkelm
स्रोत

1

जावास्क्रिप्ट, 102 94 बाइट्स

2 बाइट्स ने नील को धन्यवाद दिया

f=
a=>[...Array(parseInt(a,36)-9)].map((a,b)=>''.padEnd(b).padEnd(b*3+1,(b+10).toString(36)+' '))

console.log(f('k').join`\n`)

स्निपेट का विस्तार करें

1

रेटिना , 51 बाइट्स

^.
$&$&
}T`L`_L`^.
.
$.`$* $&$.`$* ¶
+`(\w) \B
$&$1

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

^.
$&$&

पहला (पहला) अक्षर डुप्लिकेट करें।

}T`L`_L`^.

इसे 1 वर्णमाला में वापस घुमाएँ, या इसे डुप्लिकेट होने पर हटा दें A। डुप्लिकेट और घुमाते रहें जब तक हम डुप्लिकेट नहीं करते हैं A, जिस बिंदु पर विलोपन दोहराव को हटा देता है और लूप पूरा हो जाता है।

.
$.`$* $&$.`$* ¶

प्रत्येक अक्षर को एक पंक्ति के साथ बदलें, जिसमें दोनों तरफ अक्षर अंकित हो।

+`(\w) \B
$&$1

मौजूदा अक्षरों के दाईं ओर सभी जोड़े पैडिंग स्पेस के बीच डुप्लिकेट अक्षर डालें।

— नील
स्रोत

1

हास्केल , 57 बाइट्स

x!'@'=x
x!e=([e]:[' ':r++' ':[last r]|r<-x])!pred e
([]!)

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

— गेहूं का जादूगर
स्रोत

1

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

Ｆ…·AＳ«Ｐ⪫Ｅ…@ιι ↘

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

 …·AＳ           Inclusive character range from A to the input
Ｆ    «          Loop over each character
         …@ι    Exclusive range from @ to the current character
        Ｅ   ι   Replace each element with the current character
       ⪫        Join with spaces
      Ｐ         Print without moving the cursor.
              ↘ Move the cursor down and right.

यदि अतिरिक्त पैडिंग कानूनी था, तो यह 14 बाइट्स के लिए काम करेगा:

Ｅ…·?θ⁺× κ⪫× κι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है।

— नील
स्रोत

1

गणितज्ञ, 70 बाइट्स

(T=Table)[""<>{" "~T~i,T[Alphabet[][[i]]<>" ",i]},{i,LetterNumber@#}]&

लोअरकेस

सूची तैयार करता है

सुधार के लिए thanx @ngenisis

के लिए ascii अत्याधुनिक संस्करण जगह Column@शुरुआत में

— J42161217
स्रोत

1

एक्सेल VBA, 72 बाइट्स

अनाम VBE तत्काल विंडो फ़ंक्शन जो VBE तत्काल विंडो में सेल A1और आउटपुट से इनपुट लेता है

For i=1To Asc([A1])-64:[B1]=i:?Space(i-1)[REPT(CHAR(B1+64)&" ",B1)]:Next

— टेलर स्कॉट
स्रोत

1

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

.e+*kd*+bdhk<GhxG

इसे यहाँ (सुंदर प्रिंट संस्करण) आज़माएँ।

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

hxG - निचली वर्णमाला में इनपुट के सूचकांक को लेता है।
<G - वर्णमाला से इनपुट के बाद हर वर्ण को चलाता है।
.e- प्रगणित मानचित्र। अनुक्रमित के रूप में kऔर पत्र के साथ छंटनी की वर्णमाला पर नक्शे b।
*kd- kरिक्त स्थान संलग्न करें ।
+bd- bएक स्थान (वर्तमान अक्षर + स्थान)।
*...hk- k+1बार बार।
+(...)(...) - कॉनटेनटेट।

— मिस्टर एक्सकोडर
स्रोत

1

पायथ के बारे में मेरी पसंदीदा चीजों में से एक है, एक उत्तर लिखना और यह जानना कि किसी ने एक ही उत्तर, चरित्र के लिए चरित्र लिखा है। यह हिट करता है कि पायथन "पूरी तरह से एक सबसे अच्छा जवाब है" स्पॉट!

— डेव

@pizzakingme हाँ, मुझे आश्चर्य है कि अगर मैं बेहतर कर सकता हूँ

— श्री Xcoder

अंतरिक्ष जोड़ना गलत लगता है, मुझे लगता है कि बेहतर है

— डेव

@pizzakingme मैं .e+*kdjd*bhk<GhxG17 बाइट्स भी प्राप्त कर सकता था

— श्री एक्सकोडर

16 बाइट्स:.e+*kd*+bdhkhcGQ

— डेव

1

C ++ (gcc) , 164 बाइट्स

#include<iostream>
#define f for(int i=0;i<o-'`';i++)
using namespace std;int main(){char c;cin>>c;for(char o='a';o<=c;o++){f cout<<' ';f cout<<o<<' ';cout<<'\n';}}

मेरा पहला प्रयास एक लंबे समय के बाद दुबका!

नीचे दिया गया अनगोल्ड कोड:

#include <iostream>

using namespace std;
#define f for (auto i = 0; i < output - '`'; i++)

int main()
{
  char input;

  cin >> input;

  for (char output = 'a'; output <= input; output++)
  {
    f cout << ' ';

    f cout << output << ' ';

    cout << endl;
  }
}

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

— Drise
स्रोत

मुझे पता है कि करने के लिए गोल्फ चीजों का एक समूह होना चाहिए, लेकिन अब तक, मैंने सबसे छोटी कमाई की है।

— Drise

अर्ध-विकर्ण वर्णमाला

अर्ध-विकर्ण वर्णमाला का निर्माण कैसे करें?

नियम

पायथन 3 , 59 बाइट्स

पायथन 3 , 61 बाइट्स

पायथन 2 , 63 61 59 बाइट्स

सी, 89 बाइट्स

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

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

डेमो

एपीएल (डायलॉग) , 26 बाइट्स

पर्ल 5 , 31 बाइट्स

Dyalog एपीएल, 38 बाइट्स

एपीएल (डायलॉग क्लासिक) , 26 बाइट्स

व्याख्या

V , 28, 26, 25 , 23 बाइट्स ( प्रतिस्पर्धा )

05AB1E , 10 बाइट्स

आर, 94 88 बाइट्स

हास्केल, 52 44 बाइट्स

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

टेस्ट स्निपेट

भूसी , 13 बाइट्स

व्याख्या

05AB1E , 15 14 13 बाइट्स

एपीएल (Dyalog यूनिकोड) , 22 बाइट्स SBCS

QBasic, 79 74 72 बाइट्स

व्याख्या

जाप -R , २४ २३ १ 17 15 बाइट्स

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

ब्रिंगोल्फ , 65 बाइट्स

सी # (.NET कोर) , 103 बाइट्स

जावास्क्रिप्ट, 102 94 बाइट्स

रेटिना , 51 बाइट्स

हास्केल , 57 बाइट्स

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

गणितज्ञ, 70 बाइट्स

एक्सेल VBA, 72 बाइट्स

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

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

C ++ (gcc) , 164 बाइट्स

एपीएल (Dyalog यूनिकोड) , 22 बाइट्स ^SBCS

जाप `-R` , २४ २३ १ 17 15 बाइट्स