चुनौती वास्तव में बेहद सरल है। 5 अलग-अलग अक्षर चुनें (आप केवल 5 को चुन सकते हैं जो आपको सबसे छोटा कोड पसंद है, यदि आप चाहें) और उन्हें कंसोल पर आउटपुट करें। हालाँकि, ट्विस्ट यह है कि उन्हें निम्न सूची से होना चाहिए:

 AAA      BBBB       CCCC     DDDD      EEEEE     FFFFF      GGG      H   H
A   A     B   B     C         D   D     E         F         G         H   H
AAAAA     BBBB      C         D   D     EEEE      FFFF      G  GG     HHHHH
A   A     B   B     C         D   D     E         F         G   G     H   H
A   A     BBBB       CCCC     DDDD      EEEEE     F          GGG      H   H


IIIII         J     K   K     L         M   M     N   N      OOO 
  I           J     K  K      L         MM MM     NN  N     O   O
  I           J     KKK       L         M M M     N N N     O   O
  I       J   J     K  K      L         M   M     N  NN     O   O
IIIII      JJJ      K   K     LLLLL     M   M     N   N      OOO 


PPPP       QQQ      RRRR       SSSS     TTTTT     U   U     V   V     W   W
P   P     Q   Q     R   R     S           T       U   U     V   V     W   W
PPPP      Q   Q     RRRR       SSS        T       U   U     V   V     W   W
P         Q  QQ     R  R          S       T       U   U      V V      W W W
P          QQQQ     R   R     SSSS        T        UUU        V        W W 


X   X     Y   Y     ZZZZZ
 X X       Y Y         Z 
  X         Y         Z  
 X X        Y        Z   
X   X       Y       ZZZZZ

अतिरिक्त नियम:

एक ही पत्र के 5 की अनुमति नहीं है, कोई दोहराव विकल्प नहीं।
प्रत्येक अक्षर को इसे खींचने के लिए एएससीआई-चरित्र के रूप में स्वयं की पूंजी का उपयोग करना चाहिए।
प्रत्येक अक्षर आउटपुट "एक ही पंक्ति" पर होना चाहिए और प्रत्येक अक्षर के बीच 5 रिक्त स्थान होना चाहिए।
आप कोई भी 5 अक्षर चुन सकते हैं, जो आप चाहते हैं, यह आपको कुछ कोड का पुन: उपयोग करने और अपनी बाइट की संख्या कम करने की अनुमति देगा। यह पता लगाना कि कौन से अक्षर आपको यह करने की अनुमति देंगे सबसे कुशलता से चुनौती का हिस्सा है।
अनुगामी रिक्त स्थान स्वीकार्य हैं।
एक एकल अनुगामी newline स्वीकार्य है, हालांकि एक अनुगामी newline से अधिक नहीं।
यह कोड-गोल्फ है, सबसे कम बाइट-काउंट जीतता है।

उदाहरण:

ABCDE

 AAA      BBBB       CCCC     DDDD      EEEEE
A   A     B   B     C         D   D     E    
AAAAA     BBBB      C         D   D     EEEE 
A   A     B   B     C         D   D     E    
A   A     BBBB       CCCC     DDDD      EEEEE

EFLIP

EEEEE     FFFFF     L         IIIII     PPPP 
E         F         L           I       P   P
EEEE      FFFF      L           I       PPPP 
E         F         L           I       P    
EEEEE     F         LLLLL     IIIII     P

पागल

 CCCC     RRRR       AAA      ZZZZZ     Y   Y
C         R   R     A   A        Z       Y Y 
C         RRRR      AAAAA       Z         Y  
C         R  R      A   A      Z          Y  
 CCCC     R   R     A   A     ZZZZZ       Y

हर बार अलग-अलग अक्षरों या अलग-अलग रणनीतियों के साथ एक से अधिक जवाब प्रस्तुत करने से डरो मत, यह विभिन्न तरीकों से पूरा किया जा सकता है।

code-golf ascii-art kolmogorov-complexity

— जादू ऑक्टोपस Urn
स्रोत

21

मुझे पसंद है कि आपको आउटपुट के लिए कौन से अक्षर चुनने हैं; जो गोल्फिंग के लिए एक और परत जोड़ता है। ASCII कला के साथ लघु मुद्दे: इसमें अनुगामी रिक्त स्थान का एक टन है, और दो Jएस।

— 15:15 बजे ETHproductions

2

क्या आप इनपुट के रूप में 5 अक्षर लेने के लिए बोनस जोड़ सकते हैं?

— मुकुल कुमार

5

बोनस को बहुत कम कर दिया जाता है और इस तरह के कठोर बदलाव करने के लिए बहुत सारे उत्तर हैं। लेकिन मैं आपको एक उत्थान दूंगा;)

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

1

@ मुझे पता नहीं क्यों आपको उनकी आवश्यकता होगी; अनुगामी अधिक समझ में आता है। यदि आप तार्किक रूप से समझा सकते हैं कि आप जिस भाषा का उपयोग कर रहे हैं, उसकी कोई सीमा नहीं है और आपके द्वारा लिखे गए तर्क एक अग्रणी का कारण बन रहे हैं \n, तो मैं इसकी अनुमति दूंगा।

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

1

@ टिट्स तो नहीं। अनुगामी newlines और रिक्त स्थान कुछ भाषाओं की प्रोग्रामेटिक सीमाओं के कारण हैं।

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

12

जेली , 41 बाइट्स

LICTE

“LICTE”Kż
141D+“ȷɓSɠ’“ðƁ ƥ“JrŀṘ’jḃ11Ç€ŒṙY

TryItOnline!

विचार

अक्षरों के साथ एक रन लंबाई डिकोड का उपयोग करें, जो प्रत्येक पंक्ति के प्रति "पिक्सेल मूल्य" के केवल एक रन लंबाई के साथ समान मध्य के रूप में संभव है।

पंक्तियों के लिए अलग-अलग रन लंबाई डिकोड मूल्यों से बचने के लिए "एल" की तरह एक सपाट शुरुआत डालें।

अंत में तीन मध्य पंक्तियों का एक अलग अक्षर (5 नहीं मिल सकता है) रखें ताकि सबसे छोटा अंतर अंकगणित में जोड़ा जा सके।

आउटपुट चाहता था; रन लंबाई; और ये आधार 11 से परिवर्तित हुए:

                                                  L,  , I,  , C,  , T,  , E   value
                                                  -------------------------
L         IIIII      CCCC     TTTTT     EEEEE     1, 9, 5, 6, 4, 5, 5, 5, 5   399633415
L           I       C           T       E         1,11, 1, 7, 1,11, 1, 7, 1   431646160+1
L           I       C           T       EEEE      1,11, 1, 7, 1,11, 1, 7, 4   431646160+4
L           I       C           T       E         1,11, 1, 7, 1,11, 1, 7, 1   431646160+1
LLLLL     IIIII      CCCC       T       EEEEE     5, 5, 5, 6, 4, 7, 1, 7, 5   1179122455

तीन मानों 399633415, 431646160और 1179122455आधार में 250के रूप में जेली कोड पेज सूचकांकों तो कर रहे हैं ðƁ ƥ, ȷɓSɠऔर JrŀṘरन-लंबाई जानकारी संपुटित करने के लिए इस्तेमाल किया जा सकता है।

कोड

“LICTE”Kż - Link 1, make a run length encoding for a row of the output: row's run lengths
“LICTE”    - list of characters "LICTE"
       K   - join with spaces   "L I C T E"
        ż  - zip with input     e.g. [['L',1],[' ',9],['I',5],[' ',6],['C',4],[' ',5],['T',5],[' ',5],['E',5]]

141D+“ȷɓSɠ’“ðƁ ƥ“JrŀṘ’jḃ11Ç€ŒṙY - Main link
141D                            - 141 as a decimal list: [1, 4, 1]
     “ȷɓSɠ’                     - 431646160
    +                           - add: [431646161, 431646164, 431646161]
           “ðƁ ƥ“JrŀṘ’          - list [399633415,1179122455]
                      j         - join: [399633415, 431646161, 431646164, 431646161, 1179122455]
                       ḃ11      - convert to bijective base 11: [[1, 9, 5, 6, 4, 5, 5, 5, 5], [1, 11, 1, 7, 1, 11, 1, 7, 1], [1, 11, 1, 7, 1, 11, 1, 7, 4], [1, 11, 1, 7, 1, 11, 1, 7, 1], [5, 5, 5, 6, 4, 7, 1, 7, 5]]
                          Ç€    - call last link (1) as a monad for €ach
                            Œṙ  - run-length decode e.g. [['L',1],[' ',9],['I',5],...]
                                                            -> "L         IIIII..."
                              Y - join with line feeds

— जोनाथन एलन
स्रोत

1

आपने यह विचार किया कि मेरे पास शुरू में यह था कि मैं 05AB1E में करने के लिए पर्याप्त स्मार्ट नहीं था !!! कमाल का काम है यार।

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

32

चारकोल , 51 49 बाइट्स (ECXKI)

Ｇ←⁵↓³→⁴EＭ⁷→Ｇ↑²↗²→⁴CＭ⁶→ＧＨ↘↗³XＭ⁶→ＧＨ↓→↗³KＭ⁸→ＰTIII‖Ｏ↓

आउटपुट

EEEEE      CCCC     X   X     K   K     IIIII
E         C          X X      K  K        I  
EEEE      C           X       KKK         I  
E         C          X X      K  K        I  
EEEEE      CCCC     X   X     K   K     IIIII

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

वर्णों का उपयोग करना जो लंबवत सममित हैं, शीर्ष हिस्सों को खींचता है और फिर प्रतिबिंबित करता है। इनमें से अधिकांश बहुभुज ( Ｇ) और बहुभुज ( ) का उपयोग ＧＨकिसी विशेष वर्ण के साथ जुड़े लाइन खंडों की एक श्रृंखला खींचने के लिए करते हैं। Iअधिक आसानी से मल्टीप्रिंट ( Ｐ) के साथ Tदिशा के रूप में उपयोग किया जा सकता है ।

नोट: बहुभुज केवल बहुभुज को पूरा करने या उसे भरने के बिना निर्दिष्ट खंडों को खींचता है। बहुभुज पूर्ण हो जाएगा और भरें (जो हम चाहते हैं) यदि बहुभुज आठ कार्डिनल या इंटरकार्डिनल दिशाओं में से एक में एक सरल रेखा के साथ पूरा किया जा सकता है। अन्यथा, यह एक बाइट की बचत के लिए बहुभुज की तरह व्यवहार करता है।

पात्रों के क्रम को एक के समापन बिंदु से अगले की शुरुआत तक केवल क्षैतिज चाल की आवश्यकता के लिए चुना गया था। यहां बताया गया है कि कर्सर कैसे आगे बढ़ता है:

— DLosc
स्रोत

2

अच्छा लगा। मैं एक चारकोल समाधान की कोशिश कर रहा था, लेकिन दस्तावेज़ीकरण की कमी ने मुझे ईमानदारी से मार डाला

— बैसड्रॉफ़ कम्बुब्वुबॉव

6

@Bassdrop हाँ, हम ... उम ... उस पर काम कर रहे हैं। [ ＧＨडॉक्स में जोड़ने के लिए जाता है ]

— DLosc

19

PowerShell v2 +, 138 128 114 112 106 106 बाइट्स (LICTD)

"L1    IIIII1 CCCC1TTTTT1DDDD
$("L11 I1  C11 T1  D   D
"*3)LLLLL1IIIII1 CCCC1  T1  DDDD"-replace1,'     '

विचारों को अक्षरों के बीच रिक्त स्थान को अधिकतम करना है ताकि हम बार-बार संकुचित हो सकें।

फ्लोरेंट के जवाब से मध्य-पंक्ति कटौती की चाल उधार लेता है । मध्य तीन पंक्तियों के लिए स्ट्रिंग गुणन का उपयोग करके बेन ओवेन को 6 बाइट्स धन्यवाद , और मैट के लिए एक अतिरिक्त बाइट धन्यवाद ।

उत्पादन 53.7% की कमी के लिए 227 बाइट्स की तरह है, -

PS C:\Tools\Scripts\golfing> .\5-favorite-letters.ps1
L         IIIII      CCCC     TTTTT     DDDD
L           I       C           T       D   D
L           I       C           T       D   D
L           I       C           T       D   D
LLLLL     IIIII      CCCC       T       DDDD

— AdmBorkBork
स्रोत

मुझे यह पसंद है जब पहला जवाब कुछ ऐसा है जिसकी आपको उम्मीद नहीं थी। नीट विधि।

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

2

कैसे के $("L11 I1 C11 T1 D D`n"*3)बजाय के बारे में 3 लाइनों

— बेन ओवेन

@BenOwen उत्कृष्ट विचार - धन्यवाद!

— AdmBorkBork

13

जावास्क्रिप्ट, 110 109 बाइट्स (CLOUD)

` CCCC5L9 OOO6U3U5DDDD
${x=`C9L9O3O5U3U5D3D
`,x+x+x} CCCC5LLLLL6OOO7UUU6DDDD`.replace(/\d/g,c=>" ".repeat(c))

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

console.log(
` CCCC5L9 OOO6U3U5DDDD
${x=`C9L9O3O5U3U5D3D
`,x+x+x} CCCC5LLLLL6OOO7UUU6DDDD`.replace(/\d/g,c=>" ".repeat(c))
)

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

उत्पादन 227 बाइट्स है:

 CCCC     L          OOO      U   U     DDDD
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
 CCCC     LLLLL      OOO       UUU      DDDD

— फ्लोरेंट
स्रोत

1

मध्य तीन पंक्तियों में समर्पण का अच्छा उपयोग।

— AdmBorkBork

12

ईएस 6 (जावास्क्रिप्ट), 194, 181 बाइट्स (IGOLF / कोई भी)

यह एक लंबा है, और वास्तव में अनुकूलित नहीं है (अभी तक कम से कम नहीं), लेकिन केवल बिटमैप डेटा को बदलकर किसी विशेष संदेश को प्रिंट करने के लिए संशोधित किया जा सकता है।

संपादित करें: मानचित्र के साथ आंतरिक रूप से कम किया गया , पैडिंग के लिए बिट शिफ्ट का उपयोग करें

golfed

[0x1f73a1f,0x484610,0x49c61e,0x48c610,0x1f73bf0].map(r=>[0,1,2,3,4].map(p=>('0000'+(r>>(20-p*5)<<5).toString(2)).substr(-10).replace(/(1|0)/g,b=>' IGOLF'[(p+1)*b])).join``).join`\n`

डेमो

[0x1f73a1f,0x484610,0x49c61e,0x48c610,0x1f73bf0].map(r=>[0,1,2,3,4].map(p=>('0000'+(r>>(20-p*5)<<5).toString(2)).substr(-10).replace(/(1|0)/g,b=>' IGOLF'[(p+1)*b])).join``).join`\n`

IIIII      GGG       OOO      L         FFFFF     
  I       G         O   O     L         F         
  I       G  GG     O   O     L         FFFF      
  I       G   G     O   O     L         F         
IIIII      GGG       OOO      LLLLL     F

सिद्धांत

एक पत्र लें:

IIIII      
  I        
  I        
  I        
IIIII

इसे बाइनरी मैट्रिक्स (बिटमैप) में बदलें

अन्य 4 अक्षरों के लिए भी ऐसा ही करें, एक पंक्ति को स्कैन करें, प्रत्येक से "टॉप" 5 बिट्स निकालकर

11111 01110 01110 10000 11111

एक हेक्साडेसिमल स्ट्रिंग में परिवर्तित करें (यहाँ आधार 36 या यहाँ तक कि मुद्रण योग्य ASCII का उपयोग किया जाना चाहिए)

0x1f73a1f

बिटमैप प्राप्त करने के लिए अन्य 4 लाइनों के समान एल्गोरिथ्म लागू करें।

रिवर्स ऑर्डर में रेंडर करें।

— टसेपेल्लिन
स्रोत

1

आप 2 बाइट्स बचाने के लिए regex में कोष्ठकों को हटा सकते हैं :-)

— ETHproductions

1

[32979487,4736528,4834846,4769296,32979952] अपने हेक्साडेसिमल प्रतिनिधित्व से कम है

— फ्लोरेंट

@ETHproductions सच है, इसका उपयोग तब करेंगे, जब मैं इसे ऑप्टिमाइज़ करने के लिए वापस आऊंगा। धन्यवाद!

— जेपेलिन

1

आप बदल सकते /(1|0)/gद्वारा /\d/gकुछ बाइट्स को बचाने के लिए। इसके अलावा \nएक वास्तविक नई लाइन द्वारा प्रतिस्थापित किया जा सकता है।

— फ्लोरेंट

> अपने हेक्साडेसिमल प्रतिनिधित्व यप से छोटा है, यह सच है (0x के कारण), कम से कम इन विशिष्ट अक्षरों के लिए, मैं शायद इसे अगले हेक्सेशन पर एक सतत हेक्स (या यहां तक कि Base32 / Base36 / ASCII) स्ट्रिंग में संपीड़ित करूंगा। । > आप कुछ बाइट्स बचाने के लिए / (1 | 0) / g / / d / g से बदल सकते हैं। इसके अलावा \ n वास्तविक नई पंक्ति द्वारा प्रतिस्थापित किया जा सकता है। हां, आपकी युक्तियों के लिए धन्यवाद, मैं एक बार वापस आने के बाद उनका उपयोग करूंगा।

— ज़ेप्लेन

12

PHP, 107 104 102 94 86 बाइट्स

ठीक है मुझे विश्वास है कि मेरे पास अब इस विधि के साथ सबसे छोटा संभव स्रोत है। मैंने पाँच अक्षरों के हर संभव संयोजन को उत्पन्न करने और फिर गज़िप करने के लिए एक स्क्रिप्ट लिखी। दो समाधान हैं जो सबसे छोटे संपीड़ित के लिए मेल खाते हैं - एलओडीआईसी और एलडीओआईसी। मैं पूर्व के साथ जा रहा हूं क्योंकि यह कहना ज्यादा मजेदार है।

स्रोत:

<?=gzinflate(base64_decode('81GAA39/fwjDBQggLE8QgDCdgYDLB6EYioGqoRisHkrTSCUIEOtWAA'));

आउटपुट:

% php foo.php
L          OOO      DDDD      IIIII      CCCC
L         O   O     D   D       I       C
L         O   O     D   D       I       C
L         O   O     D   D       I       C
LLLLL      OOO      DDDD      IIIII      CCCC

— एलेक्स हॉन्सस्की
स्रोत

3

आप एस को गिराकर 2 बाइट बचा सकते हैं ': स्ट्रिंग स्वयं के मूल्य के साथ एक स्थिर के रूप में माना जाएगा।

— user59178

बेनाम: Damnit, मैं हमेशा ऐसा करने के लिए भूल जाते हैं। :)

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

यदि L आपका अंतिम पत्र था, तो आप अधिक बाइट भी बचाएंगे।

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

एक खामियों का अच्छा शोषण।

— इस्माईल मिगुएल

2

रचनात्मकता व्यक्तिपरक और अथाह है। चुनौती का लक्ष्य कोड आकार को कम करना है और यह गैर-गोल्फ भाषा के लिए सबसे छोटी प्रविष्टि है।

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

10

05AB1E , 44 बाइट्स

यह एक मजेदार था।
मुझे लगता है कि मुझे वापस आने की कोशिश करनी चाहिए और जब मेरे पास समय होता है तो इसे कुछ और गोल्फ देता हूं।

CP-1252 एन्कोडिंग का उपयोग करता है । कारुसोकोम्पुटिंग के उत्तर
से प्रेरित ।

ECOIH

‘ÓÑOIHH‘SðýJ3×S•Td<UÕ‘áÓ?Â¢tWvkÔÚ•S)øü×J3äû»

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

व्याख्या

‘ÓÑOIHH‘स्ट्रिंग को धक्का देता है "ECOOIHH"।

SðýJ3×Sरिक्त स्थान से तार जुड़ता है, तीन बार दोहराता है और इसे सूची में परिवर्तित करता है।
जिसके परिणामस्वरूप सूची है ['E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H']।

•Td<UÕ‘áÓ?Â¢tWvkÔÚ•संख्या को बढ़ाता है 564631055513119191317171314619131717500।

S)ø सूची और संख्या को एक साथ जोड़ देता है।

ü×Jजोड़ीदार स्ट्रिंग पुनरावृत्ति करता है और उन्हें एक साथ जोड़ता है।
परिणाम स्ट्रिंग है EEEEE CCCC OOO IIIII H HE C O O I H HEEEE C O O I HHHHH।

3äû»बंटवारे कि 3 टुकड़ों में, पहले और दूसरे टुकड़े को रिवर्स ऑर्डर में जोड़ता है और नए सिरे से जुड़ता है।

— Emigna
स्रोत

13

" •Td<UÕ‘áÓ?Â¢tWvkÔÚ•संख्या को धक्का देता है 564631055513119191317171314619131717500" क्योंकि यह क्यों नहीं होगा ...

— geisterfurz007

3

@ geisterfurz007: अधिक सटीक होने के लिए, यह आधार -10 संख्या का आधार -214 प्रतिनिधित्व है :)

— एमिग्ना

तो संभावित रूप से यदि आप एक उच्च आधार तक जा सकते हैं, तो आपका तार छोटा हो जाएगा?

— geisterfurz007

@ geisterfurz007: यदि हम हाँ कर सकते हैं। दुर्भाग्य से 214 05AB1E में अधिकतम है।

— एमिगा

3

आप जेली को हरा सकते हैं, मुझे आप पर विश्वास है; हाहा जाने के लिए 3 बाइट्स बचे!

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

9

जावास्क्रिप्ट (ES6), 96 बाइट्स (DIOCL)

`${x="DDDD6IIIII6OOO7CCCC5L"}
${y=`D3D7I7O3O5C9L
`,y+y+y+x}LLLL`.replace(/\d/g,d=>" ".repeat(d))

यहाँ विचार केवल मध्य तीन पंक्तियों को समान बनाने का नहीं है, बल्कि पहली पंक्ति को भी पिछले के समान बना देता है। चूंकि केवल 4 अक्षर हैं जो इस विवरण को पूरी तरह से फिट करते हैं CDIO, Lअगला सबसे अच्छा विकल्प है, क्योंकि इसे केवल स्ट्रिंग के अंत में 4 अतिरिक्त वर्णों की आवश्यकता होती है।

साथ के रूप में फ्लोरेंट का जवाब है, यह एक टुकड़ा है कि परिणाम देता है। यदि कार्य करने की आवश्यकता हो तो 3 बाइट्स जोड़ें।

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

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

console.log(`${x="DDDD6IIIII6OOO7CCCC5L"}
${y=`D3D7I7O3O5C9L
`,y+y+y+x}LLLL`.replace(/\d/g,d=>" ".repeat(d)))

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

— ETHproductions
स्रोत

आप Dपहले डालकर एक बाइट बचा सकते हैं ।

— नील

@ नील धन्यवाद। मुझे Cअतीत Iऔर Oसाथ ही साथ आगे बढ़ना पड़ा

— ETHproductions

आह, ठीक है, आप के Iतुरंत बाद नहीं हो सकता है C, हालांकि दिलचस्प है कि मेरे बैच समाधान में सुधार, एक ही कारण के लिए।

— नील

9

बैश + कोरुटिल्स के साथ अंजीर, 55440 समाधान, 112 106 बाइट्स प्रत्येक

 set H E L P D;for l;do figlet -f banner $l|sed "s/.//3;s/.//5;s/#/$l/g;2d;5d">$l;done;paste $@|expand -t10

आउटपुट:

HH EEEEE L PPPP DDDD  
HHELPPDD 
HHHHH EEEE एल पीपीपीपी डीडी 
HHELPDD 
HH EEEEE LLLLL P DDDD

अरे, हमारे पास पहले से ही ASCII कला के लिए एक कार्यक्रम है ! बैनर फ़ॉन्ट लगभग, काम करता है को छोड़कर यह 7x7 पत्र आउटपुट। हम्म, चलो बस 3rd और 5th कॉलम और दूसरी और 5 वीं लाइन को हटा दें, और देखें कि यह क्या देता है ...

यह पता चला है कि कई अक्षर आवश्यक तरीके से आउटपुट होंगे, अर्थात्, BDEFHJLPTU Z।

यह सही परिणाम प्राप्त करने के लिए उन पत्रों के किसी भी संयोजन के साथ पहले सेट कमांड के तर्कों को बदलने के लिए पर्याप्त है ! इसलिए, यह हमें 11 * 10 * 9 * 8 * 7 = 55440 समाधान देता है, जिनमें से प्रत्येक 106 बाइट्स लंबा है।

— योआन
स्रोत

1

चुनौती पढ़ते समय मेरा पहला विचार था "किसी को इसे हल करने के लिए अंजीर का उपयोग करना होगा"

— FliiFe

6

05AB1E , 102 90 89 69 बाइट्स (EOIXC)

•Cv¶ÉH&9;´ß{ø‰¿šq3d$µ_©Û¶«K>Ò±sÒ9ÍÊC4ÊÚúNÏŒº9¨gÚSÞ•34B2ð:2ôvy`×}J3äû»

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

आउटपुट (230 बाइट्स):

EEEEE      OOOO     IIIII     X   X      CCCC
E         O    O      I        X X      C    
EEEE      O    O      I         X       C    
E         O    O      I        X X      C    
EEEEE      OOOO     IIIII     X   X      CCCC

69/230 = 70% संपीड़न

स्पष्टीकरण:

सिद्धांत को लंबवत सममित अक्षरों को चुनना था, फिर पहली 3 पंक्तियों को एक पैलिंड्रोमाइज़ करना सांकेतिक शब्दों में बदलना। असल में, मैंने 2 बाइट जोड़े में {लेटर ऑफ {लेटर} के रूप में एनकोड किया। मुझे यकीन है कि ऐसा करने का एक बेहतर तरीका है।

•Cv¶ÉH&9;´ß{ø‰¿šq3d$µ_©Û¶«K>Ò±sÒ9ÍÊC4ÊÚîòvÅrè‘¾)jM•34B
                    <decodes to>
"E5 6O4 5I5 5X1 3X1 6C4E1 9O1 4O1 6I1 8X1 1X1 6C1 4E4 6O1 4O1 6I1 9X1 7C1 4"

2ô            # Split into encoded pairs.
  vy   }      # Loop through each letter and number pair.
    `×        # Add the letter X number of times.
       J      # Join together.
        3ä    # Split into 3 parts length.
          û   # Palindromize.
           »  # Print separated by newlines.

-20 बाइट्स एमिग्ना के लिए धन्यवाद, मैं जल्द ही कुछ सवाल पूछने के लिए चैट में रहूंगा;)

— जादू ऑक्टोपस Urn
स्रोत

1

आप स्ट्रिंग के स्थान पर 19 बाइट्स बचा सकते हैं •Cv¶ÉH&9;´ß{ø‰¿šq3d$µ_©Û¶«K>Ò±sÒ9ÍÊC4ÊÚîòvÅrè‘¾)jM•34B2ð:। 05AB1E चैट में हॉप यदि आपके पास एन्कोडिंग के बारे में प्रश्न हैं।

— एमिगा

1

भी, 45ôहो सकता है 3ä।

— 19

@Eigna Aखड़ी सममित नहीं है, और न ही है F। यह अनुमान लगाने के लिए कि एक बार जब आप Gइसका उपयोग करना शुरू करते हैं या उच्चतर होता है, तो यह बर्बाद कर देगा कि आप किस बारे में बात कर रहे हैं? इसके अलावा, मेरी संपीड़न पद्धति के साथ, मैं उन पत्रों से बचना चाहता था जिनमें प्रति पंक्ति 1 से अधिक घटनाएँ थीं। यदि आप उस समाधान को प्राप्त करना चाहते हैं और मुझे हरा देते हैं तो मैं उदाहरण का स्वागत करूंगा :)।

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

वहाँ एक है 0में O(मध्य पंक्ति, दाईं ओर)

— ETHproductions

1

•Cv¶ÉH&9;´ß{ø‰¿šq3d$µ_©Û¶«K>Ò±sÒ9ÍÊC4ÊÚúNÏŒº9¨gÚSÞ•Oएक ही बाइट गिनती में ठीक करता है ।

— एमिगा

5

जावास्क्रिप्ट ईएस 6, 168 बाइट्स, सीएचएमपी

हम लोगों को देखना बंद कर सकते हैं, हमारे CHAMPयहाँ एक ओवर है

f=_=>
` C3cHaHdA2dMaMcP3
CgHaHcAaAcMM MMcPaP
CgH4cA4cM M McP3
CgHaHcAaAcMaMcP
 C3cHaHcAaAcMaMcP`.replace(/[a-z\d]/g,(a,i,c)=>+a?c[i-1].repeat(a):' '.repeat(parseInt(a,36)-7))

a.innerHTML = f()

<pre id=a>

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

— बैसड्रॉब कंबरवुबवबब
स्रोत

5

ब्रेनफ *** 512 411 बाइट्स

बेहतर फिर से करें:

यह टेप के अनुकूलन में बेहतर काम करता है, मुद्रण वर्णों के लिए सेटअप वर्णों का त्याग करता है। इस एक में टेप की तरह दिखता है 'C' 'E' ' ' 'F' 'I' 'L' '\n', दक्षता में सुधार। मैंने इन्हें चुना क्योंकि उनमें आंतरिक रिक्त स्थान की कमी है, जिससे यह बना है कि उन्हें चरित्र और स्थान के बीच आगे और पीछे नहीं जाना है

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

यदि आप पढ़ना चाहते हैं कि यह क्या कर रहा है:

Set the tape with 67,69,32,70,73,76,10
++++++++[>+++++++++>+++++++++>++++>+++++++++>+++++++++>+++++++++>+<<<<<<<-]>----->--->>-->+>++++>++<<<< 
.<<....>>.....<.....>.....>.....<.....>>.....<<.....>>>.>.<<<<<< First Line
.>>.........<.>.........>.<...........>>.<<.......>>>.>.<<<<<< Second Line
.>>.........<....>......>....<........>>.<<.......>>>.>.<<<<<< Third Line
.>>.........<.>.........>.<...........>>.<<.......>>>.>.<<<< Fourth Line
.<<....>>.....<.....>.....>.<.........>>.....<<.....>>>..... Fifth Line

आउटपुट:

 CCCC     EEEEE     FFFFF     IIIII     L
C         E         F           I       L
C         EEEE      FFFF        I       L
C         E         F           I       L
 CCCC     EEEEE     F         IIIII     LLLLL

पूर्व प्रस्तुतिकरण:

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

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

मैंने एक टेप के साथ समाप्त किया जिसमें मूल्य थे 0 0 'A' 'B' 'C' 'D' 'E' ' ' \nऔर फिर वहां से आउटपुट

++++++++[>++++<-]>[>++>++>++>++>++>+<<<<<<-]>+>++>+++>++++>+++++>>++++++++++     This all sets up the tape as 0 0 A B C D E ' ' '\n'
<.<<<<<...>>>>>......<<<<....>>>>.......<<<....>>>.....<<....>>......<.....>>.<<<<<< First Line
.>>>>>...<<<<<.>>>>>.....<<<<.>>>>...<<<<.>>>>.....<<<.>>>.........<<.>>...<<.>>.....<.>>.<<<<<< Second Line
.....>>>>>.....<<<<....>>>>......<<<.>>>.........<<.>>...<<.>>.....<....>>.<<<<<< Third Line
.>>>>>...<<<<<.>>>>>.....<<<<.>>>>...<<<<.>>>>.....<<<.>>>.........<<.>>...<<.>>.....<.>>.<<<<<< Fourth Line
.>>>>>...<<<<<.>>>>>.....<<<<....>>>>.......<<<....>>>.....<<....>>......<..... Last Line

आउटपुट:

 AAA      BBBB       CCCC     DDDD      EEEEE
A   A     B   B     C         D   D     E
AAAAA     BBBB      C         D   D     EEEE
A   A     B   B     C         D   D     E
A   A     BBBB       CCCC     DDDD      EEEEE

— bioweasel
स्रोत

[<]>6 बाइट्स को बचाने के लिए आप 3 अवसरों पर उपयोग कर सकते हैं ।

— जो राजा

5

विम, 116 बाइट्स 99 बाइट्स

ELITC

@DrMcMoylex की मदद से इसे 100 से कम पर पहुंचाया।

9i59Yo191919171
E L I T CPqqjx:%s/\d/\=repeat('"',submatch(0))
q8@q3bi  Y7w.PP4rE{wl4r 22wl.2x

इसमें अनपेक्षित वर्ण हैं, इसलिए मैंने उन्हें नीचे (विम शैली) में जोड़ा है, ताकि आप उन्हें देख सकें।

9i5^[9^AYo191919171
E L I T C^[Pqqjx:%s/\d/\=repeat('^R"',submatch(0))
q8@q3bi  ^[Y7w.PP4rE{wl4r 22wl.2x

TryItOnline!

यह मूल रूप से उसी रन-लंबाई डिकोड का उपयोग करता है जो जेली उत्तर देता है। मैंने उन पत्रों का उपयोग किया जहां मैं (उम्मीद है) नीचे की ओर शीर्ष दोहरा सकता हूं, और मिडिल्स सभी 3 समान होंगे। टॉपर्स, बॉटम्स और मिडलल्स बनने के बाद मैं पात्रों को सही करने के लिए संपादित करता हूं:

I में दो स्थान जोड़ें (उस पर और अधिक)
टी में दो रिक्त स्थान जोड़ें
ई की पट्टी जोड़ें
एल के शीर्ष को हटा दें
T के निचले भाग को निकालें (और 2 रिक्त स्थान हटाएं)

मुझे दो स्थानों को जोड़ना होगा, क्योंकि मैंने दो अंकों की संख्या की अनुमति नहीं दी थी (इसलिए मुझे विभाजक की आवश्यकता नहीं होगी। इससे 9 स्थान की दौड़ होती है जहां मुझे 11 की आवश्यकता होती है।

— nmjcman101
स्रोत

PPCG में आपका स्वागत है, अच्छा जवाब :)।

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

मैं लगभग विम जवाब के लिए भीख माँग रहा था।

— ज़ोल्टन श्मिट

2

मैं हमेशा विम अपवोट करता हूं। :) कुछ सुधार जो मैं देख रहा हूँ। 1) आपको अपने स्थानापन्न आदेश पर अनुगामी स्लेश की आवश्यकता नहीं है। 2) कुछ उपयोगी समानार्थी शब्द: Yके बजाय Vy, FIके बजाय ?I<cr>, {के बजाय gg, wकी बजाय fl। 3) यदि आप rइसके बजाय का उपयोग करते हैं R, तो आप निकाल सकते हैं <esc>।

— DJMcMayhem

5

MATL , 49 बाइट्स

5:lyI&(g84*t0*ytP+g73*yy!qy5XyPl5LY(90*yy!P12-&hc

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

इससे अक्षर उत्पन्न होते हैं TIHZN:

TTTTT     IIIII     H   H     ZZZZZ     N   N
  T         I       H   H        Z      NN  N
  T         I       HHHHH       Z       N N N
  T         I       H   H      Z        N  NN
  T       IIIII     H   H     ZZZZZ     N   N

व्याख्या

Tखरोंच से निर्माण करने के लिए अपेक्षाकृत आसान है। Iअनिवार्य रूप Tसे इसके ऊर्ध्वाधर प्रतिबिंब के रूप में प्राप्त किया जा सकता है । प्रत्यारोपित किया Hजाता Iहै। Nहै Zस्थानांतरित और खड़ी परिलक्षित।

5:        % Push [1 2 3 4 5]
lyI&(     % Write [1 ;2; 3; 4 ;5] in the third column, filling with zeros.
          % This gives the shape of the 'T'
g84*      % Change nonzeros into 84 (ASCII for 'T'). Zeros will be displayed
          % as spaces
t0*       % Duplicate and multiply by zeros. This gives the separator
y         % Duplicate from below: pushes the 'T' again
tP+       % Duplicate, flip vertically, add. Gives the shape of the 'I'
g73*      % Change nonzeros into 73 (ASCII for 'I')
yy        % Duplicate separator and 'I' array
!         % Transpose. Gives the shape of the 'H'
q         % Subtract 1. Transformss 73 into 72 (ASCII for 'H'), and 0 into -1,
          % which will later be changed back into 0 when converting to char
y         % Duplicate separator
5XyP      % Size-5 identity matrix flipped vertically: gives slash of the 'Z'
l5LY(     % Fill first and last rows with ones. Gives the shape of the 'Z'
90*       % Multiply by 90 (ASCII for 'Z')
yy        % Duplicate separator and 'Z' array
!P        % Transpose and flip vertically. Gives shape of the 'N'
12-       % Subtract 12 to yield ASCII code for 'N'. 0 is converted to -12
&h        % Concatenate the nine arrays horizontally
c         % Convert to char. Implicitly display

— लुइस मेंडो
स्रोत

4

वी , 62 , 53 बाइट्स

iC±  I· D³ Dµ O³ O¸ Z3ñYp$XñS ´Cµ µIµ ´D· ³O¶ µZYHP

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

यह आउटपुट C I D O Z:

 CCCC     IIIII     DDDD       OOO      ZZZZZ
C           I       D   D     O   O        Z
C           I       D   D     O   O       Z
C           I       D   D     O   O      Z
 CCCC     IIIII     DDDD       OOO      ZZZZZ

— DJMcMayhem
स्रोत

3

पर्ल, 109 बाइट्स (ABCDE)

नोट : इसमें अनपेक्षित वर्ण शामिल हैं, यहां परीक्षण में आसानी के लिए भाग निकले, xxdनीचे डंप करें।

$_="\x0e\x1e\x0f\x1e\x1f
\x11\x11\x10\x11\x10
\x1f\x1e\x10\x11\x1e
\x11\x11\x10\x11\x10
\x11\x1e\x0f\x1e\x1f";s!.!(eval'(sprintf"%5b",ord$&)=~y/01/ '.(A..E)[$i++%5].'/r').$"x5!ge;print

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

फ़ाइल, चलाने से बनाने के लिए xxd -r > favourite-letter.pl, नीचे दिए गए और प्रेस में पेस्ट Ctrl+ D:

0000000: 245f 3d22 0e1e 0f1e 1f0a 1111 1011 100a  $_="............
0000010: 1f1e 1011 1e0a 1111 1011 100a 111e 0f1e  ................
0000020: 1f22 3b73 212e 2128 6576 616c 2728 7370  .";s!.!(eval'(sp
0000030: 7269 6e74 6622 2535 6222 2c6f 7264 2426  rintf"%5b",ord$&
0000040: 293d 7e79 2f30 312f 2027 2e28 412e 2e45  )=~y/01/ '.(A..E
0000050: 295b 2469 2b2b 2535 5d2e 272f 7227 292e  )[$i++%5].'/r').
0000060: 2422 7835 2167 653b 7072 696e 74         $"x5!ge;print

प्रयोग

perl favourite-letter.pl
 AAA      BBBB       CCCC     DDDD      EEEEE     
A   A     B   B     C         D   D     E         
AAAAA     BBBB      C         D   D     EEEE      
A   A     B   B     C         D   D     E         
A   A     BBBB       CCCC     DDDD      EEEEE

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

3

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

d,i,o,c,l,s,n='DIOCL \n'
T=d*4+s*6+i*5+s*6+o*3+s*7+c*4+s*5+l
M=d+s*3+d+s*7+i+s*7+o+s*3+o+s*5+c+s*9+l+n
print T+n,M,M,M,T+l*3

मेरे अन्य उत्तर के समान , लेकिन बेहतर पत्र विकल्पों के साथ। इसे आउटपुट करता है:

DDDD      IIIII      OOO       CCCC     L
D   D       I       O   O     C         L
D   D       I       O   O     C         L
D   D       I       O   O     C         L
DDDD      IIIII      OOO       CCCC     LLLL

— nedla2004
स्रोत

3

Befunge, 120 बाइट्स (CKYTF)

स्रोत

#&49+14489+56*1449135*44711425*:12p9138*7+:89+:56*55*v_@
-1g05$$_\#!:2#-%#16#\0#/g#20#,g#+*8#4<80\9*2p06%5p05:<^:,g2!%5:

उत्पादन

  CCCC     K   K     Y   Y     TTTTT     FFFFF
 C         K  K       Y Y        T       F
 C         KKK         Y         T       FFFF
 C         K  K        Y         T       F
  CCCC     K   K       Y         T       F

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

यदि यह मायने रखता है, तो मुझे यह बताना चाहिए कि मेरे उत्पादन में प्रत्येक पंक्ति में एक अग्रणी स्थान है। नियमों ने स्पष्ट रूप से निषेध नहीं किया है, इसलिए मुझे उम्मीद है कि यह ठीक है। यदि नहीं, तो कृपया इसे गैर-प्रतिस्पर्धी प्रविष्टि मानें।

व्याख्या

शब्द के अक्षर 25 पूर्णांक के सरल अनुक्रम के रूप में एन्कोड किए गए हैं, प्रत्येक पूर्णांक 5 पिक्सल का द्विआधारी प्रतिनिधित्व है। चूंकि Befunge से आपको 9 से अधिक किसी भी पूर्णांक को तुरंत करने के लिए एक गणना करने की आवश्यकता होती है, इसलिए अक्षरों को चुना गया ताकि आवश्यक गणना की संख्या को कम किया जा सके, और आदेश दिया ताकि संभावित दोहराए गए मूल्यों को पुनर्गणना के बजाय दोहराया जा सके।

हमें प्रत्येक अक्षर के ASCII मूल्य को स्टोर करने की भी आवश्यकता है, 32 से ऑफसेट, एक सरणी में जो एक डिक्रिमेंटिंग इंडेक्स के मोडुलो 5 द्वारा अनुक्रमित होता है (इसलिए यह 0 4 3 2 1 ... जाता है)। 32 से ऑफसेट करने का कारण यह है कि मूल्य एक पिक्सेल बिट (1 या 0) से गुणा किया जा सकता है और फिर एक स्थान या आवश्यक चरित्र का उत्पादन करने के लिए 32 में जोड़ा जाता है।

अक्षर मानों की यह सरणी कोड के पहले 5 बाइट्स में संग्रहीत है, इसलिए इसे एक्सेस करना आसान है। यह तब भी अक्षरों की पसंद को प्रभावित करता था, क्योंकि एक कोड अनुक्रम के रूप में व्याख्या किए जाने पर उन मूल्यों को सार्थक करने की आवश्यकता थी। यही क्रम है #&49+। #पर कूदता है &और 49+सिर्फ ढेर जो बाद में नजरअंदाज कर दिया है पर 13 धकेलती है।

— जेम्स होल्डरनेस
स्रोत

आप पूर्णांक इनपुट के लिए पूछ रहे हैं &, लेकिन आपका कार्यक्रम वास्तव में इनपुट नहीं लेता है ... क्या चल रहा है?

— ब्रायन ग्रैडिन

उस चरित्र को '#'

— 12Me21

@ १२Me21 मैंने आखिरी पैराग्राफ में इसके पीछे के कारण को समझाया।

— जेम्स होल्डरनेस

3

रूबी, 110 107 102 बाइट्स (DOCIL)

puts a=?D*4+(t=' '*7)+?O*3+t+?C*4+(s=' '*5)+?I*5+s+?L,['D   D'+s+'O   O'+s+?C+' '*11+?I+t+?L]*3,a+?L*4

प्रिंटों

DDDD       OOO       CCCC     IIIII     L
D   D     O   O     C           I       L
D   D     O   O     C           I       L
D   D     O   O     C           I       L
DDDD       OOO       CCCC     IIIII     LLLLL

EDIT: joinचीजों को टालने और इधर-उधर जाने से कुछ चार्ट को बचाया

— ली डब्ल्यू
स्रोत

3

Befunge-98 , 109 98 बाइट्स (फंग / कोई भी)

:5%!2>j#4_;\$&\#;\:0`!#@_:::'@/'@*-\'@/2%*' +,:'@/:2/-'@*-\1+:5%!2>j#4_;' 3k:4k,#;:55*%!2>j#4_;a,;

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

इनपुट (115 पात्र):

2022 1141 1134 935 2021 102 1141 1262 103 101 998 1141 1390 1639 997 102 1141 1646 1127 101 102 949 1134 935 2021 0

इनपुट एक द्विआधारी संख्या का पूर्णांक संस्करण है, aaaaabbbbbbजहां उस प्रारूप के साथ aaaaaप्रिंट करने के लिए वर्ण का एक उल्टा नक्शा है (उदाहरण के लिए, N में दूसरी पंक्ति NN N, इसलिए मुखौटा है 10011), और bbbbbbप्रिंट करने के लिए ascii वर्ण है, ऋण 32 ।

मैंने अपने इनपुट बनाने के लिए एक befunge-98 प्रोग्राम भी बनाया:

4k~44p34p24p14p04p          v
+1.+-**244g4%5\**88_@#`0:&::<

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

आउटपुट (255 वर्ण):

FFFFF     U   U     N   N      GGG      EEEEE     
F         U   U     NN  N     G         E         
FFFF      U   U     N N N     G  GG     EEEE      
F         U   U     N  NN     G   G     E         
F          UUU      N   N      GGG      EEEEE

(255 - (115 + 98)) / 255 = 16% संपीड़न

स्पष्टीकरण:

:5%!2>j#4_;\$&\#;\:0`!#@_     Get input if it is available, else end program
:::'@/'@*-\'@/2%*' +,         Output the current input character (or a space,
                              if the mask dictates so)
:'@/:2/-'@*-                  Throw away current mask bit
\1+                           Swap loop iterator to top of stack, increment it
:5%!2>j#4_;' *3k:4k,#;        If iterator % 5 == 0, print five spaces
:55*%!2>j#4_;a,;              If iterator % 25 == 0, print newline character

यह शायद बहुत गोल्फ है; मैंने संभावित कटौती के बारे में सोचने में मुश्किल से कोई समय बिताया है।

सैद्धांतिक रूप से यह 5x5 ascii कला के किसी भी अनुक्रम को प्रिंट कर सकता है।

ट्रिपल अंकों से बाहर निकलने में मेरी मदद करने के लिए जेम्स होल्डरनेस का धन्यवाद !

— ब्रायन ग्रैडिन
स्रोत

विचार आगे ले करने के लिए, 48*के साथ प्रतिस्थापित किया जा सकता है ' (के बाद से इस 98 सब के बाद है), और 88*साथ बदला जा सकता '@। ट्रिपल अंकों से बाहर निकलने में मेरी मदद करने के लिए धन्यवाद!

— ब्रायन ग्रैडिन

3

सी #, 290 279 267 265 बाइट्स

संपादित करें: @milk के लिए धन्यवाद 12 बाइट्स सहेजे गए! और @ TheLethalCoder को 2 और धन्यवाद

golfed:

void F(){string g="     ",h="H   H",A="A   A",B=h+"|"+A;Func<string,string>j=a=>a.Replace("|",g)+"\n";Console.Write(j(" SSSS|"+h+"| AAA |RRRR |PPPP")+j("S    |"+B+"|R   R|P   P")+j(" SSS |HHHHH|AAAAA|RRRR |PPPP")+j("    S|"+B+"|R  R |P")+j("SSSS |"+B+"|R   R|P"));}

Ungolfed:

public void F()
{
  string g = "     ", h = "H   H", A = "A   A", B = h + "|" + A;
  Func<string, string> j = a => a.Replace("|", g) + "\n";
  Console.Write(j(" SSSS|" + h + "| AAA |RRRR |PPPP") +
  j("S    |" + B + "|R   R|P   P") +
  j(" SSS |HHHHH|AAAAA|RRRR |PPPP") +
  j("    S|" + B + "|R  R |P") +
  j("SSSS |" + B + "|R   R|P"));
}

आउटपुट:

 SSSS     H   H      AAA      RRRR      PPPP
S         H   H     A   A     R   R     P   P
 SSS      HHHHH     AAAAA     RRRR      PPPP
    S     H   H     A   A     R  R      P
SSSS      H   H     A   A     R   R     P

— पीट आर्डेन
स्रोत

एक दूसरा स्थान था जहां मुझे लगा कि आपका सी कोड 290279 बाइट्स था।

— स्टीवन एच।

1

@StevenH। ऐसा लगता है कि सी # :) में गोल्फिंग

— पीट आर्डेन

-12 बाइट्स यदि आप इस तरह के स्थानीय कार्य को परिभाषित करते हैंFunc<string,string>j=a=>a.Replace("|",g)+"\r\n";

— दूध

@ शांत कूल, धन्यवाद! :)

— पीट आर्डेन

क्या आपको \ r \ n में \ r की आवश्यकता है? 2 बाइट्स

— बचाएंगे

3

स्टैक्स , 33 बाइट्स "बीसीडीईओ"

┌☼&.àτ▲█╟;c♦▌ΩÅ╡≤♫¿(┌▲▲≡3*╤J s*è«

इसे चलाएं और डीबग करें

मैंने वह पत्र उठाया

ऊर्ध्वाधर समरूपता है
जिनके मध्य तीन स्तंभ समान हैं

इन गुणों का मतलब है कि प्रत्येक अक्षर को 3x3 ग्रिड द्वारा दर्शाया जा सकता है। यहां 9 क्षेत्र हैं, जो अंकों द्वारा दर्शाए गए हैं।

"बी" पत्र पर विचार करें। इसे 3 अष्टक अंकों द्वारा दर्शाया जा सकता है 656:। प्रत्येक अंक में तीन बिट होते हैं, जो नियंत्रित करते हैं कि कौन से क्षेत्र उस पत्र के लिए सक्षम हैं। यह तकनीक "CDEO" के लिए भी काम करती है।

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, कार्यक्रम इस तरह दिखता है।

"!^*14>G2eo"!   crammed integer literal             [63672, 54545, 64565]
|p              palindromize                        [63672, 54545, 64565, 54545, 63672]
m               for each, run this and output...    
  E             extract decimal digits to array     [6, 3, 6, 7, 2]
  `)"+0`        compressed string literal           "BCDEO"
  \             zip arrays                          [[6, 66], [3, 67], [6, 68], [7, 69], [2, 79]]
  {             map array using block               
    E           explode array                       6, 66
    Z\          tuck a zero under, and make pair    6, [0, 66]
    :B          custom base convert                 [66, 66, 0] 
    3)          pad to length 3                     [66, 66, 0]
    3O\         tuck a one under a 3 and pair       [66, 66, 0], [1, 3]
    :B          repeat elements corresponding times [66, 66, 66, 66, 0]
    A(          pad right to length 10              [66, 66, 66, 66, 0, 0, 0, 0, 0, 0]
  m

इसको चलाओ

— पुनरावर्ती
स्रोत

2

पायथन 3, 234 228 227 166 बाइट्स (CLOUD):

import base64,gzip;b=b'ABzY86gn$d0{>HR1_A{T@KJyRe}8`nBNU1i6kLFS%Nec$q1YdaQ51tPO;sx(oDBkK&Q=Hwg(wC)8vxUXJX_-c000';print(gzip.decompress(base64.b85decode(b)).decode())

प्रिंटों:

 CCCC     L          OOO      U   U     DDDD
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
 CCCC     LLLLL      OOO       UUU      DDDD

— L3viathan
स्रोत

2

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

e,f,i,t,h,s='EFITH '
p=print
S=s*5
D=i+s*9+t+s*7
A=e*5+S
F=S+i*5+S
B=e+s*9+f+s*11+D+h+s*3+h
C=h+s*3+h
p(A+f*5+F+t*5+S+C)
p(B)
p(e*4+s*6+f*4+s*8+D+h*5)
p(B)
p(A+f+s*4+F,s+t+s*7+C)

जीत नहीं होगी, लेकिन किसी भी संपीड़न का उपयोग नहीं करता है। यह इसे बनाता है:

EEEEE     FFFFF     IIIII     TTTTT     H   H
E         F           I         T       H   H
EEEE      FFFF        I         T       HHHHH
E         F           I         T       H   H
EEEEE     F         IIIII       T       H   H

किसी भी मदद का स्वागत है, मैं शायद कुछ याद किया। मैंने पायथन 2 का उपयोग नहीं किया क्योंकि आप ऐसा नहीं कर सकते p=print, और इससे 17 बाइट बचती हैं। इसे repl.it पर आज़माएँ।

— nedla2004
स्रोत

2

उस F के साथ क्या हो रहा है?

— विनाशकारी नींबू

@DestructibleWatermelon मुझे नहीं पता कि मैं कैसे चूक गया, लेकिन यह अब तय हो गया है।

— nedla2004

मूल आकार से नीचे गोल्फ: 160 बाइट्स, पायथन 2

— कैलकुलेटरफिनलाइन

उपयोग करने के बजाय p=print, आप printkw तर्क के साथ एकल कथन का उपयोग कर सकते हैं sep='\n'।

— लुका सिटी

2

रूबी, 101 बाइट्स (TIFLE)

"o@h@u".bytes{|i|k=3+i%2;puts "%-10s"*5%"TIFLE".chars.map{|j|i/=2;(i/16>i%2*3?'  ':'')+j+j*k*(i%2)}}

TTTTT     IIIII     FFFFF     L         EEEEE
  T         I       F         L         E
  T         I       FFFF      L         EEEE
  T         I       F         L         E
  T       IIIII     F         LLLLL     EEEEE

मैंने उन पत्रों को उठाया, जिनके लिए प्रत्येक पंक्ति पर अक्षरों के 1, ब्लॉक (1,4 या 5 अक्षर लंबे) की आवश्यकता थी। एफ, एल और ई को सही ठहराया जाता है, लेकिन टी और मुझे अग्रणी स्थान की आवश्यकता होती है जहां एक अक्षर (ऊर्ध्वाधर भाग) मुद्रित होता है। इन स्थानों को जोड़ने का कोड ऐसा लगता है कि इसमें सुधार किया जा सकता है।

ungolfed

"o@h@u".bytes{|i|               #for each byte (64 always set, 32...2 bits set for horiz bar, 1 bit=length of bar)
   k=3+i%2                      #decode least sig. bit for no of chars printed if a 1 is found
   puts "%-10s"*5%              #puts "%-10s%-10s%-10s%-10s%-10s" format string (expects array of subsitutes)
     "TIFLE".chars.map{|j|      #for each letter 
        i/=2                    #halve i
        (i/16>i%2*3?'  ':'')+   #if i large enough and i%2 zero, add leading space (or T and I)
        j+j*k*(i%2)             #print the letter once, then additional letters if bar required.
     }
}

— स्तर नदी सेंट
स्रोत

2

C 176 बाइट्स

यदि निहित चींटियों की अनुमति है, तो एक और 8 बाइट्स काटना संभव है।

#define C ,//11 bytes
#define R(r)r r r r r//21 bytes
T(int l){int c=324;printf(R(R("%c")R(" "))"\n" R(R(C(++c,l>>=1)&1?c/5:32)));}//77 bytes
f(){T(67010460);T(34702434);T(66160574);T(34702434);T(67010466);}//65 bytes

आउटपुट: EDCBA

EEEEE     DDDD       CCCC     BBBB       AAA      
E         D   D     C         B   B     A   A     
EEEEE     D   D     C         BBBB      AAAAA     
E         D   D     C         B   B     A   A     
EEEEE     DDDD       CCCC     BBBB      A   A

यह कैसे काम करता है: मैक्रो आर सिर्फ 5 बार कोड का एक टुकड़ा दोहराता है। यह देखते हुए कि इस समस्या में कितनी बार मुट्ठी दिखाई देती है, बहुत उपयोगी है। अब: यहाँ T (int) क्या करता है। T एक पूर्णांक लेता है, और यह एक छोटे से क्षेत्र के रूप में उपयोग करता है यह निर्धारित करने के लिए कि अक्षरों को कहां मुद्रित करें और सफेद स्थान को कहां मुद्रित करें। उदाहरण के लिए, यदि दिया जाता है T(0b11111111100111111110011100), तो यह आउटपुट होगा EEEEE DDDD CCCC BBBB AAA:। यह उत्तरोत्तर यह बताता है कि यह किस पत्र को मुद्रित करता है। पहले यह E, फिर D, फिर C, फिर B, फिर A. कॉलिंग f () प्रिंट करता है और पूरी चीज़ को प्रिंट करेगा।

— जे। एंटोनियो पेरेज़
स्रोत

2

बैच, 135 बाइट्स (DOCILe)

@set b=     
@set s=@echo DDDD%b%  OOO%b%  CCC%b% IIIII%b%L
@set t=@echo D   D%b%O   O%b%C%b%%b% I%b%  L
%s%
%t%
%t%
%t%
%s%LLLL

नोट: पहली पंक्ति 5 स्थानों पर समाप्त होती है।

— नील
स्रोत

2

दे घुमा के, 95, 111 बाइट्स (EBASH)

golfed

base64 -d<<<4ADlADhdACLpBDSMnNdRTj0Ob2qBPVT3HkdMRZzZ3kL+yIb6mhkz06EM+KOspSDy2EBoUKKL6pfwNo0akV0zAA==|xz -dqFraw

व्याख्या

Base64 कच्चे LZMA बाइट स्ट्रीम पर

डेमो

>base64 -d<<<4ADlADhdACLpBDSMnNdRTj0Ob2qBPVT3HkdMRZzZ3kL+yIb6mhkz06EM+KOspSDy2EBoUKKL6pfwNo0akV0zAA==|xz -dqFraw

EEEEE     BBBB       AAA       SSSS     H   H
E         B   B     A   A     S         H   H
EEEE      BBBB      AAAAA      SSS      HHHHH
E         B   B     A   A         S     H   H
EEEEE     BBBB      A   A     SSSS      H   H

अस्वीकरण

हां, मैं अच्छी तरह से जानता हूं कि यह वास्तव में पोर्टेबल नहीं है, इसलिए मैंने पहले मामले में -q के साथ xz चेतावनियों को दबाने के लिए एक बाइट का भुगतान किया है :)

— टसेपेल्लिन
स्रोत

2

पायथन 2, 208 194 193 बाइट्स

यह मेरा अब तक का पहला गोल्फ कोड है;) करने का मज़ा

for i in range(0,25,5):
 for c,p in {'M':18732593,'O':15255086,'N':18667121,'T':32641156,'Y':18157700}.items():
  print format(p,'025b')[i:i+5].replace('0',' ',).replace('1',c)+'   ',
 print

आउटपुट:

Y   Y    M   M    TTTTT     OOO     N   N
 Y Y     MM MM      T      O   O    NN  N
  Y      M M M      T      O   O    N N N
  Y      M   M      T      O   O    N  NN
  Y      M   M      T       OOO     N   N

एक शब्दकोश का उपयोग अक्षरों के क्रम को नष्ट कर देता है, लेकिन यह एक आवश्यकता नहीं थी

— Pleiadian
स्रोत

यह -4 कर सकता है यदि हम ऐसे अक्षर लेते हैं जो ऊपरी बाएँ कोने का उपयोग नहीं करते हैं। इसका परिणाम 24 बिट (25 बिट के बजाय) होता है जो हेक्स में एक कम अंक लेता है।

— प्लीजियन

2

पर्ल 94 बाइट्स।

पहले 4 पत्र ( D, O, I, C) विशेष रूप से समान ऊपरी और निचले लाइनों के लिए चुना जाता है, और मध्यम लोगों समान। जैसा कि कोई अन्य समान पत्र नहीं है, मैंने "एल" को उसी एल्गोरिथ्म को लागू करने और लापता 4 एल को जोड़ने में सक्षम होने के लिए चुना।

for(($a="D5 6O3 6I5 6C4 5L")."
","D 3D 5O 3O 7I 7C 9L
"x3,$a."4L
"){s/(.)(\d)/$1x$2/eg;print}

मैंने \nकोड में एक वास्तविक नई लाइन के साथ बदलकर कुछ अतिरिक्त बाइट्स को बचाया ।

नतीजा:

DDDD       OOO      IIIII      CCCC     L
D   D     O   O       I       C         L
D   D     O   O       I       C         L
D   D     O   O       I       C         L
DDDD       OOO      IIIII      CCCC     LLLLL

— एडम
स्रोत

5 पसंदीदा पत्र

अतिरिक्त नियम:

उदाहरण:

जेली , 41 बाइट्स

LICTE

विचार

कोड

चारकोल , 51 49 बाइट्स (ECXKI)

PowerShell v2 +, 138 128 114 112 106 106 बाइट्स (LICTD)

जावास्क्रिप्ट, 110 109 बाइट्स (CLOUD)

ईएस 6 (जावास्क्रिप्ट), 194, 181 बाइट्स (IGOLF / कोई भी)

PHP, 107 104 102 94 86 बाइट्स

05AB1E , 44 बाइट्स

जावास्क्रिप्ट (ES6), 96 बाइट्स (DIOCL)

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

बैश + कोरुटिल्स के साथ अंजीर, 55440 समाधान, 112 106 बाइट्स प्रत्येक

05AB1E , 102 90 89 69 बाइट्स (EOIXC)

आउटपुट (230 बाइट्स):

स्पष्टीकरण:

जावास्क्रिप्ट ईएस 6, 168 बाइट्स, सीएचएमपी

ब्रेनफ *** 512 411 बाइट्स

विम, 116 बाइट्स 99 बाइट्स

ELITC

MATL , 49 बाइट्स

व्याख्या

वी , 62 , 53 बाइट्स

पर्ल, 109 बाइट्स (ABCDE)

प्रयोग

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

Befunge, 120 बाइट्स (CKYTF)

रूबी, 110 107 102 बाइट्स (DOCIL)

Befunge-98 , 109 98 बाइट्स (फंग / कोई भी)

इनपुट (115 पात्र):

आउटपुट (255 वर्ण):

स्पष्टीकरण:

सी #, 290 279 267 265 बाइट्स

स्टैक्स , 33 बाइट्स "बीसीडीईओ"

पायथन 3, 234 228 227 166 बाइट्स (CLOUD):

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

रूबी, 101 बाइट्स (TIFLE)

C 176 बाइट्स

बैच, 135 बाइट्स (DOCILe)

दे घुमा के, 95, 111 बाइट्स (EBASH)

पायथन 2, 208 194 193 बाइट्स

पर्ल 94 बाइट्स।