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

48

आपको यह सटीक पाठ प्रिंट करना है:

A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA
ABCDEFGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYZYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGFEDCBA
ABCDEFEDCBA
ABCDEDCBA
ABCDCBA
ABCBA
ABA
A

ऐनक

  • आउटपुट के अंत में अतिरिक्त अनुगामी न्यूलाइन्स की अनुमति है।
  • प्रत्येक पंक्ति के अंत में अतिरिक्त अनुगामी रिक्त स्थान (U + 0020) की अनुमति है, जिसमें अतिरिक्त अनुगामी न्यूलाइन्स भी शामिल हैं।
  • आप सभी अपरकेस के बजाय सभी लोअरकेस का उपयोग कर सकते हैं, लेकिन आप आंशिक रूप से निचले स्तर के अपरकेस को प्रिंट नहीं कर सकते हैं।
  • आप पाठ को एक पूर्ण कार्यक्रम में प्रिंट करने के बजाय एक फ़ंक्शन आउटपुट के रूप में वापस कर सकते हैं।

स्कोरिंग

चूँकि यह एक त्रिभुज है, और एक त्रिभुज में 3 भुजाएँ हैं, और 3 एक छोटी संख्या है, बाइट-गिनती के संदर्भ में आपका कोड छोटा होना चाहिए।

code-golf  kolmogorov-complexity  alphabet 
— लीक नन
स्रोत
22
इतने सारे अक्षर हाल ही में
— downrep_nation
1
माई सिन्थेसिया हॉग वाइल्ड हो रहा है, @downrep_nation
— DoctorHeckle
5
"चूंकि एक त्रिभुज में 3 भुजाएं हैं और 3 एक छोटी संख्या है, इसलिए बाइट काउंट के संदर्भ में आपका कोड छोटा होना चाहिए।" वैध लगता है
— रोहन झुनझुनवाला
1
केवल 1 से बना संख्याओं का वर्ग संबंधित लगता है: 1 * 1 = 1 ~ ए, 11 * 11 = 121 ~ = एबीए, 111 * 111 = 12321 ~ = एबीसीबीए ...
— कारिडोर
1
"चूंकि एक त्रिकोण में 3 पक्ष होते हैं और ..." इलुमिनाती ने पुष्टि की।
— हाइपरएन्यूट्रीनो

जवाबों:

38

विम, 37 बाइट्स

:h<_↵↵↵YZZPP$xqqxYpGP√2G$A♥-€k$q24@qJ

यहाँ छवि विवरण दर्ज करें

किंवदंती

↵ = Return
√ = Ctrl+V
♥ = Ctrl+R
€ = Escape
— लिन
स्रोत
2
यह वास्तव में अच्छा GIF है।
— AdmBorkBork
13
मैं कभी भी विम के उत्तरों से चकित नहीं होगा।
— DanTheMan
यह समझाने की परवाह करें कि यह उन लोगों के लिए कैसे काम करता है जो विम में धाराप्रवाह नहीं हैं?
— आर। कप
6
@ R.Kap मैं आपको विम डाउनलोड करने की सलाह देता हूं और अपने आप से समाधान की कोशिश करता हूं - आप समाधान को स्ट्रोक से प्रकट कर सकते हैं! अनिवार्य रूप से, मैं एक हेल्प फ़ाइल ( :h<_↵↵↵YZZP) से वर्णमाला चुराता हूं , फिर एक मैक्रो ( qq…q) रिकॉर्ड करता हूं जो बार-बार शीर्ष पंक्ति से किसी अक्षर को काटता है, त्रिभुज को लंबवत रूप से विकसित करने के लिए इसकी दो प्रतियां बनाता है, फिर सभी लाइनों के लिए कट-ऑफ पत्र को जोड़ देता है। इसे क्षैतिज रूप से विकसित करने के लिए। पूर्ण त्रिकोण खींचने के लिए मैं इस मैक्रो को 24 बार दोहराता हूं।
— लिन
31

लोगो, 232 207 196 190 बाइट्स

किसी ने त्रिकोण कहा था?

अपने कम्पास और प्रोट्रैक्टर को बाहर निकालें, और चलो इसे ग्राफिकल तरीके से करते हैं। परिणामों को संरेखित करने के लिए ज्यामिति एक समबाहु त्रिभुज का उपयोग करती है। मेरे पास पहले एक समद्विबाहु त्रिभुज था, लेकिन इसमें बहुत अधिक दशमलव स्थान शामिल थे। इस परिवर्तन ने आउटपुट को भी संकुचित कर दिया, स्क्रीन प्रीप की मात्रा को कम करने और फ़ॉन्ट बदलने से मुझे करना पड़ा।

मैं इस एक बाहर मांस के लिए Calormen ऑनलाइन दुभाषिया का इस्तेमाल किया । यदि आपके पास पर्याप्त स्क्रीन अचल संपत्ति नहीं है, तो यह लपेटने जा रहा है, लेकिन आप इसकी देखभाल करने के लिए कुछ संख्याओं के साथ भी बेदखल कर सकते हैं। मैंने अपने ब्राउज़र पर "F11" फुल-स्क्रीन मोड का उपयोग किया।

ht
pu
to r:n:b:l repeat:n[rt:b label char 90-:n lt:b fd:l] end
to t:s
fd 12 rt 120 bk 6
repeat 2[r:s 90 12]
repeat 2[rt 120 r:s 90-heading 24]
end
rt 90 label "Z lt 210
repeat 25[t repcount]

rप्रक्रिया की एक पंक्ति ड्रॉ nअक्षर। चरित्र को स्वचालित रूप से इस बात पर निर्भर किया जाता है कि इसे कितने सेगमेंट का उपयोग करने के लिए कहा गया है। bपैरामीटर यह बताता है अस्थायी रूप से तो बारी बारी से करने के लिए कितना है कि पत्र को सही दिशा में ओर इशारा करते हैं। lपैरामीटर अक्षरों के बीच रैखिक दूरी निर्धारित करता है।

tप्रक्रिया अगले स्थिति के लिए कदम और कहता है rएक चार बार समारोह एक त्रिकोण बनाने के लिए, जब उचित घूर्णन। मैंने इसे दो बार ऊर्ध्वाधर पक्ष के लिए बुलाया क्योंकि विशेष हैंडलिंग के साथ इसे एक बार कॉल करने की तुलना में कम बाइट्स लिया। प्रक्रिया का अंत अगले चरण की शुरुआत के लिए कछुए को तैनात करता है, एक कदम ऊपर।

Zएक विशेष मामला है, इसलिए हम इसे सीधे प्रिंट करते हैं और घुमाते हैं जैसे कि हमने एक त्रिकोण पूरा किया है। अंत में, t25 बार कहा जाता है।

प्रगति में एनोटेट चित्रसमाप्त परिणाम

— GuitarPicker
स्रोत
3
अलग सोच। अच्छी तरह से किया।
— कजिनकैनिन
19

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

f x=init x++reverse x
t=unlines$f[f['A'..c]|c<-['A'..'Z']]

एक फ़ंक्शन को परिभाषित करता है tजो आउटपुट को एक स्ट्रिंग के रूप में लौटाता है।

f x=               define a helper function
init x             take the argument minus its last element
++                 and concatenate it with
reverse x          the argument reversed, producing ex. [a,b,c,b,a] from [a,b,c]

t=                                    define the main function
           [         |c<-['A'..'Z']]  for every char c from 'A' to 'Z'...
             ['A'..c]                 generate the range from 'A' to c
            f                         call the helper function to "reflect" it
          f                           call the helper function on the entire list
  unlines$                            join on newlines
— Doorknob
स्रोत
12

जेली , 16 13 बाइट्स

Ṗ;Ṛ
ØAḣJÇ€Çj⁷

3 बाइट बंद करने के लिए @LeakyNun को धन्यवाद!

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

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

Ṗ;Ṛ        Helper link. Argument: A (array)

Ṗ          Pop; yield A without its last element.
  Ṛ        Reversed; yield A with inverted order.
 ;         Concatenate the results to both sides.


ØAḣJÇ€Çj⁷  Main link. No arguments.

ØA         Alphabet; set link argument and return value to "A...Z".
   J       Indices; yield [1, ..., 26].
  ḣ        Head; take the first, the first two, etc. elements of the alphabet.
           This yields ["A", AB", ..., "A...Z"].
    ǀ     Apply the helper link to each string.
      Ç    Apply the helper link to the array itself.
       j⁷  Join, separating by linefeeds.
— डेनिस
स्रोत
3
— लीके नन
@LeakyNun धन्यवाद।
— डेनिस
4
मुझे यह जानने की उत्सुकता होगी कि दुनिया में यह कैसे काम करता है ...
— सुकराती फीनिक्स
शायद अगर लिंक डुप्लिकेट यू का उपयोग एक बाइट बचा सकता है
— लीक नून
3
@MathieuRodic जेली एक कस्टम कोड पेज का उपयोग करता है जो सभी 256 वर्णों को कूटबद्ध करता है जो इसे प्रत्येक बाइट के रूप में समझता है। बाइट्स यह करने के लिए शीर्ष लेख अंक में जोड़ देते हैं।
— डेनिस
10

पायथन, 74 बाइट्स

def f(x=66,s='A'):
 t=s+s[-2::-1];print t
 if x<91:f(x+1,s+chr(x));print t

एक पायथन 2 कार्य करता है जो प्रिंट करता है और कोई तर्क नहीं लेता है। प्रमुख विचार पुनरावृत्ति के साथ त्रिकोणीय वहाँ-और-वापस पैटर्न उत्पन्न करना है। पहले इस सरल फ़ंक्शन पर विचार करें जो 'A' को 'Z' तक प्रिंट करता है और वापस 'A' में जाता है:

def f(x=65):
 t=chr(x);print t
 if x<90:f(x+1);print t

फ़ंक्शन पहले "ए" (चार-कोड 65) प्रिंट करता है, फिर "बी" (66) और इतने पर "जेड" (90) प्रिंट करने के लिए पुनरावर्ती करता है। वहाँ से, यह पीछे हटना बंद कर देता है। पुनरावर्ती स्टैक को वापस पॉप करने के तरीके पर, यह t"Y" से "A" तक, उसी परत पर जो भी वर्ण मुद्रित करता है, प्रिंट करता है ।

मुख्य कोड वही करता है, सिवाय इसके कि यह sअब तक अक्षरों की स्ट्रिंग में जमा होता है, और ऊपर-नीचे स्ट्रिंग को प्रिंट करता है s+s[-2::-1]।

2 बाइट्स के लिए xsot का धन्यवाद।

पायथन 3 में, एक ही चीज बाइट से छोटी (73 बाइट) एक लाइन पर सब कुछ डालती है।

def f(x=66,s='A'):t=s+s[-2::-1];print(t);x>90or[f(x+1,s+chr(x)),print(t)]
— XNOR
स्रोत
आप 2 बाइट्स बचा सकते हैं यदि आप चर को ऑफसेट करते हैं, अर्थात f(x=66,s='A')। यह आपको sफ़ंक्शन बॉडी के बजाय फ़ंक्शन कॉल में अपडेट करने की अनुमति देता है।
— 12
मुझे लगता है कि आपके पायथन 3 संस्करण, इसके पायथन 2 रिश्तेदार की तरह, 89 के बजाय 90 के मूल्य की आवश्यकता है ताकि सबसे लंबी पंक्ति हो जो कि जेड और बैक के लिए सभी तरह से जाती है।
— तीबे
@Tebbe धन्यवाद, उन्हें ठीक किया।
— xnor
8

ब्रेनफक, 1733 121 119 बाइट्स

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

थोड़ा अधिक पठनीय संस्करण:

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

स्पष्टीकरण संभवतः आने के लिए।

— DanTheMan
स्रोत
प्रत्येक वर्ण को मैन्युअल रूप से बनाने के बजाय लूप का उपयोग करने का प्रयास करें।
— लीकेज नन
@LeakyNun मुझे नहीं पता कि इसके बारे में कैसे जाना जाए। कोई सुझाव?
— DanTheMan
4
अच्छा लगा, इसलिए आप केवल 4 घंटे सोए।
— लीक नून
1
कार्यक्रम को आउटपुट से छोटा होने पर बधाई!
— गिटारपिकर
1
1612 बाइट से एक गोल्फ कैसे जाता है?
— फंतासी
8

05AB1E , 20 13 12 6 बाइट्स

अदनान की बदौलत 2 बाइट बच गईं। मैजिक ऑक्टोपस Urn और कुछ नई भाषा कार्यक्षमता के
लिए 6 बाइट्स का धन्यवाद ।

Aη€ûû»

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

व्याख्या

Aη       # push prefixes of alphabet
  €û     # palendromize each prefix
    û    # palendromize the whole list
     »   # join on newlines
— Emigna
स्रोत
बहुत अच्छा! आप बदल सकते हैं Œ26£करने के लिए .pहै, जो उपसर्ग आदेश है। इसके अलावा, आप बदल सकते हैं D,करने के लिए =है, जो पॉपिंग बिना प्रिंट करता है।
— अदनान
वाह, चालाक चाल के साथ gF,!
— अदनान
@ अदनान: धन्यवाद! मुझे पता था कि वहाँ कहीं उपसर्ग कमांड था :) मैं शायद ही कभी विस्तारित लोगों की जाँच करूँ।
— एमिगा
2
यह द्विभाजित आदेश Âबहुत अच्छा और एक बहुत ही साफ सुथरा फीचर है।
— मीलों
1
@carusocomputing: दुर्भाग्य ûसे चुनौती से नया है और इस जवाब को गैर-प्रतिस्पर्धात्मक बना देगा।
— इमिग्ना
6

जे, २६ २३ २२ बाइट्स

f(f=:,1}.|.)\u:65+i.26

व्याख्या

,1}.|.  Monad f: Input: A
    |.  Reverse the items in A
 1}.    Drop the first item in the reversed A
,       Join A and the previous

f(f=:,1}.|.)\u:65+i.26
                  i.26  Create the range [0, 1, ..., 25]
               65+      Add 65 to each
             u:         Convert to characters to get 'A..Z'
  f=:,1}.|.             Define a verb f
 (         )\           Call f monadically on each prefix of 'A..Z'
f                       Call f again on that result
— मील की दूरी पर
स्रोत
f=:,1}.|.इसे आज़माएं
— लीकी नून
@LeakyNun धन्यवाद मुझे पता नहीं क्यों मुझे लगा कि वे अलग थे।
— मील
5

सी, 272 247 234 230 144 137 बाइट्स:

( पिछले बाइट में कई बाइट्स ( 272 -> 230) मेरी पिछली विधि में महान गोल्फिंग टिप्स और ट्रिक्स से साभार ! )

( बेहतर विधि पर स्विच करके लगभग 100 बाइट्स ( 230 -> 144) को बचाया )

main(q,i,e,x){for(q=0;q<51;q++){i=q>25 ? 25-(q-25):q;for(e=65;e<66+i;e++)printf("%c",e);for(x=64+i;x>64;x--)printf("%c",x);printf("\n");}}

में मेरा पहला उत्तर C। मैंने अभी हाल ही में इसे सीखना शुरू किया, तो आइए देखें कि यह कैसे होता है।

सी यह लड़ाई में! (Ideone)

— आर। कप
स्रोत
1
आह, मैं बस एक सी उत्तर जोड़ना चाहता था ... जो भी हो, मैं बस आपकी मदद करूंगा;) सबसे पहले, यह कोड गोल्फ है, आपको सही कोड लिखने की आवश्यकता नहीं है। कंपाइलर चेतावनी पूरी तरह से ठीक हैं। इसलिए आप main()रिटर्न प्रकार और यहां तक ​​कि हटा सकते हैं #include <stdio.h>। GCC (और Ideone जैसी साइटें) भी इसके साथ ठीक हैं। अगला, आप किसी फ़ंक्शन की पैरामीटर सूची के लिए चर परिभाषाओं को 'आउटसोर्स' कर सकते हैं। चलो for(int i=65;...बन for(i=65...और बदलने main()के लिए main(i)। हर दूसरे इंट वैरिएबल के लिए भी ऐसा ही करें (जीसीसी चूक प्रकार गायब int)।
— सिगलोर
@sigalor सुझावों के लिए धन्यवाद! :) बस एक सवाल: मैं क्यों बदलने की आवश्यकता main()करने के लिए main(i)?
— आर। काप
@sigalor वास्तव में, अब मुझे संकलन त्रुटियों का एक गुच्छा मिल रहा है।
— आर। काप
जब आप iलूप की शुरुआत के लिए अपने चर को घोषित नहीं करते हैं , तो आपको इसे कहीं और घोषित करने की आवश्यकता होती है। और क्योंकि (कम से कम C) किसी फ़ंक्शन के मापदंडों का उपयोग सामान्य चर की तरह किया जा सकता है, कोई समस्या नहीं होनी चाहिए। Btw, जो संकलक आप उपयोग कर रहे हैं?
— सिगेलोर
@sigalor वर्तमान Cमें Ideone में है। मुझे कई <variable> undeclaredत्रुटियां हो रही हैं।
— आर। काप
5

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

[...'ZYXWVUTSRQPONMLKJIHGFEDCBA'].reduce((p,c)=>c+`
`+p.replace(/^|$/gm,c)+`
`+c)
— ASCII-केवल
स्रोत
5

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

Column@FromCharacterCode[#@#@26+64]&[#-Abs@Range[1-#,#-1]&]
— chyanog
स्रोत
मुझे लगता है कि //Columnअंत से हटाने और Column@काम के साथ अपने कोड को उपसर्ग करना ।
— Yytsi
2
आप गिनती 〚और 〛एकल बाइट्स के रूप में लगता है । मुझे संदेह है कि एक एकल-बाइट कोड पृष्ठ है जो उनके पास है और बॉक्स से बाहर भी मैथमेटिका द्वारा समर्थित है। वे यूटीएफ -8 में तीन बाइट्स करेंगे, इसलिए वे वास्तव में सादे से अधिक कुछ भी नहीं बचाते हैं [[...]]। मुझे भी यकीन नहीं है कि यह वैध कैसे Columnहै क्योंकि यह केवल एक गणितज्ञ नोटबुक में लाइनों की सूची की तरह प्रदर्शित होता है। स्क्रिप्ट फ़ाइल से इस कोड को चलाना कुछ भी प्रदर्शित नहीं करेगा। हालाँकि, Print/@बाइट्स की समान संख्या है और दोनों ही मामलों में काम करती है।
— मार्टिन एंडर
आप एक लंबे पते के साथ एक पृष्ठ पर एक लिंक बनाना चाहते हैं, तो आपको निम्न कर सकते हैं: [what you see](actual link)। पूर्व। [Example Link](https://www.example.com), जो उदाहरण लिंक
— स्टेन स्ट्रम
4

आर, 63 61 59 बाइट्स

for(i in c(1:26,25:1))cat(LETTERS[c(1:i,i:1-1)],"
",sep="")

मददगार LETTTERS[0]किसी भी चरित्र को वापस नहीं करता है।

संपादित करें: @leakynun के लिए एक धन्यवाद खो दिया है

संपादित करें: @plannapus के लिए दो और धन्यवाद

— user5957401
स्रोत
1
आप \n
— लीकी नून
3

TSQL, 159 बाइट्स

DECLARE @ varchar(52)='ABCDEFGHIJKLMNOPQRSTUVWXY',@o varchar(max)SELECT @+='Z'+REVERSE(@)+'
',@o=@
WHILE''<@
SELECT @=STUFF(@,LEN(@)/2,2,''),@o=@+@o+@
PRINT @o

बेला

— t-clausen.dk
स्रोत
1
मैंने इसे करने की कोशिश की लेकिन 250+ बाइट्स के साथ समाप्त हो गया इसलिए कभी भी पोस्ट नहीं किया। तुम, वास्तव में, एक बेहतर समाधान तो मेरा है। एक बार फिर :)
— अनुज त्रिपाठी
3

जावास्क्रिप्ट (बाहरी पुस्तकालय-एन्युमेरेबल का उपयोग करके), 135 बाइट्स

_.Range(1,51).WriteLine(x=>(g=_.Range(65,x>25?52-x:x)).Write("",y=>(w=String.fromCharCode)(y))+(g.Reverse().Skip(1).Write("",y=>w(y))))

पुस्तकालय से लिंक: https://github.com/mvegh1/Enumerable

कोड स्पष्टीकरण: 51 की गिनती के लिए, 1 पर शुरू होने वाली कई रेंज बनाएं। प्रत्येक के लिए, जटिल पूर्वावलोकन के अनुसार एक पंक्ति लिखें। ग्लोबल वेरिएबल्स और कैशिंग ... और वॉइला के साथ कुछ JS विजार्ड्री करें। राइटलाइन में प्रत्येक इंट के लिए, हम बाएं हाथ की श्रेणी की टोपियां बना रहे हैं और वैश्विक "जी" में स्टोर कर रहे हैं, और स्ट्रिंग ज्वाइनिंग (लिखें) को ""सीमांकक के साथ जोड़ते हैं और प्रत्येक चार्ट को स्ट्रिंग चार्ट में मैपिंग के लिए प्रत्येक चार्ट को मैप करते हैं। फिर, हम उस क्रम को उलट कर (और पहले तत्व को छोड़ते हुए दाहिने हाथ की तरफ समेटते हैं, क्योंकि यह मूल क्रम के अंतिम तत्व से मेल खाएगा ...), उसी तर्क के साथ लिख रहा है। EDIT: लाइब्रेरी में राइट ऑफ़ इंटर्नल अपडेट किया गया। एक खाली अनुक्रम अब रिक्त के बजाय एक रिक्त स्ट्रिंग लिख देगा। यह भी जवाब से 15 बाइट्स मुंडा

यहाँ छवि विवरण दर्ज करें

— applejacks01
स्रोत
1
क्या आपको लाइब्रेरी को आयात करने के लिए बाइट्स को शामिल करने की आवश्यकता नहीं है?
— मैथ्यूॉक 12
1
Idk, Ive ने एक पुस्तकालय का उपयोग करते हुए 20 से अधिक उत्तर पोस्ट किए हैं और आप सबसे पहले मेरे लिए यह कहेंगे। मुझे नहीं लगता कि कोई भी वास्तव में परवाह करता है क्योंकि मेरे जवाब कभी भी जीतते नहीं हैं
— सेबजैक
1
@ applejacks01 बहुत यकीन है कि अगर आप इसे आयात नहीं करते हैं, तो आपको शीर्ष पर "JS + Enumerable" जैसा कुछ कहना होगा। "बैश + कोर्यूटिल्स" के समान
— mbomb007
2
आयात को गिनना आम बात है। पायथन + सिम्पी जवाब अभी भी import sympyया from sympy import*शीर्ष पर है। बैश + x क्योंकि आप केवल स्थापित किया है जवाब अलग हैं एक्स , यह किसी भी तरह सक्षम नहीं।
— डेनिस
1
@PatrickRoberts जब तक चुनौती पोस्ट होने से पहले पुस्तकालय मौजूद था, हाँ। अजगर जवाब का इस्तेमाल करते हैं sympy, numpy, scipyहर समय, आदि।
— डेनिस
3

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

9 बाइट बचाने के लिए टिम्मीड को धन्यवाद!

65..90+89..65|%{-join[char[]]((65..$_-ne$_)+$_..65)}

ASCII मूल्यों के माध्यम से कैपिटल अक्षरों के लिए आगे की ओर लूप, फिर पीछे की ओर। प्रत्येक संख्या के लिए, यह पहले X संख्याओं की एक सरणी बनाता है, X-1st संख्या को निकालता है, फिर पहले X संख्याओं के पीछे जोड़ता है, जो तब सभी वर्णों में डाली जाती है और एक स्ट्रिंग में शामिल हो जाती है।

— बेन ओवेन
स्रोत
अरे, यह अच्छा है, धन्यवाद! मैंने 65..90..65पहले ही बिना किसी सफलता के साथ पूरी तैयारी कर ली थी। मुझे लगता है मैं भूल गया मैं बस एक साथ श्रृंखला जोड़ सकते हैं।
— बेन ओवेन
3

चेडर , 102 96 79 69 67 बाइट्स

17 बाइट्स डाउनगोट के लिए धन्यवाद, और 10 और प्रेरणा।

"A"+(2@"27+@"(25|>1)).bytes.map(i->65@"(64+i)+@"((64+i)|>65)).vfuse

तथ्य यह है कि तार को संक्षिप्त कर सकते हैं, लेकिन सरणियों का मतलब यह नहीं है कि मुझे दो श्रेणियों को तार, समवर्ती में बदलना होगा, और फिर वापस सरणियों में बदलना होगा।

इसके अलावा, तथ्य यह है कि vfuseएक अग्रणी newliens का उत्पादन होता है इसका मतलब है कि मुझे पहली पंक्ति को मैन्युअल रूप से उत्पन्न करने की आवश्यकता होगी और फिर बाकी को समतल करना होगा।

@" एक रंग के रूप में (दो-तर्क फ़ंक्शन) सीधे स्ट्रिंग में परिवर्तित हो सकता है, लेकिन उलट सीमा के लिए काम नहीं करता है (यदि पहला तर्क दूसरे से बड़ा है)।

रेंज आधी-समावेशी थी। बग-फिक्स के बाद यह समावेशी हो गया।

प्रयोग

cheddar> "A"+(2@"27+@"(25|>1)).bytes.map(i->(65@"(64+i)+@"((64+i)|>65))).vfuse
"A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA
ABCDEFGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYZYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGFEDCBA
ABCDEFEDCBA
ABCDEDCBA
ABCDCBA
ABCBA
ABA
A"

चेडर, 55 बाइट्स (गैर-प्रतिस्पर्धात्मक)

में नवीनतम संस्करण सभी सुधारों के साथ, जवाब है:

(|>25+24|>0).map(i->65@"(65+i)+(i?(64+i)@"65:"")).vfuse

लेकिन यह चुनौती के बाद बनाया गया था।

— लीक नन
स्रोत
@"(1|>26)हो सकता है1@"26
— डाउन एंजेट
String.lettersहो सकता है(65@"91)
— बजे डाउनगैट
String.letters.slice(0,i)शायद हो सकता है65@"(66+i)
— डाउगाट
अहा, मैं तुम्हें किया गया है को देखने के झंझरी अपने bytecount।
— स्टेनबर्घ
3

VBA, 94 बाइट्स

Function T:For j=-25To 25:k=25-Abs(j):For i=-k To k:T=T &Chr(65+k-Abs(i)):Next:T=T &vbLf:Next

तत्काल विंडो में टी के साथ कॉल करें

बस यह बताने के लिए कि क्या चल रहा है: मैं दो बार ABS फ़ंक्शन का उपयोग करता हूं, दोनों वर्णमाला और रेखा की लंबाई को प्रतिबिंबित करने के लिए। यह दोनों मामलों में एकल चरम मूल्य के कारण कार्य के लिए अच्छी तरह से अनुकूल है, जो पूर्व-ABS चर के शून्य क्रॉसिंग से मेल खाती है।

VBA के तत्काल विंडो में एक प्रोग्राम या फ़ंक्शन के बजाय कमांड के सरल सेट के रूप में, निम्नलिखित को 72 बाइट्स की आवश्यकता होगी:

For j=-25To 25:k=25-Abs(j):For i=-k To k:?Chr(65+k-Abs(i));:Next:?:Next

(@GuitarPicker से साभार)

— Joffan
स्रोत
1
मैंने अपने आइसलैंड के फ्लैग सबमिशन में से एक में कुछ इसी तरह के तर्क का इस्तेमाल किया। क्या आप इसे पूरी तरह से तत्काल विंडो में चलाकर और फ़ंक्शन की घोषणा को छोड़ नहीं सकते थे, या क्या मैं इससे परिचित नहीं है, कुछ नियम को तोड़ता है?
— गिटारपिकर
@ गुइटरपिकर; सुनिश्चित नहीं है कि क्या तत्काल विंडो में चलने से पूरा कार्यक्रम मायने रखता है, लेकिन यदि ऐसा है तो 8 बाइट्स कम, प्रभावी ढंग से; के साथ शुरू करने के बजाय Function T:, अंत के साथ :?T(हालांकि यह केवल एक बार काम करेगा, क्योंकि इसके बाद आपको टी को "" रीसेट करना होगा - लेकिन इनमें से एक त्रिकोण से अधिक की आवश्यकता कौन है?)
— जोफान
2
आप के ?साथ जाने पर भी आपको T की आवश्यकता नहीं है ;।
— गिटारपीकर
मैं उस विधि का उपयोग करके इसे 71 तक शेव करने में सक्षम था। संकेत: आपको vbCrLf की आवश्यकता नहीं होगी।
— गिटारपीकर
1
हाँ, मुझे वही मिला; ध्यान दें कि वापसी आवश्यक है।
— जोफान
3

पायथन, 73 71 बाइट्स

पुनरावृत्ति के लिए @xnor को धन्यवाद

f=lambda x=66,s='A',t='':x/92*t or t+f(x+1,s+chr(x),s+s[-2::-1]+"\n")+t

व्याख्या

  • पैरामीटर :
    • x वर्णमाला में अगले अक्षर का एससीआई मान है
    • s वर्णमाला के लिए एक संचायक है
    • tत्रिकोण में एक लाइन है (यानी s+ s backwards)
  • वापसी : tयदि वर्णमाला की जाती है (यानी हम केंद्र में हैं)
  • वरना : t+f(...)+tके साथ:
    • x वृद्धि
    • s अगले पत्र के साथ जोड़ा गया
    • tपर रीसेट s+ s backwards+\n

अपडेट करें

  • -2 [16-08-05] अग्रणी \n(+1) और छोटा सशर्त (-3) सभी को @xnor के लिए धन्यवाद
— NonlinearFruit
स्रोत
1
क्या एक चतुर विधि, tअगले पाश के माध्यम से धक्का । हालांकि एक अतिरिक्त अग्रणी न्यूलाइन है; x=66,s='A''इससे छुटकारा मिलता है। आधार मामले को छोटा किया जा सकता है x/92*t or ।
— xnor
3

HTML + CSS, 884 अक्षर

(763 अक्षर HTML + 121 वर्ण CSS)

बंदर के जवाब पर लीकी नून की टिप्पणी का विस्तार करते हुए । (हालांकि मैं टिप्पणी गलत हो सकता है ...)

p{margin:0}p:before{content:"ABCDEFGH"}p:after{content:"HGFEDCBA"}a:before{content:"IJKLMNOP"}a:after{content:"PONMLKJI"}
<pre>A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA
ABCDEFGFEDCBA
ABCDEFGHGFEDCBA
<p>I</p><p>IJI</p><p>IJKJI</p><p>IJKLKJI</p><p>IJKLMLKJI</p><p>IJKLMNMLKJI</p><p>IJKLMNONMLKJI</p><p>IJKLMNOPONMLKJI</p><p><a>Q</p><p><a>QRQ</p><p><a>QRSRQ</p><p><a>QRSTSRQ</p><p><a>QRSTUTSRQ</p><p><a>QRSTUVUTSRQ</p><p><a>QRSTUVWVUTSRQ</p><p><a>QRSTUVWXWVUTSRQ</p><p><a>QRSTUVWXYXWVUTSRQ</p><p><a>QRSTUVWXYZYXWVUTSRQ</p><p><a>QRSTUVWXYXWVUTSRQ</p><p><a>QRSTUVWXWVUTSRQ</p><p><a>QRSTUVWVUTSRQ</p><p><a>QRSTUVUTSRQ</p><p><a>QRSTUTSRQ</p><p><a>QRSTSRQ</p><p><a>QRSRQ</p><p><a>QRQ</p><p><a>Q</a></p><p>IJKLMNOPONMLKJI</p><p>IJKLMNONMLKJI</p><p>IJKLMNMLKJI</p><p>IJKLMLKJI</p><p>IJKLKJI</p><p>IJKJI</p><p>IJI</p><p>I</p>ABCDEFGHGFEDCBA
ABCDEFGFEDCBA
ABCDEFEDCBA
ABCDEDCBA
ABCDCBA
ABCBA
ABA
A
स्निपेट का विस्तार करें

— मैनेटवर्क को प्रकट करता है
स्रोत
3

ब्रेकीलॉग , 37 29 बाइट्स

भर में उनकी सहायता के लिए घातक का श्रेय।

4 बाइट्स Fatalize के लिए धन्यवाद, और एक और 4 बाइट्स के लिए प्रेरणा।

@A:1&e:"a"yr:1&cw@Nw\
:Lc.r.!

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

विधेय 0 (मुख्य विधेय)

@A:1&e:"a"yr:1&cw@Nw\
@A:1&                  Apply predicate 1 to @A, which is
                       basically "abcdefghijklmnopqrstuvwxyz"
     e                 Choose one element from the result (choice point)
      :"a"yr               generate substring from element to "a"
            :1&            apply predicate 1
               c           concatenate
                w          write to STDOUT
                 @Nw       write "\n" to STDOUT
                    \  Backtrack to last choice point to choose
                       another element until there is no more
                       choice left, then halt.

1 समर्पित करें (सहायक विधेय)

यह मूल रूप से दिए गए स्ट्रिंग से एक palindrome बनाता है।

:Lc.r.!
:Lc.     output is [input:L]
   .r.   output reversed is still output
      !  stop searching after the first output
— लीक नन
स्रोत
आप एक बाइट की बचत के ,Aसाथ 1 में जगह ले सकते हैं h।
— घातक
तुम भी बदल कर दो बाइट्स बचा सकता है :1:2yt.के साथ :2&.और एक जोड़ने !विधेय 2. के अंत में (कट पसंद अंक)
— Fatalize
— 7
3

आर, 127 125 बाइट्स

k=cat;L=LETTERS;for(i in 1:26)k(c(L[1:i],L[(i-1):0],"\n"));for(i in 1:26)k(c(L[0:(26-i)],L[ifelse((25-i)>=0,25-i,0):0],"\n"))

इस समाधान से पूरी तरह से संतुष्ट नहीं हैं, विशेष रूप से दो forछोरों, लेकिन कुछ बेहतर के साथ नहीं आ सकता है!
LETTERSइसमें अपरकेस अक्षर शामिल हैं।

अधूरा:

for(i in 1:26){
  cat(c(LETTERS[1:i],LETTERS[(i-1):0],"\n"))
               }

for(i in 1:26){
  cat(c(LETTERS[0:(26-i)],LETTERS[ifelse((25-i)>=0,25-i,0):0],"\n"))
               }

ifelse एकजुट करने के लिए एक छोटा तरीका है if... else...इस तरह से और काम तरीका है:ifelse(condition,action if TRUE, action if FALSE)

अन्य 125 बाइट्स का समाधान: 

for(i in 1:26)(k=cat)(c((L=LETTERS)[1:i],L[(i-1):0],"\n"));for(i in 1:26)k(c(L[0:(26-i)],L[ifelse((25-i)>=0,25-i,0):0],"\n"))
— फ़्रेडरिक
स्रोत
— ग्यूसेप
3

जावा 131 बाइट्स

स्ट्रिंग (131 बाइट्स) का उपयोग किए बिना

public static void main(String[] args) {
    for(int i = 0 ,k=1; i>-1; i+=k){
        for(int c= 65, d = 1; c>64;){
            d = d>-1 & c < 65+i?1:-1;
            System.out.print((char)c+((c+=d)<65?"\n":""));
        }
        k = k>-1 & i < 25?1:-1;
    }
}

Codegolfed

for(int i=0,k=1;i>-1;k=k>-1&i<25?1:-1,i+=k)for(int c=65,d=1;c>64;d=d>-1&c<65+i?1:-1,System.out.print((char)c+((c+=d)<65?"\n":"")));

स्ट्रिंग के साथ (173 बाइट्स)

String a="abcdefghijklmnopqrstuvwxyz";
for(int i = 1 ,k=1; i>0; i+=k==1?1:-1){
    System.out.println(a.substring(0,i)+new StringBuilder(a).reverse().substring(27-i));
    k = k>-1 & i < 26?1:-1;
}

Codegolfed

String a="abcdefghijklmnopqrstuvwxyz";for(int i=1,k=1;i>0;k=k>-1&i<26?1:-1,System.out.println(a.substring(0,i)+new StringBuilder(a).reverse().substring(27-i)),i+=k==1?1:-1);

मैनटवर्क और केविन क्रूज़सेन के लिए धन्यवाद

— सीमेश के
स्रोत
2
PPCG में आपका स्वागत है। कृपया पढ़ें "मुझे एक कोड गोल्फ का जवाब कैसे देना चाहिए? कोई संकेत? ” कोड-गोल्फ टैग की जानकारी पृष्ठ में अनुभाग । इस तरह की चुनौतियों के जवाबों से कोड आकार को कम करने के प्रयासों को पेश करने की उम्मीद है। इसमें आपको जावा में गोल्फ के लिए टिप्स और <सभी भाषाओं में गोल्फिंग के लिए टिप्स> की मदद मिल सकती है ।
— मैनटवर्क
1
वहाँ आप 4 टर्नरी ऑपरेटरों का उपयोग करते हैं और सभी शर्तें कोष्ठक में संलग्न हैं। आप 8 वर्णों को सहेजने के लिए उन्हें निकाल सकते हैं।
— manatwork
1
d और k -1 से नीचे नहीं जा सकते, है ना? तो आप के d!=-1साथ बदल सकते हैं d>-1, कश्मीर के लिए एक ही है। (BTW, आप गोल्फ संस्करण को ठीक करना भूल गए।)
— manatwork
3 बाइट्स को बचाने के लिए लूप बॉडी से इंक्रीमेंट स्टेटमेंट सेक्शन तक ले जाया गया बयान ..
— Syamesh K
1
नमस्ते, मुझे पता है कि यह काफी समय हो गया है, लेकिन आप दो चीजों को गोल्फ कर सकते हैं: i+=k==1?1:-1हो सकता है i+=kऔर System.out.print((char)c+(c+d<65?"\n":"")),c+=d==1?1:-1);हो सकता है System.out.print((char)c+((c+=d)<65?"\n":"")));। तो कुल मिलाकर यह ( 131 बाइट्स ) हो जाता है :for(int i=0,k=1;i>-1;k=k>-1&i<25?1:-1,i+=k)for(int c=65,d=1;c>64;d=d>-1&c<65+i?1:-1,System.out.print((char)c+((c+=d)<65?"\n":"")));
— केविन क्रूज़सेन
2

सेसोस , 27 बाइट्स

0000000: a85ab9 ac5daa f8b1c7 785f9b b961f7 665c1b 73ccfc  .Z..]....x_..a.f\.s..
0000015: c01ecb 987303                                     ....s.

इसे ऑनलाइन आज़माएं! डीबग की जाँच करेंउत्पन्न SBIN कोड देखने के लिए ।

सीसोस विधानसभा

ऊपर की बाइनरी फ़ाइल निम्नलिखित एसएएसएम कोड को इकट्ठा करके बनाई गई है।

add 65, rwd 1, add 10, rwd 2, add 25
jmp
    fwd 3
    jmp
        put, fwd 1
    jnz
    rwd 1
    jmp
        fwd 1, add 1, fwd 1, add 1, rwd 2, sub 1
    jnz
    fwd 2
    jmp
        rwd 2, add 1, fwd 2, sub 1
    jnz
    rwd 1, add 1, rwd 2
    jmp
        put, rwd 1
    jnz
    rwd 1, sub 1
jnz
fwd 3
jmp
    jmp
        put, fwd 1
    jnz
    rwd 1, get, rwd 1
    jmp
        put, rwd 1
    jnz
    fwd 2
; jnz (implicit)
— डेनिस
स्रोत
2

/// , 208 बाइट्स

/'/\/\///+/BA
AB'-/DC+CD'&/FE-EF')/HG&GH'=/JI)IJ'|/LK=KL'7/NM|MN'1/PO7OP'q/RQ1QR'p/TSqST'6/VUpUV'[/XW6WX/A
A+C+C-E-E&G&G)I)I=K=K|M|M7O7O1Q1QqSqSpUpU6W6W[Y[YZY[Y[W6W6UpUpSqSqQ1Q1O7O7M|M|K=K=I)I)G&G&E-E-C+C+A
A

बेशक नहीं जीत, लेकिन यहाँ यह है, मार्टिन एंडर से पहले ...

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