Hintergrund: Zu viele illegale Einwanderer aus Blandia überqueren die Grenze nach Astan. Der Kaiser von Astan hat dich beauftragt, einen Graben auszuheben, um sie fernzuhalten, und Blandia muss für die Kosten aufkommen. Da alle Schreibkräfte bis zum Einrichten des Grabens beschäftigt waren, muss Ihr Code so kurz wie möglich sein. ^_*

Aufgabe: Lassen Sie die Blands anhand einer 2D-Karte der Grenze zwischen Astan und Blandia (mit Land) für einen Grenzgraben bezahlen.

Zum Beispiel: Wenn astanische Zellen markiert sind A, Blandic-Zellen markiert sind Bund Trench-Zellen markiert sind +(die Kartenrahmen dienen nur der Klarheit):

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

Details: Die Karte enthält mindestens drei Zeilen und drei Spalten. Die obere Reihe wird vollständig astanisch sein und die untere Reihe wird vollständig blandisch sein.
 Sie können drei beliebige Werte verwenden, um das astanische Territorium, das blandische Territorium und den Grenzgraben darzustellen, sofern Eingabe und Ausgabe konsistent sind.

Automatenformulierung: Eine blandische Zelle mit mindestens einer astanischen Zelle in ihrer Nachbarschaft Moore wird zu einer Grenzgrabenzelle.

Testfälle

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

wird:

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

wird:

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

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

wird:

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

^{_{* HAFTUNGSAUSSCHLUSS: JEGLICHE VERHÄLTNIS ZUR TATSÄCHLICHEN GEOPOLITIK IST ENTSPRECHEND!}}

Wolfram Language (Mathematica) , 15 Byte

2#-#~Erosion~1&

Probieren Sie es online!

Oder (39 Bytes):

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

Probieren Sie es online!

Was würden wir sonst noch von Mathematica erwarten? Verwendete Zeichen sind {Astan -> 0, Blandia -> 1, Trench -> 2}.

MATL , 11 8 Bytes

Inspiriert von @ flawrs Octave-Antwort und @ lirtosiasts Mathematica-Antwort .

EG9&3ZI-

Die Eingabe ist eine Matrix, in der Astan durch 0und Blandia durch dargestellt werden 1. Der Graben wird in der Ausgabe durch dargestellt 2.

Probieren Sie es online!

Wie es funktioniert

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

2 Bytes dank @Shaggy gespart

Übernimmt die Eingabe als Ganzzahlmatrix, wobei für Astan und für Blandia steht. Gibt eine Matrix mit dem zusätzlichen Wert für den Graben zurück.$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)))()

Probieren Sie es online!

Kommentiert

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 Bytes

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

Probieren Sie es online!

verwendet 0 1 2für"AB+"

{ } Funktion mit Argument x

~ logisch nicht

2{ }/ zweimal tun

• 0,x,0 Surround mit 0-s (oben und unten in der Matrix)

• 3' Dreifache von aufeinanderfolgenden Reihen

• +/' summiere jeden

• + transponieren

x&logisch und von xmit

x+hinzufügen xzu

APL (Dyalog Unicode) , 11 Byte ^SBCS

⊢⌈{2∊⍵}⌺3 3

Dies basiert auf der 12-Byte-Lösung von @ dzaima im Chat . ∊Wir danken @ Adám selbst für seine Überlegungen zur Verwendung in der DFN und @ H.PWiz dafür, dass er uns daran erinnert hat, dieselbe Kodierung für Ein- und Ausgabe zu verwenden

Probieren Sie es online!

darstellt , 'AB+'wie 2 0 1jeweils

{ }⌺3 3 Wenden Sie eine Funktion auf jede überlappende 3 × 3-Region der Eingabe an, einschließlich Regionen, die sich um 1 Einheit außerhalb der Matrix erstrecken und mit Nullen aufgefüllt sind

2∊⍵ist eine 2 im argument vorhanden? Rückgabe eines 0/1-Booleschen Werts

⊢⌈ pro Element max davon und der ursprünglichen Matrix

PowerShell , 220 Byte

Es ist nicht so klein wie die anderen Einreichungen, aber ich dachte, ich würde es als Referenz hinzufügen. [VORDERGRUND!]

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

Probieren Sie es online!

Oktave , 37 31 26 Bytes

Diese Funktion führt eine morphologische Erosion am Astan ( 1-b) - Teil des "Bildes" durch und verwendet dann eine gewisse Arithmetik, um alle drei Bereiche mit unterschiedlichen Symbolen zu versehen. Danke @LuisMendo für -5 Bytes!conv2 imerode

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

Probieren Sie es online!

J , 28 Bytes

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

Probieren Sie es online!

'AB+' -> 2 0 1

Inspiriert von der APL-Lösung von ngn. 12 Bytes nur um die Matrix mit Nullen aufzufüllen ...

Holzkohle , 20 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

≔⪫θ⸿θ

Verbinden Sie das Eingabearray mit Zeilenumbrüchen anstelle der üblichen Zeilenumbrüche. Dies ist erforderlich, damit die Zeichen einzeln gedruckt werden können.

Ｐθ

Drucken Sie die Eingabezeichenfolge, ohne den Cursor zu bewegen.

Ｆθ

Durchlaufen Sie jedes Zeichen der Eingabezeichenfolge.

⎇∧№ＫＭA⁼Bι

Wenn das Moore-Viertel ein enthält Aund das aktuelle Zeichen ein B...

+

... dann überschreibe die Bmit einem +...

ι

... ansonsten das aktuelle Zeichen drucken (oder in die nächste Zeile springen, wenn das aktuelle Zeichen ein Wagenrücklauf ist).

JavaScript, 85 Bytes

Warf das letzte Nacht zusammen und vergaß es. Wahrscheinlich gibt es irgendwo noch Raum für Verbesserungen.

Die Ein- und Ausgabe erfolgt als Array von Ziffern-Arrays, wobei 3Astan, 0Blandia und 1der Graben verwendet werden.

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

Probieren Sie es online aus.

Javascript, 126 118 Bytes

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

Übergeben Sie eines der String-Arrays aus der Frage, und Sie erhalten ein Array von String- Zeichen-Arrays (danke @Shaggy!) Mit 0 für den Graben. Kann wahrscheinlich mehr golfen werden (ohne auf numerische Arrays umzuschalten), aber mir fällt momentan nichts ein.

Retina 0.8.2 , 92 80 Bytes

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

Probieren Sie es online! Lose basierend auf meiner Antwort auf Werde ich es rechtzeitig herausfinden? Erläuterung: Alle Bs unmittelbar über oder unter As werden zu as. Dies reduziert das Problem auf das Überprüfen von Bs links oder rechts von As oder as. Die as selbst müssen +natürlich auch in s umgewandelt werden, aber zum Glück wirkt sich das iFlag Tnur auf die Regex-Übereinstimmung aus, nicht auf die tatsächliche Transliteration, sodass die As davon nicht betroffen sind.

05AB1E , 29 Bytes

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

Matrizen sind nicht wirklich der starke Anzug von 05AB1E (und sie sind auch nicht mein starker Anzug).
Inspiriert von @ngns K (ngn / k) Antwort , verwendet also auch I / O einer 2D Integer Matrix mit 012für AB+.

Probieren Sie es online aus . (Die Fußzeile im TIO dient zum hübschen Ausdrucken der Ausgabe. Sie können sie jederzeit entfernen, um die Matrixausgabe anzuzeigen.)

Erläuterung:

_                # 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 # (Visual C # Interactive Compiler) , 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;}))

Statt Take()s, Skip()s und Select()s zu verketten , werden stattdessen double for-Schleifen verwendet, um Nachbarn zu finden. GROSSE Byteabnahme von 392 Bytes auf 187. Linq ist nicht immer die kürzeste!

Probieren Sie es online!

Perl 5, 58 46 Bytes

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

TIO

-12 Bytes dank @Grimy

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

TIO

• -pmag -naber auch drucken
• -00 Absatzmodus
• um die width-1 zu erhalten, /.\n/stimmt das letzte Zeichen der ersten Zeile überein
• @{-} spezielles Array die Position des Übereinstimmungsbeginns früherer übereinstimmender Gruppen, erzwungen als Zeichenfolge (erstes Element)
• s/../+/s&&redoErsetzen Sie match durch +while matches
  • /sflag, damit .passt das auch zu newline zeichen
• A(|.{@{-}}.?.?)\KB Streichhölzer
  • ABoder Agefolgt von (width-1) bis (width + 1) Zeichen gefolgt vonB
  • \Kdas linke Bunverändert zu lassen
• B(?=(?1)A),
  • (?1) Dirvertieren rekursiv, um auf den vorherigen Ausdruck zu verweisen (|.{$m,$o})
  • (?=..) Lookahead, um ohne aufwendige Eingabe zu passen

Java 8, 169 145 Bytes

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 Bytes dank @ OlivierGrégoire .

Wird 0anstelle von Aund 1anstelle von verwendet B, wobei die Eingabe eine 2D-Ganzzahlmatrix ist. Ändert die Eingabematrix, anstatt eine neue zurückzugeben, um Bytes zu sparen.

Die Zellen werden wie in meiner Antwort für die Herausforderung Alle die einzelnen Acht überprüft .

Probieren Sie es online aus.

Erläuterung:

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 bis 80 Byte

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

Probieren Sie es online!

Die Map ist eine Zeichenfolge mit Zeilenumbrüchen. Dieses Skript ersetzt Bto +durch regexp (?<=A(.?.?.{$MapWidth-1})?)B|B(?=(.?.?.{$MapWidth-1})?A).

Weniger Golf-Testskript:

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

Ausgabe:

True
True
True

Ruby , 102 Bytes

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

Probieren Sie es online!

Eingabe / Ausgabe als durch Zeilenumbrüche getrennte Zeichenfolge

Python 2 , 123 119 Bytes

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

Probieren Sie es online!

I / O ist eine Liste von Listen

TSQL, 252 Bytes

Das Aufteilen der Zeichenfolge ist sehr kostspielig, wenn die Zeichenfolge aufgeteilt wurde und die Anzahl der Bytes bereits in einer Tabelle 127 Zeichen beträgt. Script im unteren Bereich enthalten und völlig anders. Entschuldigen Sie, dass Sie so viel Platz in Anspruch nehmen.

Golf gespielt:

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 @

Ungolfed:

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 @

Versuch es

TSQL, 127 Bytes (Tabellenvariable als Eingabe verwenden)

Führen Sie dieses Skript im Management Studio aus - verwenden Sie "query" - "result to text", um es lesbar zu machen

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

Probieren Sie es aus - der Warnausgang ist ausgewählt und nicht lesbar. Wäre mit print lesbar, aber das ist mit dieser Methode nicht möglich