आइए कुछ अटारी एसटी बमों को आकर्षित करें!


46

परिचय

अटारी अनुसूचित जनजाति के मध्य 80 के दशक से एक नहीं बल्कि लोकप्रिय पर्सनल कंप्यूटर 90 के दशक युग के लिए, एक मोटोरोला 68000 माइक्रोप्रोसेसर द्वारा संचालित किया गया था। इस मशीन पर, अनकैप्ड सीपीयू अपवादों के लिए ऑपरेटिंग सिस्टम का डिफ़ॉल्ट व्यवहार स्क्रीन पर बमों की एक पंक्ति प्रदर्शित करना था, जैसा कि निम्नलिखित चित्र में दिखाया गया है:

बमों की पंक्ति

स्रोत: https://commons.wikimedia.org/wiki/File:Row_of_bombs.png
NB: OS संस्करण के आधार पर, बम ग्राफिक्स थोड़ा भिन्न हो सकते हैं। लेकिन इसे संदर्भ के रूप में लेते हैं।

बमों की संख्या अपवाद वेक्टर पर निर्भर करती है, जो सबसे आम हैं:

  • ($ 008) बस त्रुटि: 2 बम
  • ($ 00c) पता त्रुटि: 3 बम
  • ($ 010) अवैध निर्देश: 4 बम

लक्ष्य

आपका लक्ष्य एक प्रोग्राम या फ़ंक्शन लिखना है जो ऐसे अटारी एसटी बमों के ASCII कला को प्रिंट या आउटपुट करता है।

इनपुट

प्रदर्शित करने के लिए बमों की संख्या का प्रतिनिधित्व करने वाला पूर्णांक। आपके कोड को सबसे सामान्य मूल्यों का समर्थन करना चाहिए: 2, 3 और 4. कम और / या अधिक बम का समर्थन करना ठीक है, लेकिन यह न तो आवश्यक है और न ही बोनस के अधीन है।

उत्पादन

मूल बम में एक 16x16 पिक्सेल टाइल होती है, जो ASCII और बाइनरी दोनों में यहाँ दर्शाई गई है:

....##..........    0000110000000000
.#.#..#.........    0101001000000000
.......#........    0000000100000000
#..#....#.......    1001000010000000
..#...#####.....    0010001111100000
......#####.....    0000001111100000
....#########...    0000111111111000
...###########..    0001111111111100
...###########..    0001111111111100
..#############.    0011111111111110
..########.####.    0011111111011110
...#######.###..    0001111111011100
...######.####..    0001111110111100
....#########...    0000111111111000
.....#######....    0000011111110000
.......###......    0000000111000000

इस चुनौती में, प्रत्येक ASCII बम को बेहतर प्रतिपादन के लिए इसकी मूल चौड़ाई से दोगुना तक बढ़ाया जाना चाहिए। इसलिए, इसमें 32 वर्णों की 16 पंक्तियाँ होंगी, जिनमें ##'ON' पिक्सेल और 'OFF' पिक्सेल के लिए दो स्थान होंगे। सभी बम टाइलों को एक साथ रखा जाना चाहिए। अग्रणी स्थान निषिद्ध हैं। ट्रेलिंग स्पेस को भी मना किया जाता है, सिवाय उन लोगों के जो वास्तव में बम टाइल (31 वें और 32 वें कॉलम) का हिस्सा हैं, जो मौजूद होना चाहिए। आप एक से अधिक प्रमुख लाइन-ब्रेक और एक से अधिक ट्रेलिंग लाइन-ब्रेक शामिल नहीं कर सकते हैं।

उदाहरण

नीचे दो बमों के लिए संदर्भ आउटपुट है, जहां अनिवार्य लाइन-ब्रेक को चिह्नित किया जाता है \nऔर अतिरिक्त लाइन-ब्रेक को सहन किया जाता है (\n):

(\n)
        ####                            ####                    \n
  ##  ##    ##                    ##  ##    ##                  \n
              ##                              ##                \n
##    ##        ##              ##    ##        ##              \n
    ##      ##########              ##      ##########          \n
            ##########                      ##########          \n
        ##################              ##################      \n
      ######################          ######################    \n
      ######################          ######################    \n
    ##########################      ##########################  \n
    ################  ########      ################  ########  \n
      ##############  ######          ##############  ######    \n
      ############  ########          ############  ########    \n
        ##################              ##################      \n
          ##############                  ##############        \n
              ######                          ######            (\n)

(बेशक, अन्य लाइन-ब्रेक प्रारूप जैसे कि \rया \r\nबस इस्तेमाल किया जा सकता है।)

नियम

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


मुझे लगता है कि आपने गैर-एएससीआईआई-कला रूपों को बाहर कर दिया है, इसलिए अटारी एसटी मशीन-कोड फ़ंक्शन जो सही संख्या में बमों के साथ दुर्घटनाग्रस्त हो जाता है। (यह बम फॉन्ट में नहीं है, लेकिन अटारी एसटी ने अपने मूल चरित्र सेट में मजेदार / ईगस्टर-अंडे के ग्लिफ़्स को शामिल किया है, जिसमें 28-31 अक्षर शामिल हैं जो 4 टुकड़े हैं जो व्यंग्य चर्च से जेआर "बॉब" डोब की छवि बनाते हैं। SubGenius । मुझे याद है कि एक प्रोग्राम लिखना है जो उन 4 ग्लिफ़्स को रैंडम स्क्रीन पोज़िशन्स पर स्पैम करता है, टेक्स्ट-ड्रॉइंग सिस्टम कॉल्स का उपयोग करने में एक बहुत ही प्रारंभिक अभ्यास के रूप में :)
पीटर कॉर्ड्स

1
@PeterCordes - यह सही है, यह ASCII होना चाहिए। हालाँकि, आपको एसटी रोम से बम ग्राफिक्स पढ़ने की अनुमति होगी क्योंकि ऐसा कोई नियम नहीं है जो आपको ऐसा करने से रोकता है। (बस टीओएस संस्करण इस पर काम करने के लिए माना जाता है का उल्लेख है।)
Arnauld

1
ओह वाह, यह यादें वापस लाता है। मेरा पहला कंप्यूटर अटारी एसटी था। मुझे याद है उन बमों का खौफ था।
रॉड

एक तरफ: "बम की संख्या अपवाद वेक्टर पर निर्भर करती है" - कहते हैं क्या ?! किसी भी कारण से वे वास्तविक कोड / त्रुटि का उत्पादन नहीं कर सके? (कभी कोई एसटी नहीं था, मैं अमीगा कैंप से ... "गुरु ध्यान" और वह सब।)
मृदित

जवाबों:


20

जेली , 43 44 बाइट्स

+1 बाइट - पात्रों को डबल करना भूल गए (ऐसा नहीं है कि किसी ने भी देखा हो!)

“¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P"¦ḊƥṾ’b⁴‘ĖŒṙị⁾ #Ḥs⁴ẋ€³Y

TryItOnline

कैसे?

तैयारी को मूल छवि के रन-लंबाई एन्कोडिंग के रूप में डेटा को संपीड़ित करना था:

  • छवि में प्रत्येक रन 1(स्पेस) या 0s (हैश) की लंबाई की गणना करें , नई लाइनों को अनदेखा करना - एक सूची देता है [4,2,11,1,1,...]:;
  • प्रत्येक संख्या से एक घटाएँ - यह की एक सीमा देता है [0,15];
  • इसे आधार -16 संख्या के रूप में मानें (मानों को उल्टा कर दें, रिवर्स में vसूचकांक के साथ iऔर योग करें 16**i*v= 19468823747267181273462257760938030726282593096816512166437);
  • आधार-250 में बदलें: [5,119,249,42,...];
  • इंडेक्स के रूप में जेली के कोड पेज में मैप करें: ¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P

अब कोड इस संख्या का मूल्यांकन करता है, 1एस और 0एस को अंतरिक्ष में मैप करता है और हैश अक्षर *, प्रत्येक को दोगुना करता है, लाइनों में विभाजित करता है और प्रत्येक उपयुक्त समय को दोहराता है।
* वास्तव में कार्यान्वयन बाइट्स को बचाने के लिए modulo 2 किया जाता है, इसलिए रिक्त स्थान विषम हैं और हैश भी हैं:

“¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P"¦ḊƥṾ’b⁴‘ĖŒṙị⁾ #Ḥs⁴ẋ€³Y - Main link: n
“¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P"¦ḊƥṾ’                  - base 250 number, as above
                           b⁴                - convert to base 16 (the run length - 1 list)
                             ‘               - increment (vectorises) (the run length list)
                              Ė              - enumerate (pairs each with 1,2,3...)
                               Œṙ            - run length decode
                                              ([1,1,1,1,2,2,3,3,3,3,3,3,3,3,3,3,3,4,5,...])
                                  ⁾ #        - string " #"
                                 ị           - index into (1 based and modular)
                                              (makes a bomb without line feeds)
                                     Ḥ       - double (each char becomes a list of 2 chars)
                                      s⁴     - split into slices of length 16
                                        ẋ€³  - repeat each input, n, times
                                           Y - join with line feeds

19

05AB1E , 57 55 53 50 बाइट्स

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

•ø6ŒY2l½î€ÈS`L<eÆô‚˜3ª½¨ºE»D2Âô3•b15ôvy1J€D„# è¹×,

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

व्याख्या

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

अंतरिक्ष का प्रतिनिधित्व करने के लिए 1 का उपयोग करना और # बाइनरी नंबर प्राप्त करने के लिए 0 का प्रतिनिधित्व करना है :

111100111111111101011011111111111111101111111011011110111111110111000001111111111000001111111100000000011111000000000001111000000000001110000000000000110000000010000111000000010001111000000100001111100000000011111110000000111111111100011111

फिर हम इसे बेस -10 में बदल देते हैं और फिर इसे 214 बेस पर कंप्रेस कर देते हैं, 05AB1E में अधिकतम बेस। इसका परिणाम यह है:

•ø6ŒY2l½î€ÈS`L<eÆô‚˜3ª½¨ºE»D2Âô3•

कार्यक्रम का मांस तब निम्नलिखित से मिलकर बनता है:

<base encoded string>
  b                     # convert to binary
   15ô                  # slice into pieces of 15
      v                 # for each slice  
       1J               # append a 1       
         €D             # duplicate each character
           „#           # push the string "# "
             è          # use the list of binary digits to index into the string
              ¹×        # repeat string input number of times
                ,       # and print with newline

12

पायथ, 57 56 54 53 51 50 बाइट्स

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

00000000: 6a2a 4c51 6331 3673 2e65 2a79 6240 2220  j*LQc16s.e*yb@"
00000010: 2322 6b6a 4322 4c49 c142 3c60 0cca 9437  #"kjC"LI.B<`...7
00000020: b383 76bb c246 c86d 4c04 99bd 3614 7022  ..v..F.mL...6.p"
00000030: 3137                                     17

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


11

जावास्क्रिप्ट (ईएस 6), 159 154 140 136 बाइट्स

@Hedi और @Arnauld को बहुत सारे बाइट्स धन्यवाद

n=>[..."ᅬᄉソﻶ쀇쀇考萃쐇숇ﱿ"].map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(x.charCodeAt()).repeat(n)).join`
`

यह 104 वर्ण है, लेकिन (दुख की बात है) 136 UTF-8 बाइट्स। स्ट्रिंग इस स्निपेट के साथ उत्पन्न हुआ था:

.replaceइसके बजाय का उपयोग करना [...string].mapउतना ही लंबा है:

n=>"ᅬᄉソﻶ쀇쀇考萃쐇숇ﱿ".replace(/./g,x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(x.charCodeAt()).repeat(n)+`
`)

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

चूंकि कच्चे डेटा की प्रत्येक पंक्ति को 16-बिट संख्या के रूप में दर्शाया जा सकता है, हम पूरी फ़ाइल को 16-char स्ट्रिंग में संग्रहीत कर सकते हैं। संपीड़न एल्गोरिथ्म प्रत्येक बाइनरी पंक्ति लेता है, यह flips और यह पराजयों (एक में मूल समाप्त होता है में प्रत्येक पंक्ति के बाद से 0 , संशोधित संस्करण में प्रत्येक पंक्ति अब शुरू होता है एक साथ 1 ), तो यह एक चार में बदल जाता है, और जिसके परिणामस्वरूप पात्रों concatenates ।

इसे विघटित करने के लिए, हमें चारकोड को निकालने और उसके बाइनरी प्रतिनिधित्व को हैश और रिक्त स्थान की एक स्ट्रिंग में बदलने की आवश्यकता है। यह एक पुनरावर्ती कार्य के साथ किया जा सकता है, जैसे:

(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(x.charCodeAt())

fबार-बार अंतिम स्थान लेता है q, दो स्थानों का चयन करता है यदि यह 1 या दो हैश है यदि यह 0 है, तो इसे fबाकी हिस्सों में चलाने के परिणाम के साथ मिलाएं q। यह x.charCodeAt()रिक्त स्थान और हैश के सही स्ट्रिंग में चार-कोड को चालू करने पर चलाया जाता है ।

(पहले यहाँ बहुत अधिक नाटक था, लेकिन 4-बाइट-सेविंग तकनीक ने उस सब को मिटा दिया।)

उसके बाद, हम केवल स्ट्रिंग nबार दोहरा सकते हैं और एक नई पंक्ति जोड़ सकते हैं। यह सबसे छोटा अपघटन विधि है जो मैंने पाया है, लेकिन संभवतः किसी भी छोटे तरीकों का सुझाव देने के लिए स्वतंत्र महसूस करता हूं।

स्ट्रिंग को संपीड़ित करने के अन्य प्रयास:

n=>[48,74,128,265,1988,1984,8176,16376,16376,32764,31740,15352,15864,8176,4064,896].map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(65535-x).repeat(n)).join`
`
n=>"1c,22,3k,7d,1j8,1j4,6b4,cmw,cmw,pa4,oho,bug,c8o,6b4,34w,ow".split`,`.map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(65535-parseInt(x,36)).repeat(n)).join`
`
n=>"30,4a,80,109,7c4,7c0,1ff0,3ff8,3ff8,7ffc,7bfc,3bf8,3df8,1ff0,fe0,380".split`,`.map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")('0x'+x^65535)).repeat(n)).join`
`

इनमें से पहला 153 बाइट्स है, इसलिए उनमें से कोई भी 136 के पास कहीं भी नहीं आता ...


के +x?'##':' 'बजाय के साथ कुछ बाइट्स बचा सकता है" #"[x].repeat(2)
Hedi

@ हेदी धन्यवाद, मुझे पता था कि उस बिट को गोल्फ करने का एक तरीका था।
ETHproductions

2
क्या आप सीधे x.charCodeAt()इसे द्विआधारी में बदलने के बजाय बिट्स का परीक्षण कर सकते हैं ? (मुझे लगता है कि लगभग 8 बाइट्स बचाएंगे।)
अरनौल्ड

2
आपका संपीड़न एल्गोरिथ्म लगभग क्रिप्टोग्राफिक लगता है ।
जस्टिन

1
@ जस्टिन डैम, मैं बस उस पर टिप्पणी करने वाला था।
user253751

10

MS-DOS .COM फ़ाइल, 84 बाइट्स

ठीक। सिर्फ मनोरंजन के लिए क्योंकि मैं 50 बाइट्स को हरा नहीं सकता ...

एक वर्चुअल मशीन में डॉसबॉक्स के साथ-साथ एमएस-डॉस 6.22 के तहत कोशिश की गई।

डॉसबॉक्स के तहत कार्यक्रम ठीक काम करता है लेकिन वास्तविक एमएस-डॉस के तहत आउटपुट सही ढंग से प्रदर्शित नहीं होगा क्योंकि लाइन के अंत में डॉस को एलएफ के बजाय सीआर-एलएफ की आवश्यकता होती है।

(हालांकि आउटपुट सही है।)

88 बाइट वाला संस्करण लाइन के अंत में CR-LF का उपयोग करेगा।

यहाँ फाइल है:

0000  be 32 01 fc ad 89 c3 8a  36 82 00 80 ee 30 b9 10
0010  00 d1 c3 18 d2 80 ca 20  80 e2 23 b4 02 cd 21 cd
0020  21 e2 ee fe ce 75 e7 b2  0a cd 21 ad 85 c0 75 d5
0030  cd 20 00 0c 00 52 00 01  80 90 e0 23 e0 03 f8 0f
0040  fc 1f fc 1f fe 3f de 3f  dc 1f bc 1f f8 0f f0 07
0050  c0 01 00 00

कोडांतरक कोड (एटी एंड टी सिंटैक्स में) इस तरह दिखता है:

start:
      # Read data from "image:"
    mov $image,%si
    cld
      # Read the first 16 bytes
    lodsw
nextLine:
      # Use bx as shift register
    mov %ax, %bx
      # Read the number of bombs
    mov 0x82,%dh
    sub $'0',%dh
nextBombInThisLine:
      # Number of characters
    mov $16, %cx
nextCharacter:
      # Rotate the data# get the next bit to CY
    rol $1, %bx
      # This results in 0x23 ('#') if CY is set, to 0x20 (' ') otherwise
    sbb %dl, %dl
    or $0x20, %dl
    and $0x23, %dl
      # Print result character twice
    mov $2, %ah
    int $0x21
    int $0x21
      # more Characters in this line?
    loop nextCharacter
      # More bombs to draw?
    dec %dh
    jnz nextBombInThisLine
      # Print a newline
#        mov $13, %dl # <- Additional 4 bytes needed for "\r\n"
#        int $0x21    #    at the end of the line!
    mov $10, %dl
    int $0x21
      # Read the next 16 bytes# 0x0000 means: EOF
    lodsw
    test %ax,%ax
    jnz nextLine
      # End of program
    int $0x20
image:
    # Here 34 bytes follow:
    # 16 16-bit-words "bitmap" for the bombs followed
    # by 0x0000 indicating the end of the bitmap

--- संपादित करें ---

मैं उल्लेख करना भूल गया: कार्यक्रम को निम्नलिखित कमांड लाइन के साथ शुरू किया जाना चाहिए:

COM फ़ाइल का नाम + बिल्कुल एक अंतरिक्ष वर्ण + बमों की संख्या (1-9)


1
अच्छा लगा। हमें अभी भी 68000 उत्तर की कमी है, लेकिन यह करीब हो रहा है। :-)
अर्नुलद

objdump -dwकच्चे बाइनरी को दिखाने के लिए आउटपुट एक अच्छा तरीका है, क्योंकि आप देखते हैं कि कौन से बाइट्स कौन से निर्देश हैं। मैंने gcd और adler32 उत्तरों के लिए किया। (साथ ही लोगों द्वारा स्वयं को आज़माने के लिए टिप्पणी स्रोत कोड भी शामिल है।)
पीटर कॉर्ड्स

8

पायथन, 223 179 बाइट्स

दूसरा तरीका:

f=lambda n:'\n'.join(''.join(2*' #'[int(d)]for d in bin(int('0c0052000100908023e003e00ff81ffc1ffc3ffe3fde1fdc1fbc0ff807f001c0'[i:i+4],16))[2:].zfill(16))*n for i in range(0,64,4))

यह repl.it पर कोशिश करो!

ऑन-द-फ्लाई के तारों की सूची बनाने के बजाय, एक हार्ड-कोडेड हेक्साडेसिमल स्ट्रिंग है जिसे अनुक्रमित किया जाता है और बाइनरी में परिवर्तित किया जाता है; फिर प्रत्येक बाइनरी अंक को ' 'या तो बदल दिया जाता है '#', या जो डुप्लिकेट होता है और एक साथ जुड़ जाता है ... आदि।

पहले दृष्टिकोण:

s='  ';b='##';f=lambda n:'\n'.join(n*l.ljust(32)for l in[s*4+b*2,(s+b)*2+s*2+b,s*7+b,b+s*2+b+s*4+b,s*2+b+s*3+b*5,s*6+b*5,s*4+b*9,s*3+b*11,s*3+b*11,s*2+b*13,s*2+b*8+s+b*4,s*3+b*7+s+b*3,s*3+b*6+s+b*4,s*4+b*9,s*5+b*7,s*7+b*3])

यह repl.it पर कोशिश करो!

इसमें प्रत्येक पंक्ति के स्ट्रिंग्स की हार्ड-कोडित सूची होती है (अनुगामी रिक्त स्थान शामिल नहीं) ' 'या तो '##'कई बार या कई बार डुप्लिकेट बनाकर । इनमें से प्रत्येक तार के लिए, उन्हें 32 वर्णों की लंबाई तक रिक्त स्थान के साथ गद्देदार किया जाता है n, फिर दोहराए गए समय के साथ, फिर नए सिरे से जोड़ा जाता है।


आप एक अनियंत्रित जनरेटर को प्रिंट करने के लिए स्विच करने से बाइट को बचा सकते हैं, बजाय जुड़ने के '\n'। तो, lambda n:print(*(''.join(2*' #'[int(d)]for d in bin(int('0c0052000100908023e003e00ff81ffc1ffc3ffe3fde1fdc1fbc0ff807f001c0'[i:i+4],16))[2:].zfill(16))*n for i in range(0,64,4)))। इसके अलावा, आपको लैम्ब्डा को एक नाम निर्दिष्ट करने के लिए आवश्यक बाइट्स की गणना करने की आवश्यकता नहीं है। तो आपका स्कोर 176 हो सकता है।
मॉर्गन थ्राप्प

6

सी, 250 240 208 188 बाइट्स

d[]={3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448,0},m,c,*i=d;f(k){for(;*i;i++,puts(""))for(c=k;c--;)for(m=32768;m;write(1,&"##  "[m&*i?0:2],2),m>>=1);}

किसी फ़ंक्शन का उपयोग करने के लिए स्विच करें।

m,d[]={3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448,0},*i=d;main(c,v)char**v;{for(;*i;puts(""),i++)for(c=atoi(v[1]);c--;)for(m=32768;m;write(1,&"##  "[m&*i?0:2],2),m>>=1);}

इस तरह टेस्ट करें। main(c,v)char**v; { f(atoi(v[1])); }

a.exe 2
        ####                            ####                        
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                    
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######            

आप खोने के लिए उन हेक्स संख्या के दशमलव अभ्यावेदन का उपयोग करके कुछ बाइट्स बचा सकते हैं 0x
कॉपर

@ कोपर थैंक्स, मैंने पुचर की जगह राइट का इस्तेमाल करते हुए काफी बाइट्स शेव करने में कामयाबी हासिल की।
क्लेब्लांक

6

/// , 539 532 + नहीं। बम बाइट्स की

पहला /// उत्तर, 4 बम प्रदर्शित करता है। अंतिम चार 1 को उन बमों की संख्या के किसी भी एकीकृत प्रतिनिधित्व से बदला जा सकता है जिन्हें आप प्रिंट करना चाहते हैं (2 के लिए 11, 3 के लिए 111)

/-/?|X//y/\/X//xy|//|/\/\///+/%@!|$/bcd|%/efg|@/hij|!/klm|?/nop|b/Bxc/Cxd/Dxe/Exf/Fxg/Gxh/Hxi/Ixj/Jxk/Kxl/Lxm/Mxn/Nxo/Oxp/Pxq/ss|r/tt|s/SS|t/TT|S/  |T/##|1/AX$+-$+?AXyAX$+-cd+?by$+-d+?cycd+-+?dyd+-fg@!?ey+-g@!?fyfg@!-@!?gyg@!-ij!?hy@!-j!?iyij!-!?jyj!-lm?ky!-m?lylm-?mym-opny-poyop|AXA/AA|bB/BB|cC/CC|dD/DD|eE/EE|fF/FF|gG/GG|hH/HH|iI/II|jJ/JJ|kK/KK|lL/LL|mM/MM|nN/NN|oO/OO|pP/PP|A/qtqqs|B/STSTsTqqS|C/qsSTqq|D/TsTqTqsS|E/sTsSrTqS|F/qsrTqS|G/qrrTsS|H/sSrrtTs|I/sSrrtTs|J/srrrTS|K/srrSrS|L/sSrtTStTs|M/sSrtSrs|N/qrrTsS|O/qSrtTq|P/qsStTqs|X/
/1111

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

यदि इनपुट दशमलव होना चाहिए, तो निम्न में 555 548 बाइट्स हैं (जहां अंतिम अंक को 1, 2, 3 या 4 में बदला जा सकता है):

/-/?|X//y/\/X//xy|//|/\/\///4/13|3/12|2/11|^/tT|&/rr|*/sS|+/%@!|$/bcd|%/efg|@/hij|!/klm|?/nop|b/Bxc/Cxd/Dxe/Exf/Fxg/Gxh/Hxi/Ixj/Jxk/Kxl/Lxm/Mxn/Nxo/Oxp/Pxq/ss|r/tt|s/SS|t/TT|S/  |T/##|1/AX$+-$+?AXyAX$+-cd+?by$+-d+?cycd+-+?dyd+-fg@!?ey+-g@!?fyfg@!-@!?gyg@!-ij!?hy@!-j!?iyij!-!?jyj!-lm?ky!-m?lylm-?mym-opny-poyop|AXA/AA|bB/BB|cC/CC|dD/DD|eE/EE|fF/FF|gG/GG|hH/HH|iI/II|jJ/JJ|kK/KK|lL/LL|mM/MM|nN/NN|oO/OO|pP/PP|A/qtqqs|B/STSTsTqqS|C/q*Tqq|D/TsTqTq*|E/sT*rTqS|F/qsrTqS|G/q&T*|H/*&^s|I/*&^s|J/s&rTS|K/s&SrS|L/*r^S^s|M/*rtSrs|N/q&T*|O/qSr^q|P/q*^qs|X/
/4

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

कोड के सबसे महत्वपूर्ण भाग हैं:
|
औसत // ABCDEFGHIJKLMNOP का अर्थ है बम की प्रत्येक पंक्ति क्रमशः
S का अर्थ है 2 स्थान
s का अर्थ है 4 स्थान
* का अर्थ है 6 स्थान
q का अर्थ है 8 स्थान
T का अर्थ है ## (2)
t का अर्थ है #### (4)
^ का अर्थ ##### है। # (6)
r का अर्थ है ######## (8)
और ################ (16)
अधिकांश कोड यह सुनिश्चित कर रहे हैं कि बम छपे हैं अगल-बगल, एक-दूसरे के ऊपर नहीं।


5

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

"^a1{9\b aZ5w7qQAwndIUffO"136b2b1Ser0'#erG/ri*z{:_N}%

इसे ऑनलाइन आज़माएं! (ध्यान दें कि कोड में कुछ अनपेक्षित वर्ण हैं।)


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

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


5

PHP, 138 104 + 32 = 136 बाइट्स

मैंने कभी नहीं सोचा था कि fileबाइनरी सुरक्षित है। मैं केवल यही चाहता हूं कि मुझे डेटा स्टोर करने का एक और दिलचस्प तरीका मिल जाए; लेकिन कुछ भी नहीं मैंने कच्ची बाइनरी को हरा दिया।

foreach(unpack("v*",file(b)[0])as$v)echo"
",str_repeat(strtr(sprintf("%016b",$v),["  ","##"]),$argv[1]);
  • फ़ाइल से द्विआधारी डेटा पढ़ें, छोटे एंडियन से लेकर इंट के सरणी तक अनपैक करें
  • सरणी के माध्यम से लूप: स्ट्रिंग के लिए 16 अंकों के बाइनरी प्रिंट करें, 02 रिक्त स्थान के 1साथ ##,
    दोहराएं$argv[1] बार, प्रिंट परिणाम + न्यू लाइन

साथ दौड़ो -r


फ़ाइल में बाइनरी डेटा b:

0000000 0c00 5200 0100 9080 23e0 03e0 0ff8 1ffc
0000010 1ffc 3ffe 3fde 1fdc 1fbc 0ff8 07f0 01c0

फ़ाइल बनाने के लिए कोड:

$f=fopen(b,wb);foreach(array_map(bindec,explode("
",
"0000110000000000
0101001000000000
0000000100000000
1001000010000000
0010001111100000
0000001111100000
0000111111111000
0001111111111100
0001111111111100
0011111111111110
0011111111011110
0001111111011100
0001111110111100
0000111111111000
0000011111110000
0000000111000000"))as$c)fputs($f,pack("v*",$c));fclose($f);

2
आप एक अनुगामी के बजाय एक अग्रणी लाइन ब्रेक का उपयोग करके 2 बाइट्स बचा सकते हैं और इस प्रकार प्रतिध्वनि के बाद और वास्तविक लाइन ब्रेक का उपयोग करके जगह नहीं बचा सकते हैं \n
user59178

@ user59178 मुझे पता है। कृपया क्रिया नहीं।
टाइटस

5

MATL , 64 63 60 59 58 बाइट्स

49:',cxJr(v9hW&waHB`U=NL%)C9[$aoAN'F16ZaQEY"32e!' #'w)liX"

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

व्याख्या

कोड 16 × 16 बाइनरी मैट्रिक्स के पूर्व-संकुचित संस्करण का उपयोग करता है। प्री-कंप्रेसिंग (प्रोग्राम का हिस्सा नहीं) ने दो चरणों का उपयोग किया:

  1. मैट्रिक्स की रन-लंबाई एन्कोडिंग पंक्ति-प्रमुख क्रम (पहले भर में, फिर नीचे) में पढ़ी जाती है।
  2. परिणामी रन-लंबाई 1 से 16 तक होती है, इसलिए रन-लेंथ माइनस 1 का वेक्टर बेस 16 से बेस 94 में बदल दिया गया था (एकल उद्धरण को छोड़कर सभी मुद्रण योग्य एएससीआईआई कोड का उपयोग करने के लिए, जिसका उपयोग नहीं किया जाता है क्योंकि इसे भागने की आवश्यकता होगी)।

संकुचित स्ट्रिंग,

   ',cxJr(v9hW&waHB`U=NL%)C9[$aoAN'

बेस 94 से बेस 16 तक विघटित है:

                                   F16Za

रन-लेनघट्स प्लस 1 के प्राप्त वेक्टर को 2 से गुणा किया जाता है:

                                        QE

क्षैतिज स्ट्रेचिंग करने के लिए।

रन-लेनगेट्स के वेक्टर में 49 मान हैं। उन लंबाई के साथ दोहराई जाने वाली मूल संख्या [0 1 0 1 ... 0](49 प्रविष्टियां) होनी चाहिए । लेकिन इसके बजाय, यह वेक्टर का उपयोग करने के लिए कम है [1 2 ... 49], जो मॉड्यूलर अनुक्रमण के लिए समान रूप से मान्य होगा। तो रन-लेंथ डिकोडिंग है

49:                                       Y"

उत्पन्न वेक्टर के रन containis 1, 2... 49, 512 प्रविष्टियों की कुल के लिए। इसे 16 × 32 मैट्रिक्स में बदल दिया गया है:

                                            32e!

और ' #'एक एकल बम का उत्पादन करने के लिए स्ट्रिंग में मॉड्यूलर सूचक के रूप में उपयोग किया जाता है :

                                                ' #'w)

अंत में, इनपुट द्वारा दिए गए एक कारक द्वारा क्षैतिज पुनरावृत्ति वांछित परिणाम उत्पन्न करती है:

                                                      liX"

4

पायथन 2: 143 बाइट्स

n=input()
j=2
while j<258:print''.join(2*'# '[b>'0']for b in bin(int('62XI2JG3U2Q0COCDFCZAMC8A9LAP6W1ZMM4A59GC43M49ENF3Z',36))[j:j+16])*n;j+=16

यह विचारधारा पर है

(मैंने महसूस किया कि बेस 36 में मूल बम की प्रत्यक्ष एन्कोडिंग अजगर में छोटे कोड के लिए बनाई गई है।)

स्ट्रिंग को 1s और hashes के रूप में 0s के रूप में मानकर बनाया गया था, और फिर बेस 36 में परिवर्तित कर रहा था। यह कार्यक्रम फिर बाइनरी और स्लाइस को 16 की लंबाई में परिवर्तित करता है (अजगर के सामने '0b' के लिए 2 की एक ऑफसेट के साथ) बाइनरी स्ट्रिंग), डबल स्पेस और डबल हैश में परिवर्तित हो जाता है, उन्हें जोड़ देता है, स्ट्रिंग nबार और प्रिंट को दोहराता है ।


पिछला: पायथन 2, 169 166 163 बाइट्स

n=input()
j=0
while j<512:print''.join(' #'[i%2]*2*(v+1)for i,v in enumerate(int(c,16)for c in'31A00010F07010308024A4885A4A3C2703360245035876A25'))[j:j+32]*n;j+=32

यह विचारधारा पर है

लगभग मेरे जेली उत्तर का एक बंदरगाह ।


यदि यह छोटा है तो अक्षमता अच्छी है। नाइस +1
एल्पीड्रो

4

पायथन 2.7, 144 141 बाइट्स

x=input()
for i in range(16):print"".join(" #"[b<"1"]*2for b in bin(int("5ZCAZKAVTP6J04W4VZJ2BQDH5DASIKRS524V8SWRSIVWZEWC8V",36))[2+i::16]*x)

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

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


1
आप अपने आधार 36 नंबर से अग्रणी शून्य छोड़ सकते हैं।
जोनाथन एलन

@ जोनाथनअलन: अच्छा कैच। मैंने सोचा कि यह Oकिसी कारण से था ...
लाइनस

4

सी (जीसीसी) , 216 204 183 165 134 बाइट्स

b(n,i){for(n*=16,i=--n*16;i--;i%n||puts(""))printf(L"àϸ\x7fc\xfde\xfee`\x1fff\xffe\xffe\x7fcǰᇰ䡀\x80⤀\x600"[i/n]&1<<i%n%16?"##":"  ");}

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

स्टैंडअलोन प्रोग्राम के रूप में लिखा गया ( 201 183 151 बाइट्स)

i=16;main(j,l)char**l;{for(;i--;puts(""))for(j=*l[1]*16-769;j--;printf(L"àϸ\x7fc\xfde\xfee`\x1fff\xffe\xffe\x7fcǰᇰ䡀\x80⤀\x600"[i]&1<<j%16?"##":"  "));}

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

यदि कमांड लाइन पैरामीटर की आपूर्ति नहीं की जाती है तो यह अलग हो जाता है।


3

बैच, 415 बाइट्स

@echo off
set h=#####
set s=
for %%a in ("    ##%s%%s%" " # #  #%s%    " "%s%  #%s%   " "#  #    #%s%  " "  #%h%%s%" "%s% %h%%s%" "    %h%####   " "   %h%%h%#  " "   %h%%h%#  " "  %h%%h%### " "  %h%### #### " "   %h%## ###  " "   %h%# ####  " "    %h%####   " "%s%%h%##    " "%s%  ###%s% ")do call:l %1 %%a
exit/b
:l
set r=
for /l %%i in (1,1,%1) do call set r=%%r%%%~2
set r=%r: =  %
echo %r:#=##%

नोट: पंक्ति set s=5 स्थानों पर समाप्त होती है। गिनती को एक कमांड-लाइन पैरामीटर के रूप में स्वीकार करता है। बस बम की प्रत्येक पंक्ति के माध्यम से छोरों (5 समान वर्णों के रनों को हटाकर बहुत थोड़ा संकुचित) फिर प्रत्येक वर्ण को डुप्लिकेट करने से पहले वांछित रूप से बम को कई बार दोहराता है।


3

पायथन 2, 206 205 203 199 191 188 186 184 160 बाइट्स

z=input()
for y in 3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448:print"".join(" #"[e>0]*2for e in map(int,bin(y+8**6)[5:]))*z

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

संपादित करें

-1 बदलकर e==1करने के लिए e>0। मैं हमेशा उस एक को भूल जाता हूं।

-2 बाइनरी स्ट्रिंग की लंबाई को नजरअंदाज करके, 7 0 के पूर्ववर्ती और केवल अंतिम 16 तत्वों को ले रहा है। काम करता है के रूप में 7 से अधिक कभी नहीं 0 अग्रणी रहे हैं।

-4 क्योंकि अब मैं चर b का दूसरा संदर्भ खो चुका हूं, मैं इसे bin(y)[2:]सीधे मानचित्र कार्य में उपयोग कर सकता हूं, इसे जादू 200 से नीचे ले जा रहा है :-)

-8 दूसरी सूची में स्लाइस असाइनमेंट का उपयोग करके। आज शाम कुछ नया सीखा।

-3 @ जोनाथन के लिए धन्यवाद

-2 c=d=([0]*7+map(int,bin(y)[2:]))[-16:]होने के बजाय का उपयोग करकेc=d;

-2 फिर से @ जोनाथन को धन्यवाद

-24 धन्यवाद @Linus के साथ

उत्पादन

python bombs.py
2
        ####                            ####                    
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######  

" #"[e>0]*2काम करेंगे
जोनाथन एलन

DOH! मुझे वो कैसे याद आया ??? धन्यवाद @ जोनाथन
ElPedro

... कोष्ठक (...)भी जा सकते हैं (आरई: मेरी पिछली टिप्पणी के अनुसार)।
जोनाथन एलन

आप इसे 170 तक नीचे ले जा सकते हैंfor y in ...:print"".join(" #"[e>0]*2for e in(([0]*7+map(int,bin(y)[2:]))[-16:]))*z
जोनाथन एलन

@ जोनाथन फिर से धन्यवाद। यहाँ देर हो रही है इसलिए मैं कल के लिए उस परिवर्तन को बचाऊंगा ताकि मैं इसे पूरी तरह से गड़बड़ न करूँ।
एलपेड्रो

3

RProgN , 210 193 बाइट्स

0 = '' 1 = '##' को 1 = '' 0 = '' पर स्विच करके कुछ बाइट्स सहेजे, इसका मतलब है कि मुझे अतिरिक्त शून्य को वापस जोड़ने की आवश्यकता नहीं है। इसके अलावा, इसका मतलब है कि अब B64 स्ट्रिंग जो "MAFIA" कहा करती थी, यह दुखद है।

'n' = => 64 -B 2 B ] 1 16 sub n rep \ 17 32 sub n rep '
' \ . . '1' '  ' replace '0' '##' replace } a'' = D4D/4/'' a DgQ/AH'' a DAIeAj'' a DgA8AB'' a DwB+AD'' a DcH/wf'' a D+/29/'' a Dz/63/'' a

व्याख्या

'n' =                   # Associate the input with "n"
=>                      # Push a new function to the stack.
    64 -B               # Take the value from the top of the stack, convert it to an integer from Base64
    2 B                 # Take the value from the top of the stack, convert it from an integer to binary
    ]                   # Duplicate the top of the stack.
    1 16 sub            # Push the substring from the top of the stack between 1 and 16, 1 indexed.
    n                   # Push the input.
    rep                 # Repeat, this gives us 'n' bombs, essentially.
    \                   # Flip the values such that REPEATEDBOMB_ROW TEXT
    17 32 sub           # Push the substring between 17 and 32.
    n                   # Push the input
    rep                 # Repeat
    '                   # Push a new line
'                       # RProgN doesn't actually have escapes, so the raw newline is represented as a newline between qoutes.
    \ . .               # Flip the values so we have LINE1 NEWLINE LINE2, then concatenate them all into one string.
    '1' '  ' replace    # Replace all the 1's in the binary string with two spaces.
    '0' '##' replace    # Replace all the 1's with two '#'s
} a'' =                 # Associate the function with 'a'
D4D/4/'' a              # Bottom two lines,
DgQ/AH'' a              # Next two up,
DAIeAj'' a              # Etc...
DgA8AB'' a              # Once This is done, the memory stack is implicitly printed from top to bottom.
DwB+AD'' a              # As such, the bomb is upside down.
DcH/wf'' a              # Each of these numbers represents two lines, which is why we do the substringing to split it.
D+/29/'' a              # This works out saving a few bytes.
Dz/63/'' a              # Implicitly printed output. Yay.

बहुत लंबा, विस्तार, छपाई और संपीड़ित स्ट्रिंग का 105 बाइट्स है। थोड़ा अधिक गोल्फ हो सकता है, लेकिन कम से कम यह काम करता है।

इनपुट स्टैक पर निहित है, स्टैक को स्पष्ट रूप से मुद्रित किया गया है।

उत्पादन

        ####                            ####                            ####                    
  ##  ##    ##                    ##  ##    ##                    ##  ##    ##                  
              ##                              ##                              ##                
##    ##        ##              ##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########              ##      ##########          
            ##########                      ##########                      ##########          
        ##################              ##################              ##################      
      ######################          ######################          ######################    
      ######################          ######################          ######################    
    ##########################      ##########################      ##########################  
    ################  ########      ################  ########      ################  ########  
      ##############  ######          ##############  ######          ##############  ######    
      ############  ########          ############  ########          ############  ########    
        ##################              ##################              ##################      
          ##############                  ##############                  ##############        
              ######                          ######                          ######            

कोशिश करो!

<style>
  #frame{
    width:60em;
    height:60em;
    border:none;
  }
</style>
<iframe id='frame' src="https://tehflamintaco.github.io/Reverse-Programmer-Notation/RProgN.html?rpn=%27n%27%20%3D%20%3D%3E%2064%20-B%202%20B%20%5D%201%2016%20sub%20n%20rep%20%5C%2017%2032%20sub%20n%20rep%20%27%0A%27%20%5C%20.%20.%20%271%27%20%27%20%20%27%20replace%20%270%27%20%27%23%23%27%20replace%20%7D%20a%27%27%20%3D%20D4D%2F4%2F%27%27%20a%20DgQ%2FAH%27%27%20a%20DAIeAj%27%27%20a%20DgA8AB%27%27%20a%20DwB%2BAD%27%27%20a%20DcH%2Fwf%27%27%20a%20D%2B%2F29%2F%27%27%20a%20Dz%2F63%2F%27%27%20a&input=1">Sorry, You need to support IFrame. Why don't you..?</iframe>


3

PHP, 144 140 139 138 बाइट्स

नोट: Windows-1252 एन्कोडिंग का उपयोग करता है

for(;$j%=32*$argn or$r=intval(substr("01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow",$i++*3,3),36)*print~õ;)echo~ßÜ[$r>>$j++/2%16&1];

इस तरह से चलाएं:

echo 2 | php -nR 'for(;$j%=32*$argn or$r=intval(substr("01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow",$i++*3,3),36)*print~õ;)echo~ßÜ[$r>>$j++/2%16&1];'

या IBM-850 एन्कोडिंग (135 बाइट्स और प्रीटीयर परिणाम) का उपयोग कर:

echo 2 | php -nR 'for(;$j%=32*$argn or$r=intval(substr(~¤╬£¤══¤╠ö¤╚ø╬òÃ╬ò╦╔Ø╦£Æê£ÆêÅ×╦ÉùÉØèÿ£ÃÉ╔Ø╦╠╦ê¤Éê,$i++*3,3),36)*print~§;)echo~▀M[$r>>$j++/2%16&1];'

        ▓▓▓▓                            ▓▓▓▓                    
  ▓▓  ▓▓    ▓▓                    ▓▓  ▓▓    ▓▓                  
              ▓▓                              ▓▓                
▓▓    ▓▓        ▓▓              ▓▓    ▓▓        ▓▓              
    ▓▓      ▓▓▓▓▓▓▓▓▓▓              ▓▓      ▓▓▓▓▓▓▓▓▓▓          
            ▓▓▓▓▓▓▓▓▓▓                      ▓▓▓▓▓▓▓▓▓▓          
        ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓              ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓      
      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓          ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓    
      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓          ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓    
    ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  
    ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓  
      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓          ▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓    
      ▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓          ▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓    
        ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓              ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓      
          ▓▓▓▓▓▓▓▓▓▓▓▓▓▓                  ▓▓▓▓▓▓▓▓▓▓▓▓▓▓        
              ▓▓▓▓▓▓                          ▓▓▓▓▓▓            

व्याख्या

यह कोई भी बाइनरी सामान नहीं करता है और बाहरी फ़ाइल की आवश्यकता नहीं है।

हर 16 बिट संख्या को उल्टा किया जाता है, फिर बेस -36 नंबर के रूप में एन्कोड किया जाता है, 0यदि आवश्यक हो तो एक अग्रणी के साथ गद्देदार , इसलिए प्रत्येक 16 बिट्स का परिणाम 3 बाइट्स होता है। उन परिणामों को समझने में 01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow। कोड प्रक्रिया को उलट देता है इसलिए बमों को सही Nसमय पर प्रिंट किया जाता है।

बदलाव

  • केवल एक ही लूप का उपयोग करके 4 बाइट्स सहेजे गए
  • प्रत्येक पुनरावृत्ति के लिए एक ही चार्ट को मुद्रित करने और टर्नरी के बजाय स्ट्रिंग इंडेक्स का उपयोग करके एक बाइट को बचाया
  • के $jसाथ लाइन सीमाओं पर शून्य पर रीसेट करके एक बाइट को बचाया %=। इससे कोष्ठक से छुटकारा मिलता है
  • का उपयोग करके 2 बाइट्स सहेजे गए $argn

3

जीसीसी सी 129 बाइट्स

ISO8859 / ASCII

f(r,i,d){
    for(;i<32;i+=2,puts(""))
        for(d=15*r;--d;)
             printf((*(int*)&("ÿóÿ­ÿþoÜüðààÀ!ÀCÀCàðø?þ"[i]))&(1<<d%15)?"  ":"##");
}

एक पंक्ति में:

f(r,i,d){for(;i<32;i+=2,puts(""))for(d=15*r;--d;)printf((*(int*)&("ÿóÿ­ÿþoÜüðààÀ!ÀCÀCàðø?þ"[i]))&(1<<d%15)?"  ":"##");}

साथ दौड़ो:

main(c,v)char**v;{f(atoi(v[1]),0)}

ISO8859-x (ASCII) के रूप में संकलित स्रोत।

NB ó NBo üðààÀÀ! ÐCàCþøÜ? अदृश्य ASCII कोड होना चाहिए, लेकिन जिस तरह से StackExchange अपनी सामग्री प्रस्तुत करता है, उसके कारण यह टूट गया है। कृपया उचित परीक्षण एन्कोडिंग के लिए विचार लिंक देखें वैकल्पिक रूप से मूल ASCII स्ट्रिंग यहां है: https://github.com/claydonkey/AtariBombs/blob/master/ISO8859_REPR2.txt

व्याख्या

पहले बमों के हेक्स प्रतिनिधित्व का रूपांतरण [f3 ff ad ff fe ff 6f 7f dc 1f fc 1f f0 07 e0 03 e0 03 c0 01 c0 21 c0 43 e0 43 f0 07 f8 0f fe 3f] UTF-8 (में) UTF-8 संस्करण संकलक स्ट्रिंग को वाइड चार ऐरे के रूप में संग्रहीत करता है - रनटाइम पर प्रत्येक वर्ण के लिए 2 या 4 बाइट्स लेकिन यह अकादमिक है)। जबकि UTF-8 वर्णों को 2-4 बाइट्स के रूप में संग्रहीत किया जाएगा, ये सभी मान ISO-8859-1 (ASCII) के भीतर हैं और इस प्रकार केवल 1 बाइट की आवश्यकता होती है। साथ ही इसे ISO-8859-x के रूप में संग्रहीत किया जाना सुरक्षित है (कोई 0x8_ या 0x9_ मान नहीं हैं)। इसलिए पाठ ISO-8859 में 32 बाइट्स खाता है और रूटीन कुल मिलाकर 135 बाइट्स खाता है।

(एनबी चौड़े चरों को विंडोज़ में 16 बिट पूर्णांक और लिनक्स में 32 बिट के रूप में संग्रहीत किया जाता है लेकिन फिर से यह कार्य हाथ में करने के लिए अप्रासंगिक है)

कैविएट: सभी वर्ण प्रदर्शन योग्य नहीं हैं (0x20 से नीचे के नियंत्रण वर्ण)। वे अभी भी मौजूद हैं। अधिकांश वेब पेज utf-8 / 8859/1253 ( https://w3techs.com/technologies/overview/character_encoding/all ) हैं, इसलिए मेरा मानना ​​है कि यह वैध है ( ASCII को प्रिंट करने के लिए 0x20 से नीचे के सभी मानों को ठीक करना चाहिए)।

UTF-8

यहाँ UTF-8 एन्कोडेड स्रोत के साथ मूल पोस्टिंग के करीब संस्करण है। यह 173 बाइट्स का उपभोग करता है। स्रोत के 50 बाइट्स स्वयं स्ट्रिंग। यह रूटीन भी लंबा है क्योंकि ASCII बाइट्स अब 16bit / 32bit वाइड चार्ज के लिए 0 के पेडिंग के साथ संग्रहित किए गए हैं और ऊपर दिए गए uint16_t के लिए डाली के बजाय शिफ्ट किए जाने हैं। मैंने इसे बनाए रखा है क्योंकि इसे ideone के साथ सत्यापित किया जा सकता है जो UTF-8 एन्कोडिंग का उपयोग करता है।

*w=L"óÿ­ÿþÿoÜüðààÀÀ!ÀCàCðøþ?";
f(r,i,j,m){
    for(i;i<32;i+=2,puts(""))
        for(j=r;j--;)
            for(m=65536;m>1;(m\=2,printf(((w[i]<<8)+w[i+1]&m)?"  ":"##")));}

साथ दौड़ो:

main(c,v)char**v;{f(atoi(v[1]),0)}  

यदि आप अपने मूल्य में 16bit पूर्णांक के लिए निहित मूल्य निर्धारित कर सकते हैं तो आप वाइड चार्ज के wchar_t प्रकार घोषणा को छोड़ सकते हैं। Ideone शिकायत नहीं करता है इसलिए मुझे लगता है कि यह जाना अच्छा है।

इसे आइडोन पर आज़माएं


प्रभावशाली। यह किस एन्कोडिंग का उपयोग करता है?
डीजेएमकेम

इसकी गणना मिनगॉव जीसीसी पर की गई है जहां एक विस्तृत चरित्र एक यूआईएन 16 है। इसलिए एन्कोडिंग [16-बिट प्रकार की होल्डिंग UTF-16 यूनिकोड] है। हालांकि, मुझे लगता है कि क्योंकि वर्ण 0xFF (16 बिट) के भीतर हैं, वे ASCII विस्तारित हैं। + इसलिए कुछ खास नहीं
मिट्टी के बर्तनों

क्षमा करें, मैंने एन्कोडिंग के बारे में अधिक जानकारी प्राप्त की है और हो सकता है कि इसे गलत तरीके से संग्रहीत किया जा रहा हो क्योंकि यह UTF-16.please ओवरहॉल्ड उत्तर को संदर्भित करता है।
क्लेडोनकी

2

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

प्रकार के साथ एक समारोह के रूप में Int -> String:

b z=concat$do y<-[0..15];"\n":[if odd$div 0x3800FE01FF03DF83BF87BFC7FFC3FF83FF81FF007C007C401090080004A0030(2^(16*y+x))then"##"else"  "|x<-[1..z]>>[0..15]]

IO पर सीधे प्रिंट करने पर 5 बाइट्स खर्च होंगे (या 6 यदि हम IO ()इसके बजाय वापस लौटना चाहते हैं IO [()]):

b z=mapM putStr$do y<-[0..15];"\n":[if odd$div 0x3800FE01FF03DF83BF87BFC7FFC3FF83FF81FF007C007C401090080004A0030(2^(16*y+x))then"##"else"  "|x<-[1..z]>>[0..15]]

2

सी, 175 बाइट्स

 x[]={48,74,128,265,1988,1984,8176,16376,16376,32764,31740,15352,15864,8176,4064,896};f(z,p){while(z++<16){p=1;while(p<<=1){printf("%s",p&(x[z]<<16|x[z])?"##":" ");}puts("");}}

प्रत्येक एक्स को अपने आप में समेटता है और प्रत्येक लाइन को समाप्त करने के लिए p अतिप्रवाह बनाता है।


आह, मैंने लिखने के लिए प्रिंटफ़ () को बदल दिया है जब गोल्फिंग और इसे तोड़ दिया। यहाँ परीक्षण करें ideone.com/JtHInD

2

जावा, 228 बाइट्स

import static java.lang.System.out;

public class Bombs
{
    public static void main(String[] args)
    {
        new Bombs().d(2);
        new Bombs().d(3);
        new Bombs().d(4);
    }

    void d(int n){String s="";for(int x=16,r=0;r<16*n;x=16,s+=(++r%n==0?"\n":""))while(--x>=0)s+=((new int[]{1536,10496,128,18496,4592,496,2044,4094,4094,8191,8175,4078,4062,2044,1016,224}[r/n])&(1<<x))==0?"  ":"##";out.println(s);}

}

1
मैं जानता हूँ कि यह एक साल हो गया है, लेकिन आप इस के लिए यह गोल्फ कर सकते हैं: n->{String s="";for(int x,r=0;r<16*n;s+=(++r%n<1?"\n":""))for(x=16;x-->0;)s+=((new int[]{1536,10496,128,18496,4592,496,2044,4094,4094,8191,8175,4078,4062,2044,1016,224}[r/n])&(1<<x))<1?" ":"##";return s;}( 205 बाइट्स ) के अलावा एक जावा 8 लैम्ब्डा का उपयोग करने से, मैं बदलकर अधिक बाइट्स कम किया है: की स्थिति x=16(और बदल whileकरने के लिए for); 2x ==0को <1; sइसे छापने के बजाय लौटाना (आयात भी बाइट-काउंट btw .. का हिस्सा है); --x>=0को x-->0। फिर भी, महान जवाब, तो +1!
केविन क्रूज़सेन

@KevinCruijssen धन्यवाद (इसे स्वयं के उत्तर के रूप में पोस्ट करने पर विचार करें)। मैं कोडगोल्फ पर यहाँ सक्रिय नहीं हूँ, और इस तरह नियमों के बारे में निश्चित नहीं हूँ, लेकिन मुझे लगता है कि ज्यादातर मामलों में, केवल फ़ंक्शन के बाइट्स की गिनती (और आयातों की अनदेखी) की अनुमति है।
मार्को 13

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

2

जे, 89 बाइट्स

|:@;@#&(<' #'{~2#|:16 16$}.2#.inv 95#.32x-~3 u:'u,:C>%}UwPXHn_C9wF.|U ap<{jH%O9 9wRThGs')

स्ट्रिंग को आधार -95 संख्या के रूप में एनकोड करता है, प्रत्येक अंक को बढ़ाता है 32, फिर एक एससीआई स्ट्रिंग द्वारा इसका प्रतिनिधित्व करता है।

व्याख्या

यह दो मुख्य भागों से बना है। बम का निर्माण, और वास्तविक पुनरावृत्ति है। आइए फिलहाल बम के रूप में देखें b। फिर, कोड इस तरह दिखता है:

|:@;@#&(b)

जब इनपुट के साथ बुलाया जाता है k, तो यह इसके बराबर होता है:

|: ; (k#b)

bएक बॉक्स्ड बम है, इसलिए k#bबनाता है kकी पुनरावृत्ति b, ;यह खड़ी सपाट, और|: परिणाम को स्थानांतरित करता है। (बमb का निर्माण खुद ही किया जाता है।)

अब, यहाँ बम है:

<' #'{~2#|:16 16$}.2#.inv 95#.32x-~3 u:'u,:C>%}UwPXHn_C9wF.|U ap<{jH%O9 9wRThGs'

निम्नलिखित स्ट्रिंग एक ऑफसेट के साथ एक बेस -95 एन्कोडेड स्ट्रिंग है 32, ताकि सभी वर्ण ASCII रेंज में आते हैं, और शुक्र है 'कि कोई भी ऐसा नहीं है जिसे भागने की आवश्यकता हो। 3 u:स्ट्रिंग के चार कोड प्राप्त करता है, 32x-~प्रत्येक संख्या को एक ई- xटेंडर संख्या बनाता है और 32उससे घटाता है; 95#.एक आधार -95 संख्या में 2#.invधर्मान्तरित यह एक द्विआधारी अंक सरणी में कनवर्ट करता है। मैंने 1इसे एक ठोस संख्या बनाने के लिए बाइनरी में एक अग्रणी जोड़ा , इसलिए मैं इसे बंद कर देता हूं }.। मैं एक 16x16 तालिका में सरणी को आकार देता हूं और 16 16$फिर इसका उपयोग करके स्थानांतरित करता हूं |:। (बाद के लिए संभव गोल्फ: शाब्दिक एन्कोडेड स्ट्रिंग को स्थानांतरित करें।) 2#प्रत्येक वर्ण चौड़ाई-वार डुप्लिकेट करता है। हमें 0s और 1s की तालिका के साथ छोड़ दिया गया है ।' #'{~नक्शे 0को रों ' 'और 1करने के लिए '#'। इस प्रकार, हम अपने बम के साथ रह गए हैं।

परीक्षण का मामला

   |:@;@#&(<' #'{~2#|:16 16$}.2#.inv 95#.32x-~3 u:'u,:C>%}UwPXHn_C9wF.|U ap<{jH%O9 9wRThGs') 3
        ####                            ####                            ####
  ##  ##    ##                    ##  ##    ##                    ##  ##    ##
              ##                              ##                              ##
##    ##        ##              ##    ##        ##              ##    ##        ##
    ##      ##########              ##      ##########              ##      ##########
            ##########                      ##########                      ##########
        ##################              ##################              ##################
      ######################          ######################          ######################
      ######################          ######################          ######################
    ##########################      ##########################      ##########################
    ################  ########      ################  ########      ################  ########
      ##############  ######          ##############  ######          ##############  ######
      ############  ########          ############  ########          ############  ########
        ##################              ##################              ##################
          ##############                  ##############                  ##############
              ######                          ######                          ######

2

बाकोन , 229 227 195 बाइट्स

उदासीनता के लिए BASIC में योगदान। चर 'a' बमों की मात्रा निर्धारित करता है।

a=2:FOR x=0 TO 15:FOR y=1 TO a:FOR i=15 DOWNTO 0:?IIF$(v[x]&INT(POW(2,i)),"##","  ");:NEXT:NEXT:?:NEXT:LOCAL v[]={3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448}

आउटपुट :

        ####                            ####                    
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######            

2

हास्केल, 191 181 बाइट्स

f n=h n:f(div n 2)
h n|odd n=' '
h _='#'
g b=mapM_ putStrLn[[f 0xfc7ff01fe00fc207c40784038003c007c007e00ff83ff83bfef6ff7fffb5ffcf!!(x`mod`32`div`2+y*16)|x<-[0..32*b-1]]|y<-[0..15]]

2

सी (अटारी टीओएस 2.06 यूएस), 129 124 117 113 बाइट्स

short*a=0xe013b0;main(j,l)char**l;{for(;*a++-224;puts(""))for(j=*l[1]*16-768;j--;printf(*a&1<<j%16?"##":"  "));}

यह टीओएस रोम से बम बिटमैप का उपयोग करता है, जो प्रश्न में एक से थोड़ा अलग है। टीओएस के अन्य संस्करणों के लिए, आपको बताए गए पते को समायोजित करना होगा*a । ध्यान दें कि कुछ एमुलेटर रोम में बम बिटमैप शामिल नहीं है!

यदि आप एक कमांड लाइन तर्क प्रदान नहीं करते हैं, तो कई उच्च रिज़ॉल्यूशन वाले बिटमैप मैप किए जा सकते हैं :-)


1

सी ++ 11, 252 बाइट्स

#include <iostream>
using namespace std;string d("01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow");int main(){for(int i=0;i!=45;i+=3){int z=stoi(d.substr(i,3),NULL,36);for(unsigned long p=1;p!=1<<31;p<<=1){cout<<(((z<<16|z)&p)?"##":"  ");}puts("");}}

1

स्माइलबासिक, 127 बाइट्स

INPUT N
FOR J=0TO 15FOR K=1TO N
FOR I=0TO 14?" #"[1AND ASC("xxxxxxxxxxxxxxx"[I])>>J]*2;
NEXT
NEXT?NEXT

स्क्रीनशॉट
(
डबल वर्णों के बिना संस्करण का स्क्रीनशॉट) एसबी में एक वर्ग फ़ॉन्ट है, इसलिए वर्णों को दोगुना करना बुरा लगता है (और स्क्रीन पर फिट नहीं होता है)
गैर-एएससीआईआई पात्रों को प्रतिस्थापित किया गया है x
हेक्स मान: 0008,0002,0610,1F8A,3FC1,7FC1,7FF2,FFF4,FFF8,EFF0,73F0,7FC0,3FC0,1F80,0600
चूंकि एसबी UTF-8 में फ़ाइलों को बचाता है, इनमें से कुछ की गिनती 2 या 3 बाइट्स के रूप में होती है।


@Arnauld मुझे SmileBASIC के बारे में ज्यादा जानकारी नहीं है, लेकिन यह देखते हुए कि इसमें एक लूप FOR K=1TO Nहै INPUT N, मुझे लगता है कि यह इनपुट में दिए गए बमों की संख्या को प्रदर्शित करता है। हालाँकि, मुझे कहना होगा कि वर्ग फ़ॉन्ट के बावजूद, मेरा मानना ​​है कि आवश्यकताओं के अनुरूप (अन्य उत्तरों पर लाभ से बचने के लिए) पात्रों को अभी भी दोगुना किया जाना चाहिए। आप एक अच्छे दिखने वाले समाधान के लिए वर्तमान को रख सकते हैं, लेकिन मुझे लगता है कि आपको अभी भी एक सही समाधान जोड़ना चाहिए। यदि आप इसे जोड़ते हैं, तो मैं UTF-8 वर्णों के रचनात्मक उपयोग के लिए तैयार रहूँगा!
२३

@AlexL। हां, मेरी टिप्पणी कोड अपडेट से पहले थी।
अरनौलद

1

रूबी 2.x (लैम्ब्डा) - 157 बाइट्स

शायद आगे गोल्फ हो सकता है, लेकिन मुझे यह संस्करण पसंद है:

->n{puts "0c0052000100908023e003e00ff81ffc1ffc3ffe3fde1fdc1fbc0ff807f001c0".scan(/.{4}/).map{|x|(("%016b"%x.to_i(16)).tr("10","# ").chars.map{|c|c+c}*"")*n}}

पायथन संस्करण (ओं) के समान विचार: हेक्साडेसिमल एन्कोडेड बम के तार को 4 वर्णों के वर्गों में तोड़ें, बाइनरी में कनवर्ट करें, अनुवाद 1करें #और 0में , हर चरित्र को दोगुना, और जिसके परिणामस्वरूप सरणी मुद्रित करें।

ध्यान दें कि सरणी को प्रिंट करने के लिए उपयोग किया जाता है। यह एरे को प्रति लाइन एक लाइन प्रिंट करेगा।


1

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

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

Cells.RowHeight=48:For i=0To[A1-1]:[A4,B2,C5,D4,D2,E1:F1,G2,H3,I4,G5:K6,E7:M7,D8:N9,C10:J11,K10:O10,O11,L11:N13,K13:K15,L14:L15,M14,D12:I13,J12,E14:G14,F15:G15,H14:J16].Offset(,16*i).Interior.Color=0:Next

उत्पादन

Babomb

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