ভূমিকা

Atari -এ এসটি মাঝামাঝি 80 এর থেকে বরং একটি জনপ্রিয় ব্যক্তিগত কম্পিউটার গোড়ার দিকে 90-এর যুগ, একটি মটোরোলা 68000 মাইক্রোপ্রসেসর দ্বারা চালিত ছিল। এই মেশিনে, অপ্রচলিত সিপিইউ ব্যতিক্রমগুলির জন্য অপারেটিং সিস্টেমের ডিফল্ট আচরণটি ছিল নীচের ছবিতে প্রদর্শিত পর্দায় বোমাগুলির সারি প্রদর্শন করা:

_{সূত্র: https://commons.wikimedia.org/wiki/File:Row_of_bombs.png}
_{এনবি: ওএস সংস্করণ অনুসারে বোমার গ্রাফিক্স কিছুটা আলাদা হতে পারে। তবে এর একটিকে রেফারেন্স হিসাবে নেওয়া যাক।}

বোমা সংখ্যা ব্যতিক্রম ভেক্টর উপর নির্ভর করে, সবচেয়ে সাধারণ:

(8 008) বাসের ত্রুটি: 2 টি বোমা
($ 00c) ঠিকানার ত্রুটি: 3 টি বোমা
(10 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 টি সারি থাকবে । সমস্ত বোমা টাইলস পাশাপাশি রাখতে হবে। শীর্ষস্থানীয় স্থানগুলি নিষিদ্ধ। ট্রেলিং স্পেসগুলিও নিষিদ্ধ, প্রকৃতপক্ষে বোমা টাইলের অংশ হিসাবে (যেমন 31 তম এবং 32 তম কলাম) অবশ্যই উপস্থিত থাকতে হবে। আপনি একের অধিক নেতৃস্থানীয় লাইন-ব্রেক এবং একের বেশি লম্বালম্বি বিরতি অন্তর্ভুক্ত করতে পারেন।

উদাহরণ

নীচে দুটি বোমার রেফারেন্স আউটপুট দেওয়া আছে, যেখানে বাধ্যতামূলক লাইন-ব্রেকগুলি চিহ্নিত করা হয় \nএবং অতিরিক্ত লাইন-ব্রেকগুলি সহ্য করা হয় (\n):

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

(অবশ্যই, অন্যান্য লাইন-ব্রেক ফর্ম্যাট যেমন \rবা \r\nঠিক তেমন ব্যবহার করা যেতে পারে))

বিধি

এটি কোড-গল্ফ, তাই বাইটের মধ্যে সংক্ষিপ্ত উত্তর ins স্ট্যান্ডার্ড লুফোলগুলি নিষিদ্ধ।

code-golf ascii-art kolmogorov-complexity

— Arnauld
সূত্র

আমি লক্ষ্য করেছি যে আপনি অ-এসসিআইআই-আর্ট ফর্মগুলি বাদ দিয়েছেন, সুতরাং একটি আটারি এসটি মেশিন-কোড ফাংশন যা সঠিক সংখ্যক বোমার সাথে ক্র্যাশ হয় তা গণনা করা হয় না। (বোমাটি ফন্টে নেই, তবে আটারি এসটি-এর স্থানীয় চরিত্রের সেটটিতে মজাদার / ইস্টার-ডিমের গ্লাইফ রয়েছে, ২৮-৩৩ অক্ষরের সাথে বিদ্রূপকারী চার্চের জেআর "বব" ডবসের চিত্র গঠন করে) সাবজিনিয়াসের: আমি মনে করি এমন একটি প্রোগ্রাম লিখেছিলাম যা এই 4 টি গ্লাইফকে এলোমেলো স্ক্রিন পজিশনে স্প্যামযুক্ত করে টেক্সট-অঙ্কন সিস্টেম কল ব্যবহারের খুব প্রাথমিক অনুশীলন হিসাবে :)

— পিটার কর্ডেস

1

@ পিটারকর্ডস - এটি ঠিক, এটি অবশ্যই ASCII হওয়া উচিত। তবে, আপনাকে এসটি রম থেকে বোমা গ্রাফিকগুলি পড়ার অনুমতি দেওয়া হবে কারণ কোনও নিয়ম নেই যা আপনাকে এটি করতে বাধা দেয়। (কেবল এটির টিওএস সংস্করণটি উল্লেখ করুন যা এটি কাজ করার কথা।)

— আর্নল্ড

1

ওহ বাহ, এটি স্মৃতি ফিরিয়ে দেয়। আমার প্রথম কম্পিউটারটি ছিল আটারি এসটি। আমার মনে আছে ভয়ঙ্কর বোমাগুলি।

— রড

পাশে: "বোমার সংখ্যা ব্যতিক্রম ভেক্টরের উপর নির্ভর করে" - কি বলুন ?! তারা আসল কোড / ত্রুটি আউটপুট করতে না পারার কোনও কারণ? (কখনও একটি এসটি ছিল আমি অ্যামিগার মত শিবির ... "গুরু ধ্যান" এবং যা থেকে আছি।)

— MrWhite

20

জেলি , 43 44 বাইট

+1 বাইট - অক্ষরগুলি দ্বিগুণ করতে ভুলে গেছেন (এমন কেউ দেখেছেন না!)

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

TryItOnline

কিভাবে?

প্রস্তুতিটি মূল চিত্রটির একটি রান-লেন্থ এনকোডিং হিসাবে ডেটা সংকোচিত করা ছিল:

প্রতিটি রান দৈর্ঘ্য গণনা 1গুলি (স্থান) অথবা 0ছবিতে গুলি (হ্যাশ), নতুন লাইন উপেক্ষা - একটি তালিকা উৎপাদ: [4,2,11,1,1,...];
প্রতিটি সংখ্যা থেকে একটি করে বিয়োগ - এটি একটি পরিসর দেয় [0,15];
এটি একটি বেস -১ number সংখ্যা হিসাবে বিবেচনা করুন (মূল্যগুলি গণনা করুন, বিপরীতে vসূচকের সাথে iএবং সমষ্টি 16**i*v= 19468823747267181273462257760938030726282593096816512166437);
বেস-250 এই রূপান্তর করুন: [5,119,249,42,...];
জেলির কোড পৃষ্ঠাতে সূচি হিসাবে মানচিত্র: ¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P

এখন কোডটি এই সংখ্যাটি মূল্যায়ন করে, 1s এবং 0গুলিকে মানচিত্র এবং হ্যাশ অক্ষরগুলিতে * মানচিত্র করে , প্রতিটিকে দ্বিগুণ করে, লাইনে বিভক্ত হয় এবং প্রতিটিকে যথাযথ সংখ্যার পুনরাবৃত্তি করে।
* বাস্তবে বাস্তবায়নটি বাইটস সংরক্ষণের জন্য মডুলো 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 বাইট

ব্যবহার সিপি-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

— Emigna
সূত্র

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

এটি অনলাইনে চেষ্টা করুন।

— PurkkaKoodari
সূত্র

11

জাভাস্ক্রিপ্ট (ES6), 159 154 140 136 বাইট

@ হেডি এবং @ আর্নল্ডকে ধন্যবাদ প্রচুর বাইট সংরক্ষণ করেছে

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

এটি 104 অক্ষর, তবে (দুঃখের সাথে) 136 ইউটিএফ -8 বাইট। এই স্নিপেটের সাথে স্ট্রিং তৈরি করা হয়েছিল:

কোড স্নিপেট দেখান

console.log([
0b1111111111001111,
0b1111111110110101,
0b1111111101111111,
0b1111111011110110,
0b1111100000111011,
0b1111100000111111,
0b1110000000001111,
0b1100000000000111,
0b1100000000000111,
0b1000000000000011,
0b1000010000000011,
0b1100010000000111,
0b1100001000000111,
0b1110000000001111,
0b1111000000011111,
0b1111110001111111
].map(x=>(65535-x).toString(16)).join(","))

স্নিপেট প্রসারিত করুন

.replaceপরিবর্তে ব্যবহার [...string].mapকরা সমান দীর্ঘ:

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

কিভাবে এটা কাজ করে

যেহেতু কাঁচা তথ্যের প্রতিটি সারি 16-বিট সংখ্যা হিসাবে উপস্থাপিত হতে পারে, তাই আমরা পুরো ফাইলটি 16-স্ট্রিং স্ট্রিংয়ে সঞ্চয় করতে পারি। সংক্ষেপণ অ্যালগরিদম প্রতিটি বাইনারি সারি নিয়ে যায়, এটিকে উল্টায় এবং এটিকে বিপরীত করে (যেহেতু মূল প্রতিটা সারি 0 তে শেষ হয় , পরিবর্তিত সংস্করণে প্রতিটি সারি এখন 1 দিয়ে শুরু হয় ), তারপরে এটি একটি চরকে রূপান্তরিত করে এবং ফলস্বরূপ অক্ষরগুলিকে একত্রিত করে ।

এটি সঙ্কুচিত করতে, আমাদের চারকোডটি বের করতে হবে এবং এর বাইনারি উপস্থাপনাটিকে হ্যাশ এবং স্পেসের স্ট্রিংয়ে রূপান্তর করতে হবে। এটি পুনরাবৃত্ত ফাংশন দিয়ে করা যেতে পারে, যেমন:

(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 এর কাছাকাছি কোথাও আসে না ...

— ETHproductions
সূত্র

এর +x?'##':' 'পরিবর্তে কিছু বাইট সংরক্ষণ করতে পারে" #"[x].repeat(2)

— হেডি

@ হেইডি ধন্যবাদ, আমি জানতাম যে কিছুটা গল্ফ করার একটা উপায় আছে।

— ETH প্রোডাকশনগুলি

2

x.charCodeAt()বাইনারি রূপান্তরিত করার পরিবর্তে আপনি সরাসরি বিট পরীক্ষা করতে পারবেন? (আমি মনে করি এটি প্রায় 8 বাইট সাশ্রয় করবে।)

— আর্নল্ড

2

আপনার সংক্ষেপণ অ্যালগরিদম প্রায় ক্রিপ্টোগ্রাফিক শোনায় ।

— জাস্টিন

1

@ জাস্টিন ড্যাম, আমি এই বিষয়ে মন্তব্য করতে চলেছিলাম।

— ব্যবহারকারী 253751

10

এমএস-ডস .কম ফাইল, 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

--- সম্পাদনা ---

আমি উল্লেখ করতে ভুলে গেছি: প্রোগ্রামটি অবশ্যই নিম্নলিখিত কমান্ড লাইনের মাধ্যমে শুরু করা উচিত:

সিওএম ফাইলের নাম + ঠিক একটি স্থানের অক্ষর + বোমার সংখ্যা (1-9)

— মার্টিন রোজেনাউ
সূত্র

1

খুশী হলাম। আমরা এখনও একটি 68000 উত্তর অভাব বোধ করছি, কিন্তু এটি উত্তর নিকটবর্তী হয়। :-)

— আর্নল্ড

objdump -dwকাঁচা বাইনারি প্রদর্শন করার জন্য আউটপুট একটি ভাল উপায়, যেহেতু আপনি দেখেন যে কোন বাইট কোন নির্দেশ। আমি এটি জিসিডি এবং অ্যাডলার 32 উত্তরের জন্য করেছি। (পাশাপাশি লোকেরা নিজেরাই চেষ্টা করার জন্য মন্তব্য করা সোর্স কোড সহ।)

— পিটার কর্ডেস

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 এ চেষ্টা করুন!

ফ্লাই-এ ফ্লাইংয়ের তালিকা তৈরি করার পরিবর্তে, একটি হার্ড-কোডড হেক্সাডেসিমাল স্ট্রিং রয়েছে যা সূচকযুক্ত এবং বাইনারিতে রূপান্তরিত হয়; তারপরে প্রতিটি বাইনারি অঙ্কটি হয় হয় ' 'বা '#', যা নকল হয়ে যায় এবং একসাথে যোগ হয় ... ইত্যাদি is

প্রথম পদ্ধতির:

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সময়, পরে নতুন লাইনের সাথে যুক্ত হয়ে স্পেস দিয়ে প্যাড করা হয় ।

— Hactar
সূত্র

আপনি এতে যোগদানের পরিবর্তে একটি অনিবন্ধিত জেনারেটর মুদ্রণ করে একটি বাইট সংরক্ষণ করতে পারেন '\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
        ####                            ####                        
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                    
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######

— cleblanc
সূত্র

এই হেক্স সংখ্যার দশমিক উপস্থাপনা ব্যবহার করে আপনি কয়েকটি বাইট সংরক্ষণ করতে পারেন 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 বোমার প্রতিটি লাইন যথাক্রমে
এস এর অর্থ 2 স্পেস
s এর অর্থ 4 স্পেস
* এর অর্থ 6 স্পেস
q এর অর্থ 8 স্পেস
টি মানে ## (2)
টি মানে #### (4)
^ মানে ##### # ())
আর এর অর্থ ######### (8)
এবং মানে ################# (16)
বেশিরভাগ কোড বোমাটি মুদ্রিত হয়েছে কিনা তা নিশ্চিত করছে পাশাপাশি পাশাপাশি, একে অপরের উপরে নয়।

— boboquack
সূত্র

5

সিজেম , 66 বাইট

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

এটি অনলাইন চেষ্টা করুন! (মনে রাখবেন যে কোডটিতে কিছু ছাপানো অক্ষর নেই))

স্পেসের জন্য 1 ব্যবহার করে বাইনারিতে একটি নম্বর হিসাবে এনকোড করা বোমা (1 হিসাবে শীর্ষস্থানীয় স্থানটি নিশ্চিত করে যে আমাদের বাইনারি উপস্থাপনাগুলি প্যাড করতে হবে না), স্থানান্তরিত এবং তারপরে বেস -136 এ স্ট্রিংয়ে রূপান্তরিত হয় (যা সবচেয়ে সংক্ষিপ্ত স্ট্রিং উত্পাদন করে) বিস্তৃত অক্ষর ছাড়া)। এই পদক্ষেপগুলি এখানে খেলতে পারেন ।

এই উত্তরটি তখন এনকোডিংকে বিপরীত করে, ট্রান্সপোস করার আগে বোমাটির পুনরাবৃত্তি করার মূল কৌশলটি, বোম্বের প্রতিটি লাইনকে একবারে কার্যকরভাবে কাটানো। প্রতিটি লাইনের অক্ষরগুলি চূড়ান্ত আউটপুটটির জন্য সন্নিবেশ করা নতুন লাইনের সাথে দ্বিগুণ করা যেতে পারে।

— লিনাস
সূত্র

5

পিএইচপি, 138 104 + 32 = 136 বাইট

আমি কখনই ভাবিনি যে fileএটি বাইনারি নিরাপদ। আমি কেবল চাই যে আমি ডেটা সঞ্চয় করার আরও আকর্ষণীয় উপায়টি খুঁজে পেতাম; কিন্তু কিছুই আমি কাঁচা বাইনারি বীট চেষ্টা।

foreach(unpack("v*",file(b)[0])as$v)echo"
",str_repeat(strtr(sprintf("%016b",$v),["  ","##"]),$argv[1]);

ফাইল থেকে বাইনারি ডেটা পড়ুন, সামান্য এন্ডিয়ান 16 বিট থেকে ইনট অ্যারেতে প্যাক করুন
অ্যারে মাধ্যমে লুপ: STRING মুদ্রণ 16 অঙ্কের বাইনারি, প্রতিস্থাপন 0, 2 ব্যবধান সহ 1সঙ্গে ##,
পুনরাবৃত্তি $argv[1]বার, মুদ্রণ ফলাফলের + + সম্পর্কে newline

সাথে চালানো -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।

— ব্যবহারকারী59178

@ user59178 আমি জানি। অনুগ্রহপূর্বক ভার্বোস না

— টাইটাস

5

এমএটিএল , 64 63 60 59 58 বাইট

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

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

কোডটিতে 16 × 16 বাইনারি ম্যাট্রিক্সের একটি প্রাক-সংক্ষেপিত সংস্করণ ব্যবহার করা হয়েছে। প্রাক-সংক্ষেপণ (প্রোগ্রামের অংশ নয়) দুটি পদক্ষেপ ব্যবহার করেছে:

ম্যাট্রিক্সের রান-দৈর্ঘ্যের এনকোডিংটি সারি-প্রধান ক্রমে পড়ুন (প্রথমদিকে, তারপরে নীচে)।
ফলাফলের দৈর্ঘ্যের দৈর্ঘ্য 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

এটা আদর্শে

(আমি বুঝতে পেরেছিলাম পাইথনের সংক্ষিপ্ত কোডের জন্য তৈরি বেস বেসে আসল বোমের সরাসরি এনকোডিং)

স্ট্রিংটি 1s এবং হ্যাশ 0 0 হিসাবে বিবেচনা করে এবং তারপর বেস 36 এ রূপান্তর করে গঠিত হয়েছিল The প্রোগ্রামটি পরে বাইনারি এবং টুকরাগুলিকে 16 এর দৈর্ঘ্যে রূপান্তরিত করে (পাইথনের সামনের দিকে '0 বি' এর 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 বাইনারি উপস্থাপনার প্যাডের প্রয়োজনীয়তা সরিয়ে দেয়। বোমাটি স্থানান্তরিত করা হয়েছে (অনেকটা আমার সিজেএম উত্তরের মতো ) এবং বেস ৩ in এ সঞ্চিত।

প্রোগ্রামটি বোমাকে বাইনারি হিসাবে ডিকোড করে এবং ট্রান্সপোজিশনের পরে কার্যকরভাবে (যা প্রদত্ত লাইনের টুকরো টুকলে বাইট সংরক্ষণ করে) 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?"##":"  "));}

এটি অনলাইন চেষ্টা করুন!

কোনও কমান্ড লাইন প্যারামিটার সরবরাহ না করা হলে এই সেগফাল্টগুলি।

— ceilingcat
সূত্র

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 কারণ এখন আমি ভেরিয়েবল বিটির দ্বিতীয় রেফারেন্স হারিয়ে ফেলেছি আমি bin(y)[2:]যাদু 200 :-) এর নিচে নেমে সরাসরি মানচিত্রের ফাংশনটিতে ব্যবহার করতে পারি 200

-8 দ্বিতীয় তালিকায় স্লাইস অ্যাসাইনমেন্ট ব্যবহার করে। এই সন্ধ্যায় নতুন কিছু শিখেছি।

-3 @ জোনাথনকে ধন্যবাদ সহ

-2 c=d=([0]*7+map(int,bin(y)[2:]))[-16:]থাকার পরিবর্তে ব্যবহার করেc=d;

-2 আবার @ জোনাথনকে ধন্যবাদ

@ লিনাসকে ধন্যবাদ দিয়ে -২৪

আউটপুট

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

— ElPedro
সূত্র

" #"[e>0]*2কাজ করবে

— জোনাথন অ্যালান

DOH এর! আমি সেটিকে কীভাবে মিস করলাম ??? ধন্যবাদ @ জোনাথন

— এলপিড্রো

... প্রথম বন্ধনীগুলিও (...)যেতে পারে (আরআর: আমার আগের মন্তব্যে)।

— জোনাথন অ্যালান 21

আপনি এটি দিয়ে 170 এ নামাতে পারেনfor y in ...:print"".join(" #"[e>0]*2for e in(([0]*7+map(int,bin(y)[2:]))[-16:]))*z

— জোনাথন অ্যালান

@ জোনাথন আবার ধন্যবাদ। এখানে দেরি হচ্ছে তাই আমি কালকের জন্য সেই পরিবর্তনটি সংরক্ষণ করব যাতে আমি এটি পুরোপুরি গণ্ডগোল না করি।

— এলপেড্রো

3

আরপিগ্রন , 210 193 বাইট

0 = '' 1 = '##' থেকে 1 = '' 0 = '' এ পরিবর্তন করে কিছু বাইট সংরক্ষণ করেছেন, এর অর্থ আমার অতিরিক্ত শূন্যগুলি যোগ করার দরকার নেই। এছাড়াও, এর অর্থ হল যে এখন বি 64 স্ট্রিং যা "এমএফআইএ" বলত, এটি দুঃখজনক নয়।

'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 বাইট রয়েছে is কিছুটা বেশি গল্ফযোগ্য হতে পারে তবে কমপক্ষে এটি কার্যকর হয়।

ইনপুট স্ট্যাকের উপর অন্তর্নিহিত, স্ট্যাক সুস্পষ্টভাবে মুদ্রিত হয়।

আউটপুট

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

চেষ্টা করে দেখুন!

<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>

স্নিপেট প্রসারিত করুন

— ATaco
সূত্র

3

পিএইচপি, 144 140 139 138 136 বাইট

দ্রষ্টব্য: উইন্ডোজ -১২২২ এনকোডিং ব্যবহার করে

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];'

বা আইবিএম -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 বিট সংখ্যা বিপরীত হয়, তারপরে বেস--number নম্বর হিসাবে এনকোড করা হয়, 0প্রয়োজনে শীর্ষস্থানীয় সহ প্যাড করা হয় , সুতরাং প্রতি 16 বিট 3 টি বাইটের ফলস্বরূপ। ফলাফলগুলিতে প্রতিদ্বন্দ্বিতা করা 01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow। কোডটি প্রক্রিয়াটিকে উল্টে দেয় যাতে বোমাগুলি সঠিক Nসময়ে মুদ্রিত হয় ।

বদলান

শুধুমাত্র একটি একক-লুপ ব্যবহার করে 4 বাইট সংরক্ষণ করা হয়েছে
প্রতিটি পুনরাবৃত্তির জন্য একটি একক চর মুদ্রণ করে এবং তার্নির পরিবর্তে স্ট্রিং সূচক ব্যবহার করে একটি বাইট সংরক্ষণ করা হয়েছে
এর $jসাথে লাইন সীমানায় শূন্যে পুনরায় সেট করে একটি বাইট সংরক্ষণ করা %=। এটি বন্ধনী থেকে মুক্তি পায়
ব্যবহার করে 2 বাইট সংরক্ষণ করা হয়েছে $argn

— aross
সূত্র

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 óÿÿþÿoÜüðààÀÀ! ÀCàCðøþ? অদৃশ্য এএসসিআইআই কোড থাকা উচিত তবে স্ট্যাক এক্সচেঞ্জ তার সামগ্রীটি উপস্থাপনের কারণে এটি ভেঙে গেছে। দয়া করে সঠিক পরীক্ষার এনকোডিংয়ের জন্য আইডিয়া লিঙ্কটি দেখুন বিকল্পভাবে আসল ASCII স্ট্রিংটি এখানে রয়েছে: https://github.com/claydonkey/AtariBombs/blob/master/ISO8859_REPR2.txt

ব্যাখ্যা

প্রথমে বোমের হেক্স উপস্থাপনার রূপান্তর [f3 ff বিজ্ঞাপন ff ফে 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 ফে 3f] UTF-8 তে ইউটিএফ -8 সংস্করণ সংকলকটি ওয়াইড চর অ্যারে হিসাবে স্ট্রিং সংরক্ষণ করে - রানটাইমের সময় প্রতিটি চরিত্রের জন্য 2 বা 4 বাইট তবে এটি একাডেমিক)। যেখানে ইউটিএফ -8 অক্ষর 2-4 বাইট হিসাবে সংরক্ষণ করা হবে, এই মানগুলি সমস্ত আইএসও -8859-1 (এএসসিআইআই) এর মধ্যে রয়েছে এবং সুতরাং কেবল 1 বাইট প্রয়োজন। এছাড়াও এটি ISO-8859-x হিসাবে সংরক্ষণ করা নিরাপদ (কোনও 0x8_ বা 0x9_ মান নেই)। সুতরাং পাঠ্যটি আইএসও -8859-তে 32 বাইট গ্রহণ করে এবং রুটিনটি মোট 135 বাইট গ্রহণ করে।

(এনবি ওয়াইড চরগুলি উইন্ডোতে একটি 16 বিট পূর্ণসংখ্যার হিসাবে এবং লিনাক্সে 32 বিবিট হিসাবে সংরক্ষণ করা হয় তবে এটি আবার কার্যটি অপ্রাসঙ্গিক)

ক্যাভেট: সমস্ত অক্ষর প্রদর্শনযোগ্য নয় (0x20 এর নীচে নিয়ন্ত্রণ অক্ষর) y তারা এখনও উপস্থিত রয়েছে। বেশিরভাগ ওয়েব পৃষ্ঠাগুলি utf-8 / 8859/1253 ( https://w3techs.com/technologies/overview/character_encoding/all ) তাই আমি এটিকে বৈধ মনে করি ~~(0x20 এর নীচে সমস্ত মান মুদ্রণযোগ্য ASCII এ সরিয়ে ফেলা উচিত)।~~

হল UTF-8

ইউটিএফ -8 এনকোড উত্স সহ মূল পোস্টিংয়ের কাছাকাছি সংস্করণটি এখানে। এটি 173 বাইট খায়। স্ট্রিং নিজেই উত্সের 50 বাইট। রুটিনটি আরও দীর্ঘায়িত হওয়ায় ASCII বাইটগুলি এখন 16 বিট / 32 বিবিট ওয়াইড চার্সের জন্য 0 প্যাডিং সহ সঞ্চিত রয়েছে এবং উপরের মত uint16_t এ ছাঁটাইয়ের পরিবর্তে স্থানান্তরিত করতে হবে। আমি এটি ধরে রেখেছি কারণ এটি ইউটিএফ -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)}

যদি আপনি নিজের সংস্থায় কোনও 16 বিট পূর্ণসংখ্যায় অন্তর্ভুক্ত মান সেট করতে পারেন তবে আপনি প্রশস্ত চরের wchar_t প্রকারের ঘোষণাটি বাদ দিতে পারেন। আইডিয়ন অভিযোগ করেন না তাই আমি বিবেচনা করি এটি যাওয়া ভাল।

এটি চেষ্টা করে দেখুন উপর ideone

— claydonkey
সূত্র

চিত্তাকর্ষক। এটি কোন এনকোডিং ব্যবহার করে?

— ডিজেএমসিএমহেম

এটি MinGW জিসিসিতে সংকলিত যেখানে প্রশস্ত অক্ষর একটি uint16। সুতরাং এনকোডিংটি [16-বিট প্রকারের হোল্ডিং ইউটিএফ -16 ইউনিকোড]। তবে আমি মনে করি যে অক্ষরগুলি 0xFF (16 বিট) এর মধ্যে রয়েছে সেগুলি এএসসিআইআই বাড়ানো হয়েছে। + তাই বিশেষ কিছুই নয়

— ক্লেটডনকি

দুঃখিত, আমি এনকোডিং সম্পর্কে একটি বাচ্চাকে আরও শিখেছি এবং এটি ইউটিএফ -16 হিসাবে সংরক্ষণ করা সম্পর্কে ভুল হতে পারে lease দয়া করে ওভারহুলড উত্তরটি দেখুন।

— ক্লেটডনকি

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]]

আই এ মুদ্রণ করা (যদি আমরা ফিরে পছন্দ বা 6 সরাসরি 5 বাইট খরচ হবে 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("");}}

প্রতিটি এক্সকে নিজের সাথে যুক্ত করে এবং প্রতিটি লাইন শেষ করতে পি ওভারফ্লো করে।

আহ, আমি গল্ফ করার সময় লিখতে প্রিন্টফ () পরিবর্তন করেছি এবং এটি ভেঙে গেছে। আদর্শ এখানে পরীক্ষা করুন আদর্শ জেটিআইএন

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);}

}

— Marco13
সূত্র

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এটি মুদ্রণের পরিবর্তে ফিরে (আমদানিগুলিও বাইট-কাউন্ট বিটিডব্লু এর একটি অংশ ..); --x>=0to x-->0। তবুও, দুর্দান্ত উত্তর, তাই +1!

— কেভিন ক্রুইজসেন

কেভিন ক্রুজসেন ধন্যবাদ (এটিকে নিজের উত্তর হিসাবে পোস্ট করার বিষয়টি বিবেচনা করুন) আমি কোডগল্ফে এখানে খুব সক্রিয় নই, এবং এইভাবে নিয়ম সম্পর্কে নিশ্চিত নই, তবে আমি মনে করি যে বেশিরভাগ ক্ষেত্রে কেবলমাত্র ফাংশনের বাইটগুলি গণনা করা (এবং আমদানি উপেক্ষা করে) অনুমোদিত is

— মার্কো 13

এটি আলাদা হওয়া উত্তর হিসাবে পোস্টের সাথে কিছুটা মিল, তবে আপনি যদি এক বছর আগে নিজের উত্তরটি সম্পাদনা করতে না চান তবে আমি বুঝতে পারি। :) আমি শুধু মন্তব্য এ এটি ছেড়ে দেব। এবং আমি আশঙ্কা করি আমদানিগুলি আসলে বাইট-কাউন্টের দিকে গণনা করে।

— কেভিন ক্রুইজসেন

2

জে, 89 বাইট

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

স্ট্রিংটিকে বেস -৯৯ নম্বর হিসাবে এনকোড করে প্রতিটি অঙ্ককে বাড়িয়ে তোলে, তারপরে এএসআইআই স্ট্রিং দ্বারা 32উপস্থাপন করে।

ব্যাখ্যা

এটি দুটি প্রধান অংশ নিয়ে গঠিত। বোমাটি নির্মাণ এবং আসল পুনরাবৃত্তি রয়েছে। মুহুর্তের জন্য বোমা হিসাবে উল্লেখ করুন b। তারপরে, কোডটির মতো দেখাচ্ছে:

|:@;@#&(b)

যখন ইনপুট দিয়ে ডাকা হয় k, এটি সমান:

|: ; (k#b)

bবক্স বোমা তাই k#bকরে তোলে kএর পুনরাবৃত্তির b, ;এটা উল্লম্বভাবে চ্যাপ্টা, এবং |:ফলাফলের transposes। (বোমাটি bনিজেই ট্রান্সপোজড নির্মিত)

এখন, বোমাটি এখানে:

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

স্ট্রিং নিম্নলিখিতটি অফসেট সহ বেস -৯৫ এনকোডেড স্ট্রিং 32, যাতে সমস্ত অক্ষর ASCII সীমার মধ্যে পড়ে এবং ধন্যবাদ যে সেখানে কোনও 'পালনের দরকার নেই । 3 u:স্ট্রিংয়ের চর কোডগুলি পায়, 32x-~প্রতিটি সংখ্যাকে একটি ই xটেন্ডার নম্বর করে এবং 32এটি থেকে বিয়োগ করে; 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 বাইট

নস্টালজিয়ার জন্য বেসিকের অবদান। পরিবর্তনশীল 'এ' বোমার পরিমাণ নির্ধারণ করে।

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]]

— Angs
সূত্র

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। মনে রাখবেন যে কিছু এমুলেটর রোমে বোমা বিটম্যাপ অন্তর্ভুক্ত নেই!

আপনি যদি কোনও কমান্ড লাইন যুক্তি সরবরাহ না করেন তবে বেশ কয়েকটি উচ্চ রেজোলিউশন বিটম্যাপ করা বোমা প্রদর্শিত হতে পারে :-)

— ceilingcat
সূত্র

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
এসবি যেহেতু ইউটিএফ -8 এ ফাইলগুলি সংরক্ষণ করে, এর মধ্যে কয়েকটি 2 বা 3 বাইট হিসাবে গণনা করে।

— 12Me21
সূত্র

@ আরনাউল্ড আমি স্মাইলব্যাসিক সম্পর্কে খুব বেশি কিছু জানি না, তবে একটি লুপ FOR K=1TO Nরয়েছে INPUT Nবলে আমি মনে করি এটি ইনপুটটিতে প্রদত্ত বোমার সংখ্যা প্রদর্শন করে। তবে, আমি অবশ্যই বলতে পারি যে বর্গক্ষেত্র ফন্ট সত্ত্বেও, আমি বিশ্বাস করি প্রয়োজনীয়তাগুলির সাথে সামঞ্জস্য রাখতে অক্ষরগুলি এখনও দ্বিগুণ করা উচিত (অন্যান্য উত্তরের চেয়ে সুবিধা এড়াতে)। আপনি বর্তমানটিকে একটি সুন্দর-সন্ধানী সমাধানের জন্য রাখতে পারেন, তবে আমার মনে হয় আপনার এখনও একটি সঠিক সমাধান যুক্ত করা উচিত। আপনি এটি যুক্ত করার পরে, আমি ইউটিএফ -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

এক্সেল ভিবিএ, 204 বাইট

অজ্ঞাতনামা VBE তাত্ক্ষণিক উইন্ডো ফাংশন যা সীমা থেকে ইনপুট নেয় [A1]এবং অ্যাক্টিভশিট অবজেক্টে আউটপুট দেয়

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

আউটপুট

— টেলর স্কট
সূত্র

আসুন কিছু আতারি এসটি বোমা আঁকুন!

ভূমিকা

লক্ষ্য

ইনপুট

আউটপুট

উদাহরণ

বিধি

জেলি , 43 44 বাইট

কিভাবে?

05AB1E , 57 55 53 50 বাইট

পাইথ, 57 56 54 53 51 50 বাইট

জাভাস্ক্রিপ্ট (ES6), 159 154 140 136 বাইট

কিভাবে এটা কাজ করে

এমএস-ডস .কম ফাইল, 84 বাইট

পাইথন, 223 179 বাইট

দ্বিতীয় পদ্ধতির:

প্রথম পদ্ধতির:

সি, 250 240 208 188 বাইট

/// , 539 532 + নং। বোমা বাইট

সিজেম , 66 বাইট

পিএইচপি, 138 104 + 32 = 136 বাইট

এমএটিএল , 64 63 60 59 58 বাইট

ব্যাখ্যা

পাইথন 2: 143 বাইট

পাইথন 2.7, 144 141 বাইট

সি (জিসিসি) , 216 204 183 165 134 বাইট

ব্যাচ, 415 বাইট

পাইথন 2, 206 205 203 199 191 188 186 184 160 বাইট

আরপিগ্রন , 210 193 বাইট

ব্যাখ্যা

আউটপুট

চেষ্টা করে দেখুন!

পিএইচপি, 144 140 139 138 136 বাইট

ব্যাখ্যা

বদলান

জিসিসি সি 129 বাইট

ISO8859 / হওয়া ASCII

ব্যাখ্যা

হল UTF-8

হাস্কেল, 155 বাইট

সি, 175 বাইট

জাভা, 228 বাইট

জে, 89 বাইট

ব্যাখ্যা

পরীক্ষা ক্ষেত্রে

বকন , 229 227 195 বাইট

হাস্কেল, 191 181 বাইট

সি (আতারি টিওএস 2.06 মার্কিন), 129 124 117 113 বাইট

সি ++ 11, 252 বাইট

স্মাইলব্যাসিক, 127 বাইট

রুবি 2.x (ল্যাম্বদা) - 157 বাইট

এক্সেল ভিবিএ, 204 বাইট

আউটপুট