Creuser une tranchée

59

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!

Adam
la source
23
Satire politique sous forme de code golf, j'adore ça: o)
Sok
4
-1 pour cela <sup><sub><sup><sub><sup><sub><sup><sub>:-P
Luis Mendo le
25
python, 4 octets : passles plans de construction d'une tranchée frontalière mènent à un arrêt du gouvernement et rien ne se passe.
TheEspinosa le
3
@TheEspinosa Non, l'arrêt est prévu jusqu'à ce que la tranchée soit aménagée .
Adám
1
J'ai voté juste à cause de l'histoire de fond. N'a même pas continué à lire.
pipe le

Réponses:

9

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
Luis Mendo
la source
8

JavaScript (ES7),  84  82 octets

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

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
Arnauld
la source
82 octets?
Shaggy
4
@Shaggy Pas assez de questions ces derniers temps. Je ne sais plus jouer au golf. : D Merci!
Arnauld le
Je pensais seulement à la même chose plus tôt!
Shaggy le
7

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à

ngn
la source
5

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

ngn
la source
Bien entendu, le passage à Stencil vous permettrait d’économiser plus de la moitié de vos octets.
Adám
@ Adám ce serait une réponse dans une langue différente, donc pas comparable ou en concurrence avec cette réponse. et je ne trouve pas que le golf dans des langues spéciales soit particulièrement intéressant, désolé
NDG
@ Adám un alias pour displaylequel j'ai oublié de supprimer. enlevé maintenant
ngn
5

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!

Keith S Garner
la source
1
Bienvenue chez PPCG. Belle première réponse, même avec le lien TIO! Ne vous inquiétez pas de la longueur du code; chaque langue est en compétition contre elle-même. Btw, vous pouvez enregistrer un octet en supprimant le premier saut de ligne sans effets néfastes.
Adám le
La ligne finale peut-elle devenir 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]}})}207 octets?
Gabriel Mills
4

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!

flawr
la source
2
-1 pour aucune convolution :-P
Luis Mendo
@LuisMendo Une version antérieure comportait une convolution :)
flawr
Merci, mis à jour!
mardi
3

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

Galen Ivanov
la source
pourquoi la solution APL est-elle capable de s'en sortir sans faire le remplissage à zéro?
Jonas
@Jonah: APL (Stencil) le fait de manière atomatique: "Les rectangles sont centrés sur des éléments successifs de Y et (à moins que la taille du rectangle soit égale à 1), remplis avec des éléments de remplissage."
Galen Ivanov le
cela semble tellement plus utile que la version de J ...
Jonah
@ Jonah Oui, c'est ça!
Galen Ivanov le
2

Charbon de bois , 20 octets

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

Pθ

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

Fθ

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

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

Neil
la source
2

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)

Hirsute
la source
2

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.

M Dirr
la source
Je pense que cela fonctionne pour 120 octets.
Shaggy le
Ou 116 octets renvoyant un tableau de tableaux de caractères.
Shaggy le
1
@Shaggy Votre golf ne fonctionne pas, malheureusement - il n'attrape pas les endroits où A et B sont diagonaux. D’autre part, cela indique quelques golfs très simples qui m'ont
échappé
1

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.

Neil
la source
1

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

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!

Incarnation de l'ignorance
la source
1

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
Nahuel Fouilleul
la source
-9 octets avec /. /,@m=@-while s/A(|.{@m}.?.?)\KB|B(?=(?1)A)/+/s(nouvelle ligne littérale dans la première expression régulière). TIO
Grimmy
1
Jusqu'à 46: /. /;s/A(|.{@{-}}.?.?)\KB|B(?=(?1)A)/+/s&&redo. TIO
Grimmy
merci, j'ai aussi eu l'idée, mais jeté parce que je pensais à un retour en arrière catastrophique cependant pour la performance de golf de code n'est pas important
Nahuel Fouilleul
1

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)
Kevin Cruijssen
la source
1
Je n'ai pas beaucoup vérifié, mais y a-t-il un problème avec m[i+k/3-1][j+k%3-1]? 145 octets
Olivier Grégoire Le
@ OlivierGrégoire Dang, c'est tellement plus simple .. Merci!
Kevin Cruijssen le
Je pense que cela vaut également pour vos réponses aux défis précédents étant donné qu'ils semblent avoir la même structure
Olivier Grégoire
@ OlivierGrégoire Oui, j'étais sur le point de jouer au golf avec votre suggestion, mais un autre commentaire (et une question au travail) est intervenu entre les deux. Va le faire dans un instant.
Kevin Cruijssen le
1

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
mazzy
la source
0

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

Level River St
la source
0

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

TFeld
la source
0

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

t-clausen.dk
la source
Qu'est-ce qui vous fait penser que vous ne pouvez pas prendre une table comme argument?
Adám le
@ Adám pas une mauvaise idée de créer le code en utilisant un tableau comme argument également - je vais
m'y intéresser
@ Adám Je me suis trompé. Pour que le script fonctionne avec 120 caractères, il me fallait la table et le varchar comme entrée, je l'ai réécrit. Il a fallu 151 caractères
t-clausen.dk