Có một mảng 2D hình chữ nhật chứa virus được ký hiệu là 'v', antidote1 được ký hiệu là 'a' và antidote2 được ký hiệu là 'b' (không có giá trị nào ngoài 'v', 'a' và 'b').

Antidote1 chỉ có thể tiêu diệt virus lân cận theo hướng ngang và dọc, nhưng antidote2 có thể tiêu diệt virus lân cận (nếu có) theo hướng ngang, dọc và chéo.

Một khi các thuốc giải độc được kích hoạt, cuối cùng sẽ còn bao nhiêu virus?

Ví dụ:

Đầu vào:

vv
vv

Đầu ra: 4

Đầu vào:

av
vv

Đầu ra: 1

Đầu vào:

vvv
vbv
vvv

Đầu ra: 0

Đầu vào:

bvb
bav
vab
vvv
vvb
vvv
vvv
bva
vav

Đầu ra: 3

Python 3 , 135 byte

j=''.join
p='j(s)'+4*'.replace("%s%s","%s%s")'%(*'vbbbbvbbavacvaca',)
f=lambda x:j(eval(2*'(eval(p)for s in zip(*'+'x))))')).count('v')

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

-2 byte nhờ Kevin Cruijssen

Giải trình

Thay thế tất cả 'v' thành 'b' nếu được tìm thấy bên cạnh 'b'. Tiếp theo, thay thế tất cả 'v' thành 'c' nếu được tìm thấy bên cạnh 'a'. Lặp lại thứ hai với phiên bản chuyển đổi của mảng sẽ xóa tất cả các virus dọc và chéo. Cuối cùng, nó sẽ trả về số 'v' còn lại.

Là một hàm đệ quy dễ đọc hơn (155 byte)

JavaScript (ES7), 108 byte

Đưa đầu vào như một ma trận các ký tự.

f=m=>(g=(y,X,V)=>m.map(r=>r.map((v,x)=>V?v>f&V>'a'>(x-X)**2+y*y-2?r[x]=n--:0:v<f?g(-y,x,v):n++)|y++))(n=0)|n

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

Tương tự như câu trả lời ban đầu của tôi, nhưng V>'a'>(x-X)**2+y*y-2thực tế ngắn hơn 1 byte so với sử dụng thủ thuật hexa được mô tả dưới đây. ¯ \ _ (ツ) _ /

JavaScript (ES7), 109 byte

Đưa đầu vào như một ma trận các ký tự.

f=m=>(g=(y,X,V)=>m.map(r=>r.map((v,x)=>V?v>f&(x-X)**2+y*y<V-8?r[x]=n--:0:v<f?g(-y,x,'0x'+v):n++)|y++))(n=0)|n

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

Làm sao?

$A_1=(x_1,y_1)$$A_2=(x_2,y_2)$

Xem xét tọa độ nguyên, nó trông như sau:

Vì thế:

• $A_1$$A_2$$Q(A_1,A_2)<2$
• $A_1$$A_2$$Q(A_1,A_2)<3$

$2$$3$$8$

• $\text{A}_{16} - 8_{10} = 2_{10}$
• $\text{B}_{16} - 8_{10} = 3_{10}$

Đã bình luận

f =                      // named function, because we use it to test if a character
                         // is below or above 'm'
m => (                   // m[] = input matrix
  g = (                  // g is a recursive function taking:
    y,                   //   y = offset between the reference row and the current row
    X,                   //   X = reference column
    V                    //   V = reference value, prefixed with '0x'
  ) =>                   //
    m.map(r =>           // for each row r[] in m[]:
      r.map((v, x) =>    //   for each value v at position x in r[]:
        V ?              //     if V is defined:
          v > f &        //       if v is equal to 'v'
          (x - X) ** 2 + //       and the quadrance between the reference point and
          y * y          //       the current point
          < V - 8 ?      //       is less than the reference value read as hexa minus 8:
            r[x] = n--   //         decrement n and invalidate the current cell
          :              //       else:
            0            //         do nothing
        :                //     else:
          v < f ?        //       if v is either 'a' or 'b':
            g(           //         do a recursive call:
              -y,        //           pass the opposite of y
              x,         //           pass x unchanged
              '0x' + v   //           pass v prefixed with '0x'
            )            //         end of recursive call
          :              //       else:
            n++          //         increment n
      ) | y++            //   end of inner map(); increment y
    )                    // end of outer map()
  )(n = 0)               // initial call to g with y = n = 0
  | n                    // return n

05AB1E , 33 30 29 byte

2F.•s¯}˜?•2ô€Â2ä`.:S¶¡øJ»}'v¢

Hãy thử trực tuyến hoặc xác minh một vài trường hợp thử nghiệm .

Câu trả lời Python 3 của @Jitse , vì vậy hãy đảm bảo nâng cao anh ấy!
-1 byte nhờ @Jitse .

Giải trình:

Phiên bản kế thừa có lợi thế là có thể nén / chuyển đổi danh sách chuỗi, trong đó phiên bản mới sẽ cần một bản rõ ràng Svà Jvì nó chỉ hoạt động với danh sách ký tự. Nhưng, phiên bản mới vẫn ngắn hơn 3 byte bằng cách sử dụng €Âkết hợp với chuỗi nén ngắn hơn. Trong phiên bản cũ, €sẽ chỉ giữ giá trị cuối cùng trên ngăn xếp bên trong bản đồ, nhưng trong phiên bản mới, nó sẽ giữ tất cả các giá trị trên ngăn xếp bên trong bản đồ.

2F                  # Loop 2 times:
  .•s¯}˜?•          #  Push compressed string "vbvabbca"
   2ô               #  Split it into parts of size 2: ["vb","va","bb","ca"]
     €Â             #  Bifurcate (short for duplicate & reverse copy) each:
                    #   ["vb","bv","va","av","bb","bb","ca","ac"]
       2ä           #  Split it into two parts:
                    #   [["vb","bv","va","av"],["bb","bb","ca","ac"]]
         `          #  Push both those lists separated to the stack
          .:        #  Replace all strings once one by one in the (implicit) input-string
            S       #  Then split the entire modified input to a list of characters
             ¶¡     #  Split that list by newlines into sublists of characters
               ø    #  Zip/transpose; swapping rows/columns
                J   #  Join each inner character-list back together to a string again
                 »  #  And join it back together by newlines
}'v¢               '# After the loop: count how many "v" remain

Xem 05AB1E mẹo này của tôi (phần Làm thế nào để chuỗi nén không nằm trong từ điển? ) Để hiểu tại sao .•s¯}˜?•là "vbvabbca".

Java 10, 211 209 byte

m->{int i=m.length,j,c=0,f,t,I,J;for(;i-->0;)for(j=m[i].length;j-->0;c+=m[i][j]>98?f/9:0)for(f=t=9;t-->0;)try{f-=m[I=i+t/3-1][J=j+t%3-1]==98||Math.abs(I-i+J-j)==1&m[I][J]<98?1:0;}catch(Exception e){}return c;}

Sửa đổi câu trả lời của tôi cho thử thách Tất cả các đêm .
-2 byte nhờ @ceilingcat .

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

Giải trình:

m->{                           // Method with char-matrix parameter & int return-type
  int i=m.length,              //  Amount of rows
      j,                       //  Amount of columns
      c=0,                     //  Virus-counter, starting at 0
      f,                       //  Flag-integer
      t,I,J;                   //  Temp-integers
  for(;i-->0;)                 //  Loop over the rows of the matrix
    for(j=m[i].length;j-->0    //   Inner loop over the columns
        ;c+=                   //     After every iteration: increase the counter by:
            m[i][j]>98         //      If the current cell contains a 'v'
             f/9               //      And the flag is 9:
                               //       Increase the counter by 1
            :0)                //      Else: leave the counter unchanged by adding 0
      for(f=t=9;               //    Reset the flag to 9
          t-->0;)              //    Loop `t` in the range (9, 0]:
         try{f-=               //     Decrease the flag by:
           m[I=i+t/3-1]        //      If `t` is 0, 1, or 2: Look at the previous row
                               //      Else-if `t` is 6, 7, or 8: Look at the next row
                               //      Else (`t` is 3, 4, or 5): Look at the current row
            [J=j+t%3-1]        //      If `t` is 0, 3, or 6: Look at the previous column
                               //      Else-if `t` is 2, 5, or 8: Look at the next column
                               //      Else (`t` is 1, 4, or 7): Look at the current column
            ==98               //      And if this cell contains a 'b'
            ||Math.abs(I-i+J-j)==1
                               //      Or if a vertical/horizontal adjacent cell
              &m[I][J]<98?     //      contains an 'a'
               1               //       Decrease the flag by 1
            :0;                //      Else: leave the flag unchanged by decreasing with 0
         }catch(Exception e){} //     Catch and ignore any ArrayIndexOutOfBoundsExceptions,
                               //     which is shorter than manual checks
  return c;}                   //  And finally return the virus-counter as result

Than , 39 byte

ＷＳ⊞υι≔⪫υ⸿θＰθ≔⁰ηＦθ«≧⁺›⁼ιv⁺№ＫＭb№ＫＶaηι»⎚Ｉη

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

ＷＳ⊞υι≔⪫υ⸿θＰθ

Nối các chuỗi đầu vào với các \rký tự và vẽ kết quả vào khung vẽ.

≔⁰η

Xóa số lượng virii sống.

Ｆθ«

Lặp lại các ký tự trong đầu vào.

≧⁺›⁼ιv⁺№ＫＭb№ＫＶaη

Nếu ký tự hiện tại là vi-rút và không có bs liền kề theo bất kỳ hướng nào hoặc as trực giao thì sẽ tăng số lượng virii sống.

ι»

Lặp lại với nhân vật tiếp theo.

⎚Ｉη

Xóa khung vẽ và in tổng số virii sống.

Perl ( -00lp), 82 byte

Sử dụng regex để thay thế vbằng dấu cách, sau đó đếm vs

/.
/;$,="(|..{@-})";$;="(|.{@-,@+})";$_=s/(a$,|b$;)\Kv|v(?=$,a|$;b)/ /s?redo:y/v//

TIO