परिचय

26 अगस्त, 2017 को फ्लोयड मेवेदर, जूनियर का सामना बॉक्सर मैच में कॉनर मैक्ग्रेगर से होगा।

दोनों प्रतिभागियों को 100 मिलियन डॉलर की अभूतपूर्व राशि प्राप्त होगी!

दुर्भाग्य से, हमारे पास अभी तक पैसा नहीं है, लेकिन हम पहले से ही बड़ी अटैची तैयार कर सकते हैं जिसमें सभी बैंक नोट शामिल होंगे।

        _________________________
        |                       |
|=======================================|
|       $  $$$$$  $$$$$  $       $      |
|   $   $  $   $  $   $  $$$   $$$      |
|       $  $   $  $   $  $  $$$  $      |
|       $  $$$$$  $$$$$  $       $      |
|_______________________________________|

अटैची से बना है _, |, =और $।

इसमें 41 वर्णों का आकार चौड़ाई (नई रेखाओं की अनदेखी) और 6 ऊँचाई (हैंडल के लिए +2) है।

चुनौती

बिना इनपुट दिए, एक 2 डी अटैची (ऊपर देखें) आउटपुट के लिए एक पूरा प्रोग्राम लिखें।

स्कोर

यह कोड-गोल्फ है , इसलिए सबसे छोटा समाधान (बाइट्स में) जीतता है।

code-golf ascii-art kolmogorov-complexity

— Weedoze
स्रोत

5

मैंने अंग्रेज़ी विकिपीडिया को इंगित करने के लिए लिंक बदल दिए हैं क्योंकि उपयोगकर्ताओं की भारी हिस्सेदारी अंग्रेजी बोलती है।

— बिल्ली

अंतिम प्रश्न: अटैची की चौड़ाई क्या है?

— रॉड्रिगो ए। पेरेज़

— @cat

@ RodrigoA.Pérez पहले से ही सवाल में बताया। 42 अक्षर

— वेनदेज़

@ मुझे पता है हाँ; अंतिम सवाल ...

— रॉड्रिगो ए। पेरेज़

5

बबलगम, 55 बाइट्स

शायद कुछ हेडर हटाने के जादू करना संभव है, लेकिन मैं डेनिस जितना अच्छा नहीं हूं!

00000000: 5380 8278 5c80 0ba6 a246 013b a8e1 aab1  S..x\....F.;....
00000010: 250e 0055 42f5 a800 1108 2028 9804 dc4c  %..UB..... (...L
00000020: 2847 059d 0229 8790 6080 6a26 3a85 6c36  (G...)..`.j&:.l6
00000030: 49b6 c713 076a 00                        I....j.

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

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

1

मुझे 55 के रूप में अच्छी तरह से मिलता है, वहां काम करने के लिए बहुत कुछ नहीं ...

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

7

जेली , 92 75 बाइट्स

⁽©Ḍṃ“_= ”x"“€Þ‘x2,6¤;"⁾_|x1,7¤z⁶ZUŒBY”$“¢=Ḷ't3y&ḅḄȥıḍḄḌṀṡḂẓPḣṁQṘ½ɗ’BT+134¤¦

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

कैसे?

चरण 1. एक खाली अटैची के दाहिने आधे हिस्से की पंक्तियों की एक सूची बनाएँ, अनुगामी स्थानों की अनदेखी:

⁽©Ḍṃ“_= ”x"“€Þ‘x2,6¤;"⁾_|x1,7¤
    “_= ”                      - literal list of characters = "_= "
⁽©Ḍ                            - base 250 literal = 2674
   ṃ                           - base decompress (2674 in base: 1='_', 2='=', 0=' ')
                               -   ...yields the list of characters: "_ =    _"
                   ¤           - nilad followed by link(s) as a nilad:
           “€Þ‘                -   literal list of code page indexes = [12,20]
                2,6            -   literal list of numbers = [2,6]
               x               -   repeat -> [12,12,20,20,20,20,20,20]
         x                     - repeat -> ["_"*12, " "*12, "="*20, " "*20, ..., "_"*20]
                             ¤ - nilad followed by link(s) as a nilad:
                      ⁾_|      -   literal list of characters = "_|"
                          1,7  -   literal list of numbers = [1,7]
                         x     -   repeat -> list of characters "_|||||||"
                     "         - zip with the dyad:
                    ;          -   concatenate -> ["_"+"_"*12, "|"+" "*12, ...]

चरण 2: एक पूरे खाली अटैची में बदलना:

z⁶ZUŒBY
 ⁶      - literal space character
z       - transpose with filler (adds the "leading" spaces, to the 1st 2 rows)
  Z     - transpose (back from columns to rows again)
   U    - upend (reverse each row to make it a left-hand side of an empty briefcase)
    ŒB  - bounce (add a reflection of each row with one central character)
      Y - join with new lines

चरण 3: मुझे पैसे दिखाओ!

”$“¢=Ḷ't3y&ḅḄȥıḍḄḌṀṡḂẓPḣṁQṘ½ɗ’BT+134¤¦
                                     ¦ - sparse application of:
”$                                     -   literal '$' character
                                       - ...to indexes:
                                    ¤  - nilad followed by link(s) as a nilad:
  “¢=Ḷ't3y&ḅḄȥıḍḄḌṀṡḂẓPḣṁQṘ½ɗ’         - base 250 literal = 1999171130867115278012045759181600763304793110829063794065408
                              B        - convert to a binary list -> [1,0,0,1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
                               T       - truthy indexes -> [1,4,5,6,7,8,11,12,13,14,15,18,26,39,43,46,50,53,57,60,61,62,66,67,68,85,88,92,95,99,102,105,106,107,110,127,130,131,132,133,134,137,138,139,140,141,144,152]
                                 134   - literal 134
                                +      - addition -> [135,138,139,140,141,142,145,146,147,148,149,152,160,173,177,180,184,187,191,194,195,196,200,201,202,219,222,226,229,233,236,239,240,241,244,261,264,265,266,267,268,271,272,273,274,275,278,286]
                                       -             (that's where the $s at!)

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

मम्म ... मुझे मारो तुम 5 सुंदर जानवर।

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

7

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

_=>`70
78B
B2B
9F33CDB
AEFEFEF54B
9FEFEFF6DB
9F33CDB
B1B`.replace(/./g,c=>'__=$$$$ ||||$$$$'[n=+('0x'+c)].repeat(n>6?1:n?+'0005333'[n]||39:25)+' '.repeat(n-8?'0002632707307632'[n]:23))

कैसे?

इन 16 विशिष्ट प्रतिमानों का उपयोग करके आउटपुट बनाया गया है:

ID | Character | Repeated | Following spaces | Rendering
---+-----------+----------+------------------+-------------------------------------------
 0 |     _     |    25    |         0        | "_________________________"
 1 |     _     |    39    |         0        | "_______________________________________"
 2 |     =     |    39    |         0        | "======================================="
 3 |     $     |     5    |         2        | "$$$$$  "
 4 |     $     |     3    |         6        | "$$$      "
 5 |     $     |     3    |         3        | "$$$   "
 6 |     $     |     3    |         2        | "$$$  "
 7 |   space   |     1    |         7        | "        "
 8 |     |     |     1    |        23        | "|                       "
 9 |     |     |     1    |         7        | "|       "
 A |     |     |     1    |         3        | "|   "
 B |     |     |     1    |         0        | "|"
 C |     $     |     1    |         7        | "$       "
 D |     $     |     1    |         6        | "$      "
 E |     $     |     1    |         3        | "$   "
 F |     $     |     1    |         2        | "$  "

डेमो

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

let f =

_=>`70
78B
B2B
9F33CDB
AEFEFEF54B
9FEFEFF6DB
9F33CDB
B1B`.replace(/./g,c=>'__=$$$$ ||||$$$$'[n=+('0x'+c)].repeat(n>6?1:n?+'0005333'[n]||39:25)+' '.repeat(n-8?'0002632707307632'[n]:23))

console.log(f())

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

— Arnauld
स्रोत

6

05AB1E , 80 बाइट्स

•Cā½œSÖ<ô’=-¾Ì„*нcF/“è∊αΔú9d:î₅•6B5¡.B€û»•H0αÅ±¼Āß8PβÁ19]×
ôв•bvðy.;}4ÝJ"$ |=_"‡

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

व्याख्या

अटैची की मूल रूपरेखा:

05AB1E , 41 बाइट्स

•Cā½œSÖ<ô’=-¾Ì„*нcF/“è∊αΔú9d:î₅•6B5¡.B€û»

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

उप-स्पष्टीकरण स्पष्टीकरण (भाग एक):

मैंने डिज़ाइन को आधे हिस्से में काटकर, सभी पात्रों को 2-6 के साथ बदल दिया और अंत में इसे आधार 255 में परिवर्तित कर दिया और 5एक नई रेखा के रूप में उपयोग करके आकृति को फिर से संगठित किया ।

•Cā½œSÖ<ô’=-¾Ì„*нcF/“è∊αΔú9d:î₅•  # Push the base-255 compressed number
6B                                # Convert it to  base-6 (the number of unique symbols)
  5¡                              # Split on 5 (the newlines).
    .B                            # Pad all elements with space to equal largest element length.
      €û                          # For each element, mirror it.
        »                         # Separate list with newlines.

77793946998265282127108152676813925695887415511783202442861719287811277

क्या वह संख्या जो आधार 255 में व्यक्त की गई है, और आधार 6 इसका रूपांतरण है ...

11111111444444444444511111111211111111111523333333333333333333525252525244444444444444444445

फिर, कि पत्नियों पर विभाजन, मिररिंग और newlines द्वारा शामिल हो जाता है हमें ...

111111114444444444444444444444411111111
111111112111111111111111111111211111111
233333333333333333333333333333333333332
2                                     2
2                                     2
2                                     2
2                                     2
244444444444444444444444444444444444442

उप-स्पष्टीकरण स्पष्टीकरण (भाग दो):

यह देखने के लिए कि यह कहाँ जा रहा है? अगला, मैं बेस-255 स्ट्रिंग के रूप में आंतरिक पैटर्न को संपीड़ित करता हूं:

•H0αÅ±¼Āß8PβÁ19]×
ôв•

जो है:

353343914082943027578174279006736773101445087

बाइनरी में कनवर्ट करें:

1111110110000011000001101111111011111110111011011101101110110001110001111111111101101110110111011011000110111111111110110000011000001101111111011111

उन पात्रों में से प्रत्येक के लिए, अगले वर्ण के साथ एक स्थान बदलें, जो कि:

111111114444444444444444444444411111111
111111112111111111111111111111211111111
233333333333333333333333333333333333332
211111101100000110000011011111110111112
211011101101110110111011000111000111112
211111101101110110111011011000110111112
211111101100000110000011011111110111112
244444444444444444444444444444444444442

अंत में, उन पात्रों को प्रतिस्थापित करें जो वे होना चाहिए।

0 = '$'
1 = ' '
2 = '|'
3 = '='
4 = '_'

4ÝJ"$ |=_"‡

नुकसान के लिए:

        _______________________        
        |                     |        
|=====================================|
|      $  $$$$$  $$$$$  $       $     |
|  $   $  $   $  $   $  $$$   $$$     |
|      $  $   $  $   $  $  $$$  $     |
|      $  $$$$$  $$$$$  $       $     |
|_____________________________________|

इसे दो अलग-अलग पैटर्नों के रूप में संपीड़ित करके मैं 20 बाइट बचाता हूं:

7ºnF@É₄S¡‘nz'W›мλнbнžSÍõ₄óð½²Ç0Δεenë3aŽÖk∍&1ŒâÜ[¤öüuиSð±zαÛÊ¸q¥KÃĀ›Ć^ü¹ÉRKq®Ùì=Ö‚≠ØÖì¾!(Δ∍Ú

जो है:

111111114444444444444444444444411111111
111111112111111111111111111111211111111
233333333333333333333333333333333333332
211111101100000110000011011111110111112
211011101101110110111011000111000111112
211111101101110110111011011000110111112
211111101100000110000011011111110111112
244444444444444444444444444444444444442

बेस -10 में परिवर्तित:

29962958783786255124710309272045448655717311098547870227488323781868803792449842685227629539722703574931794395923080776255103394202825327279714682601797290475465885089686540986020693577678744259173981845378875732421872

92 बाइट्स के साथ लिप्यंतरण भी, जो कुल लगभग 105 होगा।

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

3

एसओजीएल , 58 57 बाइट्स

¹&‘┐4Ο"ε@»-⅜Η⁄№ν½7bč═⁴‘'⁴n{╥ι}¹54"~æαΟ9≠š:+VæΨT-⅟yu7‘'∑nž

स्पष्टीकरण:

¹&‘┐                            push 20 spaces
    4Ο                          swap between the 20 spaces and "|" 9 times, resulting in "|                    |                    |                    |                    |"
      "...‘                     push "        _____________        |            |====================ŗ____________________", with ŗ replaced with the string above
           '⁴n                  split into chunks of length 21
              {╥ι}¹             palendromize horizontally
                     "...‘      push the sign - "    $  $$$$$  $$$$$  $       $$   $  $   $  $   $  $$$   $$$    $  $   $  $   $  $  $$$  $    $  $$$$$  $$$$$  $       $"
                          '∑n   split into chunks of length 30
                   54        ž  at coordinates (5;4) place the sign in the briefcase

यह कोशिश करो!

54 बाइट्स ( प्रतिस्पर्धा? )

¹&‘┐4Ο"ε@»-⅜Η⁄№ν½7bč═⁴‘'⁴n╥ι54"~æαΟ9≠š:+VæΨT-⅟yu7‘'∑nž

यहां इस्तेमाल की जाने वाली कमांड है ╥- पैलेंड्रोमाइज़, जिसने केवल स्ट्रिंग्स पर काम किया, लेकिन ऐरे के लिए भी दस्तावेज किया गया था । (वर्तमान में यह केवल ऑनलाइन दुभाषिया पर लागू है)
इसे यहाँ आज़माएँ!

— dzaima
स्रोत

3

PHP, 117 बाइट्स

मुझे दुःख है कि आलसी दृष्टिकोण से कम कुछ नहीं है - स्ट्रिंग स्ट्रिंग और बेस 64-एनकोड करें:

<?=gzinflate(base64_decode(U1CAgHhcACqvwAVj1ChgB3Bxrhpb4kANF0yPChCBAIJCSIDNBqtUgapEpVTADBUUlQpYVUKVYVVJwHacwYMKagA));

कस्टम संपीड़न: 188 बाइट्स

for(;$c=" 6_777
 6| 883|
|=8899|
| 5$  $3  $3  $ 5$ 4|
| 1$ 1$  $ 1$  $ 1$  $1 1$1 4|
| 5$  $ 1$  $ 1$  $  $2  $ 4|
| 5$  $3  $3  $ 5$ 4|
|_8899|"[$i++];)echo+$c?str_pad($d,$c+1,$d):$d=$c;

~~168 164 159 152~~ 151 बाइट्स ऑफिशियल ऑफिशियली ऑफिशियल आइडियाज:

लाइनों को एक सीमा चरित्र (पहले दो के लिए स्थान, उसके बाद पाइप), अंतरिक्ष के रूप में 0और एक अन्य चरित्र के बीच बिटमैप के रूप में देखा जा सकता है 1।
लाइनों 3 और 8 को बदलने से उन्हें एक मूल्य मिला0 , इसलिए मैं 6 बिट्स द्वारा सभी मानों को स्थानांतरित कर सकता था।

सरणी में बिटमैप होते हैं (बेस 34 में कनवर्ट किया जाता है; लेकिन केवल 7 मान - 8 वां तत्व छोड़ा गया है, एक खाली तत्व इसके लिए प्रेरित करता है 0 करता है)। बेस 35 भी काम करेगा; लेकिन आधार 33 में अधिक मूल्य हैं और बेस 36 को एक और अधिक मूल्य की आवश्यकता होगी।

स्ट्रिंग में प्रत्येक पंक्ति के लिए उस क्रम में सीमाएँ 0और 1वर्ण होते हैं (अंतिम वर्ण को छोड़ना, क्योंकि लाइनों 3 और 8 को किसी 1वर्ण की आवश्यकता होती है, जिसमें कोई बिट सेट नहीं है)।

for(;$i<8;)echo strtr(sprintf("b%039bb
",intval(["1g7em2",p3ob4,0,v839j,cm7f3d,sfxq9,v839j][+$i],34)<<6),b01,substr("  _  ||= | $| $| $| $|_",$i++*3));

कस्टम संपीड़न Jörg द्वारा, ~~159~~ 156 बाइट्स :

<?=strtr("5 _2222
5 |555  |
|===333333|
|516161504$414141$$4$$0514141  6  051616150___222222|",["$      |
|","$  $",______,"======","   ","       ","$$$"]);

— टाइटस
स्रोत

1

मुझे लगता है कि यह बेहतर है इसे ऑनलाइन आज़माएं!

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

1

क्षमा करें, मुझे एक बेहतर तरीका मिल गया है इसे ऑनलाइन आज़माएं!

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

@ JörgHülsermann: मुझे भी

— टाइटस

क्या आप प्रतिध्वनि के क्रम को बदल सकते हैं और प्रतिध्वनित करने के लिए स्ट्रेट कर सकते हैं?

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

@ JörgHülsermann: नहीं, मुझे बाइनरी अंकों को बदलने से पहले नंबर को बदलना होगा।

— टाइटस

2

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

“£zḂİẹḋmẋ>zạṾʂṀAYnŀ67ŻḢkðṡẉHLV'²ṙæṠṆoPẸCÞƒṿÑḢƲp4ƊƘṂɠ5×ṗ²X³⁻%ẹṄÑỊWÐh.ẹƁɗṫ0ạṢṆ@Gị}xM`JʠɠS"LṂÐ÷ṙḃ?ṄP9÷/⁵EṛṇD’ṃ“ ¶|=$_

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

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

2

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

764*.7,2-#&744742222222562222574474#&[# ][#_]#
[# ]#|[# ]"|
|"[#=]"|
|"[# ]#$,.[#$]# .[#$]"  $"[# ]#$,[# ]"|
|"[# ]#$[# ]"$  $"[# ]"$  $"[# ]"$  "[#$][# ][#$][# ]"|
|"[# ]"$  $"[# ]"$  $"[# ]#$[# ]#$,.[#$]"  $"[# ]"|
|"[# ]#$,.[#$]# .[#$]"  $"[# ]#$,[# ]"|
|"[#_]#|&@

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

तो गोल्फ ...

— Skidsdev
स्रोत

2

/// , 155 बाइट्स

/~/\/\///2/  ~3/2 ~6/33~7/6 ~1/____~4/__111~5/411___~#/=============~%/$$$~&/%$$~9/$2$3$2$3$2~@/|
|~8/@7$2&2&2$7$6/ 75
 7|33377@###8@3$39%3%6@79$2%2$68@45|

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

मुझे यह पसंद है जब /// प्रतिस्पर्धा कर सकते हैं।

स्पष्टीकरण:

यह आम प्रतिस्थापनों को परिभाषित करके काम करता है $$$$$ , फिर मेटा-प्रतिस्थापनों को परिभाषित करता है जिसमें मूल प्रतिस्थापन शामिल होते हैं।

अधिक गहराई में:

सबसे पहले, /// की एकमात्र विशेषता यह /pattern/replacement/सिंटैक्स है और अन्य बैकस्लैश और फ़ॉरवर्ड-स्लैश से बचने के लिए बैकस्लैश का उपयोग करने की क्षमता है। स्पष्टीकरण में यह जानकारी महत्वपूर्ण है।

कोड में पहला पैटर्न / प्रतिस्थापन केवल गोल्फिंग उद्देश्यों के लिए है (और यहां विस्तृत है )। इसके ~साथ बदलता है //, इसलिए परिणामी कोड इस तरह दिखता है:

/2/  //3/2 //6/33//7/6 //1/____//4/__111//5/411___//#/=============//%/$$$//&/%$$//9/$2$3$2$3$2//@/|
|//8/@7$2&2&2$7$6/ 75
 7|33377@###8@3$39%3%6@79$2%2$68@45|

फिर बुनियादी प्रतिस्थापन का एक गुच्छा बनाया जाता है। कुछ दूसरों पर भरोसा करते हैं (मेटा-प्रतिस्थापन), लेकिन प्रतिस्थापन की तालिका इस तरह दिखती है (कोड `s में लिपटे हुए ):

Pattern             |Replacement
=====================================
`2`                 |`  `
-------------------------------------
`3`                 |`   `
-------------------------------------
`6`                 |`      `
-------------------------------------
`7`                 |`       `
-------------------------------------
`1`                 |`____`
-------------------------------------
`4`                 |`______________`
-------------------------------------
`5`                 |`_________________________`
-------------------------------------
`#`                 |`=============`
-------------------------------------
`%`                 |`$$$`
-------------------------------------
`&`                 |`$$$$$`
-------------------------------------
`@`                 |`|
                    ||` (Pipe, newline, pipe)
-------------------------------------

यहां मेटा-रिप्लेसमेंट जैसी चीजें हैं /&/%$$/। यह पहले से मौजूद प्रतिस्थापन को लेता है $$$और एक नए प्रतिस्थापन को परिभाषित करने के लिए इसका उपयोग करता है $$$$$।

फिर बहुत बड़े प्रतिस्थापन आते हैं। पहला एक के 9साथ बदलता है $ $ $ $ $ $और दूसरा एक के 8साथ बदलता है:

|
|       $  $$$$$  $$$$$  $       $

अनुगामी रिक्त स्थान पर ध्यान दें।

फिर इन सभी प्रतिस्थापनों का उपयोग निम्नलिखित स्ट्रिंग में किया जाता है:

 75
 7|33377@###8@3$39%3%6@79$2%2$68@45|

वांछित उत्पादन प्राप्त करने के लिए।

— कॉमरेड स्पार्कलपनी
स्रोत

वाह, मुझे और अधिक गहराई से स्पष्टीकरण चाहिए।

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

@carusocomputing किया गया।

— कॉमरेड स्पार्कलपनी

2

पायथन 2 , 221 205 197 196 193 बाइट्स

सहेजे गए 16 बाइट्स: संपीड़न 16-बेस से 36-बेस में बदल गया
सहेजे गए 8 बाइट्स: का उपयोग a="6ZBRS533| $"औरb="70JYF0U7|"
बचा 1 बाइट: पायथन 3 से 2 तक स्विच किया गया
सहेजे गए 3 बाइट्स: एक सफ़ेद-स्थान और ब्रेसिज़ की एक जोड़ी को हटा दिया (स्ट्रिंग-प्रतिस्थापन को पुन: व्यवस्थित करने के बाद)

a="6ZBRS533| $"
b="70JYF0U7|"
for u in["6YKXAYYN  _","6ZKFUZR3  |",b+"= ",a,"6JNFT2RJ| $","6ZFOPPKV| $",a,b+"_ "]:print u[-3]+bin(int(u[:-3],36))[2:].replace("1",u[-2]).replace("0",u[-1])+u[-3]

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

स्पष्टीकरण:

प्रत्येक पंक्ति एक सामान्य रूप में होती है pupजहां pएक सीमा वर्ण होता है और यू दो विशिष्ट वर्णों (प्रत्येक पंक्ति के लिए) के साथ एक स्ट्रिंग होता है जिसे 1 और 0. द्वारा दर्शाया जा सकता है। उदाहरण के लिए, पंक्ति 5 है:

| $ $ $ $ $ $ $$$ $$$ |

यह है | सीमा के रूप में चरित्र और मध्य स्ट्रिंग में केवल और $। मध्य स्ट्रिंग द्वारा प्रतिनिधित्व किया जा सकता है:

111011101101110110111011000111000111111

अब इस बाइनरी स्ट्रिंग को 36-आधार संख्या द्वारा दर्शाया जा सकता है:

6JNFT2RJ

हम 36-बेस स्ट्रिंग, सीमा वर्ण और मध्य स्ट्रिंग में उपयोग किए जाने वाले वर्णों के साथ एक निश्चित स्ट्रिंग द्वारा सभी लाइनों का प्रतिनिधित्व कर सकते हैं:

111111100000000000000000000000001111111  "6YKXAYYN  _"
111111101111111111111111111111101111111  "6ZKFUZR3  |"
111111111111111111111111111111111111111  "70JYF0U7|= "
111111101100000110000011011111110111111  "6ZBRS533| $"
111011101101110110111011000111000111111  "6JNFT2RJ| $"
111111101101110110111011011000110111111  "6ZFOPPKV| $" 
111111101100000110000011011111110111111  "6ZBRS533| $"
111111111111111111111111111111111111111  "70JYF0U7|_ "

हम इस प्रकार बेस -36 स्ट्रिंग (निश्चित स्ट्रिंग से इसे निकालने के बाद) को बाइनरी स्ट्रिंग तक विघटित कर सकते हैं, मध्य स्ट्रिंग में उपयोग किए गए वर्णों (भी निश्चित स्ट्रिंग से प्राप्त) द्वारा 1 और 0 को बदलें और दोनों सिरों पर सीमा वर्णों के साथ गोंद करें । इस प्रकार, आवश्यक स्ट्रिंग प्राप्त की जाती है।

— officialaimm
स्रोत

1

यदि आप पूर्ण लाइनों को उलटा करते हैं, तो आप सबसे कम 6 बिट्स काट सकते हैं; कि 5 बाइट्स या तो बचाना चाहिए।

— टाइटस

2

सी, 415 402 397 बाइट्स

#define P(x)D(x,4,4)
#define S(r,c)i=r;j=c;
#define D(x,c,n)for(k=x+n;x<k;t[i][j]=c)++x;
t[8][41]={0};i,j,k;o(x){S(2,x)P(i)P(j)S(3,x)P(j)D(i,4,3)}f(){t[1][8]=t[1][32]=92;t[4][4]=4;S(0,7)D(j,63,25)S(1,0)D(i,92,6)D(j,63,39)S(2,0)D(j,29,39)S(1,40)D(i,92,6)S(2,9)P(i)o(12);o(19);S(2,26)P(i)i-=2;D(j,4,2)++i;D(j,4,3)--i;D(j,4,3)i-=2;P(i)for(i=0;i<8;++i,puts(t))for(j=0;j<41;)printf("%c",t[i][j++]+32);}

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

— Steadybox
स्रोत

2

रेटिना , 140 137 129 बाइट्स

-3 बाइट्स @ @ नील को धन्यवाद


8aaaa_¶8|23|¶|bbbbbb===c3A3d3d3dAA3AAA6|¶|7d3d3d2AAd6caaaaaa___|
d
A2A
c
|¶|7A2AAAAA2AAAAA2A7A6|¶|
b
======
a
______
A
$
\d+
$*

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

— OVS
स्रोत

चूंकि आप 1कुछ और के लिए एस का उपयोग नहीं कर रहे हैं , क्या आप $*<space>सीधे नहीं लिख सकते हैं?

— नील

2

सी (जीसीसी) , 388 386 302 बाइट्स

char*r="8 24_08 1|22 1|01|37=1|01|6 1$2 5$2 5$2 1$7 1$5 1|01|2 1$3 1$2 1$3 1$2 1$3 1$2 3$3 3$5 1|01|6 1$2 1$3 1$2 1$3 1$2 1$2 3$2 1$5 1|01|6 1$2 5$2 5$2 1$7 1$5 1|01|37_1|";char d[9];main(i){do{if(*r==48)puts(""),r++;for(i=0;isdigit(*r);d[i++]=*r++);for(d[i]=0,i=atoi(d);i--;putchar(*r));}while(*r++);}

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

— cleblanc
स्रोत

1

05AB1E , 121 बाइट्स

•?íLñ>ć£P¹ĀJδšlÔ@.ì@E'a‘2‡ΔÉ₅’Õ'8¾—Hú∊‹£ñ₂C*ƶ¬}ʒ³öG`ŒªKµδB₁вÑ(δüc›½ćˆ3αÂÝβ+Í‘]~é£42îĆ$Ÿ₅Ë!∊s₆L×ä5Uñ₁δǝβζ•6B•1’₃•" _
|=$"‡

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

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

आप आंतरिक और बाहरी / आंतरिक पैटर्न को अलग-अलग संस्थाओं के रूप में व्यक्त करके बाइट्स को बचा सकते हैं और उन्हें पुनरावृत्त करने के लिए प्रतिस्थापित कर सकते हैं। मैंने हाल ही में आवर्त सारणी चुनौती करते समय आधार रूपांतरण बाइट-काउंट को कम करने के लिए इस रणनीति को सीखा है :)। बबलगम ने इसे 3 आंतरिक पैटर्न से कम किसी भी चीज पर मार दिया, और यह केवल 1 :( है। codegolf.stackexchange.com/a/126995/59376

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

@carusocomputing बबलगम भी एसओजीएल को मारता है, तो यह वास्तव में इसके लायक नहीं है ...

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

1

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

_=>` 8_25
 8| 23|
|=39|
${r='| 7$ 2$5 2$5 2$ 7$ 6|'}
| 3$ ${s='3$ 2$ 3$ 2$ '}3$ 2$3 3$3 6|
| 7$ 2$ ${s}2$3 2$ 6|
${r}
|_39|`.replace(/(.)(\d+)/g,(_,b,c)=>b.repeat(c))

स्ट्रिंग बार-बार दोहराने के लिए प्रदर्शित करने के लिए वर्णों का एक संग्रह रखती है। यदि कोई चरित्र दोहराया नहीं जाता है, तो समय की संख्या को छोड़ा जा सकता है।

बार-बार स्ट्रिंग रन को चर में संग्रहीत करके अनुकूलित किया जाता है rऔर s।

स्निपेट:

f=
_=>` 8_25
 8| 23|
|=39|
${r='| 7$ 2$5 2$5 2$ 7$ 6|'}
| 3$ ${s='3$ 2$ 3$ 2$ '}3$ 2$3 3$3 6|
| 7$ 2$ ${s}2$3 2$ 6|
${r}
|_39|`.replace(/(.)(\d+)/g,(_,b,c)=>b.repeat(c))

console.log(f());

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

— रिक हिचकॉक
स्रोत

0

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

print'eNpTUICAeFwAKq/ABWPUKGAHcHGuGlviQA0XTI8KEIEAgkJIgM0Gq1SBqkSlVMAMFRSVClhVQpVhVUnA9njiQA0AtPhDOg=='.decode('base64').decode('zlib')

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

— mdahmoune
स्रोत

0

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

←×_²⁰↑⁵|×=²⁰↖↑←×_¹³↘↙|↓↷‖Ｏ”{“↷γαc7sa%}⦃Ｎ№Ｔ⊕ＶⅉＨ➙Ｕ₂＆ηy

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

←×_²⁰↑⁵|×=²⁰↖↑←×_¹³↘↙|

ब्रीफकेस के बाएं आधे भाग को प्रिंट करें।

↓↷

कर्सर तैयार करें ताकि संपीड़ित स्ट्रिंग को प्रतिबिंबित करने के बाद सीधे मुद्रित किया जा सके। (प्रतिबिंब के बाद या संपीड़ित स्ट्रिंग से पहले नीचे की ओर गति डालने से उनका अर्थ बदल जाता है।)

‖Ｏ

अटैची को पूरा करने के लिए प्रतिबिंबित करें।

”{“↷γαc7sa%}⦃Ｎ№Ｔ⊕ＶⅉＨ➙Ｕ₂＆ηy

एक संपीड़ित स्ट्रिंग के रूप में राशि प्रिंट करें। (दुख की बात है कि यह सबसे छोटा तरीका था, अन्यथा Mबहुत सारे बाइट्स का सेवन किया जाता था।)

— नील
स्रोत

मेवेदर बनाम मैकग्रेगर: नकद पुरस्कार तैयार करें

परिचय

चुनौती

स्कोर

बबलगम, 55 बाइट्स

जेली , 92 75 बाइट्स

कैसे?

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

कैसे?

डेमो

05AB1E , 80 बाइट्स

व्याख्या

05AB1E , 41 बाइट्स

एसओजीएल , 58 57 बाइट्स

54 बाइट्स ( प्रतिस्पर्धा? )

PHP, 117 बाइट्स

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

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

/// , 155 बाइट्स

पायथन 2 , 221 205 197 196 193 बाइट्स

स्पष्टीकरण:

सी, 415 402 397 बाइट्स

रेटिना , 140 137 129 बाइट्स

सी (जीसीसी) , 388 386 302 बाइट्स

05AB1E , 121 बाइट्स

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

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

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