^{sandbox (ถูกลบ)}

ให้นิยามเมทริกซ์ของ 9s เป็น:

$$N = \begin{bmatrix} 9&9&9\\9&9&9\\9&9&9 \end{bmatrix}$$

ให้กำหนดหมายเลขการระเบิดเป็นตัวเลขที่ตำแหน่งที่สามารถแยกย่อยเป็นจำนวนเต็มเท่ากันระหว่างเพื่อนบ้านที่อยู่ติดกันทั้งหมด (รวมถึงตัวเอง) และค่าสัมบูรณ์ของแต่ละส่วนนั้นมากกว่า 0$(x,y)$

จากเมทริกซ์ก่อนหน้าให้ปล่อยตัวเลขที่ตำแหน่ง (0 ดัชนี) $(1,1)$

$$N = \begin{bmatrix} 9&9&9\\9&\color{red}9&9\\9&9&9 \end{bmatrix}$$ $$N = \begin{bmatrix} 9+\color{red}1&9+\color{red}1&9+\color{red}1\\9+\color{red}1&\color{blue}0+\color{red}1&9+\color{red}1\\9+\color{red}1&9+\color{red}1&9+\color{red}1 \end{bmatrix}$$

$$N = \begin{bmatrix} 10&10&10\\10&\color{red}1&10\\10&10&10 \end{bmatrix}$$

บางครั้งการแยกย่อยผลลัพธ์เป็นจำนวนตรรกยะที่มากกว่า 1 นี่คือสิ่งที่เราต้องหลีกเลี่ยงเมื่อระเบิดตัวเลข ในกรณีนี้ส่วนที่เหลือจะถูกกำหนดให้กับหมายเลขที่ถูกระเบิด

หากต้องการสาธิตให้เราทำงานกับเมทริกซ์ก่อนหน้าของเราต่อไป ครั้งนี้เราจะระเบิดตัวเลขที่ตำแหน่ง$(0,0)$

$$N = \begin{bmatrix} \color{red}{10}&10&10\\10&1&10\\10&10&10 \end{bmatrix}$$

ที่นี่เรามี 3 เพื่อนบ้านและจำนวนของตัวเอง สมการนี้คืออะไรเช่นซึ่งให้2กับเราสำหรับ2และเหลือ 2$10/4$

$$N = \begin{bmatrix} \color{blue}2+\color{red}{2}&\color{red}{10+2}&10\\\color{red}{10+2}&\color{red}{1+2}&10\\10&10&10 \end{bmatrix}$$

$$N = \begin{bmatrix} \color{red}{4}&12&10\\12&3&10\\10&10&10 \end{bmatrix}$$

เช่นกันบางครั้งตัวเลขจะไม่ใหญ่พอที่จะย่อยสลายในส่วนที่เท่ากัน (ที่ abs มากกว่า 0) ระหว่างเพื่อนบ้านของเขา (| จำนวนตรรกยะ | <1) ในกรณีนี้เราต้อง"กู้"จากหมายเลขระเบิดในการสั่งซื้อเพื่อรักษา"มากกว่า 0"สภาพ ให้ดำเนินการกับตัวอย่างก่อนหน้านี้ของเราและระเบิดจำนวนที่ตำแหน่ง(1,1)$(1,1)$

$$N = \begin{bmatrix} 4&12&10\\12&\color{red}3&10\\10&10&10 \end{bmatrix}$$

$$N = \begin{bmatrix} 4+\color{red}1&12+\color{red}1&10+\color{red}1\\12+\color{red}1&\color{blue}0+\color{red}{1}-\color{green}6&10+\color{red}1\\10+\color{red}1&10+\color{red}1&10+\color{red}1 \end{bmatrix}$$ $$N = \begin{bmatrix} 5&13&11\\13&\color{red}{-5}&11\\11&11&11 \end{bmatrix}$$

---

ความท้าทายคือให้รายการของตำแหน่งและอาเรย์ที่ไม่ว่างเปล่าของจำนวนธรรมชาติส่งคืนรูปแบบการระเบิดหลังจากที่แต่ละหมายเลขจากรายการตำแหน่งถูกระเบิด$(x,y)$

---

กรณีทดสอบ

การป้อนข้อมูล: initial matrix: [[3, 3, 3], [3, 3, 3], [3, 3, 3]], numbers: [[0,0],[0,1],[0,2]]

เอาท์พุท: [[1, 0, 1], [5, 6, 5], [3, 3, 3]]

---

การป้อนข้อมูล: Initial matrix: [[9, 8, 7], [8, 9, 7], [8, 7, 9]], numbers: [[0,0],[1,1],[2,2]]

เอาท์พุท: [[4, 11, 8],[11, 5, 10],[9, 10, 4]]

---

การป้อนข้อมูล: Initial matrix: [[0, 0], [0, 0]], numbers: [[0,0],[0,0],[0,0]]

เอาท์พุท: [[-9, 3],[3, 3]]

---

การป้อนข้อมูล: Initial Matrix: [[10, 20, 30],[30, 20, 10],[40, 50, 60]], numbers: [[0,2],[2,0],[1,1],[1,0]]

เอาท์พุท: [[21, 38, 13], [9, 12, 21], [21, 71, 64]]

---

การป้อนข้อมูล: Initial Matrix: [[1]], numbers: [[0,0]]

เอาท์พุท: [[1]]

---

การป้อนข้อมูล: Initial Matrix: [[1, 2, 3]], numbers: [[0,0], [0, 1]]

เอาท์พุท: [[1, 1, 4]]

---

หมายเหตุ

• ใช้กฎอินพุต / เอาท์พุต

• คุณสามารถสมมติว่าอินพุตเมทริกซ์จะไม่ว่างเปล่า

• คุณสามารถสันนิษฐานได้ว่าพิกัดนั้นจะถูกต้องเสมอ

• ป้อนค่า coord ในกรณีทดสอบให้เป็น (แถว, คอลัมน์) หากคุณต้องการให้เป็น (x, y) คุณสามารถสลับค่าได้ ถ้าเป็นเช่นนั้นโปรดระบุว่าในคำตอบของคุณ

C (GCC) 220 216 214 212 ไบต์

เครดิตไปที่ @ceilingcat เป็นเวลา 2 ไบต์

#define L(v)for(int v=2;~v--;)
#define P l/C+r<0|l/C+r>=R|l%C+c<0|l%C+c>=C
f(int R,int C,int*m){for(int*i=m+R*C;~*i;) {int*M,l=*i+++C**i++,a=0,b;L(r)L(c)P?:++a;M=m+l;b=*M/a;b+=!b;*M- =b*a;L(r)L(c)M[r*C+c]+=P?0:b;}}

เรียกใช้ที่นี่

รุ่น golfed น้อยกว่าเล็กน้อย

#define L(v)for(int v=2;~v--;)
#define P l/C+r<0|l/C+r>=R|l%C+c<0|l%C+c>=C
f(int R, int C, int*m) {
    for(int*i=m+R*C;~*i;) {
        int*M,l=*i+++C**i++,a=0,b;
        L(r)
            L(c)
                P?:++a;
        M=m+l;
        b=*M/a;
        b+=!b;
        *M-=b*a;
        L(r)
            L(c)
                M[r*C+c]+=P?0:b;
    }
}

รหัสการโทรพร้อมตัวอย่าง

int main()
{
  int matrix[] = {3,3,3,3,3,3,3,3,3,0,0,0,1,0,2,-1};
  int rows = 3;
  int columns = 3;
  f(rows,columns,matrix);
  for(int r = 0; r < rows; ++r) {
    for(int c = 0; c < columns; ++c) {
      printf("%03d,",matrix[r*columns + c]);
    }
    printf("\n");
  }
}

และเอาท์พุท

001,005,003,
000,006,003,
001,005,003,

JavaScript (ES7),  126 125 123  121 ไบต์

บันทึก 2 ไบต์ขอบคุณ @Shaggy

(matrix)(list)จะเข้าเป็น เอาท์พุทโดยการปรับเปลี่ยนเมทริกซ์

m=>a=>a.map(([Y,X])=>(g=n=>m[m.map((r,y)=>r.map((_,x)=>(x-X)**2+(y-Y)**2<3&&r[n++,x]++)),(m[Y][X]+=~n)<n||g``,Y][X]++)``)

ลองออนไลน์!

อย่างไร?

$(x,y)$

1. $n$
2. $\lfloor m(x,y) / n\rfloor$$q$
3. เดินผ่านเมทริกซ์อีกครั้งเพื่ออัพเดทแต่ละเพื่อนบ้าน
4. $m(x,y)$

แทนที่จะเป็นเช่นนั้นเราใช้ฟังก์ชั่นวนซ้ำซึ่งเรียกใช้การดำเนินงานที่ง่ายขึ้นซ้ำหลาย ๆ ครั้งตามที่ต้องการ:

1. $n$$0$
2. $n+1$
3. $n$
4. เพิ่มเซลล์อ้างอิง (ทุกขั้นตอนของประเภทนี้จะถูกดำเนินการอย่างต่อเนื่องเมื่อการเรียกซ้ำครั้งล่าสุดเสร็จสมบูรณ์)

ประโยชน์หลักคือเราต้องการลูปเดียวผ่านเมทริกซ์ ประโยชน์ที่สองคือเราไม่ต้องคำนวณผลหารใด ๆ เลย

ตัวอย่าง

$$M=\begin{pmatrix} 0&0&0\\ 0&26&0\\ 0&0&0 \end{pmatrix}\text{ and }(x,y)=(1,1)$$

หลังจากขั้นตอนที่ 1ของการทำซ้ำครั้งแรกเรามี:

$$M=\begin{pmatrix} 1&1&1\\ 1&27&1\\ 1&1&1 \end{pmatrix}\text{ and }n=9$$

และหลังจากขั้นตอนที่ 2ของการทำซ้ำครั้งแรก :

$$M=\begin{pmatrix} 1&1&1\\ 1&17&1\\ 1&1&1 \end{pmatrix}$$

$-9$$+1$

$26$

$17$$9$

หลังจากขั้นตอนที่ 1ของการทำซ้ำครั้งที่สองเรามี:

$$M=\begin{pmatrix} 2&2&2\\ 2&18&2\\ 2&2&2 \end{pmatrix}\text{ and }n=9$$

และหลังจากขั้นตอนที่ 2ของการทำซ้ำครั้งที่สอง :

$$M=\begin{pmatrix} 2&2&2\\ 2&8&2\\ 2&2&2 \end{pmatrix}$$

$8<9$

ตอนนี้เราเพิ่มเซลล์อ้างอิงสองครั้ง ( ขั้นตอนที่ 4ของการวนซ้ำทั้งสอง ) นำไปสู่ผลลัพธ์สุดท้าย:

$$M=\begin{pmatrix} 2&2&2\\ 2&10&2\\ 2&2&2 \end{pmatrix}$$

แสดงความคิดเห็น

m => a =>                     // m[] = input matrix, a[] = list of positions
  a.map(([Y, X]) => (         // for each pair (X, Y) in a[]:
    g = n =>                  //   g = recursive function expecting n = 0
      m[                      //
        m.map((r, y) =>       //     for each row r[] at position y in m[]:
          r.map((_, x) =>     //       for each value at position x in r[]:
            (x - X) ** 2 +    //         if the quadrance between (x, y)
            (y - Y) ** 2 < 3  //         and (X, Y) is less than 3:
            && r[n++, x]++    //           increment n and increment r[x]
          )                   //       end
        ),                    //     end
        (m[Y][X] += ~n)       //     subtract n + 1 from m[Y][X]
        < n                   //     if the result is greater than or equal to n:
        || g``,               //       do a recursive call
        Y                     //     
      ][X]++                  //     increment m[Y][X]
    )``                       //   initial call to g
  )                           // end

R , 163 162 161 159 155 146 ไบต์

function(m,l){for(e in l){v=m[i<-e[1],j<-e[2]];s=m[x<--1:(i<dim(m))+i,y<--1:(j<ncol(m))+j];z=sum(1|s);d=max(1,v%/%z);m[x,y]=s+d;m[i,j]=v+d-d*z};m}

ลองออนไลน์!

คำอธิบาย

(สอดคล้องกับรหัสรุ่นก่อนหน้า)

function(m,l) {          # Take input as matrix m and 1-indexed list of explosion points l
  for(e in l) {          # Loop over the list of explosion points
    i=e[1]; j=e[2]       # Assign current coordinates to (i,j) for brevity
    x=-1:1+i             # Assign the ranges of neighboring cells: (i-1) to (i+1),
    y=-1:1+j             # and (j-1) to (j+1)
    s=                   # Take the submatrix s=m[x,y]
      m[x<-x[x<=dim(m)]  # But first trim x and y from above to prevent out of bounds errors,
     ,y<-y[y<=ncol(m)]]  # trimming from below isn't necessary, as R tolerates index 0
    z=sum(1|s)           # Count the neighbors
    d=max(1,m[i,j]%/%z)  # Estimate, how much we'll distribute to each neighbor
    m[x,y]=s+d           # Add the distributed amount to each cell of the submatrix
    m[i,j]=m[i,j]-d*z    # Subtract the total amount from the exploded cell
  }
  m                      # Return the modified matrix
}

ทำความสะอาด , 181 167 ไบต์

import StdEnv;

foldl\m(x,y)={{if(d>2)0b+e-if(d>0)0b*n\\e<-:l&v<-[0..],let{b=max m.[y,x]n/n;$a b=2+sign a-(a+1)/size b;n= $x l* $y m;d=(v-x)^2+(u-y)^2}}\\l<-:m&u<-[0..]}

ลองออนไลน์!

ในรูปแบบของฟังก์ชั่นตัวอักษรที่ใช้บางส่วน

ขยาย (รุ่นแรก):

f // functinon f on {{Int}} and [(Int,Int)]
    = foldl \m (x, y) // fold :: (a -> b -> a) a [b] -> a with first argument \ {{Int}} (Int,Int) -> {{Int}} giving \ {{Int}} [(Int,Int)] -> {{Int}}
        = {                     // an array of
            {                   // arrays of
                if(d > 2) 0 b   // the amount we give to the neighbors
                + e             // plus the current entry
                - if(d > 0) 0 b // minus the amount taken from the target entry
                * n             // times the number of neighbors, if we're on the target
            \\                  // for each
                e <-: l         // element of row l
                & v <- [0..]    // and x-index v
                , let           // local definitions:
                    b           // the amount given to the neighbors
                        = max   // we need at least 1 each, so take the largest of
                            m.[y, x] // the target entry
                            n   // or the number of neighbors
                        / n     // divide it by the number of neighbors
                    n           // the number of neighbors
                        = (     // sum of
                            1   // one
                            + s x // if x is at the left edge = 0 else 1
                            + s ( // if x is at the right edge = 0 else 1
                                size l
                                - x 
                                - 1
                            )
                        ) * (   // times the sum of
                            1   // one
                            + s y // if y is at the top edge = 0 else 1
                            + s ( // if y is at the bottom edge = 0 else 1
                                size m
                                - y
                                - 1
                            )
                        )
                    d           // distance from the target point
                        = (v - x)^2
                        + (u - y)^2
            }
        \\                      // for each
            l <-: m             // row l in matrix m
            & u <- [0..]        // and y-index u
        }

สนิม - 295 ไบต์

fn explode(p:(i8,i8),v:&mut Vec<Vec<i8>>){let x=v[p.0 as usize][p.1 as usize];let q=|x,y|x*x+y*y;loop{let mut t=0;for i in 0..v.len(){for j in 0..v[i].len(){if q(i as i8-p.0,j as i8-p.1)<3{v[i][j]+=1;v[p.0 as usize][p.1 as usize]-=1;t+=1;}}}if v[p.0 as usize][p.1 as usize]<=(x/t+x%t){break;}}}

นี่ค่อนข้างยาวเนื่องจาก Rust ต้องการการทำดัชนีจำนวนเต็มแบบไม่มีเครื่องหมายของพาหะ อย่างไรก็ตามฉันเชื่อว่าอัลกอริทึมของฉันคือ "อัลกอริทึมที่สั้นที่สุด" จนถึงตอนนี้ ไม่จำเป็นต้องจัดการกับการตรวจจับขอบด้านล่าง ฯลฯ

สังเกตสิ่งที่สาม: หนึ่งผลรวมของเซลล์ทั้งหมดจะคงที่เสมอ สองนี่คือสถานการณ์การแบ่ง / ส่วนที่เหลือดังนั้นเราจึงสามารถใช้การคิดสไตล์ Bresenham- อัลกอริทึม สามคำถามจะเพิ่มจำนวนเดียวกันในทุกเซลล์ในระยะที่กำหนดของเซลล์ตำแหน่งพิเศษก่อนที่จะจัดการกับสิ่งที่ "พิเศษ" ในตำแหน่งพิเศษ

ขั้นตอนวิธีการ:

เก็บค่าดั้งเดิมของเซลล์ที่ตำแหน่ง P เป็น M

เริ่มต้นลูป:

วนซ้ำทุกเซลล์ในเมทริกซ์ หากตำแหน่งของเซลล์ I อยู่ภายใน 3 Quadrance (กำลังสองระยะห่าง) ของตำแหน่ง P ให้ลบ 1 จากเซลล์ P และเพิ่ม 1 ลงในเซลล์ I นับจำนวนครั้งนี้ทำซ้ำในเมทริกซ์เดียวผ่านเมทริกซ์

หากค่าที่เหลือในเซลล์ที่ตำแหน่ง P น้อยกว่าหรือเท่ากับ M / Count + M modulo Count ดังนั้นให้แบ่งลูป มิฉะนั้นให้ทำการวนซ้ำอีกครั้ง

เมทริกซ์ที่ได้จะเป็นเวอร์ชั่นที่ถูกระเบิด การนับนั้นเป็นวิธีการนับเพื่อนบ้านโดยไม่ติดต่อกับขอบ การวนซ้ำเป็นวิธีที่จะแยกแยะส่วนย่อย / ส่วนเพิ่มเติมออกเป็นส่วนเพิ่มเติม / ลบเดียวซ้ำ ๆ การตรวจสอบแบบโมดูโลทำให้มั่นใจได้ว่าเราจะเหลือเศษที่เหมาะสมไว้ที่ตำแหน่ง P เพื่อจัดการกับ 'การระเบิด' ซึ่งไม่สามารถแบ่งแยกได้ในหมู่เพื่อนบ้าน โครงสร้าง do / while ทำให้ P <0 ทำงานได้อย่างถูกต้อง

เวอร์ชันที่ไม่ดีบนสนามเด็กเล่นสนิม

Java 10, 194 193 191 190 184 182 171 ไบต์

M->C->{for(var q:C){int n,X=q[0],Y=q[1],x,y,c=0;do{c++;x=n=0;for(var r:M){y=0;for(int $:r)r[y]+=Math.hypot(x-X,y++-Y)<2?++n/n:0;x++;}}while((M[X][Y]+=~n)>=n);M[X][Y]+=c;}}

พอร์ตซ้ำของ@Arnauld 'คำตอบ JavaScript
-17 ไบต์ขอบคุณ@Arnauld @Arnauld

แก้ไขอินพุตเมทริกซ์แทนการส่งคืนใหม่เพื่อบันทึกไบต์

ลองออนไลน์

คำอธิบาย:

M->C->{                      // Method with two integer-matrix parameters and no return-type
  for(var q:C){              //  Loop over the coordinates:
    int n,                   //   Count integer
        X=q[0],Y=q[1],       //   The current X,Y coordinate
        x,y,                 //   Temp x,y coordinates
        c=0;                 //   Counter, starting at 0
    do{                      //   Do-while:
      c++;                   //    Increase the counter `c` by 1
      x=n=0;                 //    (Re)set both `x` and the count `n` to 0
      for(var r:M)           //    Loop over the rows `r`:
        y=0;                 //     (Re)set `y` to 0
        for(int $:r)         //     Loop over the cells of the current row:
          r[y]+=             //      Increase the value at x,y by:
            Math.hypot(      //       If the hypot (builtin for `sqrt(a*a, b*b)`) of:
              x-X,           //        the difference between `x` and `X`,
                  y++-Y)     //        and difference between `y` and `Y`
                             //        (and increase `y` by 1 afterwards with `y++`)
              <2?            //       Is smaller than 2:
                 ++n/n       //        Increase count `n` and the value at x,y both by 1
                :            //       Else:
                 0;          //        Leave the value at x,y the same by increasing by 0
       x++;}}                //     Increase `x` by 1
    while((M[X][Y]+=~n)      //    Decrease the value at X,Y by n+1
          >=n);              //    Continue the do-while if this new value is still larger
                             //    than or equal to count `n`
    M[X][Y]+=c;}}            //   Increase the value at X,Y with counter `c`

เสียงกระเพื่อมสามัญ 498 ไบต์

(defmacro s(l c x)`(incf(aref m,l,c),x))
(defmacro w(a &rest f)`(if(,a(or(= l 0)(= l(d 0)))(or(= c 0)(= c(d 1)))),@f))
(defmacro d(n)`(1-(array-dimension m,n)))
(defmacro p(i l m &rest f)`(loop for,i from(1-,l)to(1+,l)when(and(>=,i 0)(<=,i,m))do,@f))
(defmacro g()`(or(p i l(d 0)(p j c(d 1)(s i j 1)))(s l c(- v))))
(defun f(m l c)(let((v(w and 4(w or 6 9))))(if (<(/(s l c 0)v)1)(g)(loop for i to(1-(/(s l c 0)v))do(g)))))
(defun c(m n)(dotimes(i(length n))(f m(nth 0(nth i n))(nth 1(nth i n))))m)

ลองออนไลน์!

ใช้ฟังก์ชั่นนี้เป็น (print (c #2A((3 3 3) (3 3 3) (3 3 3)) '((0 0)(0 1)(0 2))))

รุ่นที่อ่านได้ดีกว่า:

(defmacro s (l c x)
  `(incf (aref m ,l ,c) ,x))

(defmacro w (a &rest f)
  `(if (,a (or (= l 0)
           (= l (d 0)))
       (or (= c 0)
           (= c (d 1))))
       ,@f))

(defmacro d (n)
  `(1- (array-dimension m ,n)))

(defmacro p (i l m &rest f)
  `(loop for ,i from (1- ,l) to (1+ ,l)
     when (and (>= ,i 0) (<= ,i ,m))
     do ,@f))

(defmacro g ()
  `(or(p i l (d 0)
     (p j c (d 1)
        (s i j 1)))
      (s l c (- v))))

(defun f (m l c)
  (let ((v (w and 4 (w or 6 9))))
    (if (< (/ (s l c 0) v) 1)
    (g)
      (loop for i to (1- (/ (s l c 0) v))
        do (g)))))

(defun c (m n)
  (dotimes (i (length n))
    (f m (nth 0 (nth i n))
       (nth 1 (nth i n))))
  m)

ตัวอย่างผลลัพธ์:

(print (c #2A((3 3 3) (3 3 3) (3 3 3) (3 3 3) (3 3 3) (3 3 3)) '((5 0)(4 1)(0 2))))
;; #2A((3 4 0) (3 4 4) (3 3 3) (4 4 4) (5 -4 4) (1 5 4))

(print (c #2A((3 3 3) (3 3 3) (3 3 3)) '((0 0)(0 1)(0 2))))
; #2A((1 0 1) (5 6 5) (3 3 3))  => #2A((1 0 1) (5 6 5) (3 3 3))

(print (c #2A((9 8 7) (8 9 7) (8 7 9)) '((0 0)(1 1)(2 2))))
;; #2A((4 11 8) (11 5 10) (9 10 4))  => #2A((4 11 8) (11 5 10) (9 10 4))

(print (c #2A((0 0) (0 0)) '((0 0)(0 0)(0 0))))
;; #2A((-9 3) (3 3))  => #2A((-9 3) (3 3))

(print (c #2A((10 20 30)(30 20 10)(40 50 60)) '((0 2)(2 0)(1 1)(1 0))))
;; #2A((21 38 13) (9 12 21) (21 71 64))  => #2A((21 38 13) (9 12 21) (21 71 64))

Python 2 , 171 ไบต์

M,p=input()
l=len
for i,j in p:
 y=[(i+y,j+x)for x in-1,0,1for y in-1,0,1if l(M)>j+x>-1<i+y<l(M[0])];x=max(M[i][j]/l(y),1);M[i][j]-=x*l(y)
 for i,j in y:M[i][j]+=x
print M

ลองออนไลน์!