একটি সর্পিল জুড়ে একটি রানির পদচারণা

Question

একটি সুদূর রাজ্যে, দাবা রানী একটি সর্পিল পথ ধরে প্রতিদিন হাঁটেন n, যা সর্পিলটি অনুসরণ করার জন্য যত্নশীল নয়, কেবল রানির চালচলন করে যেমন তিনি দাবা বোর্ডে যাচ্ছিলেন। রানী তার প্রজাদের কাছে প্রিয় এবং তারা তার পথে যে সমস্ত স্কোয়ার ঘুরে দেখেন তার একটি নোট তৈরি করে। রানী যে কোনও স্কোয়ারে তার হাঁটাচলা শুরু করতে পারে এবং এটি কোনও স্কোয়ারে শেষ করতে পারে তা দিয়ে, রানীর সবচেয়ে সংক্ষিপ্ত পদচারণা কী হতে পারে?

চ্যালেঞ্জ

একটি আয়তক্ষেত্রাকার গ্রিডে পূর্ণসংখ্যার একটি সর্পিল দেওয়া, একটি ফাংশন লিখুন যা দাবা রানির চালগুলি ব্যবহার করে এই সর্পিল গ্রিডে দুটি সংখ্যার মধ্যে সবচেয়ে সংক্ষিপ্ততম পথ (যাতায়াতকৃত সেলগুলির সংখ্যা দ্বারা গণিত) ফিরে আসে write

উদাহরণস্বরূপ, থেকে 16থেকে 25:

25 10 11 12 13
24  9  2  3 14
23  8  1  4 15
22  7  6  5 16
21 20 19 18 17

কিছু সম্ভাব্য পাথ অন্তর্ভুক্ত 16, 4, 2, 10, 25এবং 16, 5, 1, 9, 25।

বিধি

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

সর্বদা হিসাবে, সমস্যাটি যদি অস্পষ্ট হয় তবে দয়া করে আমাকে জানান। শুভকামনা এবং ভাল গল্ফিং!

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

>>> queen_spiral(4, 5)
4, 5
>>> queen_spiral(13, 20)
13, 3, 1, 7, 20
>>> queen_spiral(14, 14)
14
>>> queen_spiral(10, 3)
10, 11, 3
>>> queen_spiral(16, 25)
16, 4, 2, 10, 25
>>> queen_spiral(80, 1)
80, 48, 24, 8, 1

Comments

সম্পর্কিত ।

— Leaky নুন

আপনি উল্লেখ করতে চাইতে পারেন যে আপনি ভ্রমণের জন্য সংখ্যক কক্ষের সংক্ষিপ্ততম পথটি সন্ধান করছেন (ইউক্যালিডিয়ান দূরত্বের বিপরীতে, বলুন)।

— মার্টিন ইন্ডার

এটি কি "রাজার পদচারণা" হিসাবে আরও বোঝায় না?

— জো কিং

@ জোকিং আহ, এখন আপনি এটি উল্লেখ করেছেন, এটি রাজার পদচারণা হওয়া উচিত। তবে শিরোনাম পরিবর্তন করতে কিছুটা দেরি হতে পারে।

— শার্লক 9

Answer 1

এপিএল (ডায়ালগ ইউনিকোড) , ⁵⁹ 57 বাইট ^{এসবিসিএস}

{v⍳+\v[⍺],↓⍉↑(|⍴¨×)⊃⍵⍺-.⊃⊂v←9 11∘○¨+\0,0j1*{⍵/⍨⌈⍵÷2}⍳⍺⌈⍵}

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

^{-২ বাইটস @ জিএনএনকে ধন্যবাদ}

বেনামে ফাংশন যা বাম এবং ডান যুক্তি হিসাবে দুটি টিপয়েন্টকে স্বীকার করে।

অসম্পূর্ণ এবং এটি কীভাবে কাজ করে

রানী প্রথমে তির্যকভাবে সরানো হয়, তাই প্রতিটি সংখ্যার স্থানাঙ্কগুলি পূর্ব পর্যন্ত গণনা করা যথেষ্ট max(start,end)।

সমন্বয়-উত্পাদক অ্যালগরিদম সম্পর্কিত চ্যালেঞ্জ সম্পর্কিত বিভিন্ন উত্তর থেকে অনুপ্রাণিত , তবে বিদ্যমান উত্তরগুলির থেকে কিছুটা পৃথক:

• 10 এর প্রয়োজনীয় সীমা দেওয়া হয়েছে
• 1-ভিত্তিক পরিসর তৈরি করুন r=1 2 3 4 5 6 7 8 9 10
• প্রতিটি সংখ্যার অর্ধেকের সিলিং নিন n=1 1 2 2 3 3 4 4 5 5
• rদ্বারা প্রতিটি আইটেম প্রতিলিপি n।1 2 3 3 4 4 5 5 5 6 6 6 7 7 7 7 8 8 8 8 9 9 9 9 9 10 10 10 10 10
• শুরুর পয়েন্টের সাথে কাল্পনিক ইউনিটের পাওয়ারের সংখ্যাসমূহ নিন (এই অংশটি লিঙ্কযুক্ত চ্যালেঞ্জের বিভিন্ন পাইথন সমাধানের পক্ষে সাধারণ)

এর পরে, একবার স্থানাঙ্ক এর ভেক্টর vপ্রস্তুত, আমরা সহজেই সর্পিল সূচক ও কোঅর্ডিনেটগুলি দিয়ে মধ্যবর্তী রূপান্তর করতে পারেন v[i]এবং v⍳coord(প্রথম সূচক খোঁজার coordমধ্যে v)।

⍝ Define a function; ⍺=start, ⍵=end
f←{
  ⍝ Construct a vector of spiral coordinates v
  v←9 11∘○¨+\0,0j1*{⍵/⍨⌈⍵÷2}⍳⍺⌈⍵
                             ⍺⌈⍵  ⍝ max of start, end
                            ⍳     ⍝ range of 1 to that number
                   {⍵/⍨⌈⍵÷2}  ⍝ for each number n of above, copy itself ceil(n/2) times
               0j1*  ⍝ raise imaginary unit to the power of above
           +\0,      ⍝ prepend 0 and cumulative sum
                     ⍝ (gives vector of coordinates as complex numbers)
    9 11∘○¨  ⍝ convert each complex number into (real, imag) pair
  v←         ⍝ assign it to v

  ⍝ Extract start and end coordinates
  a w←(⍺⊃v)(⍵⊃v)

  ⍝ Compute the path the Queen will take
  v⍳+\(⊂a),↓⍉↑(|⍴¨×)w-a
                    w-a  ⍝ coordinate difference (end-start)
              (|⍴¨×)     ⍝ generate abs(x) copies of signum(x) for both x- and y-coords
                         ⍝ e.g. 4 -> (1 1 1 1), ¯3 -> (¯1 ¯1 ¯1)
           ↓⍉↑  ⍝ promote to matrix (with 0 padding), transpose and split again
                ⍝ (gives list of steps the Queen will take)
    +\(⊂a),     ⍝ prepend the starting point and cumulative sum
                ⍝ (gives the path as coordinates)
  v⍳  ⍝ index into the spiral vector (gives the spiral numbers at those coordinates)
}

Comments

(⍵⊃v)-⍺⊃v->⊃⍵⍺-.⊃⊂

— ngn

(⍺⌷v)->v[⍺]

— এনজিএন

Answer 2

গণিত 615 530 বাইট

এটি একটি নম্বর গ্রিড তৈরি করে, এটিকে গ্রাফে রূপান্তর করে এবং তারপরে দুটি সংখ্যার মধ্যে একটি সংক্ষিপ্ততম পথ খুঁজে পায় যা ইনপুট ছিল।

---

UnGolfed

numberSpiralম্যাথওয়ার্ল্ড প্রাইম সর্পিল থেকে । এটি এন উলাম সর্পিল দ্বারা একটি এন তৈরি করে (প্রাইমগুলি হাইলাইট না করে)।

findPathনম্বর গ্রিডকে গ্রাফে রূপান্তর করে। কিনারা সংখ্যা গ্রিডে বৈধ রানী পদক্ষেপ।

---

numberSpiral[n_Integer?OddQ]:= 
  Module[{a,i=(n+1)/2,j=(n+1)/2,cnt=1,dir=0,len,parity,vec={{1,0},{0,-1},{-1,0},{0,1}}},a=Table[j+n(i-1),{i,n},{j,n}];Do[Do[Do[a[[j,i]]=cnt++;{i,j}+=vec[[dir+1]],{k,len}];dir=Mod[dir+1,4],{parity,0,1}],{len,n-1}];a];  

findPath[v1_, v2_] := 
  Module[{f, z, k},
    (*f  creates edges between each number and its neighboring squares *)
    f[sp_,n_]:=n<->#&/@(sp[[Sequence@@#]]&/@(Position[sp,n][[1]]/.{r_,c_}:>Cases[{{r-1,c},{r+1,c},{r,c-1},{r,c+1},{r-1,c-1},{r-1,c+1},{r+1,c+1}, {r+1,c-1}},{x_,y_}/; 0<x<k&&0<y<k]));k=If[EvenQ[
     z=\[LeftCeiling]Sqrt[Sort[{v1, v2}][[-1]]]\[RightCeiling]],z+1,z];
    FindShortestPath[Graph[Sort/@Flatten[f[ns=numberSpiral[k],#]&/@Range[k^2]] //Union],v1,v2]]

---

উদাহরণ

findPath[4,5]
findPath[13,22]
findPath[16,25]
numberSpiral[5]//Grid

{4,5}

{13,3,1,7,22}

{16,4,1,9,25}

---

80 থেকে 1 এর সংক্ষিপ্ততম পথে 6 টি নয়, 5 টি রয়েছে।

findPath[80,1]
numberSpiral[9]//Grid

{80, 48, 24, 8, 1}

---

Golfed

u=Module;
w@n_:=u[{a,i=(n+1)/2,j=(n+1)/2,c=1,d=0,l,p,v={{1,0},{0,-1},{-1,0},{0,1}}},
a=Table[j+n(i-1),{i,n},{j,n}];
Do[Do[Do[a[[j,i]]=c++;{i,j}+=v[[d+1]],{k,l}];d=Mod[d+1,4],{p,0,1}],{l,n-1}];a];
h[v1_,v2_]:=u[{f,z},
s_~f~n_:=n<->#&/@(s[[Sequence@@#]]&/@(Position[s,n][[1]]/.{r_,c_}:> 
Cases[{{r-1,c},{r+1,c},{r,c-1},{r,c+1},{r-1,c-1},{r-1,c+1},{r+1,c+1},{r+1,c-1}},{x_,y_}/;0<x<k&&0<y<k]));
k=If[EvenQ[z=\[LeftCeiling]Sqrt[Sort[{v1,v2}][[-1]]]\[RightCeiling]],z+1,z];
FindShortestPath[g=Graph[Sort/@Flatten[f[ns=w@k,#]&/@Union@Range[k^2]]],v1,v2]]

Answer 3

স্কালা (830 বাইট)

চারটি পারস্পরিক পুনরাবৃত্তি ফাংশন ব্যবহার করে বর্গ 2D অ্যারেতে সর্পিল তৈরি করে। পথের তালিকাটি তৈরি করতে অন্য পুনরাবৃত্ত অনুসন্ধান।

def P(s:Int,e:Int):List[Int]={
import scala.math._
type G=Array[Array[Int]]
type I=Int
type T=(I,I)
def S(z:I)={def U(g:G,x:I,y:I,c:I,r:I):Unit={for(i<-0 to r.min(y)){g(y-i)(x)=c+i}
if(r<=y)R(g,x,y-r,c+r,r)}
def R(g:G,x:I,y:I,c:I,r:I)={for(i<-0 to r){g(y)(x+i)=c+i}
D(g,x+r,y,c+r,r+1)}
def D(g:G,x:I,y:I,c:I,r:I)={for(i<-0 to r){g(y+i)(x)=c+i}
L(g,x,y+r,c+r,r)}
def L(g:G,x:I,y:I,c:I,r:I)={for(i<-0 to r){g(y)(x-i)=c+i}
U(g,x-r,y,c+r,r+1)}
val g=Array.ofDim[I](z,z)
U(g,z/2,z/2,1,1)
g}
def C(n:I,g:G):T={var(x,y)=(0,0)
for(i<-g.indices){val j=g(i).indexOf(n)
if(j>=0){x=j
y=i}}
(x,y)}
def N(n:Int)=if(n==0)0 else if(n<0)-1 else 1
def Q(a:T,b:T):List[T]={val u=N(b._1-a._1)
val v=N(b._2-a._2)
if(u==0&&v==0)b::Nil else a::Q((a._1+u,a._2+v),b)}
val z=ceil(sqrt(max(s,e))).toInt|1
val p=S(z)
Q(C(s,p),C(e,p)).map{case(x,y)=>p(y)(x)}}

Ungolfed

  import scala.math._
  type Grid=Array[Array[Int]]
  def spiral(size: Int) = {
    def up(grid:Grid, x: Int, y: Int, c: Int, r: Int): Unit = {
      for (i <- 0 to r.min(y)) {
        grid(y-i)(x) = c + i
      }
      if (r <= y)
        right(grid,x,y-r,c+r,r)
    }
    def right(grid:Grid, x: Int, y: Int, c: Int, r: Int) = {
      for (i <- 0 to r) {
        grid(y)(x+i) = c + i
      }
      down(grid,x+r,y,c+r,r+1)
    }
    def down(grid:Grid, x: Int, y: Int, c: Int, r: Int) = {
      for (i <- 0 to r) {
        grid(y+i)(x) = c + i
      }
      left(grid,x,y+r,c+r,r)
    }
    def left(grid:Grid, x: Int, y: Int, c: Int, r: Int) = {
      for (i <- 0 to r) {
        grid(y)(x-i) = c + i
      }
      up(grid,x-r,y,c+r,r+1)
    }
    val grid = Array.ofDim[Int](size,size)
    up(grid,size/2,size/2,1,1)
    grid
  }
  def findPath(start: Int, end: Int): List[Int] = {
    def findCoords(n: Int, grid: Grid): (Int, Int) = {
      var (x,y)=(0,0)
      for (i <- grid.indices) {
        val j = grid(i).indexOf(n)
        if (j >= 0) {
          x = j
          y = i
        }
      }
      (x,y)
    }
    def sign(n: Int) = if (n == 0) 0 else if (n < 0) -1 else 1
    def path(stc: (Int, Int), enc: (Int, Int)) : List[(Int, Int)] = {
      val dx = sign(enc._1 - stc._1)
      val dy = sign(enc._2 - stc._2)
      if (dx == 0 && dy == 0) {
        enc :: Nil
      } else {
        stc :: path((stc._1 + dx, stc._2 + dy), enc)
      }
    }
    val size = ceil(sqrt(max(start, end))).toInt | 1
    val spir = spiral(size)
    path(findCoords(start, spir),findCoords(end, spir)).
      map { case (x, y) => spir(y)(x) }
  }

Answer 4

রুবি, 262 218 216 বাইট

এটি আমার পাইথন উত্তরের একটি বন্দর । গল্ফিং পরামর্শ স্বাগত জানাই।

সম্পাদনা: 45 জর্ডান এবং তাদের পরামর্শ ধন্যবাদ বাইট d=[0]*n=m*m;*e=c=0;*t=a, .rect, 0<=>xএবং x,y=(e[a]-g=e[b]).rect; t<<d[(g.real+x)*m+g.imag+y]। থেকে আরেকটি বাইট (x+y*1i)থেকে (x+y.i)।

->a,b{m=([a,b].max**0.5).to_i+1;d=[0]*n=m*m;*e=c=0;*t=a
n.times{|k|d[c.real*m+c.imag]=k+1;e<<c;c+=1i**((4*k+1)**0.5-1).to_i}
x,y=(e[a]-g=e[b]).rect
(x+=0<=>x;y+=0<=>y;t<<d[(g.real+x)*m+g.imag+y])while(x+y.i).abs>0
t}

Ungolfed:

def q(a,b)
  m = ([a,b].max**0.5).to_i+1
  n = m*m
  d = [0]*n
  c = 0
  *e = c   # same as e=[0]
  *t = a   # same as t=[a]

  (1..n).each do |k|
    d[c.real * m + c.imag] = k+1
    e << c
    c += 1i**((4*k+1)**0.5-1).to_i
  end

  x, y = (e[a] - g=e[b]).rect

  while (x+y.i).abs > 0 do
    if x<0
      x += 1
    elsif x>0
      x += -1
    end

    if y<0
      y += 1
    elsif y>0
      y -= 1
    end

    t << d[(g.real+x)*m+g.imag+y]
  end

  return t
end

Comments

আপনি q=আপনার উত্তরটি অপসারণ করবেন কারণ আপনি এর বাইটগুলি গণনা করছেন না। c=0;e=[c];t=[a]সংক্ষিপ্ত করা যেতে পারে *e=c=0;*t=a। আপনি প্রতিস্থাপন করতে পারেন z=e[a]-e[b];x,y=z.real,z.imagসঙ্গে x,y=(e[a]-e[b]).rectএবং x+=x<0?1:x>0?-1:0সঙ্গে x+=0<=>x(জন্য একই y)। আমি মনে করি এটি 229 বাইটে নেমে গেছে।

— জর্ডান

আপনি যদি 1-মাত্রিক অ্যারেতে স্যুইচ করেন তবে আপনি আরও 6 টি বাইট সংরক্ষণ করতে পারবেন। আরম্ভের প্রতিস্থাপন dসঙ্গে d=[0]*m*m, তারপর প্রতিস্থাপন d[c.real][c.imag]সঙ্গে d[c.real*m+c.imag]এবং d[e[b].real+x][e[b].imag+y]সঙ্গে d[(e[b].real+x)*m+e[b].imag+y]।

— জর্ডান

আমার আগের মন্তব্যের চেয়ে 2-বাইট উন্নতি: t<<d[(e[b].real+x)*m+e[b].imag+y]এটি সংক্ষিপ্ত করা যেতে পারে u,v=e[b].rect;t<<d[(u+x)*m+v+y]।

— জর্ডান

আরও দুইজন পরিবর্তন করে বাইট d=[0]*m*mথেকে d=[0]*n=m*mএবং (m*m).timesথেকে n.times। এটি 219.

— জর্ডান

আপনি পরিবর্তন করে দুটি অতিরিক্ত বাইট সংরক্ষণ করতে পারবেন x,y=(e[a]-e[b]).rectকরার x,y=(e[a]-g=e[b]).rect, মুছে ফেলা u,v=e[b].rectএবং পরিবর্তন t<<d[(u+x)*m+v+y]করার জন্য t<<d[(g.real+x)*g.imag+v+y](মূলত আমার দ্বিতীয় টু গত মন্তব্য প্রত্যাবর্তন)।

— জর্দান

Answer 5

পাইথন 3, 316 বাইট

এই উত্তরটি সর্পিলের (স্থির সংখ্যার সাহায্যে) স্থানাঙ্কগুলি aএবং এর দিকে লক্ষ্য করে bএবং প্রথমে তির্যক চলগুলি যুক্ত করে, তারপরে অরথোগোনাল মুভগুলি যুক্ত করে।

def q(a,b):
 m=int(max(a,b)**.5)+1;d=[];c=0;e=[c];t=[a]
 for i in range(m):d+=[[0]*m]
 for k in range(m*m):d[int(c.real)][int(c.imag)]=k+1;e+=[c];c+=1j**int((4*k+1)**.5-1)
 z=e[a]-e[b];x,y=int(z.real),int(z.imag)
 while abs(x+y*1j):x+=(x<0)^-(x>0);y+=(y<0)^-(y>0);t+=[d[int(e[b].real)+x][int(e[b].imag)+y]]
 return t

Ungolfed:

def queen_spiral(a,b):
    square_size = int(max(a,b)**.5)+1
    complex_to_spiral = []
    complex = 0
    spiral_to_complex = [c] # add 0 first, so that it's 1-indexed later
    result = [a]

    for i in range(square_size):
        complex_to_spiral.append([0]*square_size) # the rows of the spiral

    for k in range(square_size**2):
        row = int(complex.real)
        column = int(complex.imag)
        complex_to_spiral[row][column] = k+1 # 1-indexing

        spiral_to_complex.append(complex)

        quarter_turns = int((4*k+1)**.5-1)
        complex += 1j**quarter_turns

    z = spiral_to_complex[a] - spiral_to_complex[b]
    v = spiral_to_complex[b]
    x, y = int(z.real), int(z.imag)
    r, s = int(v.real), int(v.imag)

    while abs(x+y*1j):
        if x < 0:
            x += 1
        elif x > 0:
            x += -1
        # else x == 0, do nothing
        if y < 0:
            y += 1
        elif y > 0:
            y += -1

        vertex = complex_to_spiral[r+x][s+y]
        result.append(vertex)
    return result