Antecedentes: Demasiados inmigrantes ilegales de Blandia están cruzando la frontera a Astan. El emperador de Astan te ha encargado que caves una trinchera para mantenerlos alejados, y Blandia debe pagar los gastos. Dado que todos los mecanógrafos han sido suspendidos hasta que se arregle la zanja, su código debe ser lo más breve posible. ^{_{* *}}

Tarea: Dado un mapa 2D de la frontera entre Astan y Blandia, haga que los Blands paguen (con tierra) por una zanja fronteriza.

Por ejemplo: con las celdas de Astania marcadas A, las celdas de Blandic marcadas By las celdas de trinchera marcadas +(los marcos del mapa son solo para mayor claridad):

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

Detalles: el mapa tendrá al menos tres filas y tres columnas. La fila superior será completamente de Astania y la fila inferior será completamente de Blandic.
 Puede usar cualquiera de los tres valores para representar el territorio de Astania, el territorio de Blandic y la trinchera fronteriza, siempre que la entrada y la salida sean consistentes.

Formulación de autómatas: una célula blandica con al menos una célula de Astania en su vecindario de Moore se convierte en una célula de trinchera fronteriza.

Casos de prueba

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

se convierte en:

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

se convierte en:

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

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

se convierte en:

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

^{_{* DESCARGO DE RESPONSABILIDAD: ¡CUALQUIER RESULTADO A LA GEOPOLÍTICA REAL ES PURAMENTE COINCIDENTAL!}}

Wolfram Language (Mathematica) , 15 bytes

2#-#~Erosion~1&

Pruébalo en línea!

O (39 bytes):

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

Pruébalo en línea!

¿Qué más esperaríamos de Mathematica? Los caracteres utilizados son {Astan -> 0, Blandia -> 1, Trench -> 2}.

MATL , 11 8 bytes

Inspirado por @ flawr de Octave respuesta y @ de lirtosiast respuesta Mathematica .

EG9&3ZI-

La entrada es una matriz con Astan representado por 0y Blandia por 1. La trinchera está representada en la salida por 2.

Pruébalo en línea!

Cómo funciona

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 bytes

Guardado 2 bytes gracias a @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)))()

Pruébalo en línea!

Comentado

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}

Pruébalo en línea!

usos 0 1 2para"AB+"

{ } funcionar con argumento x

~ lógico no

2{ }/ hacer dos veces

• 0,x,0 rodear con 0-s (arriba y abajo de la matriz)

• 3' triples de filas consecutivas

• +/' suma cada

• + transponer

x&lógico y de xcon

x+agregar xa

APL (Dyalog Unicode) , ^{SBCS de} 11 bytes

⊢⌈{2∊⍵}⌺3 3

Esto se basa en la solución de 12 bytes de @ dzaima en el chat . crédito a @ Adám mismo por pensar en usar ∊en el dfn, y a @ H.PWiz por recordarnos que usemos la misma codificación para entrada y salida

Pruébalo en línea!

representa 'AB+'como 2 0 1respectivamente

{ }⌺3 3 aplique una función a cada región 3 × 3 superpuesta de la entrada, incluidas las regiones que se extienden 1 unidad fuera de la matriz, rellenadas con 0s

2∊⍵¿Hay un 2 presente en el argumento? devolver un booleano 0/1

⊢⌈ máximo por elemento de eso y la matriz original

PowerShell , 220 bytes

No es tan pequeño como las otras presentaciones, pero pensé en agregarlo como referencia. [¡DELANTERO!]

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

Pruébalo en línea!

Octava , 37 31 26 bytes

Esta función realiza una erosión morfológica en la parte Astan ( 1-b) de la "imagen" usando , y luego usa algo de aritmética para hacer que las tres áreas sean símbolos diferentes. ¡Gracias @LuisMendo por -5 bytes!conv2 imerode

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

Pruébalo en línea!

J , 28 bytes

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

Pruébalo en línea!

'AB+' -> 2 0 1

Inspirado en la solución APL de ngn. 12 bytes solo para rellenar la matriz con ceros ...

Carbón de leña , 20 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

≔⪫θ⸿θ

Unir la matriz de entrada con retornos de carro en lugar de las líneas nuevas habituales. Esto es necesario para que los caracteres se puedan imprimir individualmente.

Ｐθ

Imprima la cadena de entrada sin mover el cursor.

Ｆθ

Pase sobre cada carácter de la cadena de entrada.

⎇∧№ＫＭA⁼Bι

Si el vecindario de Moore contiene un A, y el personaje actual es un B...

+

... luego sobrescribe el Bcon un +...

ι

... de lo contrario, imprima el carácter actual (o pase a la siguiente línea si el carácter actual es un retorno de carro).

JavaScript, 85 bytes

Lancé esto juntos anoche y lo olvidé. Probablemente todavía hay espacio para alguna mejora en alguna parte.

La entrada y salida es como una matriz de matrices de dígitos, usando 3para Astan, 0para Blandia y 1para la trinchera.

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

Pruébelo en línea (para mayor comodidad, mapas desde y hacia el formato de E / S utilizado en el desafío)

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

Pase una de las matrices de cadenas de la pregunta y obtendrá una matriz de matrices de caracteres de cadenas (¡gracias @Shaggy!) Usando 0 para la trinchera. Puede probablemente ser más Jugamos al golf (sin cambiar a matrices numéricas), pero no puedo pensar en nada por el momento.

Retina 0.8.2 , 92 80 bytes

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

Pruébalo en línea! Basada en mi respuesta a ¿Lo lograré a tiempo? Explicación: Cualquier Bs inmediatamente superior o inferior a As se convierte en as. Esto reduce el problema a verificar Bs a la izquierda o derecha de Aso as. Los as también deben convertirse en +s, por supuesto, pero afortunadamente la ibandera Tsolo afecta la coincidencia de expresiones regulares, no la transliteración real, por lo que los As no se ven afectados.

05AB1E , 29 bytes

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

Las matrices no son realmente el fuerte de 05AB1E (ni tampoco mi fuerte). Sin embargo, definitivamente se puede jugar un poco más.
Inspirado por la respuesta K (ngn / k) de @ngn , también usa E / S de una matriz entera 2D con 012for AB+respectivamente.

Pruébalo en línea . (El pie de página en el TIO es imprimir una bonita impresión de la salida. Siéntase libre de eliminarla para ver la salida de la matriz).

Explicación:

_                # 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 # (compilador interactivo de Visual C #) , 187 bytes

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

En lugar de encadenar Take()s, Skip()sy Select()s, en su lugar, esto usa el doble de bucles para encontrar vecinos. ENORME disminución de bytes, de 392 bytes a 187. ¡Linq no siempre es el más corto!

Pruébalo en línea!

Perl 5, 58 46 bytes

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

TIO

-12 bytes gracias a @Grimy

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

TIO

• -pcomo -npero imprimir también
• -00 modo párrafo
• para obtener el ancho-1 /.\n/coincide con el último carácter de la primera línea
• @{-} matriz especial la posición de inicio de la coincidencia de grupos coincidentes anteriores, coaccionados como cadena (primer elemento)
• s/../+/s&&redoreemplazar partido por +partidos mientras
  • /sbandera, para que .coincida también con el carácter de nueva línea
• A(|.{@{-}}.?.?)\KB partidos
  • ABo Aseguido de (ancho-1) a (ancho + 1) caracteres seguidos deB
  • \Kpara mantener la izquierda de Bsin cambios
• B(?=(?1)A),
  • (?1) dirverting recursivo, para hacer referencia a expresiones anteriores (|.{$m,$o})
  • (?=..) anticipado, para que coincida sin consumir insumos

Java 8, 169145 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 gracias a @ OlivierGrégoire .

Utiliza en 0lugar de Ay en 1lugar de B, siendo la entrada una matriz de enteros 2D. Modifica la matriz de entrada en lugar de devolver una nueva para guardar bytes.

Las celdas están marcadas de la misma manera que en mi respuesta para el desafío Todos los ochos individuales .

Pruébalo en línea.

Explicación:

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 bytes

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

Pruébalo en línea!

El mapa es una cadena con líneas nuevas. Este script reemplaza Ba +con regexp (?<=A(.?.?.{$MapWidth-1})?)B|B(?=(.?.?.{$MapWidth-1})?A).

Guión de prueba menos golfizado:

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

Salida:

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

Pruébalo en línea!

entrada / salida como una cadena separada de nueva línea

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

Pruébalo en línea!

I / O es una lista de listas

TSQL, 252 bytes

Dividir la cadena es muy costoso, si la cadena se dividió y ya está en una tabla, el recuento de bytes sería de 127 caracteres. Guión incluido en la parte inferior y completamente diferente. Perdón por ocupar tanto espacio.

Golfizado:

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 @

Sin golf:

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 @

Pruébalo

TSQL, 127 bytes (usando la variable de tabla como entrada)

Ejecute este script en el estudio de administración - use "query" - "result to text" para que sea legible

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

Pruébelo : la salida de advertencia está seleccionada y no es legible. Sería legible con print, pero eso no es posible usando este método