46

एक प्रोग्राम या फ़ंक्शन लिखें जो इस सटीक पाठ, केस-असंवेदनशील को आउटपुट करता है:

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 string kolmogorov-complexity

— ETHproductions
स्रोत

4

रेगेक्स आधारित भाषाओं के लिए एक 0 चौड़ाई पर गौर करें .../(?=[HQTW])/

— मैजिक ऑक्टोपस उर

29

मैंने सोचा कि यह था H, I, J, K, LMNO, P?

— मोनिका

7

"वाई और जेड" के साथ अंतिम पंक्ति समाप्त नहीं होनी चाहिए?

— के.एम.

@KM। सैंडबॉक्स में इस पर चर्चा की गई थी , और हमने चुनौती को कम जटिल बनाने के लिए इस संस्करण के साथ चिपके रहने का फैसला किया।

— ETHproductions

6

गोल्फ उबाऊ लगता है। क्रिकेट बेहतर है।

— मनोज कुमार

15

विम, 42 , 40 कीस्ट्रोक्स / बाइट्स

:h<_<cr>jjYZZP:s/./&, /g<cr>7f r<cr>9;.3;.3;.$ch.

मदद के लिए वर्णमाला हड़पने के लिए लिन और उसके भयानक विम जवाब के लिए धन्यवाद ।

दो बाइट बचाने के लिए RomanGräf के लिए धन्यवाद!

स्पष्टीकरण:

:h<_<cr>                                      " Open up vim-help
        jj                                    " Move down two lines
          Y                                   " Yank this line (containing the alphabet)
           ZZ                                 " Close this buffer
             P                                " Paste the line we just yanked
              :s/./&, /g<cr>                  " Replace every character with that character followed by a comma and a space
                            7f                " Find the seven space on this line
                               r<cr>          " And replace it with a newline
                                    9;        " Repeat the last search (space) 9 times
                                      .       " Repeat the last edit (replace with a newline)
                                       3;     " Third space
                                         .    " Replace with newline
                                          3;  " Third space
                                            . " Replace with newline

फिर, हम पंक्ति के अंत को साथ स्थानांतरित करते हैं $, एक वर्ण को वापस बदलते हैं chऔर एक डॉट डालते हैं।

— DJMcMayhem
स्रोत

2

आपको अपरकेस में परिवर्तित नहीं होना चाहिए। ओपी ने कहा "यह सटीक पाठ, केस-असंवेदनशील"।

— रोमन ग्रैफ़

@ RomanGräf टिप के लिए धन्यवाद!

— DJMcMayhem

हा! विम मदद से वर्णमाला प्राप्त करना प्रतिभाशाली है! क्या आप जानते हैं कि आपने इस चुनौती के लिए इसे देखा था?

— क्रिश्चियन रोंडेउ

3

@christianRondeau मैं इसके साथ नहीं आया। लिन में किया था क्या यह उत्तर

— DJMcMayhem

@ RomanGräf +1 का उपयोग नहीं करने के लिए

— FantaC

12

05AB1E , 16 बाइट्स

कोड

A',â79334S£»¨'.J

स्पष्टीकरण:

A                  # Push the alphabet.
 ',â               # Cartesian product with ','.
    79334S         # Push [7, 9, 3, 3, 4].
          £        # Contigious substring, pushes the substrings [0:7], [7:7+9], 
                     [7+9:7+9+3], [7+9+3:7+9+3+3], [7+9+3+3:7+9+3+3+4].
           »       # Gridify, join the inner arrays with spaces and join those arrays
                     with newlines.
            ¨      # Remove the last character.
             '.J   # Append a '.'-character.

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

11

बैश + जीएनयू उपयोगिताओं, 36

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

echo {A..Y}, Z.|sed 's/[HQTW]/\n&/g'

Ideone।

— डिजिटल आघात
स्रोत

2

सिर्फ क्यों नहीं echo {A..Y}, Z.|sed 's/[HQTW]/\n&/g'?

— नील

@ नील ओहो बहुत अच्छा! धन्यवाद!

— डिजिटल ट्रामा

11

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

बीटिंग @Neil असंभव था ... इसलिए मैंने किया। :-)

f=(i=10)=>i>34?"z.":i.toString(++i)+","+` 
`[9568512>>i-9&1]+f(i)

से एक चाल के लिए golfed 1 बाइट धन्यवाद @LevelRiverSt । String.fromCharCode7 बाइट्स का उपयोग करना अधिक लंबा है:

f=(i=65)=>i>89?"Z.":String.fromCharCode(i,44,i%86%83%80%71?32:10)+f(i+1)

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

यह पुनरावर्ती वर्णमाला के प्रत्येक वर्ण को प्रयोग aसे y, के लिए उत्पन्न करता है .toString()। प्रत्येक अक्षर के बाद एक अल्पविराम जोड़ा जाता है, साथ ही एक नई पंक्ति यदि 9568512>>i-9&11, या अन्यथा एक स्थान है। जब पुनरावृत्ति 34 हो जाती है, अर्थात z, फ़ंक्शन केवल वापस आ जाता है "z."।

— ETHproductions
स्रोत

प्रतीक्षा करें कि यह कैसे करता है- स्पष्टीकरण pls? : 3

— डाउनगेट

10

पायथन 2.7, 67 66 63 बाइट्स

a=65;exec"print'%c'%a+',.'[a>89]+'\\n'[a%42%39%9^2:],;a+=1;"*26

डेनिस ने एक बाइट को बचाया।

— लिन
स्रोत

execइसके बजाय का उपयोग करके forएक बाइट को बचाना चाहिए।

— डेनिस

6

जेली , 19 18 बाइट्स

ØAp”,ṁ79334DR¤GṖ”.

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

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

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

ØAp”,ṁ79334DR¤GṖ”.  Main link. No arguments.

ØA                  Yield "ABCDEFGHIJKLMNOPQRSTUVWXYZ".
  p”,               Cartesian product with ','; append a comma to each letter.
             ¤      Combine the two links to the left into a niladic chain.
      79334D          Decimal; yield [7, 9, 3, 3, 4].
            R         Range; yield [[1, 2, 3, 4, 5, 6, 7], ..., [1, 2, 3, 4]].
     ṁ              Mold; reshape the array of letters with commata like the
                    generated 2D array.
              G     Grid; separate rows by spaces, columns by linefeeds.
               Ṗ    Pop; discard the last comma.
                ”.  Print the previous result and set the return value to '.'.
                     (implicit) Print the return value.

— डेनिस
स्रोत

11

31 सेकंड? डांग ...

— ETHproductions

5

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

_=>[...`ABCDEFGHIJKLMNOPQRSTUVWXYZ`].join`, `.replace(/[HQTW]/g,`
$&`)+`.`

यदि आप आईएसओ-8859-1 एन्कोडिंग का उपयोग करने के लिए काम कर सकते हैं, तो इसे एओबी / बीटीओए के साथ छोटा करना संभव है। संपादित करें: @RickHitchcock के लिए 6 बाइट्स सहेजे गए।

— नील
स्रोत

1

@RickHitchcock हाँ, मुझे एहसास हुआ कि PHP उत्तर पढ़ने के बाद खुद को।

— नील

@RickHitchcock आप चाहते थे .join`, `? बैकटिक्स से पहले बैकस्लैश लगाएं। (हां, टिप्पणी मार्कडाउन अलग है, आह ...)

— नील

5

पाइके, 23 19 17 बाइट्स

G\,J\.+2cu  /P

यहाँ कोशिश करो!

G\,J\.+        -    ",".join(alphabet)+"."
       2c      -   split(^, size=2)
            /  -  split_sized(^, V)
         u     -   yield list [7,9,3,3] (actual bytes `u%04%07%09%03%03`)
             P - print(^)

— नीला
स्रोत

5

आर, 83 71 बाइट्स

a=rbind(LETTERS[-26],","," ");a[3,7+3*c(0,3:5)]="\n";cat(a,"Z.",sep="")

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

3 पंक्तियों का एक मैट्रिक्स बनाता है (अक्षरों के साथ एक, अल्पविराम के साथ एक और एक स्थान या एक नई पंक्ति के साथ)।

संपादित करें : धन्यवाद बिलीवोब!

— plannapus
स्रोत

cat(a,sep="")कुछ बाइट्स बचाता है:a=rbind(LETTERS,","," ");a[3,7+3*c(0,3:5)]="\n";cat(a[,-26],"Z.",sep="")

— बिलीवोब

धन्यवाद! इससे बहुत मदद मिली! का प्रयोग [-26]पर LETTERSसीधे अभी तक एक और बाइट बचाता है।

— प्लेनपस

4

सीजेएम, 26 बाइट्स

'A79333Ab{{',S2$)}*N\}/'.@

ऑनलाइन दुभाषिया

'A                             Push 'A'
  79333Ab                      Push [7 9 3 3 3]
         {           }/        For each number n in the previous array...
          {      }*              Execute n times...
           ',S                     Push a comma and a space
              2$)                  Copy last letter and increment
                   N\            Place a newline under the letter on top
                       '.@     Push '.' and rotate

— Sp3000
स्रोत

4

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

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

पहले चार पंक्तियों में से प्रत्येक में एक अनुगामी स्थान होता है, और कार्यक्रम 8-बिट कोशिकाओं को मानता है। इसे ऑनलाइन आज़माएं!

^{(अंतिम पंक्ति को संभालना मुश्किल है ...)}

— Sp3000
स्रोत

4

पर्ल, 37 बाइट्स

इस समाधान के लिए @ डॉम हेस्टिंग्स को श्रेय (मेरी तुलना में 3 बाइट्स, बलो देखें)।

say+(map"$_, ".$/x/[GPSV]/,A..Y),"Z."

-E(या -M5.010) ध्वज के साथ चलाएँ :

perl -E 'say+(map"$_, ".$/x/[GPSV]/,A..Y),"Z."'

मेरा पिछला संस्करण, 3 बाइट्स लंबा (कुल 40 बाइट्स):

perl -E '$_=join", ",A..Z;s/[HQTW]/\n$&/g;say"$_."'

— बापू
स्रोत

1

थोड़ा अलग दृष्टिकोण (अभी भी regex का उपयोग करता है ...) 37 बाइट्स के लिए:say+(map"$_, ".$/x/[GPSV]/,A..Y),"Z."

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

@DomHastings अच्छा लगा, अच्छा किया। और यह तीन के बजाय एक बयान के लिए अधिक सुंदर है! ;-)

— दादा

4

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

_=>`ABCDEFG
HIJKLMNOP
QRS
TUV
WXY`.replace(/./g,"$&, ")+"Z."

रेगेक्स पात्रों से मेल खाता है, लेकिन गाड़ी वापस नहीं आती है, इसलिए रेगेक्स की जगह, मैं प्रत्येक चरित्र में "," जोड़ सकता हूं।

संपादित करें: निकाले गए 2 वर्ण ETHProductions के लिए धन्यवाद

— Grax32
स्रोत

1

मुझे नहीं पता कि अन्य जेएस गोल्फर पहले इस समाधान के लिए क्यों नहीं गए। यहाँ, एक उत्थान है।

— मामा फन रोल

1

डांग, एक अच्छा! मुझे लगता है कि अगर आप बदलना आप regex में कोष्ठक हटा सकते हैं $1करने के लिए $&।

— ETHproductions

3

चेडर, 70 बाइट्स

->[65@"71,72@"80,"QRS","TUV","WXYZ"].map(@.chars.join(", ")).vfuse+'.'

ऐसा लगता है कि यह इससे छोटा नहीं हो रहा है। मैंने इसके अन्य संस्करण बनाए हैं जो काफी दिलचस्प तरीकों का उपयोग करते हैं लेकिन यह सबसे छोटा है

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

व्याख्या

->                        // Function with no arguments
  [                       // Array, each item represents a line
   65@"71,                // See below on what @" does
   72@"80,
   "QRS",
   "TUV",
   "WXYZ"
  ].map(                  // On each item...
    @.chars.join(", ")    // Join the characters on ", "
  ).vfuse                 // Vertical fuse or join by newlines
  + '.'                   // The period at the end

@"ऑपरेटर लेकर स्ट्रिंग उत्पन्न करने के लिए प्रयोग किया जाता है। यह बाएं चार कोड से शुरू होकर दाईं ओर कोड तक एक स्ट्रिंग बनाता है।

उदाहरण के लिए, 65के लिए Aऔर के 90लिए चार कोड है Z। ऐसा करने से 65 @" 90Z या वर्णमाला के माध्यम से एक उत्पन्न होगा।

— Downgoat
स्रोत

3

सी, 112 102 81 बाइट्स

cleblanc और LevelRiverSt को धन्यवाद!

i,c;main(){for(c=64;++c<91;)printf("%c%c%c",c,44+c/90*2,c=="‌GPSVZ"[i]?++i,10:32)‌;}

— musarithmia
स्रोत

अच्छा समाधान है। आप कुछ बाइट्स बचा सकते हैं क्योंकि 44 'से कम', 'और 46 1 से कम' है। '

— क्लेब्लैंक सिप

इंट को घोषित करने की कोई आवश्यकता नहीं है और आप i,c,d;main(){for(c=65;c<91;++c){if(c-"GPSVZ"[i])d=32;else d=10,++i;printf("%c%c%c",c,c-90?44:46,d);}}

— इनट्स

आप इस दृष्टिकोण को 82 बाइट्स तक प्राप्त कर सकते हैं i,c;main(){for(c=64;++c<91;)printf("%c%c%c",c,44+c/90*2,c=="GPSVZ"[i]?++i,10:32);}:। ध्यान दें कि आप एक टर्नरी ऑपरेटर के बीच बिल्कुल कुछ भी चिपका सकते हैं ?:, यहां तक कि कई भाव अल्पविराम से अलग हो जाते हैं (यह पिछले एक का मूल्यांकन करता है।)

— लेवल रिवर सेंट

3

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

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

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

— gtwebb
स्रोत

3

रूबी, 56 54 बाइट्स

$><<(?A..?Y).map{|c|c+('GPSV'[c]?",
":", ")}.join+"Z."

पहली पंक्ति एक शाब्दिक नई रेखा के साथ समाप्त होती है।

संपादित करें: के'A'..'Y' साथ प्रतिस्थापित करके दो बाइट्स सहेजे गए ?A..?Y।

— pgks
स्रोत

3

विम, 32 बाइट्स

26o<C-V><C-V>64,<Esc>r.V{g<C-A>8Jj9Jj3Jj.j4JcH<C-R>"

अंत में एक रिक्त रेखा छोड़ता है, जिसे अनुमति दी गई थी, लेकिन यह अजीब है यह अनाड़ी है। इससे भी बदतर यह मैं डालने मोड में खत्म होने वाली हूँ। मैंने देखा है कुछ अन्य लोग इसे यहाँ करते हैं, इसलिए मुझे लगता है कि इसकी अनुमति है? यह गंदा लगता है।

26o<C-V><C-V>64,<Esc>: पहला <C-V>दूसरा एक डालने सचमुच बनाता है। <C-V>64एस बफर में इस पत्ते तो पत्र में ASCII कोड अंक में तब्दील किया जा जाएगा। पहले से ही में अल्पविराम।
r.: कभी नहीं फिर अंत में होने जा रहा, ऐसा .अब।
V{g<C-A>: 64बड़े अक्षरों के ASCII कोड बिंदुओं में सभी s को चालू करने के लिए दृश्य वृद्धि का उपयोग करता है ।
8Jj9Jj3Jj.j4J: मनमाने ढंग से लाइन मिलती है। पहले की 8Jबजाय 7Jहम खाली लाइन के साथ काम कर रहे हैं। बार-बार 3Jएक डॉट दोहराने के लिए पात्र हैं।
cH<C-R>": लोग आमतौर पर i<C-R>एक इंसर्ट मोड पेस्ट के रूप में सोचते हैं , लेकिन यह एक इंसर्ट मोड मैक्रो की तरह है। जैसे <C-V>65टाइप किया जाएगा, वैसे ही स्टफ चलेगा और दशमलव कोड बिंदु के रूप में व्याख्या की जाएगी। यह अंत में एक अतिरिक्त (अनुमत) लाइन छोड़ता है, और इन्सर्ट मोड में रहता है।

— udioica
स्रोत

4

यदि आपके पास एक नीति (या इसके अभाव) के साथ कोई समस्या है, तो इसे मेटा में लें, उत्तर में नहीं।

— मेघ

2

PowerShell v3 +, 60 78 67 बाइट्स

-join(65..90|%{[char]$_+'.,'[$_-le89]+" "+"`n"*($_-in71,80,83,86)})

ठीक। मैंने वास्तव में इस बार युक्ति पढ़ी, समझी और उसका अनुसरण किया। वादा। : डी

65..90प्रत्येक तत्व पर सरणी और लूप लेता है|%{...} । प्रत्येक पुनरावृत्ति, हम संघनन, अनुक्रमण और गुणन का उपयोग करते हुए एक नए तार का निर्माण कर रहे हैं।

सबसे पहले, हम वर्तमान संख्या लेते हैं और charइसे ASCII पत्र बनाने के लिए डालते हैं। इसे स्ट्रिंग में अनुक्रमित करने के आधार पर एक और चार के साथ सम्‍मिलित किया जाता है, '.,'चाहे हम हों 90या न हों (यानी, Z.शेष सभी अल्पविराम होने पर खाते में )। कि स्ट्रिंग " "को अलग-अलग अक्षरों के साथ स्पेस-अलग किया जा सकता है, और "`n"वर्तमान तत्व -inनिर्दिष्ट सरणी है या नहीं (इसके लिए, हमें नई पंक्ति वर्ण पर संक्षिप्त करने की आवश्यकता है) के लिए बूलियन मान पर आधारित स्ट्रिंग गुणन । परिणामी स्ट्रिंग को पाइप लाइन पर छोड़ दिया जाता है।

उन तारों को Parens में एनकैप्सुलेट किया जाता है, और -joinएक नए स्ट्रिंग में एक साथ एड किया जाता है, जिसे बाद में पाइपलाइन पर छोड़ दिया Write-Outputजाता है और अंत में परिणाम को प्रिंट करता है। चूंकि हमारे पास `nस्ट्रिंग है, इसलिए यह स्वचालित रूप से प्रिंटिंग पर नई सुर्खियों में बदल जाता है।

-inऑपरेटर के लिए v3 + की आवश्यकता होती है । प्रत्येक पंक्ति पर एक अनुगामी स्थान है, जो चुनौती के चश्मे के अनुसार ठीक है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\now-i-know-my-abc.ps1
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.

— AdmBorkBork
स्रोत

1

समाप्ति की अवधि गायब है।

— डाउनगेट

क्या पहले चार पंक्तियों के अंत में अल्पविराम नहीं होना चाहिए?

— नील

@ नील अच्छी ग्रेवी। मैं इसे तब तक हटाने जा रहा हूं जब तक कि मैं वास्तव में कल्पना को नहीं समझ सकता।

— AdmBorkBork

2

PHP, 62 बाइट्स

<?=preg_filter("# ([HQTW])#","\n$1",join(", ",range(A,Z)));?>.

केवल 87 बाइट्स की तुलना के लिए

<?="A, B, C, D, E, F, G,\nH, I, J, K, L, M, N, O, P,\nQ, R, S,\nT, U, V,\nW, X, Y, Z.";

— जार्ग हुल्सरमन
स्रोत

आप के स्थान पर एक वास्तविक newline का उपयोग करके एक बाइट बचा सकते हैं \n।

— एलेक्स हॉवान्स्की 23

जैसा कि आपको प्रत्येक पंक्ति में रिक्त स्थान की अनुमति है, आप regex से अंतरिक्ष को गिराकर एक बाइट को बचा सकते हैं। इसके अलावा, आप एक बाइट को (7.0 में हटाए गए और हटाए गए) ereg_replace के उपयोग से बचा सकते हैं क्योंकि यह आपको रेमीक्स में सीमांकक को छोड़ देता है।

— user59178

@ user59178 मैं 3 बाइट्स बचा सकता था लेकिन मैं इससे बचता। हाँ अनुगामी स्थान की अनुमति है। मैं regex के रूप में लिख सकता था "# (?=[HQTW])#"और "\n"एक ही बाइट्स को प्रतिस्थापित कर सकता था और इसे स्पष्ट कर देता था। एक पदावनत समारोह का उपयोग करने के लिए शुरुआती भ्रमित कर सकते हैं। और भौतिक विराम की अन्य प्रणालियों पर गलत व्याख्या की जा सकती है। आप इसे अपने खुद के सगेस्टेशन के रूप में पोस्ट कर सकते हैं।

— जोर्ग हल्सरमन

2

MATL, 38 29 बाइट्स

9 बाइट्स @Luis को धन्यवाद बचा लिया!

1Y2X{', '&Zc46h1[CEII]I*11hY{

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

व्याख्या

1Y2     % Push the upper-case alphabet to the stack
X{      % Break the character array into a cell array (similar to a list)
        % where each element is a letter
', '&Zc % Combine back into a string with ', ' between each element
46h     % Append '.' (via ASCII code) to the end of the string
1       % Push the number 1
[CEII]  % Push the array: [7, 9, 3, 3]
I*      % Multiply this array by 3: [21, 27, 9, 9]  
llh     % Append an 11 to this array: [21, 27, 9, 9, 11] 
Y{      % Break our comma-separated list of characters into groups of this size
        % Implicitly display the result

— Suever
स्रोत

2

आर, 146 बाइट्स

L=LETTERS
f=function(x,y=""){paste(x,collapse=paste0(", ",y))}
cat(f(c(f(L[1:7]),f(L[8:16]),f(L[17:19]),f(L[20:22]),f(L[23:26])),"\n"),".",sep="")

स्पष्टीकरण:

LETTERSअपरकेस अक्षरों के लिए पूर्वनिर्धारित है। समारोह पर वेक्टर x श्रृंखलाबद्ध के लिए है अतिरिक्त के साथ (नई-पंक्तियों के लिए इस्तेमाल किया)। बिल्ली का इस्तेमाल तब किया जाता है, जब वह नए सिरे से प्रिंट करती है। अक्षरों पर पंक्तियों को बनाने के लिए और फिर पंक्तियों पर पूरे आउटपुट को बनाने के लिए कहा जाता है।
f,y
\nf

शायद गोल्फ - मैं च के कई कॉल पसंद नहीं है ...

— pajonk
स्रोत

3

कच्चा आउटपुट केवल 77 बाइट्स लंबा होता है। मुद्रण जो सीधे छोटा हो सकता है ...

— लिन

@ लियन, मुझे पता है, लेकिन यहां मुझे कुछ गोल्फ की संभावनाएं दिखती हैं।

— पजाकों

2

सीजेएम, 31 बाइट्स

'[,65>", "*7933Ab{3*/(\:+}%N*'.

स्पष्टीकरण:

'[,65>                             push uppercase alphabet
      ", "*                        ", " between all letters
           7933Ab                  push [7 9 3 3]
                 {3*/(\:+}%        slices of lengths 21, 27, 9, 9
                           N*'.    join slices with newlines, add final "."

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

— Neorej
स्रोत

2

जूलिया, 71 बाइट्स

f()=join(join.(['A':'G','H':'P',"QRS","TUV","WXYZ"],[", "]),",\n")*"."

प्रसारण के लिए 0.5 या बेहतर की आवश्यकता है .()

— लिंडन व्हाइट
स्रोत

एक ओर, यह वर्तमान में एक अनुगामी अवधि नहीं है, और इसे print/ फ़ंक्शन परिभाषा की आवश्यकता नहीं है ? दूसरी ओर, joinएक चर के लिए बचत नहीं एक बाइट बचाता है।

— Sp3000

मेरा बुरा wrt "" को याद कर रहा है, और पॉइंटर ऑन करने के लिए धन्यवाद join। मैं चूक गया। प्रोग्राम चलाने से स्ट्रिंग वापस आती है। क्या कोई प्रोग्राम स्ट्रिंग को वैध आउटपुट नहीं दे रहा है? (या यह केवल ऐसे कार्य हैं जिन्हें आउटपुट के रूप में गिनने के लिए चीजों को वापस करने की अनुमति दी जाती है। यदि f()=यह छोटा है तो print())

— लिंडन व्हाइट

ज़रूर, f()=या ()->ठीक है - मुझे लगता है कि विचार यह है कि फ़ंक्शन असाइन करने योग्य हैं और कई बार चलाए जा सकते हैं, और इसके विपरीत यह एक कोड स्निपेट होगा।

— Sp3000

2

चेडर, 57 बाइट्स

->(65@"90).sub(/[GPSV]/g,"$0
").sub(/[^Z\n]/g,"$0, ")+"."

इसे ऑनलाइन आज़माएं! क्या वह सुंदर नहीं है? यह एक अच्छी आयत है।

दो रेगेक्स प्रतिस्थापन। (65@"90)अपरकेस वर्णमाला है, स्वयं के साथ .sub(/[GPSV]/g,"$0\n")बदलता GPSVहै और "\n", .sub(/[^Z\n]/g,"$0, ")सभी गैर नईलाइन और Zवर्णों को स्वयं के साथ बदलता है ", ", और "."एक अंतिम जोड़ता है .।

— कोनोर ओ ब्रायन
स्रोत

1

अच्छी तकनीक, और अच्छी नौकरी के लिए डाउनगॉटिंग;)

— ETHproductions

2

जाप, 24 बाइट्स

;B¬qJ+S r"[HQTW]"@R+XÃ+L

इसे ऑनलाइन टेस्ट करें!

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

;                        // Reset various variables. B is set to "ABC...XYZ", J is set to ",", and L is set to ".".
 B¬                      // Take the uppercase alphabet and split into chars.
   qJ+S                  // Join with ", ".
        r"[HQTW]"        // Replace each H, Q, T, or W with
                 @R+XÃ   //   a newline plus the character.
                      +L // Append a period to the result.
                         // Implicit: output last expression

— ETHproductions
स्रोत

2

जावा, 116 109 105 104

String f(){String s="";for(char c=65;c<91;)s=s+c+(c>89?46:',')+("GPSV".indexOf(c++)<0?' ':10);return s;}

Ungolfed:

String f() {
  String s = "";
  for (char c = 65; c < 91;) {
    s = s + c
      + (c > 89 ? 46 : ',')
      + ("GPSV".indexOf(c++) < 0 ? ' ' : 10);
  }
  return s;
}

आप इसे 7 बाइट्स द्वारा गोल्फ कर सकते हैं: सभी तीन ||से |(-3); बदल रहा c==90है c>89(-1); बदल रहा '.'है 46(-1); और बदलते '\n'करने के लिए 10(-2)।

— केविन क्रूज़सेन

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

2

@ केविनक्रूजसेन धन्यवाद। अगर मेरे अंदर पर्याप्त कॉफी होती तो मुझे खुद को अपडेट करने की याद होती।

1

2 और बाइट्स: के "GPSV".contains(""+c)बजाय c==71|c==80|c==83|c==86।

— टीएनटी

1

@TNT मैं थोड़ा बेहतर कर पा रहा था। मुझे पता था कि भाग को बेहतर बनाया जा सकता है, सही दिशा में धक्का के लिए धन्यवाद।

1

क्यू, 46 बाइट्स

-1@'(", "sv/:0 7 16 19 22_,:'[.Q.A]),'",,,,.";

— skeevey
स्रोत

1

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


Z
{2`
$`
}T01`L`_L
.
$&, 
[HQTW]
¶$&
, $
.

अग्रणी नई पंक्ति महत्वपूर्ण है। इसे ऑनलाइन आज़माएं!

यह मेरा पहली बार रेटिना का उपयोग कर रहा है, इसलिए किसी भी गोल्फ युक्तियाँ की सराहना की जाती है ...

— ETHproductions
स्रोत

1

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

+Pjmj\ dc*G\,j94092 23)\.

एक प्रोग्राम जो परिणाम को STDOUT में प्रिंट करता है।

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

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

+Pjmj\ dc*G\,j94092 23)\.  Program. Input: none
          G                Yield string literal'abcdefghijklmnopqrstuvwxyz'
         * \,              Cartesian product of that with ',', yielding a list of
                           characters with appended commas
             j94092 23)    Yield the integer 94092 in base-23, giving [7, 16, 19, 22]
        c                  Split the comma-appended character list at those indices
   mj\                     Join each element of that on spaces
  j                        Join that on newlines
 P                         All but the last element of that, removing trailing ','
+                      \.  Append '.'
                           Implicitly print

— TheBikingViking
स्रोत

अब मैं अपने एबीसी को जानता हूं, क्या आप मेरे साथ गोल्फ नहीं आएंगे?

विम, 42 , 40 कीस्ट्रोक्स / बाइट्स

05AB1E , 16 बाइट्स

बैश + जीएनयू उपयोगिताओं, 36

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

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

पायथन 2.7, 67 66 63 बाइट्स

जेली , 19 18 बाइट्स

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

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

पाइके, 23 19 17 बाइट्स

आर, 83 71 बाइट्स

सीजेएम, 26 बाइट्स

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

पर्ल, 37 बाइट्स

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

चेडर, 70 बाइट्स

व्याख्या

सी, 112 102 81 बाइट्स

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

रूबी, 56 54 बाइट्स

विम, 32 बाइट्स

PowerShell v3 +, 60 78 67 बाइट्स

उदाहरण

PHP, 62 बाइट्स

MATL, 38 29 बाइट्स

आर, 146 बाइट्स

सीजेएम, 31 बाइट्स

जूलिया, 71 बाइट्स

चेडर, 57 बाइट्स

जाप, 24 बाइट्स

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

जावा, 116 109 105 104

क्यू, 46 बाइट्स

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

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