विस्फोट संख्या

Question

^{सैंडबॉक्स (हटाए गए)}

9 के एक मैट्रिक्स को परिभाषित करते हैं:

$$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 शेष के रूप में।$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}$$

साथ ही, कभी-कभी एक संख्या इतनी बड़ी नहीं होगी कि वह अपने पड़ोसियों के समान भागों में विघटित हो जाए (जहां एब्स 0 से अधिक हो) (तर्कसंगत संख्या | <<1) इस मामले में हमें "0 से अधिक" की स्थिति बनाए रखने के लिए विस्फोट संख्या से "उधार" लेने की आवश्यकता है । हमारे पिछले उदाहरण के साथ जारी रखें और स्थिति पर संख्या में विस्फोट करें ।$(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]]

---

टिप्पणियाँ

• इनपुट / आउटपुट नियम लागू होते हैं

• आप मान सकते हैं कि इनपुट मैट्रिक्स कभी खाली नहीं होगा

• आप मान सकते हैं कि निर्देशांक हमेशा मान्य होने वाले हैं

• परीक्षण मामलों में इनपुट समन्वय (पंक्ति, स्तंभ) के रूप में दिया गया है। यदि आपको इसकी आवश्यकता है (x, y) तो आप मानों को स्वैप कर सकते हैं। यदि हां, तो कृपया अपने उत्तर में बताएं

Comments

गोल्फ कोड के लिए नया; नमूना इन मैट्रिसेस को लेने के लिए किस प्रारूप की अनुमति है? कोई भी प्रारूप जो भाषा में मौजूद है? स्ट्रिंग रूप बिल्कुल लिखित?

— 19

मेरा सुझाव है कि गैर-वर्ग मैट्रिक के लिए एक परीक्षण मामला जोड़ना।

— 21

@ ओह उह, मैं अपना कार्यक्रम लिख रहा था, यह मानते हुए कि वे चौकोर होने की गारंटी दे रहे हैं, ड्राइंग बोर्ड पर मेरा अनुमान है

— rtpax

क्या हम मान सकते हैं कि मैट्रिक्स का आकार कम से कम 2 बाई 2 है? या 1 बाय 1 मैट्रिक्स इनपुट भी हो सकता है?

— केविन क्रूज़सेन

@rtpax कोई भी प्रारूप जब तक प्रश्न अन्यथा नहीं बताता, हां

— केवल

Answer 1

सी (जीसीसी) 220 216 214 212 बाइट्स

2 बाइट्स के लिए @ceilingcat को क्रेडिट

#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;}}

इसे यहां चलाएं

थोड़ा कम गोल्फ वाला संस्करण

#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,

Comments

पीपीसीजी में आपका स्वागत है :)

— झबरा

198 बाइट्स

— छत

Answer 2

जावास्क्रिप्ट (ईएस 7),  126 125 123  121 बाइट्स

@ बग्घी के लिए 2 बाइट्स को सहेजा गया

के रूप में इनपुट लेता है (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

Comments

आप (0)2 backticks के साथ दोनों घटनाओं को बदलकर बाइट्स के एक जोड़े को बचा सकते हैं ।

— झबरा

Answer 3

आर , 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
}

Answer 4

साफ , 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
        }

Answer 5

जंग - 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;}}}

यह बहुत लंबा है क्योंकि रस्ट को वैक्टर के अहस्ताक्षरित पूर्णांक अनुक्रमण की आवश्यकता होती है, लेकिन हस्ताक्षरित पूर्णांक को घटाव के परिणामस्वरूप घटाव करने की आवश्यकता होती है। हालाँकि मेरा मानना ​​है कि मेरा एल्गोरिथ्म अब तक का "सबसे छोटा एल्गोरिथम" है। वास्तव में किनारों, नीचे आदि का पता लगाने से निपटने की कोई आवश्यकता नहीं है।

तीन चीजों पर ध्यान दें: एक, सभी कोशिकाओं का योग हमेशा स्थिर होता है। दो, यह एक विभाजन / शेष स्थिति है, इसलिए हम ब्रेसेनहैम-एल्गोरिदम शैली सोच को लागू कर सकते हैं। तीन, प्रश्न हमेशा विशेष स्थिति में "अतिरिक्त" सामान से निपटने से पहले, विशेष स्थिति सेल की एक निश्चित दूरी के भीतर सभी कोशिकाओं में एक ही नंबर जोड़ता है।

कलन विधि:

सेल के मूल मान को स्थिति P में M में स्टोर करें।

शुरुआत लूप:

मैट्रिक्स में प्रत्येक सेल I पर फेरबदल करें। यदि सेल I की स्थिति P की स्थिति के 3 क्वाडरेन्स (चुकता दूरी) के भीतर है, तो सेल P से 1 घटाएं और 1 सेल में जोड़ें। गणना करें कि मैट्रिक्स के माध्यम से यह एक पुनरावृत्ति में कितनी बार किया जाता है।

यदि स्थिति P पर सेल में मान बचे हुए भाग M / Count + M modulo Count से कम या बराबर है, तो लूप को तोड़ दें। अन्यथा फिर से लूप प्रदर्शन करें।

परिणामी मैट्रिक्स विस्फोट संस्करण होगा। गणना मूल रूप से किनारों से निपटने के बिना पड़ोसियों की गणना करने का एक तरीका है। लूपिंग एक बार के एकल एकल जोड़ / घटाव में विभाजन / अतिरिक्त सामान को तोड़ने का एक तरीका है। मोडुलो चेक सुनिश्चित करता है कि हमारे पास पड़ोसी विस्फोटकों के बीच समान रूप से विभाज्य नहीं होने वाले 'विस्फोटों' से निपटने के लिए स्थिति P पर बचे हुए शेष भाग होंगे। लूप संरचना करते / करते समय P <0 को ठीक से काम करने की अनुमति देता है।

जंग खेल के मैदान पर अनप्लग्ड संस्करण

Comments

इस तरह के एक लंबे फ़ंक्शन नाम आवश्यक नहीं है, जैसे कोई भी 1-बायटर ऐसा fकरेगा। लेकिन आप शायद अनाम फ़ंक्शन का उपयोग करके और भी बाइट्स बचा सकते हैं:|p:(i8,i8),v:&mut Vec<Vec<i8>>|{...}

— Kirill L.

Answer 6

जावा 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 के जावास्क्रिप्ट उत्तर का इरेटिकल पोर्ट ।
-17 बाइट्स @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`

Comments

m[y]$y$m[y][x]$y$

@ अर्नुलद आह ठीक है। मुझे वास्तव में सीमा से बाहर याद है आमतौर पर जेएस में कोई समस्या नहीं है, लेकिन मैं समझ सकता हूं कि undefined[x]असफल क्यों होगा। वैसे भी, आपका (x-X)**2+(y-Y)**2<3चेक बहुत स्मार्ट है। यह याद रखने की आवश्यकता है कि जब मैं कभी भी एक 3x3 ब्लॉक (और सीमा के भीतर) मैट्रिक्स में मूल्यों की जांच करना चाहता हूं। मुझे लगता है कि मेरे पास वास्तव में कुछ उत्तर हैं जैसे कि, मैं अब एक कोशिश-कैच का उपयोग करता हूं, और एक मामले में अंत में कोशिश करता हूं .. उन पर गौर करेंगे जब मेरे पास कुछ समय होगा।

— केविन क्रूज़सेन

छोरों के लिए बढ़ाया के साथ 171 बाइट्स ।

— Arnauld

@Arnauld ओह अच्छा। अब जब मैं यह देख रहा हूँ तो मुझे विश्वास नहीं हो रहा है कि मैंने इस बारे में नहीं सोचा था कि जब मैंने आपके उत्तर से एक पोर्ट बनाया था, तब से आप ऐसा ही करते हैं।>>;)

— केविन क्रूज़सेन

Answer 7

आम लिस्प , 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))

Answer 8

पायथन 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

इसे ऑनलाइन आज़माएं!