Tło: Zbyt wielu nielegalnych imigrantów z Blandii przekracza granicę do Astanu. Cesarz Astanu zlecił ci wykopanie rowu, aby ich nie wpuścić, a Blandia musi zapłacić za wydatki. Ponieważ wszystkie maszyny do pisania były rozwłóknione do momentu ułożenia rowu, kod musi być możliwie jak najkrótszy. ^_*

Zadanie: mając mapę 2D granicy między Astanem a Blandią, spraw, aby Blands płacili (wraz z gruntami) za wykop graniczny.

Na przykład: z zaznaczonymi komórkami Astanian, zaznaczonymi komórkami Agruczołów Bi zaznaczonymi komórkami wykopów +(ramki mapy są tylko dla przejrzystości):

┌──────────┐ ┌──────────┐
│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│
└──────────┘ └──────────┘

Szczegóły: mapa będzie mieć co najmniej trzy rzędy i trzy kolumny. Górny rząd będzie całkowicie astanski, a dolny rząd będzie całkowicie blandycki.
 Możesz użyć dowolnych trzech wartości do reprezentowania terytorium Astanian, terytorium Blandic i wykopu granicznego, o ile dane wejściowe i wyjściowe są spójne.

Formułowanie automatyczne: Komórka gruczołowa z co najmniej jedną komórką astańską w sąsiedztwie Moore staje się komórką okopu granicznego.

Przypadki testowe

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

staje się:

[
  "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"
]

staje się:

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

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

staje się:

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

^{_{* WYŁĄCZENIE ODPOWIEDZIALNOŚCI: JAKIEKOLWIEK PONIESIONE RZECZYWISTE GEOPOLITYKI JEST PRAWDOPODOBIEŃSTWO PRZYPADKOWE!}}

Wolfram Language (Mathematica) , 15 bajtów

2#-#~Erosion~1&

Wypróbuj online!

Lub (39 bajtów):

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

Wypróbuj online!

Czego jeszcze moglibyśmy oczekiwać od Mathematica? Używane są znaki {Astan -> 0, Blandia -> 1, Trench -> 2}.

MATL , 11 8 bajtów

Zainspirowani na Octave odpowiedź @ flawr i @ lirtosiast za Mathematica odpowiedź .

EG9&3ZI-

Dane wejściowe to macierz z 0Astanem reprezentowanym przez i Blandia przez 1. Wykop jest reprezentowany w danych wyjściowych przez 2.

Wypróbuj online!

Jak to działa

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 bajtów

Zaoszczędzono 2 bajty dzięki @Shaggy

Pobiera dane wejściowe jako macierz liczb całkowitych, z dla Astanu i dla Blandii. Zwraca macierz z dodatkową wartością dla rowu.$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)))()

Wypróbuj online!

Skomentował

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 bajty

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

Wypróbuj online!

używa 0 1 2dla"AB+"

{ } funkcja z argumentem x

~ logiczne nie

2{ }/ dwa razy

• 0,x,0 surround 0-s (góra i dół matrycy)

• 3' trzy kolejne rzędy

• +/' zsumuj każdy

• + transponować

x&logiczne i xz

x+dodaj xdo

APL (Dyalog Unicode) , 11 bajtów ^SBCS

⊢⌈{2∊⍵}⌺3 3

jest to oparte na 12-bajtowym rozwiązaniu @ dzaima na czacie . ∊podziękowania dla samego @ Adáma za myślenie o użyciu w dfn i @ H.PWiz za przypomnienie nam, abyśmy używali tego samego kodowania dla wejścia i wyjścia

Wypróbuj online!

oznacza 'AB+'jak 2 0 1odpowiednio

{ }⌺3 3 zastosować funkcję do każdego nakładającego się regionu 3 × 3 wejścia, w tym regionów rozciągających się o 1 jednostkę poza matrycę, wypełnionych zerami

2∊⍵jest 2 w argumencie? zwraca wartość logiczną 0/1

⊢⌈ na element maksymalnie tej i oryginalnej macierzy

PowerShell , 220 bajtów

Nie jest tak mały jak inne zgłoszenia, ale pomyślałem, że dodam go w celach informacyjnych. [DZIOBOWY!]

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]}})} 

Wypróbuj online!

Oktawa , 37 31 26 bajtów

Ta funkcja wykonuje erozję morfologiczną w 1-bczęści „obrazu” Astan ( ) za pomocą , a następnie używa pewnej arytmetyki, aby wszystkie trzy obszary były różnymi symbolami. Dzięki @LuisMendo za -5 bajtów!conv2 imerode

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

Wypróbuj online!

J , 28 bajtów

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

Wypróbuj online!

'AB+' -> 2 0 1

Zainspirowany rozwiązaniem APL firmy ngn. 12 bajtów tylko do wypełnienia macierzy zerami ...

Węgiel drzewny , 20 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

≔⪫θ⸿θ

Połącz tablicę wejściową ze znakami powrotu karetki zamiast zwykłych znaków nowej linii. Jest to konieczne, aby znaki mogły być drukowane indywidualnie.

Ｐθ

Wydrukuj ciąg wejściowy bez przesuwania kursora.

Ｆθ

Pętla nad każdym znakiem ciągu wejściowego.

⎇∧№ＫＭA⁼Bι

Jeśli sąsiedztwo Moore zawiera A, a obecna postać to B...

+

... następnie nadpisać Bz +...

ι

... w przeciwnym razie wydrukuj bieżący znak (lub przejdź do następnego wiersza, jeśli bieżącym znakiem jest powrót karetki).

JavaScript, 85 bajtów

Zrzuciłem to zeszłej nocy i zapomniałem o tym. Prawdopodobnie wciąż gdzieś jest miejsce na jakąś poprawę.

Dane wejściowe i wyjściowe są tablicami tablic cyfrowych 3, 0używanymi dla Astanu , dla Blandii i 1dla rowu.

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

Wypróbuj online (dla wygody, mapy zi do formatu I / O użytego w wyzwaniu)

JavaScript, 126 118 bajtów

_=>_.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))

Przekaż jedną z tablic łańcuchowych z pytania, a otrzymasz tablicę znaków łańcuchowych (dzięki @Shaggy!), Używając 0 dla rowu. Mogą prawdopodobnie być golfed więcej (bez przełączania do tablic numerycznych), ale nie mogę myśleć o niczym w tej chwili.

Retina 0.8.2 , 92 80 bajtów

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

Wypróbuj online! Luźno oparty na mojej odpowiedzi na Czy zdążę na czas? Objaśnienie: Wszelkie Bs bezpośrednio powyżej lub poniżej As są zamieniane na as. To redukuje problem do sprawdzania Bs po lewej lub prawej stronie As lub as. aS sami również muszą się zamienił +s oczywiście, ale na szczęście iflagę Ttylko wpływa na mecz regex, a nie rzeczywistymi transliteracji, więc As pozostają niezmienione.

05AB1E , 29 bajtów

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

Macierze nie są tak naprawdę mocnym kolorem 05AB1E (ani nie są moim mocnym kolorem) .. Zdecydowanie można jednak grać w golfa.
Zainspirowany odpowiedzią K (ngn / k) @ngn , więc używa również we / wy macierzy 2D z liczbami całkowitymi odpowiednio 012dla AB+.

Wypróbuj online . (Stopka w TIO polega na ładnym wydrukowaniu wydruku. Możesz go usunąć, aby zobaczyć wynik matrycy.)

Wyjaśnienie:

_                # 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 # (interaktywny kompilator Visual C #) , 187 bajtów

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

Zamiast łączenia łańcuchów Take()s, Skip()si i Select()s, zamiast tego używa podwójnej pętli for do znajdowania sąsiadów. OGROMNY spadek bajtów, z 392 bajtów do 187. Linq nie zawsze jest najkrótszy!

Wypróbuj online!

Perl 5, 58 46 bajtów

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

TIO

-12 bajtów dzięki @Grimy

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

TIO

• -pjak, -nale także drukuj
• -00 tryb akapitowy
• aby uzyskać szerokość-1 /.\n/dopasowuje ostatni znak pierwszego wiersza
• @{-} specjalna tablica pozycja początku dopasowania poprzednich dopasowanych grup, wymuszona jako ciąg znaków (pierwszy element)
• s/../+/s&&redozamień dopasowanie na +chwilę
  • /sflaga, dzięki czemu .pasuje również do znaku nowej linii
• A(|.{@{-}}.?.?)\KB mecze
  • ABlub Apo których następuje (szerokość-1) do (szerokość + 1) znaków, po których następujeB
  • \Kpozostawić lewą Bniezmienioną
• B(?=(?1)A),
  • (?1) dirverting rekurencyjny, odwołujący się do poprzedniego wyrażenia (|.{$m,$o})
  • (?=..) patrz przed siebie, aby dopasować bez zużywania danych wejściowych

Java 8, 169 145 bajtów

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 bajty dzięki @ OlivierGrégoire .

Używa 0zamiast Ai 1zamiast B, z wejściem będącym macierzą całkowitą 2D. Zmienia macierz wejściową zamiast zwracać nową, aby zapisać bajty.

Komórki są sprawdzane tak samo jak w mojej odpowiedzi na wyzwanie Wszystkie pojedyncze ósemki .

Wypróbuj online.

Wyjaśnienie:

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 bajtów

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

Wypróbuj online!

Mapa to ciąg znaków z nowymi liniami. Ten skrypt zastępuje Bna +regexp (?<=A(.?.?.{$MapWidth-1})?)B|B(?=(.?.?.{$MapWidth-1})?A).

Skrypt testowy mniej golfowy:

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

Wynik:

True
True
True

Rubin , 102 bajty

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

Wypróbuj online!

wejście / wyjście jako ciąg rozdzielany znakiem nowej linii

Python 2 , 123 119 bajtów

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

Wypróbuj online!

I / O to lista list

TSQL, 252 bajty

Podział łańcucha jest bardzo kosztowny, jeśli łańcuch zostałby podzielony i już w tabeli liczba bajtów wynosiłaby 127 znaków. Skrypt zawarty w dolnej części i zupełnie inny. Przepraszam, że zajmowałem tyle miejsca.

Gra w golfa:

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 @

Nie golfowany:

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 @

Wypróbuj to

TSQL, 127 bajtów (przy użyciu zmiennej tabeli jako danych wejściowych)

Uruchom ten skrypt w studiu zarządzania - użyj „zapytanie” - „wynik do tekstu”, aby był czytelny

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

Wypróbuj - wyjście ostrzegawcze zostało wybrane i nie można go odczytać. Byłby czytelny z drukowaniem, ale nie jest to możliwe przy użyciu tej metody