Contexte: Trop d’immigrants clandestins en provenance de Blandia traversent la frontière pour se rendre à Astan. L'empereur d'Astan vous a demandé de creuser une tranchée pour les empêcher d'entrer, et Blandia doit payer les frais. Toutes les dactylographes étant en attente jusqu'à l'aménagement de la tranchée, votre code doit être aussi court que possible. ^_*

Tâche: À partir d’une carte 2D de la frontière entre Astan et Blandia, faites payer aux Blands (avec la terre) pour une tranchée frontalière.

Par exemple: avec les cellules AAstanian marquées , les cellules Blandic marquées Bet les cellules de tranchée marquées +(les cadres de la carte servent uniquement à la clarté):

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

Détails: La carte comportera au moins trois lignes et trois colonnes. La rangée supérieure sera entièrement composée d'Astanian et la rangée inférieure de Blandic.
 Vous pouvez utiliser trois valeurs quelconques pour représenter le territoire Astanian, le territoire Blandic et la fosse frontalière, à condition que les entrées et les sorties soient cohérentes.

Formulation d'automate: une cellule blandique avec au moins une cellule astanienne dans son voisinage de Moore devient une cellule de tranchée frontière.

Cas de test

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

devient:

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

devient:

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

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

devient:

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

^{_{* LIMITATION DE RESPONSABILITÉ: TOUTE RÉSEMBLATION À LA GÉOPOLITIQUE RÉELLE EST PURELLEMENT COINCIDENTALE!}}

Wolfram Language (Mathematica) , 15 octets

2#-#~Erosion~1&

Essayez-le en ligne!

Ou (39 octets):

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

Essayez-le en ligne!

Qu'attendions-nous d'autre de Mathematica? Les caractères utilisés sont {Astan -> 0, Blandia -> 1, Trench -> 2}.

MATL , 11 8 octets

Inspiré par @ flawr réponse est Octave et réponse Mathematica de @ lirtosiast .

EG9&3ZI-

L'entrée est une matrice avec Astan représentée par 0et Blandia par 1. La tranchée est représentée dans la sortie par 2.

Essayez-le en ligne!

Comment ça fonctionne

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 octets

2 octets sauvés grâce à @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)))()

Essayez-le en ligne!

Commenté

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 octets

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

Essayez-le en ligne!

utilise 0 1 2pour"AB+"

{ } fonction avec argument x

~ pas logique

2{ }/ deux fois faire

• 0,x,0 entourer avec 0-s (haut et bas de la matrice)

• 3' triples de lignes consécutives

• +/' somme chaque

• + transposer

x&logique et de xavec

x+ajouter xà

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

⊢⌈{2∊⍵}⌺3 3

ceci est basé sur la solution de chat de 12 octets de @ dzaima . crédit à @ Adám lui-même d’avoir envisagé de l’utiliser ∊dans le dfn, et à @ H.PWiz de nous avoir rappelé d’utiliser le même encodage pour les entrées et les sorties

Essayez-le en ligne!

représente 'AB+'comme 2 0 1respectivement

{ }⌺3 3 applique une fonction à chaque région 3 × 3 superposée de l'entrée, y compris les régions s'étendant sur 1 unité en dehors de la matrice, complétées par des 0

2∊⍵est un 2 présent dans l'argument? retourne un booléen 0/1

⊢⌈ par élément maximum de cela et de la matrice d'origine

PowerShell , 220 octets

Ce n'est pas aussi petit que les autres soumissions, mais je pensais l'ajouter pour référence. [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]}})} 

Essayez-le en ligne!

Octave , 37 31 26 octets

Cette fonction effectue une érosion morphologique sur la partie Astan ( 1-b) de "l'image" à l'aide de , puis utilise une arithmétique pour rendre différents symboles des trois zones. Merci @LuisMendo pour -5 octets!conv2 imerode

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

Essayez-le en ligne!

J , 28 octets

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

Essayez-le en ligne!

'AB+' -> 2 0 1

Inspiré par la solution APL de ngn. 12 octets juste pour remplir la matrice de zéros ...

Charbon de bois , 20 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

≔⪫θ⸿θ

Joignez le tableau d'entrée avec les retours chariot plutôt que les sauts de ligne habituels. Cela est nécessaire pour que les caractères puissent être imprimés individuellement.

Ｐθ

Imprimer la chaîne de saisie sans déplacer le curseur.

Ｆθ

Boucle sur chaque caractère de la chaîne d'entrée.

⎇∧№ＫＭA⁼Bι

Si le quartier de Moore contient un A, et le personnage actuel est un B...

+

... puis écrasez le Bavec un +...

ι

... sinon, imprimer le caractère actuel (ou passer à la ligne suivante si le caractère actuel est un retour à la ligne).

JavaScript, 85 octets

Jeté cela ensemble tard hier soir et oublié à ce sujet. Probablement encore place à quelque amélioration quelque part.

L'entrée et la sortie se présentent sous la forme d'un tableau de chiffres, utilisant 3pour Astan, 0pour Blandia et 1pour la tranchée.

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

Essayez-le en ligne (pour plus de commodité, les cartes de et en arrière au format I / O utilisé dans le défi)

Javascript, 126 118 octets

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

Passez dans l' un des tableaux de chaînes de la question, et vous obtiendrez un tableau de chaînes des tableaux de caractères (merci @Shaggy!) À l' aide de 0 pour la tranchée. Peut probablement être plus joué au golf (sans passer aux tableaux numériques), mais je ne peux penser à rien pour le moment.

Retina 0.8.2 , 92 à 80 octets

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

Essayez-le en ligne! Lâchement basé sur ma réponse à Est-ce que je vais le faire à temps? Explication: Tous les Bs immédiatement supérieurs ou inférieurs à As sont transformés en as. Cela réduit ensuite le problème à vérifier Bs à gauche ou à droite de As ou as. Les as eux-mêmes doivent également être transformés en +s bien sûr, mais heureusement, le idrapeau Tn’affecte que la correspondance des expressions rationnelles, pas la translittération, de sorte que les As restent inchangés.

05AB1E , 29 octets

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

Les matrices ne sont pas vraiment le point fort de 05AB1E (elles ne sont pas non plus le mien). On peut certainement en jouer un peu plus, cependant.
Inspiré par la réponse K (ngn / k) de @ngn , utilise également les E / S d’une matrice entière 2D avec 012pour AB+.

Essayez-le en ligne . (Le pied de page de la TIO est d’imprimer joliment la sortie. N'hésitez pas à la supprimer pour voir la sortie matricielle.)

Explication:

_                # 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 # (compilateur interactif Visual C #) , 187 octets

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

Au lieu de chaîner Take()s, Skip()s et Select()s, cette méthode utilise le double des boucles de recherche pour trouver des voisins. Énorme diminution d'octets, de 392 octets à 187. Linq n'est pas toujours le plus court!

Essayez-le en ligne!

Perl 5, 58 46 octets

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

TIO

-12 octets grâce à @Grimy

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

TIO

• -pcomme -nmais imprimer aussi
• -00 mode paragraphe
• pour obtenir la largeur-1 /.\n/correspond au dernier caractère de la première ligne
• @{-} tableau spécial la position du début de la correspondance des groupes correspondants précédents, forcée sous forme de chaîne (premier élément)
• s/../+/s&&redoremplacer match par +match
  • /sdrapeau, de sorte que .correspond également au caractère de nouvelle ligne
• A(|.{@{-}}.?.?)\KB allumettes
  • ABou Asuivi de (largeur-1) à (largeur + 1) caractères suivis deB
  • \Kgarder la gauche Binchangée
• B(?=(?1)A),
  • (?1) dirverting récursif, pour faire référence à l'expression précédente (|.{$m,$o})
  • (?=..) lookahead, pour correspondre sans consommer d'entrée

Java 8, 169 145 octets

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 octets grâce à @ OlivierGrégoire .

Utilise à la 0place de Aet à la 1place de B, l'entrée étant une matrice entière 2D. Modifie la matrice d'entrée au lieu d'en retourner une nouvelle pour économiser des octets.

Les cellules sont vérifiées de la même manière que dans ma réponse au défi Tous les célibataires .

Essayez-le en ligne.

Explication:

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 octets

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

Essayez-le en ligne!

La carte est une chaîne avec des nouvelles lignes. Ce script remplace Bà +des expressions rationnelles (?<=A(.?.?.{$MapWidth-1})?)B|B(?=(.?.?.{$MapWidth-1})?A).

Script de test moins joué:

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

Sortie:

True
True
True

Ruby , 102 octets

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

Essayez-le en ligne!

entrée / sortie sous forme de chaîne séparée par une nouvelle ligne

Python 2 , 123 119 octets

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

Essayez-le en ligne!

I / O est une liste de listes

TSQL, 252 octets

Fractionner la chaîne est très coûteux, si la chaîne était fractionnée et déjà dans une table, le nombre d'octets serait de 127 caractères. Script inclus dans le bas et complètement différent. Désolé de prendre autant de place.

Golfé:

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 @

Essaye le

TSQL, 127 octets (utilisation d'une variable de table en entrée)

Exécutez ce script dans Management Studio - utilisez "query" - "result to text" pour le rendre lisible

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

Essayez-le - la sortie d'avertissement est sélectionnée et illisible. Serait lisible avec print, mais ce n'est pas possible avec cette méthode