গল্ফ পেটারসনের কৃমি

Question

পিটারসনের কীটগুলি এক ধরণের সেলুলার অটোমেটন যা অসীম ত্রিভুজাকার গ্রিডে বিদ্যমান এবং প্রতিটি পদক্ষেপে তারা কিছু দিক ঘুরিয়ে নিয়ে একটি একককে স্থানান্তরিত করে। তাদের নির্ধারিত বৈশিষ্ট্য হ'ল তারা কখনই একই জায়গার উপর দিয়ে দু'বার যেতে পারে না এবং যখনই তারা একই আশেপাশের মুখোমুখি হয়, তারা একই সিদ্ধান্ত নেয়। একটি কীট সর্বদা নিজের দৃষ্টিকোণ থেকে তার লেজটি 3 এ অবস্থিত এবং এর মাথাটি এই ষড়যন্ত্রের কেন্দ্রে অবস্থিত সাথে "দেখায়" sees

উদাহরণস্বরূপ, নিয়ম সহ কীটটিকে বিবেচনা করুন:

1. যদি 0, 1, 2, 4 এবং 5 সমস্ত ফাঁকা থাকে তবে 2 দিকে এগিয়ে যান
2. যদি 0, 1, 4, এবং 5 টি ফাঁকা হয় এবং 2 টি ভরাট হয় তবে 0 দিকে এগিয়ে যান
3. যদি 0, 1, এবং 5 টি ফাঁকা হয় এবং 2 এবং 4 ভরাট হয় তবে 0 দিকে এগিয়ে যান

এটি নিম্নলিখিত পথে (উইকিপিডিয়া থেকে) ফলাফল:

কীটটি যদি এমন পরিস্থিতি আবিষ্কার করে যেখানে সমস্ত আশপাশ ভরাট হয়ে যায় তবে এটি বন্ধ হয়ে যায়।

ইনপুট

সংখ্যার একটি তালিকা। নবম সংখ্যাটি নির্দেশ করে যে কীটটিকে কী সিদ্ধান্ত নেওয়া উচিত তা নবম পরিস্থিতিটির মুখোমুখি হয় যেখানে এটি সিদ্ধান্ত নিতে হয়। মনে রাখবেন যে এর আশেপাশের কোনও একটি ছাড়া যদি সমস্ত ভরাট হয় তবে এটি অবশ্যই খালি একমাত্র দিকে চলতে হবে। এটি একটি "সিদ্ধান্ত" হিসাবে গণ্য হয় না এবং একটি সংখ্যা গ্রাস করে না। উপরে দেখানো উদাহরণস্বরূপ কীট তৈরি করতে, ইনপুটটি হবে [2, 0, 0]। ইনপুটটি এমন একটি কীট উৎপাদনের গ্যারান্টিযুক্ত যা শেষ হয়ে যায় এবং তার পথটি সরিয়ে না ফেলে এবং ইনপুটটি কখনই খুব কম হবে না।

আউটপুট

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

(1, 0), (1, 1), (0, 0), (-1, -1), (0, -1), (0, 0), (0, 1), (-1, 0), (0, 0)

পরীক্ষার মামলা

পরীক্ষা চালানোর জন্য আপনি জাভাস্ক্রিপ্ট স্নিপেট ব্যবহার করতে পারেন।

[2,0,0]: (1,0),(1,1),(0,0),(-1,-1),(0,-1),(0,0),(0,1),(-1,0),(0,0)
[1,0,4,0,1,5]: (1,0),(2,1),(2,2),(1,2),(0,1),(0,0),(0,-1),(1,-1),(2,0),(2,1),(3,1),(4,2),(4,3),(3,3),(2,2),(1,1),(1,0),(2,0),(3,1),(3,0),(4,0),(5,1),(5,2),(4,2),(3,2),(2,1),(1,1),(0,0),(-1,0),(-2,-1),(-2,-2),(-1,-2),(0,-1),(1,0),(1,-1),(2,-1),(3,0),(4,1),(4,2),(5,3),(5,4),(4,4),(3,3),(3,4),(2,4),(1,3),(1,2),(1,1),(0,1),(-1,0),(-1,1),(-2,1),(-3,0),(-3,-1),(-2,-1),(-1,-1),(0,0)
[1,0,5,1]: (1,0),(2,1),(2,2),(1,2),(0,1),(0,0),(0,-1),(1,-1),(2,0),(2,1),(3,2),(3,3),(2,3),(1,2),(0,2),(-1,1),(-1,0),(0,0),(1,1),(1,2),(1,3),(0,3),(-1,2),(-1,1),(-2,0),(-2,-1),(-1,-1),(0,0)
[2,0,1,0]: (1,0),(1,1),(0,0),(-1,-1),(0,-1),(0,0),(-1,0),(-1,-1),(-1,-2),(0,-1),(1,0),(2,1),(1,1),(0,1),(0,0)

নীচের তাড়াতাড়ি একত্রিত (সম্ভবত বগি) প্রোগ্রামটি কীটগুলি প্রদর্শন করবে:

var canvas = document.querySelector("canvas");
var ctx = canvas.getContext("2d");

var input, memory;

var log = str => {
  console.log(str);
  document.querySelector("textarea").value += str + "\n";
};

var orientations = [
  [1, 0],
  [1, 1],
  [0, 1],
  [-1, 0],
  [-1, -1],
  [0, -1]
];

var arena = {
  grid: [[[1, 0, 0]]],
  maxX: 1,
  maxY: 0,
  expandGrid: function() {
    var grid = this.grid;
    var newWidth = grid[0].length + 2,
      newHeight = grid.length + 2;
    var createRow = () => {
      var result = [];
      for (let i = 0; i < newWidth; ++i) result.push([0, 0, 0]);
      return result;
    };
    for (let row of grid) {
      row.push([0, 0, 0]);
      row.unshift([0, 0, 0]);
    };
    grid.push(createRow());
    grid.unshift(createRow());
  },

  gridWidth: function() {
    return this.grid[0].length
  },
  gridHeight: function() {
    return this.grid.length
  },
  get: function(x, y) {
    var colOffset = Math.floor(this.gridWidth() / 2),
      rowOffset = Math.floor(this.gridHeight() / 2);
    return this.grid[y + rowOffset][x + colOffset];
  },
  isAtEnd: function(x, y) {
    var colOffset = Math.floor(this.gridWidth() / 2),
      rowOffset = Math.floor(this.gridHeight() / 2);
    return x === -colOffset || x + colOffset + 1 === this.gridWidth() ||
      y === -rowOffset || y + rowOffset + 1 === this.gridHeight();
  },
  getEdge: function(x, y, o) {
    if (o % 2 === 0) return this.get(x, y)[o / 2];
    else {
      let a, b;
      [a, b] = orientations[(o + 3) % 6];
      return this.get(x - a, y - b)[((o + 3) % 6) / 2];
    }
  },
  setEdge: function(x, y, o) {
    if (Math.abs(x) > this.maxX) this.maxX = Math.abs(x);
    if (Math.abs(y) > this.maxY) this.maxY = Math.abs(y);
    if (o % 2 === 0) {
      if (this.get(x, y)[o / 2]) throw new Error("Path already taken");
      this.get(x, y)[o / 2] = 1;
    } else {
      let a, b;
      [a, b] = orientations[(o + 3) % 6];
      if (this.get(x - a, y - b)[((o + 3) % 6) / 2]) throw new Error("Path already taken");
      this.get(x - a, y - b)[((o + 3) % 6) / 2] = 1;
    }
  }
};

var drawGrid = function(area) {
  var width = canvas.width,
    height = canvas.height;
  ctx.clearRect(0, 0, width, height);
  var gridWidth = arena.gridWidth(),
    gridHeight = arena.gridHeight();
  var triangleLen = Math.floor(Math.min(
    width / (arena.maxX * 2 + arena.maxY),
    height / (arena.maxY * Math.sqrt(3)),
    width / 4
  ));
  var convert = (x, y) => [(x - y / 2) * triangleLen, triangleLen * y * Math.sqrt(3) / 2];
  var drawCirc = function(x, y) {
    var a, b;
    ctx.beginPath();
    [a, b] = convert(x, y);
    ctx.arc(a, b, 5, 0, 2 * Math.PI);
    ctx.fill();
  };
  ctx.fillStyle = "black";
  for (let y = 0; triangleLen * y * Math.sqrt(3) / 2 < height; ++y) {
    for (let x = Math.floor(y / 2); triangleLen * (x - y / 2) < width; ++x) {
      drawCirc(x, y);
    }
  };

  var drawLine = function(a, b, c, d) {
    var x, y;
    ctx.beginPath();
    [x, y] = convert(a, b);
    ctx.moveTo(x, y);
    [x, y] = convert(a + c, b + d);
    ctx.lineTo(x, y);
    ctx.stroke();
  };

  var centerY = Math.round(height / (triangleLen * Math.sqrt(3)));
  var centerX = Math.round(width / (2 * triangleLen) + centerY / 2);
  ctx.fillStyle = "red";
  drawCirc(centerX, centerY);

  for (let row = -(gridHeight - 1) / 2; row < (gridHeight + 1) / 2; ++row) {
    for (let col = -(gridWidth - 1) / 2; col < (gridWidth + 1) / 2; ++col) {
      let lines = arena.get(col, row);
      for (let j = 0; j < lines.length; ++j) {
        if (lines[j]) {
          let or = orientations[2 * j];
          drawLine(col + centerX, row + centerY, or[0], or[1]);
        }
      }
    }
  }
};


var step = function(x, y, absoluteOrientation) {
  log('(' + x + ',' +  y + ')');
  var surroundings = 0;
  for (let i = 0; i < 6; ++i) {
    if (arena.getEdge(x, y, (absoluteOrientation + i) % 6)) {
      surroundings |= (1 << i);
    }
  }
  if (surroundings == 63) {
    console.log("Done!");
    return;
  }
  var action;
  if (memory[surroundings] !== undefined)
    action = memory[surroundings];
  else {
    action = input.shift();
    memory[surroundings] = action;
  }
  absoluteOrientation = (absoluteOrientation + action) % 6;
  arena.setEdge(x, y, absoluteOrientation);
  var or = orientations[absoluteOrientation];
  x += or[0];
  y += or[1];
  if (arena.isAtEnd(x, y)) arena.expandGrid();
  drawGrid(arena);
  setTimeout(function() {
    step(x, y, absoluteOrientation);
  }, parseFloat(document.querySelector("input[type=number]").value));
};

var go = function() {
  input = document.querySelector("input[type=text]").value.split(",").map(x => parseInt(x, 10));
  arena.grid = [[[1, 0, 0]]];
  arena.maxX = 1;
  arena.maxY = 0;
  memory = {};

  for (let i = 0; i < 6; ++i) {
    memory[(~(1 << i)) & 63] = i;
  }

  arena.expandGrid();
  arena.expandGrid();

  step(1, 0, 0);
};

document.querySelector("button").onclick = go;

canvas {
  border: 1px solid black;
}

Input: <input type="text" placeholder="Comma separated input"><br />
Delay (ms): <input type="number" placeholder="delay" value="500"/><button>Go</button><br />
<canvas width="500" height="400"></canvas><br />
<textarea></textarea>

Comments

প্রস্তাবিত পরীক্ষার কেস : পি (এটি [1,0,4,2,0,1,5]))

— আর্নল্ড

আমরা কি বিপরীত ক্রমে ইনপুট নিতে পারি?

— আরনাউল্ড

@ আরনাউল্ড নিশ্চিত হয়েছেন যে এটি ঠিক আছে

— soktinpk

Answer 1

জাভাস্ক্রিপ্ট (ES6),  261 250  249 বাইট

$[x,y]$

a=>(G=[[[x=1]]],v=[0,1,1,0,-1,-1],F=y=>[[x,y],...v.every((_,i)=>k^=g(o+i)[q%3]<<i,k=63,g=o=>(r=G[Y=y-o%2*v[q=(o+3)%6]]=G[Y]||[])[X=x-o%2*v[-~q%6]]=r[X]||[])?F(y+v[g(o+=F[k]|=1/F[k]?0:k&~-k?a.pop():31-Math.clz32(k))[q%3]=1,o%6],x+=v[-~o%6]):[]])(o=0)

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

এটি মূলত ডেমো স্নিপেটের একটি বন্দর।

Answer 2

কে (এনএনজি / কে) , 115 বাইট

D,:-D:2\6 3;f:{d::0;m::2/=6;X::(!6),x;{m::?m,p:2/^(+':x)?(2*h:*|x)+/:D 6!d+!6;$[(~p)|^c:X m?p;x;x,,h+D 6!d+:c]}/,1 0}

(ফাংশন নামকরণ অংশ গণনা, f:)

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

D,:-D:2\6 3 ছয়টি মূল দিকনির্দেশ উত্পন্ন করে (1 0;1 1;0 1;-1 0;-1 -1;0 -1)

d::0 বর্তমান দিক, এটি ইনডেক্স মডেল 6 ইন হিসাবে ব্যবহৃত হয় D

m::2/=6প্রাথমিক কীট স্মৃতি জেনারেট করে 32 16 8 4 2 1। প্রতিটি সংখ্যার বিট আশেপাশে এনকোড করে (0 = পরিদর্শন করা বিভাগ; ​​1 = অপ্রকাশিত)। প্রাথমিকভাবে mকেবল দ্ব্যর্থহীন পারিপার্শ্বিকতা থাকে - সেগুলিতে যেখানে একক প্রস্থান পাওয়া যায়।

X::(!6),xকৃমির নিয়ম। আমরা অভ্যন্তরীণ 0 1 2 3 4 5দ্ব্যর্থহীন আশেপাশের সাথে ম্যাচ করার জন্য প্রস্তুতি নিই m।

{... }/,1 0কনভার্জেন্স পর্যন্ত প্রয়োগ করুন { }1-উপাদান তালিকা সমেত ফাংশন থেকে শুরু করে 1 0। তালিকায় কীট দ্বারা পরিদর্শন করা কয়েকটি সমন্বয় সমন্বয় থাকবে।

D 6!d+!6ছয়টি মূল নির্দেশিকা থেকে শুরু হয়ে dঘড়ির কাঁটার দিকে ঘুরে

h:*|x যুক্তির সর্বশেষে, অর্থাৎ কৃমির মাথার অবস্থান

(2*h:*|x)+/:D 6!d+!6মাথার স্থানাঙ্কগুলি 2 দিয়ে গুণ করুন এবং মূল দিকনির্দেশগুলি যুক্ত করুন। পয়েন্টগুলির মধ্যে বিভাগগুলি উপস্থাপনের এটি আমাদের উপায়।

+':x সংলগ্ন পরিদর্শন করা পয়েন্টগুলির জোড়া যুক্ত করুন - এটি আমাদের মধ্যে সেগমেন্টগুলির প্রতিনিধিত্ব করে

^(... )?... মাথার আশেপাশের কোন অংশটি এখনও পরিদর্শন করা হয়নি তা সন্ধান করুন

p:2/ বাইনারি এনকোড এবং বরাদ্দ করুন p

m::?m,pসংযোজন করতে mএবং রাখতে স্বতন্ত্র, অর্থাত পরিশেষে যোগ pকরার mশুধুমাত্র যদি pদেখা দেয় নাm

$[... ;... ;... ]অন্যথায় যদি

c:X m?pইনডেক্সটি pসন্ধান করুন mএবং এটি ইনডেক্স হিসাবে ব্যবহার করুন X। সীমানার বাইরে ফলাফলের সূচি 0N("নাল")

$[(~p)|^c:X m?p;x;... ]যদি p0 হয় (কোনও প্রস্থান পথ নেই) বা cহয় 0N, তবে প্রত্যাবর্তন xযা রূপান্তরকে বাধ্য করবে এবং লুপটি বন্ধ করবে

x,,h+D 6!d+:cঅন্যথায় নতুন মাথা সংযুক্ত করুন xএবং পুনরাবৃত্তি করুন