Bối cảnh: Quá nhiều người nhập cư bất hợp pháp từ Blandia đang vượt biên sang Astan. Hoàng đế Astan đã giao nhiệm vụ cho bạn đào một chiến hào để ngăn chặn chúng và Blandia phải trả chi phí. Vì tất cả các nhân viên đánh máy đã được sắp xếp lại cho đến khi rãnh được sắp xếp, mã của bạn phải càng ngắn càng tốt. ^_*

Nhiệm vụ: Đưa ra một bản đồ 2D về biên giới giữa Astan và Blandia, làm cho Blands trả tiền (bằng đất) cho một rãnh biên giới.

Ví dụ: Với các ô của người Ailen được đánh dấu A, các ô Blandic được đánh dấu Bvà các ô được đánh dấu +(các khung bản đồ chỉ rõ ràng):

┌──────────┐ ┌──────────┐
│AAAAAAAAAA│ │AAAAAAAAAA│
│ABAAAAAABA│ │A+AAAAAA+A│
│ABBBAABABA│ │A+++AA+A+A│
│ABBBAABABA│ │A+B+AA+A+A│
│ABBBBABABA│→│A+B++A+A+A│
│ABBBBABBBB│ │A+BB+A++++│
│ABBBBABBBB│ │A+BB+A+BBB│
│ABBBBBBBBB│ │A+BB+++BBB│
│BBBBBBBBBB│ │++BBBBBBBB│
└──────────┘ └──────────┘

Chi tiết: Bản đồ sẽ có ít nhất ba hàng và ba cột. Hàng trên cùng sẽ hoàn toàn là tiếng Ailen và hàng dưới cùng sẽ hoàn toàn là Blandic.
 Bạn có thể sử dụng bất kỳ ba giá trị nào để đại diện cho lãnh thổ của Ailen, lãnh thổ Blandic và rãnh biên giới, miễn là đầu vào và đầu ra đều nhất quán.

Công thức tự động: Một tế bào Blandic có ít nhất một tế bào A-nia trong khu phố Moore của nó trở thành một tế bào rãnh biên.

Các trường hợp thử nghiệm

[
  "AAAAAAAAAA",
  "ABAAAAAABA",
  "ABBBAABABA",
  "ABBBAABABA",
  "ABBBBABABA",
  "ABBBBABBBB",
  "ABBBBABBBB",
  "ABBBBBBBBB",
  "BBBBBBBBBB"
]

trở thành:

[
  "AAAAAAAAAA",
  "A+AAAAAA+A",
  "A+++AA+A+A",
  "A+B+AA+A+A",
  "A+B++A+A+A",
  "A+BB+A++++",
  "A+BB+A+BBB",
  "A+BB+++BBB",
  "++BBBBBBBB"
]

[
  "AAA",
  "AAA",
  "BBB"
]

trở thành:

[
  "AAA",
  "AAA",
  "+++"
]

[
  "AAAAAAAAAA",
  "AAAABBBAAA",
  "AAAABBBAAA",
  "AAAABBBAAA",
  "AAAAAAAAAA",
  "BBBBBBABBB",
  "BBBBBBAABB",
  "BBBAAAAABB",
  "BBBBBBBBBB"
]

trở thành:

[
  "AAAAAAAAAA",
  "AAAA+++AAA",
  "AAAA+B+AAA",
  "AAAA+++AAA",
  "AAAAAAAAAA",
  "++++++A+++",
  "BB++++AA+B",
  "BB+AAAAA+B",
  "BB+++++++B"
]

^{_{* TUYÊN BỐ TỪ CHỐI: BẤT K RES KHẢ NĂNG NÀO ĐỂ KIẾN TRÚC THỰC TẾ LÀ HỢP TÁC MUA SẮM!}}

Ngôn ngữ Wolfram (Mathicala) , 15 byte

2#-#~Erosion~1&

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

Hoặc (39 byte):

MorphologicalPerimeter[#,Padding->1]+#&

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

Những gì chúng ta sẽ mong đợi từ Mathematica? Nhân vật được sử dụng là {Astan -> 0, Blandia -> 1, Trench -> 2}.

MATL , 11 8 byte

Lấy cảm hứng từ câu trả lời Octave của @ flawr và câu trả lời Mathicala của @ lawosiast .

EG9&3ZI-

Đầu vào là một ma trận với Astan được đại diện bởi 0và Blandia bởi 1. Rãnh được thể hiện trong đầu ra bởi 2.

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

Làm thế nào nó hoạt động

E       % Implicit input. Multiply by 2, element-wise
G       % Push input again
9       % Push 9
&3ZI    % Erode with neighbourhood of 9 elements (that is, 3×3) 
-       % Subtract, element-wise. Implicit display

JavaScript (ES7),  84  82 byte

Đã lưu 2 byte nhờ @Shaggy

$3$$0$$1$

a=>(g=x=>a.map(t=(r,Y)=>r.map((v,X)=>1/x?t|=(x-X)**2+(y-Y)**2<v:v||g(X,y=Y)|t)))()

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

Đã bình luận

a => (                      // a[] = input matrix
  g = x =>                  // g = function taking x (initially undefined)
    a.map(t =               //   initialize t to a non-numeric value
      (r, Y) =>             //   for each row r[] at position Y in a[]:
      r.map((v, X) =>       //     for each value v at position X in r[]:
        1 / x ?             //       if x is defined (this is a recursive call):
          t |=              //         set the flag t if:
            (x - X) ** 2 +  //           the squared Euclidean distance
            (y - Y) ** 2    //           between (x, y) and (X, Y)
            < v             //           is less than v (3 = Astan, 0 = Blandia)
        :                   //       else (this is the initial call to g):
          v ||              //         yield v unchanged if it's equal to 3 (Astan)
          g(X, y = Y)       //         otherwise, do a recursive call with (X, Y) = (x, y)
          | t               //         and yield the flag t (0 = no change, 1 = trench)
      )                     //     end of inner map()
    )                       //   end of outer map()
)()                         // initial call to g

K (ngn / k) , 23 byte

{x+x&2{++/'3'0,x,0}/~x}

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

sử dụng 0 1 2cho"AB+"

{ } chức năng với đối số x

~ logic không

2{ }/ hai lần làm

• 0,x,0 bao quanh với 0-s (trên cùng và dưới cùng của ma trận)

• 3' bộ ba hàng liên tiếp

• +/' tổng hợp từng

• + hoán vị

x&hợp lý và xvới

x+thêm xvào

APL (Dyalog Unicode) , 11 byte ^SBCS

⊢⌈{2∊⍵}⌺3 3

điều này dựa trên giải pháp 12 byte của @ dzaima trong trò chuyện . tín dụng cho chính @ Adám vì đã nghĩ đến việc sử dụng ∊trong dfn và @ H.PWiz để nhắc nhở chúng tôi sử dụng cùng một mã hóa cho đầu vào và đầu ra

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

đại diện 'AB+'như 2 0 1tương ứng

{ }⌺3 3 áp dụng một hàm cho mỗi vùng 3 × 3 chồng chéo của đầu vào, bao gồm các vùng mở rộng 1 đơn vị bên ngoài ma trận, được đệm bằng 0s

2∊⍵là 2 hiện diện trong tranh luận? trả lại boolean 0/1

⊢⌈ tối đa cho mỗi phần tử của ma trận đó và ma trận gốc

PowerShell , 220 byte

Nó không nhỏ như các bài nộp khác, nhưng tôi nghĩ tôi nên thêm nó để tham khảo. [FORE!]

function m($i,$m){($i-1)..($i+1)|?{$_-in0..$m}}
$h=$a.count-1;$w=$a[0].length-1
foreach($i in 0..$h){-join$(foreach($j in 0..$w){if ($a[$i][$j]-eq'B'-and($a[(m $i $h)]|?{$_[(m $j $w)]-match'A'})){'+'}else{$a[$i][$j]}})} 

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

Octave , 37 31 26 byte

Hàm này thực hiện một sự xói mòn hình thái trên phần Astan ( 1-b) của "hình ảnh" bằng cách sử dụng , và sau đó sử dụng một số số học để làm cho cả ba khu vực biểu tượng khác nhau. Cảm ơn @LuisMendo cho -5 byte!conv2 imerode

@(b)2*b-imerode(b,ones(3))

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

J , 28 byte

>.3 3(2 e.,);._3(0|:@,|.)^:4

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

'AB+' -> 2 0 1

Lấy cảm hứng từ giải pháp APL của ngn. 12 byte chỉ để đệm ma trận với số không ...

Than , 20 byte

≔⪫θ⸿θＰθＦθ⎇∧№ＫＭA⁼Bι+ι

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:

≔⪫θ⸿θ

Tham gia mảng đầu vào với lợi nhuận vận chuyển thay vì các dòng mới thông thường. Điều này là cần thiết để các ký tự có thể được in riêng lẻ.

Ｐθ

In chuỗi đầu vào mà không di chuyển con trỏ.

Ｆθ

Lặp lại từng ký tự của chuỗi đầu vào.

⎇∧№ＫＭA⁼Bι

Nếu vùng lân cận Moore chứa một Avà ký tự hiện tại là B...

+

... sau đó ghi đè lên Bbằng một +...

ι

... Nếu không thì in ký tự hiện tại (hoặc di chuyển đến dòng tiếp theo nếu ký tự hiện tại là trả về vận chuyển).

JavaScript, 85 byte

Đã ném nó cùng nhau đêm qua và quên nó đi. Có lẽ vẫn còn chỗ cho một số cải tiến ở đâu đó.

Đầu vào và đầu ra là một mảng các mảng chữ số, sử dụng 3cho Astan, 0cho Blandia & 1cho rãnh.

a=>a.map((x,i)=>x.map((y,j)=>o.map(v=>o.map(h=>y|=1&(a[i+v]||x)[j+h]))|y),o=[-1,0,1])

Dùng thử trực tuyến (Để thuận tiện, bản đồ từ & trở lại định dạng I / O được sử dụng trong thử thách)

Javascript, 126 118 byte

_=>_.map(x=>x.replace(/(?<=A)B|B(?=A)/g,0)).map((x,i,a)=>[...x].map((v,j)=>v>'A'&&(a[i-1][j]<v|(a[i+1]||x)[j]<v)?0:v))

Chuyển vào một trong các mảng chuỗi từ câu hỏi và bạn sẽ nhận được một mảng các chuỗi ký tự chuỗi (cảm ơn @Shaggy!) Ra bằng cách sử dụng 0 cho rãnh. Có thể có thể chơi gôn nhiều hơn (mà không chuyển sang mảng số), nhưng tôi không thể nghĩ bất cứ điều gì vào lúc này.

Võng mạc 0.8.2 , 92 80 byte

(?<=¶(.)*)B(?=.*¶(?<-1>.)*(?(1)_)A|(?<=¶(?(1)_)(?<-1>.)*A.*¶.*))
a
iT`Ba`+`.?a.?

Hãy thử trực tuyến! Dựa vào câu trả lời của tôi một cách lỏng lẻo tôi sẽ đưa ra kịp thời? Giải thích: Bất kỳ Bs ngay lập tức trên hoặc dưới As đều được chuyển thành as. Điều này sau đó giảm vấn đề kiểm tra Bs sang trái hoặc phải của As hoặc as. Bản athân họ cũng cần phải biến thành +s, nhưng may mắn là icờ Tchỉ ảnh hưởng đến trận đấu regex chứ không phải phiên âm thực tế, vì vậy As vẫn không bị ảnh hưởng.

05AB1E , 29 byte

_2FIн¸.øVgN+FYN._3£})εøO}ø}*Ā+

Ma trận không thực sự là bộ đồ mạnh mẽ của 05AB1E (cũng không phải là bộ đồ mạnh mẽ của tôi) .. Mặc dù vậy, chắc chắn có thể được chơi gôn nhiều hơn.
Lấy cảm hứng từ @ngn K (NGN / k) câu trả lời 's , vì vậy cũng sử dụng I / O của một ma trận số nguyên 2D với 012cho AB+tương ứng.

Hãy thử trực tuyến . (Phần chân trang trong TIO là in đẹp đầu ra. Vui lòng xóa nó để xem đầu ra ma trận.)

Giải trình:

_                # Inverse the values of the (implicit) input-matrix (0→1 and 1→0)
                 #  i.e. [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,1,1]]
                 #   → [[1,1,1,1],[1,0,1,1],[1,0,0,0],[0,0,0,0]]
 2F              # Loop `n` 2 times in the range [0, 2):
   Iн            #  Take the input-matrix, and only leave the first inner list of 0s
                 #   i.e. [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,1,1]] → [0,0,0,0]
     ¸           #  Wrap it into a list
                 #   i.e. [0,0,0,0] → [[0,0,0,0]]
      .ø         #  Surround the inverted input with the list of 0s
                 #   i.e. [[1,1,1,1],[1,0,1,1],[1,0,0,0],[0,0,0,0]] and [0,0,0,0]
                 #    → [[0,0,0,0],[1,1,1,1],[1,0,1,1],[1,0,0,0],[0,0,0,0],[0,0,0,0]]
        V        #  Pop and store it in variable `Y`
   g             #  Take the length of the (implicit) input-matrix
                 #   i.e. [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,1,1]] → 4
    N+           #  Add `n` to it
                 #   i.e. 4 and n=0 → 4
                 #   i.e. 4 and n=1 → 5
      F          #  Inner loop `N` in the range [0, length+`n`):
       Y         #   Push matrix `Y`
        N._      #   Rotate it `N` times towards the left
                 #    i.e. [[0,0,0,0],[1,1,1,1],[1,0,1,1],[1,0,0,0],[0,0,0,0],[0,0,0,0]] and N=2
                 #     → [[1,0,1,1],[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[1,1,1,1]]
            3£   #   And only leave the first three inner lists
                 #    i.e. [[1,0,1,1],[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[1,1,1,1]]
                 #     → [[1,0,1,1],[1,0,0,0],[0,0,0,0]]
              }  #  After the inner loop:
    )            #  Wrap everything on the stack into a list
                 #   → [[[0,0,0,0],[1,1,1,1],[1,0,1,1]],[[1,1,1,1],[1,0,1,1],[1,0,0,0]],[[1,0,1,1],[1,0,0,0],[0,0,0,0]],[[1,0,0,0],[0,0,0,0],[0,0,0,0]]]
     €ø          #  Zip/transpose (swapping rows/columns) each matrix in the list
                 #   → [[[0,1,1],[0,1,0],[0,1,1],[0,1,1]],[[1,1,1],[1,0,0],[1,1,0],[1,1,0]],[[1,1,0],[0,0,0],[1,0,0],[1,0,0]],[[1,0,0],[0,0,0],[0,0,0],[0,0,0]]]
       O         #  And take the sum of each inner list
                 #   → [[2,1,2,2],[3,1,2,2],[2,0,1,1],[1,0,0,0]]
        ø        #  Zip/transpose; swapping rows/columns the entire matrix again
                 #   i.e. [[2,1,2,2],[3,1,2,2],[2,0,1,1],[1,0,0,0]]
                 #    → [[2,3,2,1],[1,1,0,0],[2,2,1,0],[2,2,1,0]]
               } # After the outer loop:
                 #   i.e. [[3,5,5,4,2],[4,6,5,4,2],[2,3,2,2,1],[1,1,0,0,0]]
  *              # Multiple each value with the input-matrix at the same positions,
                 # which implicitly removes the trailing values
                 #  i.e. [[3,5,5,4,2],[4,6,5,4,2],[2,3,2,2,1],[1,1,0,0,0]]
                 #   and [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,1,1]]
                 #    → [[0,0,0,0],[0,1,0,0],[0,2,1,0],[2,2,1,0]]
   Ā             # Truthify each value (0 remains 0; everything else becomes 1)
                 #  i.e. [[0,0,0,0],[0,1,0,0],[0,2,1,0],[2,2,1,0]]
                 #   → [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,0,0]]
    +            # Then add each value with the input-matrix at the same positions
                 #  i.e. [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,0,0]]
                 #   and [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,1,1]]
                 #    → [[0,0,0,0],[0,2,0,0],[0,2,2,2],[2,2,1,1]]
                 # (and output the result implicitly)

C # (Trình biên dịch tương tác Visual C #) , 187 byte

a=>a.Select((b,i)=>b.Select((c,j)=>{int k=0;for(int x=Math.Max(0,i-1);x<Math.Min(i+2,a.Count);x++)for(int y=Math.Max(0,j-1);y<Math.Min(j+2,a[0].Count);)k+=a[x][y++];return k>1&c<1?9:c;}))

Thay vì xâu chuỗi Take()s, Skip()s và Select()s, thay vào đó, sử dụng gấp đôi cho các vòng lặp để tìm hàng xóm. Giảm byte HUGE, từ 392 byte xuống 187. Linq không phải lúc nào cũng ngắn nhất!

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

Perl 5, 58 46 byte

$m=($n=/$/m+"@+")-2;s/A(|.{$m,$n})\KB|B(?=(?1)A)/+/s&&redo

TIO

-12 byte nhờ @Grimy

/.
/;s/A(|.{@{-}}.?.?)\KB|B(?=(?1)A)/+/s&&redo

TIO

• -pthích -nnhưng cũng in
• -00 chế độ đoạn
• để có chiều rộng-1 /.\n/khớp với ký tự cuối cùng của dòng đầu tiên
• @{-} mảng đặc biệt vị trí bắt đầu khớp của các nhóm khớp trước đó, được ép buộc dưới dạng chuỗi (phần tử đầu tiên)
• s/../+/s&&redothay thế trận đấu +trong khi trận đấu
  • /scờ, để .phù hợp với nhân vật dòng mới
• A(|.{@{-}}.?.?)\KB Diêm
  • ABhoặc Atheo sau bởi (width-1) đến (width + 1) ký tự theoB
  • \Kgiữ bên trái Bkhông thay đổi
• B(?=(?1)A),
  • (?1) đệ quy đệ quy, để tham chiếu biểu thức trước (|.{$m,$o})
  • (?=..) Nhìn, để phù hợp mà không tiêu thụ đầu vào

Java 8, 169 145 byte

m->{for(int i=m.length,j,k;i-->0;)for(j=m[i].length;j-->0;)for(k=9;m[i][j]==1&k-->0;)try{m[i][j]=m[i+k/3-1][j+k%3-1]<1?2:1;}catch(Exception e){}}

-24 byte nhờ @ OlivierGrégoire .

Sử dụng 0thay vì Avà 1thay vì B, với đầu vào là ma trận số nguyên 2D. Sửa đổi ma trận đầu vào thay vì trả về một ma trận mới để lưu byte.

Các ô được kiểm tra giống như trong câu trả lời của tôi cho thử thách Tất cả các đêm .

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

Giải trình:

m->{                            // Method with integer-matrix parameter and no return-type
  for(int i=m.length,j,k;i-->0;)//  Loop over the rows
    for(j=m[i].length;j-->0;)   //   Inner loop over the columns
      for(k=9;m[i][j]==1&       //    If the current cell contains a 1:
          k-->0;)               //     Inner loop `k` in the range (9, 0]:
        try{m[i][j]=            //      Set the current cell to:
             m[i+k/3-1]         //       If `k` is 0, 1, or 2: Look at the previous row
                                //       Else-if `k` is 6, 7, or 8: Look at the next row
                                //       Else (`k` is 3, 4, or 5): Look at the current row
              [j+k%3-1]         //       If `k` is 0, 3, or 6: Look at the previous column
                                //       Else-if `k` is 2, 5, or 8: Look at the next column
                                //       Else (`k` is 1, 4, or 7): Look at the current column
               <1?              //       And if this cell contains a 0:
                  2             //        Change the current cell from a 1 to a 2
                 :              //       Else:
                  1;            //        Leave it a 1
        }catch(Exception e){}}  //      Catch and ignore ArrayIndexOutOfBoundsExceptions
                                //      (try-catch saves bytes in comparison to if-checks)

PowerShell , 86 80 byte

$p="(.?.?.{$(($args|% i*f '
')-1)})?"
$args-replace"(?s)(?<=A$p)B|B(?=$p`A)",'+'

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

Bản đồ là một chuỗi với các dòng mới. Kịch bản này thay thế Bđể +với regexp (?<=A(.?.?.{$MapWidth-1})?)B|B(?=(.?.?.{$MapWidth-1})?A).

Kịch bản kiểm tra ít chơi gôn hơn:

$f = {
$l=($args|% indexOf "`n")-1
$p="(.?.?.{$l})?"
$args-replace"(?s)(?<=A$p)B|B(?=$p`A)",'+'
}

@(
,(@"
AAAAAAAAAA
ABAAAAAABA
ABBBAABABA
ABBBAABABA
ABBBBABABA
ABBBBABBBB
ABBBBABBBB
ABBBBBBBBB
BBBBBBBBBB
"@,@"
AAAAAAAAAA
A+AAAAAA+A
A+++AA+A+A
A+B+AA+A+A
A+B++A+A+A
A+BB+A++++
A+BB+A+BBB
A+BB+++BBB
++BBBBBBBB
"@)
,(@"
AAA
AAA
BBB
"@,@"
AAA
AAA
+++
"@)
,(@"
AAAAAAAAAA
AAAABBBAAA
AAAABBBAAA
AAAABBBAAA
AAAAAAAAAA
BBBBBBABBB
BBBBBBAABB
BBBAAAAABB
BBBBBBBBBB
"@,@"
AAAAAAAAAA
AAAA+++AAA
AAAA+B+AAA
AAAA+++AAA
AAAAAAAAAA
++++++A+++
BB++++AA+B
BB+AAAAA+B
BB+++++++B
"@)
) | % {
    $map,$expected = $_
    $result = &$f $map
    $result-eq$expected
    #$result # uncomment this line to display results
}

Đầu ra:

True
True
True

Ruby , 102 byte

->a{a+=?.*s=a.size
(s*9).times{|i|a[j=i/9]>?A&&a[j-1+i%3+~a.index($/)*(i/3%3-1)]==?A&&a[j]=?+}
a[0,s]}

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

đầu vào / đầu ra dưới dạng một chuỗi phân tách dòng mới

Python 2 , 123 119 byte

lambda m:[[[c,'+'][c=='B'and'A'in`[x[j-(j>0):j+2]for x in m[i-(i>0):i+2]]`]for j,c in e(l)]for i,l in e(m)];e=enumerate

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

I / O là danh sách các danh sách

TSQL, 252 byte

Việc tách chuỗi rất tốn kém, nếu chuỗi được tách và đã có trong một bảng thì số byte sẽ là 127 ký tự. Kịch bản bao gồm ở phía dưới và hoàn toàn khác nhau. Xin lỗi vì đã chiếm nhiều không gian này.

Chơi gôn

WITH C as(SELECT x,x/z r,x%z c,substring(@,x+1,1)v
FROM spt_values CROSS APPLY(SELECT number x,charindex(char(10),@)z)z
WHERE'P'=type)SELECT @=stuff(@,x+1,1,'+')FROM c WHERE
exists(SELECT*FROM c d WHERE abs(r-c.r)<2and
abs(c-c.c)<2and'AB'=v+c.v)PRINT @

Ung dung:

DECLARE @ varchar(max)=
'AAAAAAAAAA
ABAAAAAABA
ABBBAABABA
ABBBAABABA
ABBBBABABA
ABBBBABBBB
ABBBBABBBB
ABBBBBBBBB
BBBBBBBBBB';

WITH C as
(
  SELECT x,x/z r,x%z c,substring(@,x+1,1)v
  FROM spt_values
  CROSS APPLY(SELECT number x,charindex(char(10),@)z)z
  WHERE'P'=type
)
SELECT
  @=stuff(@,x+1,1,'+')
FROM c
WHERE exists(SELECT*FROM c d 
         WHERE abs(r-c.r)<2 
           and abs(c-c.c)<2 and'AB'=v+c.v)
PRINT @

Dùng thử

TSQL, 127 byte (Sử dụng biến bảng làm đầu vào)

Thực thi tập lệnh này trong studio quản lý - sử dụng "truy vấn" - "kết quả thành văn bản" để làm cho nó dễ đọc

--populate table variable
USE master
DECLARE @v varchar(max)=
'AAAAAAAAAA
ABAAAAAABA
ABBBAABABA
ABBBAABABA
ABBBBABABA
ABBBBABBBB
ABBBBABBBB
ABBBBBBBBB
BBBBBBBBBB'

DECLARE @ table(x int, r int, c int, v char)

INSERT @
SELECT x+1,x/z,x%z,substring(@v,x+1,1)
FROM spt_values
CROSS APPLY(SELECT number x,charindex(char(10),@v)z)z
WHERE'P'=type and len(@v)>number

-- query(127 characters)

SELECT string_agg(v,'')FROM(SELECT
iif(exists(SELECT*FROM @
WHERE abs(r-c.r)<2and abs(c-c.c)<2and'AB'=v+c.v),'+',v)v
FROM @ c)z

Dùng thử - đầu ra cảnh báo được chọn và không thể đọc được. Có thể đọc được bằng in, nhưng không thể sử dụng phương pháp này