এএসসিআইআই ম্যাজেস কম্প্রেশন

Question

চ্যালেঞ্জ

এএসসিআইআই মেজগুলি সংকুচিত করার জন্য বিশেষত একটি সংক্ষেপণ অ্যালগরিদম ডিজাইন করুন। আপনাকে একটি সংক্ষেপণ অ্যালগরিদম এবং ডিকম্প্রেশন অ্যালগরিদম উভয়ই তৈরি করতে হবে। আপনার স্কোরটি আপনার সঙ্কুচিত মেজেসের আকারের উপর ভিত্তি করে তৈরি হবে।

mazes

এই mazes প্রাথমিকভাবে অক্ষর তৈরি হয় (মেঝে), +, -, |, এবং #(দেয়াল), এবং ঠিক একটি প্রতিটি ^(শুরু) এবং $(শেষ)। এগুলিতে ASCII অক্ষরও থাকতে পারে যা মেঝে টাইল হিসাবে গণনা করে। এই চ্যালেঞ্জের উদ্দেশ্যে, ম্যাজগুলিকে সমাধানযোগ্য হতে হবে না এবং ধাঁধা বিষয়বস্তুর প্রকৃত অর্থ অপ্রাসঙ্গিক।

• + কমপক্ষে একটি অনুভূমিকভাবে সংলগ্ন প্রাচীর ঘর এবং কমপক্ষে একটি উল্লম্বভাবে সংলগ্ন প্রাচীর ঘর রয়েছে এমন প্রাচীর ঘরগুলির জন্য ব্যবহার করা হবে।
• | কমপক্ষে একটি উল্লম্বভাবে সংলগ্ন প্রাচীর ঘর রয়েছে এমন প্রাচীরের কক্ষগুলির জন্য ব্যবহৃত হবে, তবে অনুভূমিকভাবে সংলগ্ন প্রাচীরের ঘরগুলি নেই।
• - যেখানে কমপক্ষে একটি অনুভূমিকভাবে সংলগ্ন প্রাচীর ঘর রয়েছে সেখানে প্রাচীরের কক্ষগুলির জন্য ব্যবহৃত হবে, তবে উল্লম্বভাবে সংলগ্ন প্রাচীরের ঘরগুলি নেই
• # কেবলমাত্র ওয়াল কোষগুলির জন্য ব্যবহৃত হবে যা অন্যান্য প্রাচীর কোষগুলির সাথে অर्थোগোনালি সংলগ্ন নয়।

সমস্ত ম্যাজগুলি আয়তক্ষেত্রাকার, তবে নিয়মিত গ্রিড / প্রাচীর প্রান্তিককরণ প্রয়োজন হয় না।

মাজেস টু কমপ্রেস

গোলকধাঁধা ঘ

+----+----
|  o |    |
| -- | o--+
|    | |  $
 --^-+-+---

ধাঁধা 2

+-----+---+
|  a  |   |
^ +-+-+ # |
| | |  B  |
| | | --+ |
|   c   | $
+-------+--

ধাঁধা 3

----------+-+-+-----+-+
^         | | |     | |
+-- --+R #  | |p| | | |
|     | |       | |   |
+---+ +-+-+-- +-+ | | |
|  m| | | |   |   | | |
| +-+ | | | | | --+ | |
| | |    h  | |   | | |
| | | | | |  #  --+-+ |
|     | | | | |  S|   $
+-----+-+-+-+-+---+----

ধাঁধা 4

+-----+---+-+---+-------^-----+
|     |x  | |   |     tsrq    |
+-+-- +-- | +--  #  --+---- --+
| |   |           |   |       |
| | | | | +-+-+---+ | +-- | +-+
| | | u | | | |     | |   | | |
| +-+ | | | | +---- +-+---+ | |
| |   | |   |    y  |       w |
| | --+ | --+ +-- | +---- | | |
|     | |   | |   | |     | | |
+-- --+ +-+ | | | | +-- | +-+-+
|     | | |   | | | |   |     |
$ | --+-+ | --+-+ | +-+-+-- --+
| |   |      z|   |   |    v  |
+-+---+-------+---+---+-------+

গোলকধাঁধা 5

++ -----------+
++-       Beep|
$  ----+---+--+
+-+boop|   |  |
| +--- | | | ++
|      | |  +++
+------+-+--+ ^

ধাঁধা 6

+-$---------------+-+--
|                 | |j 
| |l ---- # ---+ |  |  
| | |       m  | +--+ |
| | | +-+---- #       |
| | | | |      +----+ |
|o| | | | +----+    | |
|       | |    | -- | |
| | | | | | -+ |    | |
| | | | |  | | +--- | |
| | | | +- | | |   | ++
+-+ |n| |  | ++ +--+ | 
    | |   -+- | |  | +-
+---+ +---    |  | |  ^
|    |     --+ --+ | | 
| -- | |  k  |     | ++
|    | |      +--- | ++
|    |      | |    |  |
+-- -+----  | +----+--+

ধাঁধা 7

+---+-+-------------+-+^+-----+-------+---+-+---+-+---+-+---+
|   |c|             | | |  c  |       |   | |   | |   |c|   |
+-- | | +-- +-- # | | | +-- --+ +---- +-- | +-+ | | +-+ | --+
|       |   |     | |           |         |   | |c| |       |
| | +-- | +-+-- +-+ +-- # +- # -+-- +-- | | --+ | | | | --+C|
|c| |   | | c   |         |         |c  |             |   | |
+-+-+---+-+-----+---------+---------+---+-------------+---+$|

ধাঁধা 8

------+-+-+---+-+---+-----------+---+-----+---------------+-+
^     | | |   | |   |           |   |     |      r        | |
+-- | | | t | | +-- +----- # ---+-- +-- --+-- ----+-+ --+ | |
|   |   | | |   |   |         r |   |             | |   |   |
| | | | | +-+ --+ --+-- --------+-- | ----+ --+ | | | --+ | |
| |r| |            rotation               |   | |   |   | | $
+-+-+-+-----------------------------------+---+-+---+---+-+--

ধাঁধা 9

|$|^--+-+---+-----+-+---+-+-+---+---+-+---+-----+
| |   | |   |     | |   | | | f |   | |   |     |
| +-+ | | # +-+ --+ +-+ | | | # | +-+ +-- | ----+
|   |       | |    f| |           | | |   |   f |
| |F+-+ | | | | +---+ | | | ----+-+ | | --+ --+-+
| |   | | |     |     | | |   f |   |         | |
| | | | +-+-+---+-- | | | +-+-+-+ +-+ +--- # -+ |
| | | |     |   |   |   | | | |   | | |         |
+-+-+ | +---+ --+ | +---+-+ | | --+ f | | | | --+
|     | |         |                 | | | | |   |
| --+f| | | +-- --+--f--+ --+ | ----+ | +-+ +---+
|   |     | |     |     |   | |           |     |
+---+-----+-+-----+-----+---+-+-----------+-----+

ম্যাজ 10

+-----+-+-----------+
|  q  | |         q |
|Q+-+ | +-+-+-+---- |
$ | |     | | |  q  |
+-+ | | | | | +-- +-+
| |   | |     |   | |
| +-- +-+ |q| +-+ | |
|    q|   | |   |   |
| | | +-- | +-+ | --+
| | | |   | | |     |
+-+-+-+ +-+-+ +-- | |
|       |         | |
+--- # -+ | | +-- | |
|  q      | | |   | ^
+-+ +-- | | +-+ | +-+
| | |   | |q|   |   |
| +-+-+ | +-+-- | | |
|     | | |     | | |
| | | +-+-+-- +-+ +-+
| | |         | q   |
+-+-+---------+-----+

বিধি, অনুমান, স্কোরিং

• স্ট্যান্ডার্ড লুফোলগুলি নিষিদ্ধ করা হয়েছে
  • একটি সাধারণ প্রোগ্রাম লিখুন, একটি নয় যা কেবল দশটি পরীক্ষার ক্ষেত্রে কাজ করে। এটি অবশ্যই যেকোন যথেচ্ছ ধাঁধাটি পরিচালনা করতে সক্ষম হবে।
• আপনি ধরে নিতে পারেন যে ঠিক একটি প্রবেশদ্বার এবং একটি প্রস্থান থাকবে। প্রবেশদ্বার এবং প্রস্থানগুলি সর্বদা গোলকধাঁধার সীমানায় থাকবে।
• আপনি ধরে নিতে পারেন যে সমস্ত ইনপুটগুলি উপরে বর্ণিত বিধিগুলি অনুসরণ করে দেয়াল ব্যবহার করে। আপনার সংকোচনের অ্যালগরিদমটিতে সেই নিয়ম লঙ্ঘনকারী দেয়ালযুক্ত ম্যাসেজগুলির জন্য কাজ করতে হবে না।
• ইনপুট ম্যাজগুলি দ্রবণযোগ্য হতে পারে বা নাও পারে।
• আপনি ধরে নিতে পারেন ধাঁধাঁটি কোনও দিকের 100 টি অক্ষরের চেয়ে বড় হবে না।
• আপনি ধরে নিতে পারেন অক্ষরগুলি গোলকধাঁধার প্রান্তে উপস্থিত হবে না। (যেহেতু প্রদত্ত উদাহরণগুলির ক্ষেত্রে এটি হ'ল)
• আপনার স্কোরটি সমস্ত সংকুচিত মেজেগুলির মোট আকার, বাইটস (অক্টেটস) এ।
  • আপনি যদি আরও সুবিধাজনক মনে করেন তবে আপনি সংক্ষেপিত গোলকধাঁধার জন্য উপস্থাপনা হিসাবে হেক্স, বেস 64, বাইনারি স্ট্রিং বা অন্য কোনও অনুরূপ ফর্ম্যাট ব্যবহার করতে পারেন। আপনার প্রতিটি ফলাফলের জন্য গোল গোল করে পুরো অষ্টেটগুলিতে ফলাফলটি এখনও গণনা করা উচিত (উদাহরণস্বরূপ 4 বেস 64 সংখ্যা 3 বাইট, 2 হেক্স সংখ্যা 1 বাইট, 8 বাইনারি সংখ্যা 1 বাইট, ইত্যাদি ...)
  • সর্বনিম্ন স্কোর জয়!

Comments

একটি গোলকধাঁধা একটি আকার সীমা আছে?

— অজ্ঞতার

@ এম্বোডিমেন্টফ ইগনিয়ার 100x100

— গরুর মাংস

@ আর্নল্ড আসলে এটি একটি অনুলিপি-পেস্ট করার সমস্যা ছিল তবে আমি মনে করি যে যাই হোক না কেন লাইনের শেষে এসই ফর্ম্যাটিংয়ের ফাঁকা স্থান রয়েছে। হ্যাঁ, এটি স্থান প্যাডযুক্ত হওয়ার কথা।

— গরুর মাংস

@ চ্যাসব্রাউন, এটি একটি স্ট্যান্ডার্ড লুফোল হিসাবে গণ্য, যার অর্থ এটি ডিফল্টরূপে নিষিদ্ধ।

— গরুর মাংস

@ শকনাডার, উদাহরণ পরীক্ষার ক্ষেত্রে এটি যুক্তিযুক্ত বলে মনে হয়।

— গরুর মাংসের মাংস

Answer 1

জাভাস্ক্রিপ্ট (নোড.জেএস) , স্কোর =  586 541 503 492  479 বাইট

কোনও ভবিষ্যদ্বাণী ফাংশন সঠিক অনুমানটি ফিরিয়ে দিচ্ছে কিনা তা বর্ণনা করে দেয়ালগুলি বিটগুলির হাফম্যান-এনকোডেড স্ট্রিম হিসাবে সঞ্চিত রয়েছে।

বিশেষ অক্ষর হিসাবে সংরক্ষণ করা হয় $(d, c)$, কোথায় $d$ পূর্ববর্তী বিশেষ চরিত্র থেকে দূরত্ব এবং $c$ এএসসিআইআই কোড।

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

সাধারণ

const HUFFMAN = [
  '00',       // 0000
  '010',      // 0001
  '1001',     // 0010
  '11100',    // 0011
  '011',      // 0100
  '101',      // 0101
  '11110',    // 0110
  '100010',   // 0111
  '110',      // 1000
  '11101',    // 1001
  '1111100',  // 1010
  '1111101',  // 1011
  '10000',    // 1100
  '1111110',  // 1101
  '100011',   // 1110
  '1111111'   // 1111
];

let bin = (n, w) => n.toString(2).padStart(w, '0');

let wallShape = (row, x, y) => {
  let vWall = (row[y - 1] || [])[x] | (row[y + 1] || [])[x],
      hWall = row[y][x - 1] | row[y][x + 1];

  return ' -|+'[row[y][x] ? vWall * 2 | hWall : 0];
}

let predictWall = (row, x, y, w, h) => {
  let prvRow = row[y - 1] || [];
  return !x | !y | x == w - 1 | y == h - 1 | (prvRow[x] | row[y][x - 1]) & !prvRow[x - 1];
}

সঙ্কোচন

let pack = str => {
  let row = str.split('\n').map(r => [...r]),
      w = row[0].length,
      h = row.length;

  let wall = row.map((r, y) => r.map((c, x) => +/[-+|]/.test(c)));

  if(row.some((r, y) => r.some((c, x) => wall[y][x] && wallShape(wall, x, y) != c))) {
    throw "invalid maze";
  }

  row = wall.map((r, y) => r.map((v, x) => predictWall(wall, x, y, w, h) ^ v));
  row = row.map(r => r.join('')).join('');
  row = row.replace(/.{1,4}/g, s => HUFFMAN[parseInt(s.padEnd(4, '0'), 2)]);

  str =
    str.replace(/[\n|+-]/g, '').replace(/ *(\S)/g, (s, c) => {
      let n = c.charCodeAt(),
          i = '^$#'.indexOf(c);

      return (
        bin(s.length > 63 ? 0xFC000 | s.length - 1 : s.length - 1, 6) +
        bin(~i ? i : n < 91 ? (n > 80 ? 0x1F0 : 0x1E0) | ~-n & 15 : n - 94, 5)
      );
    }).trim();

  return (
    Buffer.from(
      (bin(w, 7) + bin(h, 7) + row + str)
      .match(/.{1,8}/g).map(s => parseInt(s.padEnd(8, '0'), 2))
    ).toString('binary')
  );
}

decompression

let unpack = str => {
  str = [...str].map(c => bin(c.charCodeAt(), 8)).join('');

  let x, y, n, i, s,
      ptr = 0,
      read = n => parseInt(str.slice(ptr, ptr += n), 2),
      w = read(7),
      h = read(7),
      row = [];

  for(x = s = ''; s.length < w * h;) {
    ~(i = HUFFMAN.indexOf(x += read(1))) && (s += bin(i, 4), x = '');
  }
  for(i = y = 0; y < h; y++) {
    for(row[y] = [], x = 0; x < w; x++) {
      row[y][x] = predictWall(row, x, y, w, h) ^ s[i++];
    }
  }

  row = row.map((r, y) => r.map((c, x) => wallShape(row, x, y)));

  for(i = 0; str[ptr + 10];) {
    for(
      n = (n = read(6)) == 0x3F ? read(14) + 1 : n + 1;
      n -= row[i / w | 0][i % w] == ' ';
      i++
    ) {}

    row[i / w | 0][i % w] = String.fromCharCode(
      (n = read(5)) >= 0x1E ? read(4) + (n == 0x1F ? 81 : 65) : [94, 36, 35][n] || n + 94
    );
  }
  return row.map(r => r.join('')).join('\n');
}

কিভাবে?

একটি গোলকধাঁধাটিকে বিট স্ট্রিম হিসাবে এনকোড করা হয় যা শেষ পর্যন্ত একটি স্ট্রিতে রূপান্তরিত হয়।

শিরোলেখ

শিরোনামটি নিয়ে গঠিত:

• প্রস্থ $w$ 7 বিট উপর
• উচ্চতা $h$ 7 বিট উপর

ওয়াল ডেটা

আমরা পুরো গোলকধাঁধা দিয়ে চলেছি এবং ভবিষ্যদ্বাণী করার চেষ্টা করেছিলাম যে পরবর্তী কক্ষটি প্রাচীর কিনা, পূর্বে সম্মুখীন হওয়া কক্ষগুলির উপর ভিত্তি করে। আমরা নির্গত a$0$ আমরা সঠিক হলে, বা একটি $1$ আমরা যদি ভুল হয়।

এর ফলে উল্লেখযোগ্যভাবে আরও বেশি (আশাবাদী) সংশোধন বিটের ক্রম ঘটে $0$এর চেয়ে বেশি $1$'S। এই ক্রমটি নিবলগুলিতে বিভক্ত হয় এবং হার্ড-কোডড হাফম্যান কোডগুলি ব্যবহার করে সংরক্ষণ করা হয়:

• 00 → 0000
• 010 → 0001
• 1001 → 0010
• 11100 → 0011
• 011 → 0100
• প্রভৃতি

দেয়াল ডিকোড করতে $W_n$, ডিকম্প্রেশন রুটিন একই পূর্বাভাস গণনা করে $P_n$ এবং সংশোধন বিট ব্যবহার করে ফলাফল টগল করে $C_n$:

$$W_n=P_n\oplus C_n$$

চূড়ান্ত প্রাচীরের আকারগুলি এমনভাবে অনুমিত করা হয় যা নিক কেনেডি-র উত্তরের অনুরূপ ।

বিশেষ অক্ষর

প্রতিটি বিশেষ অক্ষর হিসাবে এনকোড করা হয়:

• দূরত্ব বিয়োগ $1$ শেষ বিশেষ চরিত্র থেকে (দেয়াল উপেক্ষা করে):

  • এটির চেয়ে কম হলে 6 বিটে $63$
  • বা হিসাবে $111111$ + 14 বিট অন্যথায় (পরীক্ষার ক্ষেত্রে কখনও ব্যবহৃত হয় না, তবে তত্ত্বের প্রয়োজন হয়)

• চরিত্রের কোড:

  • 5 বিট তে এটি যদি ^, $, #বা[a-z]
  • অথবা $11110$ জন্য + 4 বিট [A-O]
  • অথবা $11111$ জন্য + 4 বিট [P-Z]

Comments

আপনি কি সংক্ষেপে অ্যালগোরিদম ছাড়া অন্য চেষ্টা করেছেন deflate? তাকটিতে একটি ভয়ঙ্কর লট রয়েছে!

— ডিফিউয়ার

কোনও নিয়ম নেই যা বলে যে এটি টিআইওতে কাজ করতে হবে!

— ডিফিউয়ার

ওহ, দুর্দান্ত, দশমিক সংকোচনটি আদৌ সহায়তা করবে কিনা তা অবাক করে (মূলত হাফম্যানের বিপরীতে, স্থানটি 0 থেকে 1 হয়, স্বেচ্ছাসেবী আকারের (<1 অবশ্যই) বিভাগে বিভক্ত হয়, এবং এনকোডিং হ'ল সংক্ষিপ্ততম বাইনারি সংখ্যা যা এর মধ্যে পড়ে স্থানটির সঠিক টুকরো

— ASCII- কেবল

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

— আর্নৌল্ড

@ এএসসিআইআই-উদাহরণস্বরূপ, আমার সম্ভবত দীর্ঘতর কোডগুলি চেষ্টা করা উচিত (নিবলগুলি ব্যবহার করা স্বেচ্ছাসেবী)। আমি ডিফল্ট স্ট্যাটিক হাফম্যান কোডগুলি দিয়ে বা গতিশীল কোডগুলির সাথে ডেটা আনপ্যাক করা উচিত কিনা তা জানিয়ে হেডারে একটি 1-বিট পতাকা যুক্ত করতে পারতাম (যদি এটি কিছু ম্যাসের সংকোচনের উন্নতি ঘটাতে পারে)। একটি জিনিস যা আমি চেষ্টা করেছিলাম তা হল ধাঁধাটি 90 by দ্বারা ঘোরানো এবং আরও ভালভাবে সংকোচন করা হচ্ছে কিনা তা দেখুন। তবে এটি সামগ্রিকভাবে 1 বাইট সঞ্চয় করছিল।

— আর্নৌল্ড

Answer 2

আর, স্কোর 668 বাইট

এটি প্রাচীরের চরিত্রটি তার চারপাশের দ্বারা নির্ধারিত হয় এ বিষয়টি গ্রহণ করে। যেমন, প্রাচীর অক্ষরগুলি বিট হিসাবে এনকোড করা যেতে পারে। অবশিষ্ট তথ্য যা সংরক্ষণ করা দরকার তা হ'ল ধাঁধাটির মাত্রা, শুরু এবং সমাপ্তির অবস্থান এবং অন্য কোনও প্রাচীরবিহীন অক্ষরের অবস্থান। যেহেতু প্রাচীরবিহীন অক্ষরগুলি ASCII, তাই আমি প্রতিটি বাইটের সর্বাধিক উল্লেখযোগ্য বিট ব্যবহার করেছি যাতে এটি বর্ণিত হয় যে এর পরে অন্য কোনও অক্ষর রয়েছে যা ম্যাসের কয়েকটি শব্দ প্রতিটি অক্ষরের অবস্থান সংরক্ষণ করতে না পারে আলাদাভাবে। আরও মনে রাখবেন যে 256 অক্ষরের চেয়ে কম বা সমান মেজেগুলির জন্য (উদাহরণস্বরূপ 16x16 বা সমতুল্য আয়তক্ষেত্রাকার ম্যাজগুলি), অবস্থানগুলি একটি বাইটে সংরক্ষণ করা যেতে পারে, তবে বৃহত্তর মেজগুলির জন্য পজিশনে দুটি বাইট প্রয়োজন।

ইউটিলিটি ফাংশন

r <- as.raw

int_as_raw <- function(int, bytes = 2) {
  if (bytes == 1) {
    r(int)
  } else {
    do.call(c, lapply(int, function(.x) r(c(.x %/% 256, .x %% 256))))
  }
}

raw_as_int <- function(raw, bytes = 2) {
  if (bytes == 1) {
    as.integer(raw)
  } else {
    sapply(
      seq(1, length(raw) - 1, 2),
      function(.x) as.integer(as.integer(raw[.x + 0:1]) %*% c(256, 1))
    )
  }
}

সংক্ষেপণ অ্যালগরিদম

compress_maze <- function(maze) {
  maze_array <- do.call(rbind, strsplit(maze, ""))
  simple_maze <- r(maze_array %in% c("+", "#", "-", "|"))
  simple_maze <- packBits(c(simple_maze, rep(r(0), (8 - length(simple_maze)) %% 8)))
  maze_dim <- int_as_raw(dim(maze_array), 1)
  bytes_needed <- 1 + (length(maze_array) > 256)
  start_finish <- int_as_raw(sapply(c("^", "$"), function(.x) which(maze_array == .x)) - 1, bytes = bytes_needed)
  other_ascii_locs_rle <- rle(!(maze_array %in% c(" ", "+", "#", "-", "|", "$", "^")))
  other_ascii_locs <- cumsum(
    c(1, other_ascii_locs_rle$lengths[-length(other_ascii_locs_rle$lengths)])
  )[other_ascii_locs_rle$values]
  other_ascii_locs_length <- other_ascii_locs_rle$lengths[other_ascii_locs_rle$values]

  encode_ascii <- function(loc, len) {
    text <- charToRaw(paste(maze_array[loc:(loc + len - 1)], collapse = ""))
    if (len > 1) {
      text[1:(len - 1)] <- text[1:(len - 1)] | r(128)
    }
    c(int_as_raw(loc - 1, bytes = bytes_needed), text)
  }

  other_ascii_encoded <- Map(encode_ascii,
    other_ascii_locs,
    other_ascii_locs_length
    )
  other_ascii_encoded <- do.call(c, other_ascii_encoded)
  c(maze_dim, simple_maze, start_finish, other_ascii_encoded)
}

ডিকম্প্রেশন অ্যালগরিদম

decompress_maze <- function(c_maze) {
  dim_maze <- as.integer(c_maze[1:2])
  len_maze <- prod(dim_maze)
  len_maze_b <- ceiling(len_maze / 8)
  bit_maze <- rawToBits(c_maze[-(1:2)])[1:len_maze]
  dim(bit_maze) <- dim_maze
  bit_maze[-1, ] <- bit_maze[-1, ] | rawShift(bit_maze[-nrow(bit_maze), ] & r(1), 1)
  bit_maze[-nrow(bit_maze), ] <- bit_maze[-nrow(bit_maze), ] | rawShift(bit_maze[-1, ] & r(1), 1)
  bit_maze[, -1] <- bit_maze[, -1] | rawShift(bit_maze[, -ncol(bit_maze)] & r(1), 2)
  bit_maze[, -ncol(bit_maze)] <- bit_maze[, -ncol(bit_maze)] | rawShift(bit_maze[, -1] & r(1), 2)
  bit_maze[(bit_maze & r(1)) == r(0)] <- r(0)
  array_maze <- c(" ", "#", "|", "-", "+")[(as.integer(bit_maze) + 1) %/% 2 + 1]
  dim(array_maze) <- dim_maze
  bytes_needed <- 1 + (len_maze > 256)
  start_finish <- raw_as_int(c_maze[2 + len_maze_b + 1:(bytes_needed * 2)], bytes_needed) + 1
  array_maze[start_finish] <- c("^", "$")
  i <- 3 + len_maze_b + 2 * bytes_needed
  while (i < length(c_maze)) {
    loc <- raw_as_int(c_maze[i + 1:bytes_needed - 1], bytes_needed) + 1
    i <- i + bytes_needed
    text <- character(0)
    while (c_maze[i] & r(128)) {
      text <- c(text, rawToChar(c_maze[i] & r(127)))
      i <- i + 1
    }
    text <- c(text, rawToChar(c_maze[i]))
    array_maze[loc:(loc + length(text) - 1)] <- text
    i <- i + 1
  }
  apply(array_maze, 1, paste, collapse = "")
}

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

Comments

আমি জানতাম আপনি বিট হিসাবে দেয়ালগুলি সঞ্চয় করতে সক্ষম হবেন তবে আমি প্রাচীরবিহীন চরিত্রের অবস্থানের ডেটা সংকুচিত করার জন্য আপনার পদ্ধতির পছন্দ করি। +1

— নীল