'v'로 표시되는 바이러스, antidote1은 'a'로 표시되고 antidote2는 'b'로 표시되는 직사각형 2D 배열이 있습니다 ( 'v', 'a'및 'b'이외의 값은 없음).

Antidote1은 가로 및 세로 방향으로 만 인접한 바이러스를 제거 할 수 있지만, antidote2는 가로, 세로 및 대각선 방향으로 인접한 (있는 경우) 바이러스를 제거 할 수 있습니다.

해독제가 활성화되면 몇 개의 바이러스가 결국 남아 있습니까?

예 :

입력:

vv
vv

출력 : 4

입력:

av
vv

출력 : 1

입력:

vvv
vbv
vvv

출력 : 0

입력:

bvb
bav
vab
vvv
vvb
vvv
vvv
bva
vav

출력 : 3

파이썬 3 , 135 바이트

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')

온라인으로 사용해보십시오!

Kevin Cruijssen 덕분에 -2 바이트

설명

'b'옆에있는 경우 모든 'v'를 'b'로 바꿉니다. 다음으로 'a'옆에있는 경우 모든 'v'를 'c'로 바꿉니다. 조옮김 된 버전의 어레이를 두 번 반복하면 모든 수직 및 대각선 바이러스가 지워집니다. 마지막으로, 나머지 'v'수를 반환합니다.

더 읽기 쉬운 재귀 함수 (155 바이트)

자바 스크립트 (ES7), 108 바이트

문자 행렬로 입력을받습니다.

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

온라인으로 사용해보십시오!

내 원래의 대답과 비슷하지만 V>'a'>(x-X)**2+y*y-2실제로 아래에 설명 된 hexa trick을 사용하는 것보다 1 바이트가 짧습니다. ¯ \ _ (ツ) _ / ¯

자바 스크립트 (ES7), 109 바이트

문자 행렬로 입력을받습니다.

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

온라인으로 사용해보십시오!

어떻게?

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

정수 좌표를 고려하면 다음과 같습니다.

따라서:

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

댓글

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 바이트

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

온라인으로 시도 하거나 몇 가지 테스트 사례를 확인하십시오 .

@Jitse 의 Python 3 답변 포트이므로 그를 투표 하십시오! @Jitse
덕분에 -1 바이트 .

설명:

레거시 버전은 압축 할 수있는 장점이있다 / 새 버전이 명시를해야하는 문자열 목록, 트랜스 S그리고 J그것은 단지 문자리스트와 함께 작동하기 때문에를. 그러나 새 버전은 €Â더 짧은 압축 문자열과 함께 사용하여 여전히 3 바이트 더 짧습니다 . 레거시 버전에서는 €맵 내부의 스택에 마지막 값만 유지하지만 새 버전에서는 스택 내의 모든 값을 맵 내부에 유지합니다.

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

이 05AB1E 광산의 팁을 참조하십시오 (섹션 압축 문자열 사전의 일부에 어떻게? ) 이유를 이해하는 .•s¯}˜?•것입니다 "vbvabbca".

Java 10, 211 209 바이트

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

모든 싱글 여덟 도전에 대한 내 대답의 수정 . @ceilingcat
덕분에 -2 바이트 .

온라인으로 사용해보십시오.

설명:

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

숯 , 39 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

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

입력 문자열을 \r문자와 결합하고 결과를 캔버스에 그립니다.

≔⁰η

살아있는 virii의 수를 지우십시오.

Ｆθ«

입력 된 문자를 반복합니다.

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

현재 캐릭터가 바이러스이고 b어떤 방향으로 또는 a직교로 인접한 s 가 없다면 라이브 virii의 수를 늘리십시오.

ι»

다음 문자로 반복하십시오.

⎚Ｉη

캔버스를 지우고 총 라이브 비리 수를 인쇄하십시오.

펄 ( -00lp), 82 바이트

정규식을 사용하여 v공백 으로 교체 한 다음 vs 를 계산하십시오.

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

TIO