বিস্ফোরক সংখ্যা

Question

^{স্যান্ডবক্স (মুছে ফেলা)}

9s এর ম্যাট্রিক্সকে এটি হিসাবে সংজ্ঞায়িত করতে দেয়:

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

একটি বিস্ফোরক সংখ্যাকে অবস্থানের $(x,y)$ সংখ্যা হিসাবে সংজ্ঞায়িত করতে দেয় যা এর সাথে সংলগ্ন সমস্ত প্রতিবেশী (নিজেই) এর মধ্যে সমান পূর্ণসংখ্যায় বিভক্ত হতে পারে এবং প্রতিটি অংশের পরম মান 0 এর চেয়ে বেশি হয়।

পূর্ববর্তী ম্যাট্রিক্স থেকে, অবস্থানটি $(1,1)$ (0 সূচিত)

$$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 জন নেটিবার্স এবং নম্বরটি রয়েছে। এখানে সমীকরণ মত কিছু $10/4$ যা আমাদের দিতে 2 প্রত্যেকের জন্য এবং 2 বাকি হিসাবে।

$$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}$$

পাশাপাশি, কখনও কখনও একটি সংখ্যা তার প্রতিবেশীদের (| যুক্তিযুক্ত সংখ্যা | <1) এর মধ্যে সমান অংশে (যেখানে অ্যাবস 0 এর চেয়ে বেশি হয়) পচে যাওয়ার পক্ষে যথেষ্ট বড় হবে না। এই ক্ষেত্রে "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

কোড গল্ফ নতুন; নমুনাটি কোন মাপের এই ম্যাট্রিকগুলি গ্রহণের অনুমতি দেয়? ভাষায় বিদ্যমান কোন বিন্যাস? স্ট্রিং ফর্ম ঠিক যেমন লেখা আছে?

— আরটিপ্যাক্স

আমি স্কোয়ারবিহীন ম্যাট্রিকগুলির জন্য একটি পরীক্ষার কেস যুক্ত করার পরামর্শ দিই।

— শে

@ অরৌস ওহ, আমি মনে করি যে তারা বর্গক্ষেত্র হওয়ার নিশ্চয়তা পেয়েছিল তা ধরে নিয়ে আমি আমার প্রোগ্রামটি লিখছিলাম, আমার অনুমান অঙ্কন বোর্ডে ফিরে

— rtpax

আমরা কি ধরে নিতে পারি যে ম্যাট্রিক্স-আকারটি কমপক্ষে 2 বাই 2? বা 1 বাই 1 ম্যাট্রিক্সও ইনপুট হতে পারে?

— কেভিন ক্রুইজসেন

@ আরটিপ্যাক্স কোনও ফর্ম্যাট না থাকলে প্রশ্ন অন্যথায় না বলে, হ্যাঁ

— কেবল এএসসিআইআই

Answer 1

সি (জিসিসি) 220 216 214 212 বাইট

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

এটি এখানে চালান

একটি সামান্য কম গল্ফ সংস্করণ

#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

জাভাস্ক্রিপ্ট (ES7),  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$ , আমরা একটি recursive কল না।

পরে ধাপ 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)ব্যাকটিক দিয়ে উভয় ঘটনাকে প্রতিস্থাপন করে কয়েকটি বাইট সংরক্ষণ করতে পারেন ।

— শেগি

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 অবস্থানের ঘরের মূল মান সংরক্ষণ করুন

শুরু লুপ:

ম্যাট্রিক্সের প্রতিটি কক্ষের উপরে Iterate করুন। যদি कक्ष I এর অবস্থান পজিশনের 3 চতুর্ভুজ (স্কোয়ার্ড দূরত্ব) এর মধ্যে থাকে, তবে সেল পি থেকে 1 টি বিয়োগ করুন এবং 1 ঘরের আইতে যুক্ত করুন the ম্যাট্রিক্সের মাধ্যমে এক পুনরাবৃত্তিতে এটি কতবার করা হয় তা গণনা করুন।

P অবস্থিত ঘরে ঘরে মান বাকীটি যদি এম / কাউন্ট + এম মডুলো কাউন্টের চেয়ে কম বা সমান হয় তবে লুপটি ভেঙে দিন। অন্যথায় লুপটি আবার সম্পাদন করুন।

ফলাফল ম্যাট্রিক্স বিস্ফোরিত সংস্করণ হবে। গণনা মূলত প্রান্তগুলি ব্যবহার না করে প্রতিবেশীদের গণনা করার একটি উপায়। লুপিং একটি বিভাজন / সংযোজন স্টাফকে একটির পুনরাবৃত্তি একক সংযোজন / বিয়োগফলকে ভাঙ্গার একটি উপায়। মডুলো চেকটি নিশ্চিত করে যে আমাদের 'বিস্ফোরণ' মোকাবিলার জন্য যথাযথভাবে অবশিষ্ট প বাকি থাকবে যা প্রতিবেশীদের মধ্যে সমানভাবে বিভাজ্য নয়। Do / while লুপ কাঠামো পি <0 কে সঠিকভাবে কাজ করতে দেয়।

মরিচা খেলার মাঠে অগলিত সংস্করণ

Comments

এ জাতীয় দীর্ঘ ফাংশনের নাম প্রয়োজন নেই, যে কোনও 1-বাইটার যেমন fকরবে। তবে আপনি বেনামে কোনও ফাংশন ব্যবহার করে সম্ভবত আরও বাইটস সংরক্ষণ করতে পারেন:|p:(i8,i8),v:&mut Vec<Vec<i8>>|{...}

— ক্যারিল এল

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

@ আরনাউল্ডের জাভাস্ক্রিপ্ট উত্তরের Iterative পোর্ট ।
-17 বাইটস @ আরনাউল্ডকে ধন্যবাদ জানায় ।

বাইটগুলি সংরক্ষণ করতে কোনও নতুন ফেরতের পরিবর্তে ইনপুট-ম্যাট্রিক্স পরিবর্তন করে।

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

ব্যাখ্যা:

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

পছন্দ করুন এখন যেহেতু আমি এটি দেখছি আমি বিশ্বাস করতে পারছি না যে আমি যখন আপনার উত্তর থেকে কোনও বন্দর তৈরি করেছি তখন আমি সে সম্পর্কে ভেবে দেখিনি, যেহেতু

— আপনিও

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

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