^{(Có những câu hỏi liên quan về các hố cát vô hạn và tìm các yếu tố nhận dạng của các hố cát .)}

Cho một ma trận các số nguyên không âm, trả về một ma trận có cùng kích thước, nhưng được lật đổ :

1. Nếu ma trận không chứa bất kỳ giá trị nào lớn hơn 4, hãy trả về nó.
2. Mỗi "ô" lớn hơn 3 được giảm 4 và tất cả các ô lân cận trực tiếp (trên, dưới, trái và phải) đều được tăng lên, nếu chúng tồn tại.
3. GOTO 1.

Ví dụ:

0 1 0        0 2 0
2 4 0   ->   3 0 1
0 0 3        0 1 3

1 2 3    2 3 4    2 5 1    4 1 2    0 3 3    0 3 3    0 3 3
4 5 6 -> 2 4 4 -> 4 2 3 -> 0 5 4 -> 3 2 1 -> 3 3 1 -> 3 3 2
7 8 9    5 7 7    2 6 5    4 3 2    0 5 3    1 1 4    1 2 0

(Bạn chỉ cần trả về kết quả cuối cùng. Đường dẫn mà bạn đạt được có thể khác với đường dẫn được hiển thị ở đây: không quan trọng bạn thực hiện các thao tác lật đổ nào, tất cả đều dẫn đến cùng một kết quả.)

Để được giải thích sâu hơn và một số động lực, hãy xem video Numberphile này hoặc bài viết trên Wikipedia về mô hình hố cát Abelian .

Quy tắc:

• Bạn có thể lấy đầu vào và đầu ra theo bất kỳ cách tiêu chuẩn nào
• Lỗ hổng bị cấm
• Đầu vào và đầu ra có thể là:
  • một danh sách lồng nhau: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  • một danh sách đơn giản: [1, 2, 3, 4, 5, 6, 7, 8, 9] và hình dạng
  • một số loại ma trận bản địa
  • một chuỗi, ví dụ 1 2 3\n4 5 6\n7 8 9
  • hoặc bất cứ điều gì khác làm việc trong ngôn ngữ của bạn.
• Đầu vào và đầu ra phải ở cùng một dạng
• Đầu vào có thể chứa số lớn hơn số được hiển thị ở đây, nhưng kích thước có thể bị ràng buộc bởi các giới hạn của ngôn ngữ của bạn (tương đương MAXINT, nếu có)
• Ma trận có thể có bất kỳ hình dạng nào (ví dụ: 1x1, 2x2, 3x3, 4x4, 2x7, 11x3, ...)
• Bạn không cần xử lý trường hợp hình dạng là 0xN hoặc Nx0.

Tủ thử

[[2, 5, 4], [8, 6, 4], [1, 2, 3]] -> [[3, 3, 0], [1, 2, 2], [1, 3, 2]]
[[0, 0, 2], [1, 3, 3], [0, 0, 0]] -> [[0, 0, 2], [1, 3, 3], [0, 0, 0]]
[[9, 9, 9], [9, 9, 9], [9, 9, 9]] -> [[1, 3, 1], [3, 1, 3], [1, 3, 1]]
[[4, 5], [2, 3]] -> [[2, 3], [0, 1]]
[[2, 3, 5], [2, 2, 0]] -> [[3, 0, 2], [2, 3, 1]]
[[7]] -> [[3]]

Đây là codegolf , mã ngắn nhất (theo ngôn ngữ) sẽ thắng.

MATL , 17 byte

tss:"t3>t1Y6Z+w4*-+

Hãy thử nó tại MATL Online! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Chương trình lặp đi lặp lại nhiều lần bằng tổng của đầu vào. Đây là một giới hạn trên lỏng lẻo trên số lần lặp yêu cầu.

Đối với mỗi lần lặp, các mục trong ma trận hố cát vượt quá 3được phát hiện, đưa ra một ma trận 1và 0, được kết hợp với mặt nạ 4 lân cận. Các mục vượt quá 3trong ma trận hố cát được giảm đi 4và kết quả của phép chập được thêm vào.

Đối với các lần lặp cuối cùng, trong đó ma trận sandpile không có bất kỳ số nào vượt quá 3, các số 0 được trừ và thêm vào nó, vì vậy nó không bị ảnh hưởng.

t       % Implicit input (matrix). Duplicate
ss      % Sum of matrix entries
:"      % Repeat that many times
  t     %   Duplicate
  3>    %   True for matrix entries that exceed 3
  t     %   Duplicate
  1Y6   %   Push predefined literal [0, 1, 0; 1, 0, 1; 0, 1, 0]
  Z+    %   2D convolution, keeping size
  w     %   Swap
  4*    %   Multiply by 4
  -     %   Subtract
  +     %   Add
        % Implicit end. Implicit display

Toán học, 65 byte

#//.s_:>s+ListConvolve[{v={0,1,0},1-v,v},x=UnitStep[s-4],2,0]-4x&

Giải trình

#//.s_:>...&

Chuyển đổi liên tục đầu vào bằng cách lật đổ tất cả các cọc lớn hơn 3. Quá trình này tự động dừng khi chuyển đổi không thay đổi ma trận (nghĩa là khi không còn cọc lớn nào nữa). Trong biểu thức sau đây, ma trận được gọi s.

...x=UnitStep[s-4]...

Tạo một ma trận có 1bất cứ khi nào ma trận hiện tại có 4hoặc lớn hơn và bằng không. Đây thực chất là một mặt nạ chỉ ra những cọc nào cần được lật đổ. Gọi mặt nạ x.

ListConvolve[{v={0,1,0},1-v,v},x=UnitStep[s-4],2,0]

Đầu tiên, chúng tôi tính toán số lượng cát được thêm vào mỗi đống do các cọc lân cận bị lật đổ. Điều này được thực hiện với một tổ hợp của ma trận sau x:

0 1 0
1 0 1
0 1 0

Về cơ bản, nó thêm một vào ô hiện tại cho mỗi hàng xóm von-Neumann của nó trong mặt nạ.

s+...-4x

Chúng tôi thêm kết quả trước đó svà sau đó chúng tôi trừ bốn lần mặt nạ từ nó để giảm các cọc bị lật đổ.

Octave, 65 byte

Điều này có vẻ không tốt lắm, tôi phải bỏ lỡ một số mánh khóe ...

m=input(0);do;m+=conv2(m>3,[0 1 0;1 -4 1;0 1 0],"same")
until m<4

JavaScript (ES6), 101 95 byte

Lấy chiều rộng của ma trận wvà một mảng các giá trị atrong cú pháp currying (w)(a). Trả về một mảng các giá trị.

w=>g=a=>(b=a.map((n,i)=>n%4+(F=d=>~m|i%w&&a[i+d]>>2)(m=w)+F(-w)+F(m=-1)+F(!++i)))+0==a+0?a:g(b)

Định dạng và nhận xét

w =>                      // main function: takes w as input, returns g
  g = a =>                // recursive function g: takes a as input
    (                     //
      b = a.map((n, i) => // for each element n at position i in a:
        n % 4 + (         //   keep only n MOD 4
          F = d =>        //   define F(): function that takes d as input
            ~m |          //     if m is not equal to -1
            i % w &&      //     or i MOD w is not null:
            a[i + d] >> 2 //       return a fourth of the value of the cell at i + d
        )(m = w) +        //   test the cell below the current cell
        F(-w) +           //   test the cell above
        F(m = -1) +       //   test the cell on the left
        F(!++i)           //   test the cell on the right
      )                   // end of map(): assign the result to b
    ) + 0 == a + 0 ?      // if b is equal to a:
      a                   //   stop recursion and return a
    :                     // else:
      g(b)                //   do a recursive call with b

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

let f =

w=>g=a=>(b=a.map((n,i)=>n%4+(F=d=>~m|i%w&&a[i+d]>>2)(m=w)+F(-w)+F(m=-1)+F(!++i)))+0==a+0?a:g(b)

console.log(JSON.stringify(f(3)([2, 5, 4, 8, 6, 4, 1, 2, 3]))); // -> [3, 3, 0, 1, 2, 2, 1, 3, 2]
console.log(JSON.stringify(f(3)([0, 0, 2, 1, 3, 3, 0, 0, 0]))); // -> [0, 0, 2, 1, 3, 3, 0, 0, 0]
console.log(JSON.stringify(f(3)([9, 9, 9, 9, 9, 9, 9, 9, 9]))); // -> [1, 3, 1, 3, 1, 3, 1, 3, 1]
console.log(JSON.stringify(f(2)([4, 5, 2, 3]))); // -> [2, 3, 0, 1]
console.log(JSON.stringify(f(3)([2, 3, 5, 2, 2, 0]))); // -> [3, 0, 2, 2, 3, 1]
console.log(JSON.stringify(f(1)([7]))); // -> [3]

JavaScript (ES6), 118 114 104 byte

Đã lưu 2 byte nhờ @Neil

f=a=>a.find(b=>++y&&b.find(c=>++x&&c>3,x=0),y=0)?f(a.map(b=>b.map(c=>c+=--i|y?i*i+y*y==1:-4,i=x,--y))):a

C ++, 261 258 250 byte

#import<vector>
#define S size()
void f(std::vector<std::vector<int>>&m){s:int i,j,r;for(i=r=0;i<m.S;++i)for(j=0;j<m[i].S;++j){if(m[i][j]>3){r=1;m[i][j]-=4;j>0&&m[i][j-1]++;i>0&&m[i-1][j]++;j<m[i].S-1&&m[i][j+1]++;i<m.S-1&&m[i+1][j]++;}}if(r)goto s;}

Lấy đầu vào làm tham chiếu đến một vectơ của vectơ và sửa đổi nó trực tiếp.

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