Cavar una zanja fronteriza

59

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!

Adán
fuente
23
Sátira política en forma de código de golf, me encanta: o)
Sok
44
-1 por eso <sup><sub><sup><sub><sup><sub><sup><sub>:-P
Luis Mendo
25
python, 4 bytes : passlos planes para construir una zanja fronteriza conducen a un cierre del gobierno y no sucede nada.
TheEspinosa
3
@TheEspinosa No, no, el cierre es hasta que se arregle la zanja .
Adám
1
Voté por la historia de fondo. Ni siquiera seguí leyendo.
tubería

Respuestas:

9

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
Luis Mendo
fuente
8

JavaScript (ES7),  84  82 bytes

Guardado 2 bytes gracias a @Shaggy

301

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
Arnauld
fuente
82 bytes?
Shaggy
44
@Shaggy No hay suficientes preguntas últimamente. Ya no sé jugar al golf. : D Gracias!
Arnauld
¡Solo estaba pensando lo mismo antes!
Shaggy
7

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

ngn
fuente
5

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

ngn
fuente
Por supuesto, cambiar a Stencil le ahorraría más de la mitad de sus bytes.
Adám
@ Adám sería una respuesta en un idioma diferente, por lo que no es comparable ni compite con esta respuesta. y no encuentro jugar al golf en lenguajes de propósito especial particularmente interesante, lo siento
NGN
@ Adám, un alias del displayque olvidé eliminarlo. eliminado ahora
ngn
5

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!

Keith S Garner
fuente
1
Bienvenido a PPCG. Buena primera respuesta, ¡incluso con el enlace TIO! No te preocupes por la longitud del código; Cada idioma compite contra sí mismo. Por cierto, puede guardar un byte eliminando el primer salto de línea sin efectos nocivos.
Adám
¿Puede la línea final llegar 0..$h|%{-join$(foreach($j in 0..$w){if ($a[$_][$j]-eq'B'-and($a[(m $_ $h)]|?{$_[(m $j $w)]-match'A'})){'+'}else{$a[$_][$j]}})}a 207 bytes?
Gabriel Mills
4

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!

falla
fuente
2
-1 para ninguna convolución :-P
Luis Mendo
@LuisMendo Una versión anterior incluía una convolución :)
falla
Gracias, actualizado!
falla
3

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

Galen Ivanov
fuente
¿Por qué la solución APL puede escapar sin hacer el relleno cero?
Jonás
@Jonah: APL (Stencil) lo hace atómicamente: "Los rectángulos se centran en elementos sucesivos de Y y (a menos que el tamaño del rectángulo sea 1), se rellenan con elementos de relleno".
Galen Ivanov
eso parece mucho más útil que la versión de J ...
Jonás
@ Jonás Sí, lo es!
Galen Ivanov
2

Carbón de leña , 20 bytes

≔⪫θ⸿θPθFθ⎇∧№KMA⁼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.

Pθ

Imprima la cadena de entrada sin mover el cursor.

Fθ

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

⎇∧№KMA⁼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).

Neil
fuente
2

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)

Lanudo
fuente
2

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.

M Dirr
fuente
Creo que esto funciona para 120 bytes.
Shaggy
O 116 bytes que devuelven una matriz de matrices de caracteres.
Shaggy
1
@ Shaggy Su golf no funciona, lamentablemente, no atrapa lugares donde A y B son diagonales entre sí. Por otro lado, señala algunos campos de golf realmente simples que me perdí ...
M Dirr
1

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.

Neil
fuente
1

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)
Kevin Cruijssen
fuente
1

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!

Encarnación de la ignorancia
fuente
1

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
Nahuel Fouilleul
fuente
-9 bytes con /. /,@m=@-while s/A(|.{@m}.?.?)\KB|B(?=(?1)A)/+/s(nueva línea literal en la primera expresión regular). TIO
Grimmy
1
A 46: /. /;s/A(|.{@{-}}.?.?)\KB|B(?=(?1)A)/+/s&&redo. TIO
Grimmy
gracias, también tuve la idea, pero la descarté porque estaba pensando en retroceder catastróficamente, sin embargo, para el rendimiento del golf de código no es importante
Nahuel Fouilleul
1

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)
Kevin Cruijssen
fuente
1
No he comprobado mucho, pero ¿hay algo malo m[i+k/3-1][j+k%3-1]? 145 bytes
Olivier Grégoire
@ OlivierGrégoire Dang, eso es mucho más fácil ... ¡Gracias!
Kevin Cruijssen
Creo que también es válido para sus respuestas a desafíos anteriores dado que parecen tener la misma estructura
Olivier Grégoire
@ OlivierGrégoire Sí, estaba a punto de jugar golf también con su sugerencia, pero luego apareció otro comentario (y una pregunta en el trabajo). Lo haré en un momento.
Kevin Cruijssen
1

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
mazzy
fuente
0

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

Level River St
fuente
0

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

TFeld
fuente
0

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

t-clausen.dk
fuente
¿Qué te hace pensar que no puedes tomar una mesa como argumento?
Adám
@ Adám no es una mala idea para crear el código usando una tabla como argumento también - Lo entenderé bien
t-clausen.dk
@ Adám Supongo que estaba equivocado, para que el script funcione para 120 caracteres, necesitaría tanto la tabla como el varchar como entrada, lo reescribí. Tomó 151 caracteres
t-clausen.dk