Vẽ tam giác Sierpinki đã được thực hiện cho đến chết . Có những điều thú vị khác chúng ta có thể làm với nó mặc dù. Nếu chúng ta nheo mắt đủ cứng tại tam giác, chúng ta có thể xem các tam giác lộn ngược như các nút của đồ thị fractal. Hãy tìm cách của chúng tôi xung quanh biểu đồ đó!

Đầu tiên, hãy gán một số cho mỗi nút. Tam giác lộn ngược lớn nhất sẽ là nút 0, và sau đó chúng ta chỉ đi xuống từng lớp (chiều rộng đầu tiên), gán các số liên tiếp theo thứ tự trên cùng bên trái:

^{Nhấp vào để xem phiên bản lớn hơn trong đó các số nhỏ sẽ mờ hơn một chút.}

(Tất nhiên, mô hình này tiếp tục vô cùng tận bên trong tam giác màu xanh.) Một cách khác để xác định việc đánh số là các nút trung tâm có chỉ số 0, và các con của nút i(hình tam giác liền kề của quy mô tiếp theo nhỏ hơn) có chỉ số 3i+1, 3i+2và 3i+3.

Làm thế nào để chúng ta di chuyển xung quanh biểu đồ này? Có tối đa sáu bước tự nhiên người ta có thể thực hiện từ bất kỳ tam giác nào:

• Người ta luôn có thể di chuyển qua điểm giữa của một trong các cạnh đến một trong ba phần tử con của nút hiện tại. Chúng tôi sẽ chỉ định những động thái này là N, SWvà SE. Ví dụ, nếu chúng ta hiện đang ở trên nút 2, những sẽ dẫn đến các nút 7, 8, 9, tương ứng. Các di chuyển khác qua các cạnh (đến hậu duệ gián tiếp) không được phép.
• Người ta cũng có thể di chuyển qua một trong ba góc, với điều kiện nó không chạm vào cạnh của tam giác, với cha mẹ trực tiếp hoặc một trong hai tổ tiên gián tiếp. Chúng tôi sẽ chỉ định những động thái này là S, NEvà NW. Ví dụ: nếu chúng tôi hiện đang ở trên nút 31, Ssẽ dẫn đến 10, NEsẽ không hợp lệ và NWsẽ dẫn đến 0.

Các thách thức

Cho hai số nguyên không âm xvà y, tìm đường đi ngắn nhất từ xđến y, chỉ sử dụng sáu động tác được mô tả ở trên. Nếu có một vài đường dẫn ngắn nhất, hãy xuất bất kỳ một trong số chúng.

Lưu ý rằng mã của bạn sẽ hoạt động không chỉ cho 5 cấp độ được mô tả trong sơ đồ trên. Bạn có thể cho rằng x, y < 1743392200. Điều này đảm bảo rằng chúng vừa với số nguyên có chữ ký 32 bit. Lưu ý rằng điều này tương ứng với 20 cấp độ của cây.

Mã của bạn phải xử lý bất kỳ đầu vào hợp lệ nào trong vòng chưa đầy 5 giây . Mặc dù điều này loại trừ một tìm kiếm đầu tiên theo chiều rộng, nó phải là một ràng buộc khá lỏng lẻo - việc triển khai tham chiếu của tôi xử lý đầu vào tùy ý cho độ sâu 1000 trong nửa giây (đó là ~ 480 chữ số cho các nút).

Bạn có thể viết chương trình hoặc hàm, lấy đầu vào qua STDIN (hoặc thay thế gần nhất), đối số dòng lệnh hoặc đối số hàm và xuất kết quả qua tham số STDOUT (hoặc thay thế gần nhất), tham số trả về hàm hoặc tham số hàm (out).

Sản lượng nên được một căn hộ, danh sách rõ ràng của chuỗi N, S, NE, NW, SE, SW, sử dụng bất kỳ phân cách hợp lý (không gian, linefeeds, dấu phẩy, ","...).

Luật golf tiêu chuẩn được áp dụng.

Các trường hợp thử nghiệm

Một vài trường hợp thử nghiệm đầu tiên có thể được xử lý bằng tay bằng cách sử dụng sơ đồ trên. Những người khác đảm bảo rằng câu trả lời là đủ hiệu quả. Đối với những người, có thể có các giải pháp khác có cùng độ dài không được liệt kê.

0 40                    => N N N N
66 67                   => S SW N N N
30 2                    => NW NW -or- NE SW
93 2                    => NE SW
120 61                  => NW NW NW NW N SE SW N
1493682877 0            => S S NW NW
0 368460408             => SW SW N N SW SW SE SW SW N SE N N SW SW N SE SE
1371432130 1242824      => NW NW NE NW N SE SW SW SW SE SE SW N N N N SW
520174 1675046339       => NE NW NE NE SE SE SW SW N SE N SW N SW SE N N N N SE SE SW SW
312602548 940907702     => NE NW S SW N N SW SE SE SE SW SE N N SW SE SE SE SW
1238153746 1371016873   => NE NE NE SE N N SW N N SW N SE SE SW N SW N N SE N SE N
547211529 1386725128    => S S S NE NW N N SE N SW N SE SW SE SW N SE SE N SE SW SW N
1162261466 1743392199   => NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE

Ruby, 195 194 190 184 byte

Bản gốc: Với lời xin lỗi tới Ell , vì đây thực chất là một câu trả lời của họ và cảm ơn Doorknob rất nhiều vì đã giúp họ gỡ lỗi câu trả lời này. Có lẽ có một thuật toán khác cho vấn đề này - một cái gì đó để làm *f[x[0,**however far x matches with y**],y]- nhưng tôi sẽ lưu nó vào một lần khác.

a=->n{n<1?[]:a[~-n/3]+[-n%3]}
f=->x,y{j=x.size
(Array===x)?x==y[0,j]?y[j..-1].map{|m|%w[SE SW N][m]}:x.uniq.map{|m|[%w[NW NE S][m],*f[x[0,x.rindex(m)],y]]}.min_by(&:size):f[a[x],a[y]]}

EDIT: Thuật toán tham lam không hoạt động h[299792458, 1000000]. Tôi đã trả lại số byte cho 195, trong khi tôi sửa chữa thuật toán của mình một lần nữa. Đã sửa nó chỉ cho số byte tăng lên 203. Thở dài

Đang xây dựng: Chương trình này sử dụng thuật toán tham lam để tìm tổ tiên chung x[0,j]==y[0,j](lưu ý: có thể có một số tổ tiên chung). Thuật toán dựa rất lỏng lẻo vào tìm kiếm tổ tiên đệ quy của Ell . Nửa đầu của các hướng dẫn kết quả là làm thế nào để có được tổ tiên chung này, và nửa thứ hai là nhận được y dựa trên y[j..-1].

Lưu ý: a[n]đây trả về một cơ sở-3 đếm song ánh sử dụng các chữ số 2,1,0thay vì 1,2,3.

Ví dụ, hãy chạy qua f[59,17]hoặc f[[2,0,2,1],[2,1,1]]. Đây , j == 1. Để đến x[0,j], chúng tôi đi 0hoặc NW. Sau đó, để có được y, đi [1,1]hoặcSW SW

a=->n{n<1?[]:a[~-n/3]+[-n%3]}
h=->m,n{x=a[m];y=a[n];c=[];j=x.size
(j=x.uniq.map{|m|k=x.rindex(m);x[0..k]==y[0..k]?j:k}.min
c<<%w[NW NE S][x[j]];x=x[0,j])until x==y[0,j]
c+y[j..-1].map{|m|%w[SE SW N][m]}}

Con trăn 2 208 205 200 byte

A=lambda n:n and A(~-n/3)+[-n%3]or[]
f=lambda x,y:f(A(x),A(y))if x<[]else["SSNEW"[m::3]for m in
y[len(x):]]if x==y[:len(x)]else min([["NNSWE"[m::3]]+f(x[:~x[::-1].index(m)],y)for
m in set(x)],key=len)

Một hàm, flấy một cặp số nút và trả về đường dẫn ngắn nhất dưới dạng danh sách các chuỗi.

Giải trình

Chúng tôi bắt đầu bằng cách sử dụng một sơ đồ địa chỉ khác nhau cho các hình tam giác; địa chỉ của mỗi tam giác là một chuỗi, được định nghĩa như sau:

• Địa chỉ của tam giác trung tâm là chuỗi rỗng.

• Địa chỉ của phía bắc, phía tây nam, và trẻ em phía đông nam của mỗi tam giác được hình thành phụ thêm 0, 1và 2, tương ứng, đến địa chỉ của tam giác.

Về cơ bản, địa chỉ của mỗi tam giác mã hóa đường dẫn (ngắn nhất) từ tam giác trung tâm đến nó. Điều đầu tiên mà chương trình của chúng tôi làm là dịch các số tam giác đầu vào sang các địa chỉ tương ứng.

^{Click vào hình ảnh cho một phiên bản lớn hơn.}

Các di chuyển có thể có tại mỗi tam giác được xác định dễ dàng từ địa chỉ:

• Để di chuyển về phía bắc, phía tây nam, và trẻ em Đông Nam, chúng tôi chỉ đơn giản là append 0, 1và 2, tương ứng, để địa chỉ.

• Để di chuyển về phía nam, phía đông bắc, và tổ tiên về phía tây bắc, chúng ta tìm thấy (ngoài cùng bên phải) xuất hiện cuối cùng của 0, 1và 2, tương ứng, và trim địa chỉ để bên trái của nó. Nếu không có 0, 1hoặc 2trong địa chỉ, thì tổ tiên tương ứng không tồn tại. Ví dụ, để chuyển sang tổ tiên phía tây bắc 112(ví dụ, cha mẹ của nó), chúng ta thấy sự xuất hiện cuối cùng của 2năm 112, đó là ký tự cuối cùng, và trim địa chỉ để bên trái của nó, cho chúng ta 11; để chuyển sang tổ tiên về phía đông bắc, chúng ta thấy sự xuất hiện cuối cùng của 1năm 112, đó là nhân vật thứ hai, và trim địa chỉ để bên trái của nó, cho chúng ta 1; tuy nhiên, 112không có tổ tiên phía nam, vì không có0 trong địa chỉ của nó.

Lưu ý một vài điều về một cặp địa chỉ xvà y:

• Nếu xlà một chuỗi ban đầu y, sau đó ylà một hậu duệ của x, và do đó con đường ngắn nhất từ xđể ychỉ đơn giản là đi theo con tương ứng của mỗi tam giác giữa xvà y; nói cách khác, chúng ta có thể thay thế từng 0, 1và 2ở y[len(x):]với N, SWvà SE, tương ứng.

• Mặt khác, hãy ilà chỉ số của sự không phù hợp đầu tiên giữa xvà y. Không có con đường từ xđể ymà không đi qua x[:i](mà cũng giống như y[:i]), tức là tổ tiên chung đầu tiên của xvà y. Do đó, bất kỳ con đường từ xđến yphải đến x[:i], hay một trong những tổ tiên của mình, chúng ta hãy gọi tam giác này z, và sau đó tiếp tục y. Đến từ xtới z, chúng tôi làm theo tổ tiên như đã mô tả ở trên. Con đường ngắn nhất từ zđến yđược đưa ra bởi điểm đạn trước đó.

Nếu xlà một chuỗi con ban đầu của y, thì con đường ngắn nhất từ xđến ydễ dàng được đưa ra bởi dấu đầu dòng đầu tiên ở trên. Nếu không, chúng ta để cho jlà nhỏ nhất của các chỉ số trong những sự cố cuối cùng của 0, 1và 2trong x. Nếu jlớn hơn, hoặc bằng, chỉ số của không phù hợp đầu tiên giữa xvà y, ichúng ta chỉ cần thêm động thái tương ứng ( S, NEhoặc NW, tương ứng) để con đường, cắt xbên trái của j, và tiếp tục. Mọi thứ trở nên phức tạp hơn nếu jít hơn i, kể từ đó chúng ta có thể đạt được ynhanh nhất bằng cách tăng x[:j]trực tiếp đến tổ tiên chung và giảm dần tất cả các cách đểyhoặc chúng ta có thể đến một tổ tiên chung khác xvà ygần hơn ybằng cách tăng dần đến một tổ tiên khác xở bên phải ivà đi từ đó đến ynhanh hơn. Ví dụ, để đi từ 1222đến 1, con đường ngắn nhất là trước tiên đi lên tam giác trung tâm (có địa chỉ là chuỗi rỗng), sau đó đi xuống 1, tức là di chuyển đầu tiên đưa chúng ta sang bên trái của điểm không khớp. tuy nhiên, để đi từ 1222đến 12, con đường ngắn nhất là đi lên 122, và sau đó 12, tức là, bước đầu tiên giữ chúng ta ở bên phải điểm không khớp.

Vì vậy, làm thế nào để chúng ta tìm thấy con đường ngắn nhất? Chương trình "chính thức" sử dụng cách tiếp cận brute-force-ish, thử tất cả các động thái có thể đến bất kỳ tổ tiên nào mỗi khi xkhông phải là một chuỗi con ban đầu y. Nó không tệ như âm thanh! Nó giải quyết tất cả các trường hợp thử nghiệm, kết hợp, trong vòng một hoặc hai giây.

Nhưng sau đó, một lần nữa, chúng ta có thể làm tốt hơn nhiều: Nếu có nhiều hơn một tổ tiên có thể tiếp cận trực tiếp ở bên trái của điểm không khớp, chúng ta chỉ cần kiểm tra một bên phải nhất, và nếu có nhiều hơn một tổ tiên có thể tiếp cận trực tiếp với bên phải của điểm không phù hợp, chúng ta chỉ cần kiểm tra cái ngoài cùng bên trái. Điều này mang lại một thuật toán thời gian tuyến tính, ghi lại độ dài của x(nghĩa là độ sâu của tam giác nguồn hoặc thời gian tỷ lệ với logarit của số tam giác nguồn), phóng to qua các trường hợp thử nghiệm lớn hơn nhiều. Chương trình sau đây thực hiện thuật toán này, ít nhất là về bản chất, do chơi golf, sự phức tạp của nó, trên thực tế, tệ hơn tuyến tính, nhưng nó vẫn rất nhanh.

Con trăn 2 271 266 261 byte

def f(x,y):
 exec"g=f;f=[]\nwhile y:f=[-y%3]+f;y=~-y/3\ny=x;"*2;G=["SSNEW"[n::3]for
n in g];P=G+f;p=[];s=0
 while f[s:]:
    i=len(f)+~max(map(f[::-1].index,f[s:]));m=["NNSWE"[f[i]::3]]
    if f[:i]==g[:i]:P=min(p+m+G[i:],P,key=len);s=i+1
    else:p+=m;f=f[:i]
 return P

Lưu ý rằng, không giống như phiên bản ngắn hơn, phiên bản này được viết riêng không sử dụng đệ quy trong việc chuyển đổi các giá trị đầu vào thành địa chỉ tương ứng của chúng, để nó có thể xử lý các giá trị rất lớn mà không bị tràn ngăn xếp.

Các kết quả

Đoạn mã sau có thể được sử dụng để chạy thử nghiệm cho cả hai phiên bản và tạo kết quả:

def test(x, y, length):
    path = f(x, y)
    print "%10d %10d  =>  %2d: %s" % (x, y, len(path), " ".join(path))
    assert len(path) == length

#         x           y        Length
test(          0,          40,    4   )
test(         66,          67,    5   )
test(         30,           2,    2   )
test(         93,           2,    2   )
test(        120,          61,    8   )
test( 1493682877,           0,    4   )
test(          0,   368460408,   18   )
test( 1371432130,     1242824,   17   )
test(     520174,  1675046339,   23   )
test(  312602548,   940907702,   19   )
test( 1238153746,  1371016873,   22   )
test(  547211529,  1386725128,   23   )
test( 1162261466,  1743392199,   38   )

Phiên bản chơi gôn

         0         40  =>   4: N N N N
        66         67  =>   5: S SW N N N
        30          2  =>   2: NE SW
        93          2  =>   2: NE SW
       120         61  =>   8: NW NW NW NW N SE SW N
1493682877          0  =>   4: S S NW NW
         0  368460408  =>  18: SW SW N N SW SW SE SW SW N SE N N SW SW N SE SE
1371432130    1242824  =>  17: NW NW NE NW N SE SW SW SW SE SE SW N N N N SW
    520174 1675046339  =>  23: NE NE NE NE SE SE SW SW N SE N SW N SW SE N N N N SE SE SW SW
 312602548  940907702  =>  19: NE NW S SW N N SW SE SE SE SW SE N N SW SE SE SE SW
1238153746 1371016873  =>  22: NE NE NE SE N N SW N N SW N SE SE SW N SW N N SE N SE N
 547211529 1386725128  =>  23: S S S S NW N N SE N SW N SE SW SE SW N SE SE N SE SW SW N
1162261466 1743392199  =>  38: NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE

Phiên bản hiệu quả

         0         40  =>   4: N N N N
        66         67  =>   5: S SW N N N
        30          2  =>   2: NW NW
        93          2  =>   2: NE SW
       120         61  =>   8: NW NW NW NW N SE SW N
1493682877          0  =>   4: NE S NW NW
         0  368460408  =>  18: SW SW N N SW SW SE SW SW N SE N N SW SW N SE SE
1371432130    1242824  =>  17: NW NW NE NW N SE SW SW SW SE SE SW N N N N SW
    520174 1675046339  =>  23: NE NW NE NE SE SE SW SW N SE N SW N SW SE N N N N SE SE SW SW
 312602548  940907702  =>  19: NE NW S SW N N SW SE SE SE SW SE N N SW SE SE SE SW
1238153746 1371016873  =>  22: NE NE NE SE N N SW N N SW N SE SE SW N SW N N SE N SE N
 547211529 1386725128  =>  23: S S S S NW N N SE N SW N SE SW SE SW N SE SE N SE SW SW N
1162261466 1743392199  =>  38: NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE NE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE SE

APL (Dyalog Unicode) , 144 132 129 118 133 132 130 124 117 byte ^SBCS

Cảm ơn bạn rất nhiều đến Ven và ngn vì sự giúp đỡ của họ trong việc chơi golf này trong The APL Orchard , một nơi tuyệt vời để học ngôn ngữ APL. ⎕IO←0. Gợi ý chơi golf chào mừng.

Chỉnh sửa: -12 byte nhờ Ven và ngn bằng cách thay đổi cách nxác định và chuyển từ lập chỉ mục 1 sang lập chỉ mục 0. -3 do sửa lỗi trong đó không phải mọi thứ đều được chuyển sang lập chỉ mục 0. -11 byte do thay đổi cách thức Pvà Qđược xác định. +15 byte do khắc phục sự cố trong đó thuật toán của tôi không chính xác với nhiều lời cảm ơn vì đã giúp đỡ trong việc tìm ra s[⊃⍋|M-s]phần. -2 byte từ việc sắp xếp lại phương pháp tìm đường dẫn quay lại và byte 1 để sửa lỗi. -2 byte nhờ Adám sắp xếp lại định nghĩa I. -6 byte nhờ ngn từ sắp xếp lại định nghĩa 'S' 'NE' 'NW' 'N' 'SW' 'SE'và từ sắp xếp lại cách txác định (nó không còn là một biến riêng biệt). -7 byte nhờ ngn từ việc chơi golf sđược định nghĩa như thế nào .

{M←⊃⍸≠⌿↑1+P Q←⍵{(⍵/3)⊤⍺-+/3*⍳⍵}¨⌊3⍟1+⍵×2⋄(∪¨↓6 2⍴'SSNENWNNSWSE')[P[I],3+Q↓⍨⊃⌽I←⍬{M≥≢⍵:⍺⋄(⍺∘,∇↑∘⍵)s[⊃⍋|M-s←⌽⊢.⊢⌸⍵]}P]}

Hãy thử trực tuyến!

Giải thích về lỗi trong thuật toán

Vấn đề cơ bản là tôi đã nghĩ rằng con đường ngắn nhất đã đi thẳng qua tổ tiên chung, và trên thực tế, không thể đi qua một tổ tiên của tổ tiên chung. Điều này là không chính xác như các ví dụ sau đây sẽ chứng minh.

Từ 66 đến 5

66 → 0 2 2 2 → 0 2 2 2
5  → 0 1     → 0 1
      ↑ common ancestor

The two ancestors of 0 2 2 2 are:
0 2 2
(empty)

(empty) has the shorter path back to 0 1 as it only needs two forward moves,
while 0 2 2 requires two more backtracks and one more forward move.

Từ 299792458 đến 45687

299792458 → 0 2 1 1 0 1 1 2 1 1 1 2 1 0 2 2 2 0
45687     → 0 2 1 1 0 1 1 1 2 2
                         ↑ common ancestor

The three ancestors of 299792458 are:
0 2 1 1 0 1 1 2 1 1 1 2 1 0 2 2 2
0 2 1 1 0 1 1 2 1 1 1 2            ← choose this one
0 2 1 1 0 1 1 2 1 1 1 2 1 0 2 2

And the three ancestors of 0 2 1 1 0 1 1 2 1 1 1 2 are:
0 2 1 1
0 2 1 1 0 1 1 2 1 1
0 2 1 1 0 1 1 2 1 1 1

0 2 1 1 0 1 1 1 2 2    ← 45687 for reference
             ↑ common ancestor

While it seems like `0 2 1 1` is the shorter path,
it actually results in a path that is 8 steps long
(2 backtracks, 6 forward steps to 45687).

Meanwhile, `0 2 1 1 0 1 1 2 1 1` is at an equal distance
to the common ancestor and has the following ancestors:
0 2 1 1
0 2 1 1 0 1 1 2 1
0 2 1 1 0 1 1

0 2 1 1 0 1 1 1 2 2    ← 45687 for reference
             ↑ common ancestor

Clearly, this is the superior path, as with three backtracks, we have reached
the point of the common ancestor. With 3 backtracks and 3 forward moves,
we have a path that is 6 steps long.

Giải thích về mã

                       ⍝ ⍵ should be an array of 2 integers, x y
SierpinskiPath←{⎕IO←0  ⍝ 0-indexing
        ⍝ P Q←{...}¨⍵  ⍝ First, the bijective base-3 numeration of x and y
    P Q←{
        n←⌊3⍟1+⍵×2  ⍝ The number of digits in the numeration
        z←+/3*⍳⍵    ⍝ The number of numerations with ≤ n digits
        (n/3)⊤⍵-z   ⍝ And a simple decode ⊤ (base conversion) of ⍵-z
    }¨⍵             ⍝ gets us our numerations, our paths

    A←↑1+P Q      ⍝ We turn (1+P Q) into an 2-by-longest-path-length array 
                  ⍝ ↑ pads with 0s and our alphabet also uses 0s
                  ⍝ So we add 1 first to avoid erroneous common ancestor matches
    Common←⊃⍸≠⌿A  ⍝ We find the length of the common ancestor, Common

        ⍝ I←⍬{...}P  ⍝ Now we get the shortest backtracking path from P
    I←⍬{
        Common=≢⍵:⍺       ⍝ If P is shorter than Common, return our backtrack path
        s←⌽⊢.⊢⌸⍵          ⍝ Get the indices of the most recent N SW SE
        t←s[⊃⍋|Common-s]  ⍝ and keep the index that is closest to Common
                          ⍝ and favoring the ancestors to the right of
                          ⍝ Common in a tiebreaker (which is why we reverse ⊢.⊢⌸⍵)
        (⍺,t)∇t↑⍵         ⍝ Then repeat this with each new index to backtrack
    }P                    ⍝ and the path left to backtrack through

    Backtrack←P[I]   ⍝ We get our backtrack directions
    Forward←(⊃⌽I)↓Q  ⍝ and our forward moves to Q
                     ⍝ starting from the appropriate ancestor
    (∪¨↓6 2⍴'SSNENWNNSWSE')[Backtrack,Forward]    ⍝ 'S' 'NE' 'NW' 'N' 'SW' 'SE'
}                    ⍝ and return those directions

Giải pháp thay thế sử dụng Dyalog Extended và dfns

Nếu chúng ta sử dụng ⎕CY 'dfns''s adicchức năng, nó thực hiện song ánh base-n thù lao của chúng tôi (đó là nguồn cảm hứng cho phiên bản tôi sử dụng) cho byte rất ít. Chuyển sang Dyalog Extended cũng tiết kiệm khá nhiều byte và vì vậy chúng tôi ở đây. Rất cám ơn Adám đã giúp đỡ trong việc chơi golf này. Gợi ý chơi golf chào mừng!

Chỉnh sửa: -8 byte do thay đổi cách thức Pvà Qđược xác định. -14 byte do chuyển sang Dyalog Extended. -2 do sử dụng một chương trình đầy đủ để loại bỏ các dấu ngoặc dfn {}. +17 byte do khắc phục sự cố trong đó thuật toán của tôi không chính xác với nhiều lời cảm ơn vì đã giúp đỡ trong việc tìm ra s[⊃⍋|M-s]phần. +1 byte để sửa lỗi. -2 byte nhờ Adám sắp xếp lại định nghĩa I và -1 byte từ việc ghi nhớ để đưa các gôn của tôi vào cả hai giải pháp . -3 byte nhờ ngn bằng cách sắp xếp lại việc tạo ra các hướng hồng y, +1 byte từ việc sửa lỗi golf và -3 byte nhờ ngn bằng cách sắp xếp lại cách txác định (nó không còn là biến riêng biệt). -7 byte nhờ ngn bằng cách sắp xếp lại cách sxác định.

APL (Dyalog mở rộng) , 123 115 101 99 116 117 114 109 102 byte

M←⊃⍸≠⌿↑1+P Q←(⍳3)∘⌂adic¨⎕⋄(∪¨↓6 2⍴'SSNENWNNSWSE')[P[I],3+Q↓⍨⊃⌽I←⍬{M≥≢⍵:⍺⋄(⍺∘,∇↑∘⍵){⍵[⊃⍋|M-⍵]}⌽⊢.⊢⌸⍵}P]

Hãy thử trực tuyến!