Cavar uma trincheira de borda


59

Antecedentes: Muitos imigrantes ilegais de Blandia estão cruzando a fronteira para Astan. O imperador de Astan encarregou você de cavar uma trincheira para mantê-los afastados, e Blandia deve pagar pelas despesas. Como todos os datilógrafos foram distribuídos até a trincheira ser organizada, seu código deve ser o mais curto possível. *

Tarefa: Dado um mapa 2D da fronteira entre Astan e Blandia, faça os Blands pagarem (com terra) por uma vala na fronteira.

Por exemplo: Com as células astanianas marcadas A, as células Blandic marcadas Be as trincheiras marcadas +(os quadros do mapa são apenas para maior clareza):

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

Detalhes: o mapa terá pelo menos três linhas e três colunas. A linha superior será totalmente astana e a linha inferior será totalmente blandic.
 Você pode usar quaisquer três valores para representar o território astano, território blandico e trincheira de fronteira, desde que a entrada e a saída sejam consistentes.

Formulação de autômatos: Uma célula Blandic com pelo menos uma célula astânica em sua vizinhança de Moore se torna uma célula de trincheira de fronteira.

Casos de teste

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

torna-se:

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

torna-se:

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

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

torna-se:

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

* ISENÇÃO DE RESPONSABILIDADE: QUALQUER REEMBOLSO AOS GEOPOLÍTICOS REAIS É PURAMENTE COINCIDENTAL!


23
Sátira política na forma de código de golfe, eu adoro: o)
Sok

4
-1 para isso <sup><sub><sup><sub><sup><sub><sup><sub>:-P
Luis Mendo

25
python, 4 bytes : passOs planos para construir uma trincheira na fronteira levam ao desligamento do governo e nada acontece.
TheEspinosa 16/01

3
@TheEspinosa Não, não, o desligamento ocorre até a trincheira ser organizada .
Adám 16/01

1
Eu votei apenas por causa da história de fundo. Nem continuou lendo.
pipe

Respostas:




8

JavaScript (ES7),  84  82 bytes

Guardado 2 bytes graças a @Shaggy

30 01

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

Experimente online!

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


4
@ Shaggy Não há perguntas suficientes ultimamente. Não sei mais jogar golfe. : D Obrigado!
Arnauld

Eu estava pensando a mesma coisa antes!
Shaggy

7

K (ngn / k) , 23 bytes

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

Experimente online!

usa 0 1 2para"AB+"

{ } função com argumento x

~ lógico não

2{ }/ duas vezes

  • 0,x,0 surround com 0-s (superior e inferior da matriz)

  • 3' triplos de linhas consecutivas

  • +/' somar cada

  • + transpor

x&lógico e de xcom

x+adicionar xa


5

APL (Dyalog Unicode) , 11 bytes SBCS

⊢⌈{2∊⍵}⌺3 3

isso é baseado na solução de 12 bytes do @ dzaima no chat . agradecemos ao próprio @ Adám por pensar em usar no dfn e ao @ H.PWiz por nos lembrar de usar a mesma codificação para entrada e saída

Experimente online!

representa 'AB+'como 2 0 1respectivamente

{ }⌺3 3 aplique uma função a cada região 3 × 3 sobreposta da entrada, incluindo regiões que estendem 1 unidade fora da matriz, preenchidas com 0s

2∊⍵existe um 2 presente no argumento? retornar um booleano 0/1

⊢⌈ por elemento máximo disso e da matriz original


Obviamente, mudar para o Stencil economizaria mais da metade dos seus bytes.
Adám 16/01

@ Adám que seria uma resposta em um idioma diferente, portanto não comparável ou concorrendo com essa resposta. e eu não acho o golfe em idiomas especiais especialmente interessante, desculpe
ngn 16/01

@ Adám um apelido para o displayqual eu esqueci de remover. removido agora
ngn 17/01

5

PowerShell , 220 bytes

Não é tão pequeno quanto os outros envios, mas pensei em adicioná-lo para referência. [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]}})} 

Experimente online!


1
Bem-vindo ao PPCG. Ótima primeira resposta, com link TIO par! Não se preocupe com o comprimento do código; cada idioma compete contra si mesmo. Aliás, você pode salvar um byte removendo a primeira quebra de linha sem causar efeitos negativos.
Adám 20/01

A linha final pode ter 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 bytes?
Gabriel Mills

4

Oitava , 37 31 26 bytes

Essa função executa uma erosão morfológica na parte Astan ( 1-b) da "imagem" usando e, em seguida, usa alguma aritmética para tornar as três áreas símbolos diferentes. Obrigado @LuisMendo por -5 bytes!conv2 imerode

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

Experimente online!


2
-1 para nenhuma convolução :-P
Luis Mendo

@LuisMendo Uma versão anterior incluía uma convolução :)
flawr 16/01

Obrigado, atualizado!
flawr 17/01

3

J , 28 bytes

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

Experimente online!

'AB+' -> 2 0 1

Inspirado pela solução APL da ngn. 12 bytes apenas para preencher a matriz com zeros ...


por que a solução APL é capaz de escapar sem fazer o preenchimento zero?
Jonah

@Jonah: o APL (Stencil) faz isso automaticamente: "Os retângulos estão centrados em elementos sucessivos de Y e (a menos que o tamanho do retângulo seja 1), preenchidos com elementos de preenchimento".
Galen Ivanov

que parece muito mais útil que a versão de J ...
Jonah

@ Jonah Sim, é!
Galen Ivanov

2

Carvão , 20 bytes

≔⪫θ⸿θPθFθ⎇∧№KMA⁼Bι+ι

Experimente online! Link é a versão detalhada do código. Explicação:

≔⪫θ⸿θ

Associe-se à matriz de entrada com retornos de carro, em vez das novas linhas usuais. Isso é necessário para que os caracteres possam ser impressos individualmente.

Pθ

Imprima a sequência de entrada sem mover o cursor.

Fθ

Faça um loop sobre cada caractere da sequência de entrada.

⎇∧№KMA⁼Bι

Se o bairro de Moore contém um A, e o personagem atual é um B...

+

... em seguida, substitua o Bpor um +...

ι

... caso contrário, imprima o caractere atual (ou vá para a próxima linha se o caractere atual for um retorno de carro).


2

JavaScript, 85 bytes

Reunimos isso tarde da noite passada e esquecemos. Provavelmente ainda há espaço para algumas melhorias em algum lugar.

Entrada e saída é como uma matriz de matrizes de dígitos, usando 3para Astan, 0Blandia e 1trincheira.

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

Experimente on-line (por conveniência, mapas de e para o formato de E / S usado no desafio)


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

Passe uma das matrizes de strings da pergunta e você obterá uma série de matrizes de caracteres de strings (obrigado @Shaggy!) Usando 0 para a trincheira. Provavelmente pode jogar mais golfe (sem mudar para matrizes numéricas), mas não consigo pensar em nada no momento.


Eu acho que isso funciona para 120 bytes.
Shaggy

Ou 116 bytes retornando uma matriz de matrizes de caracteres.
Shaggy

1
@ Shaggy Infelizmente, seu golfe não funciona - ele não pega lugares onde os pontos A e B são diagonais entre si. Por outro lado, ele aponta alguns
campos

1

Retina 0.8.2 , 92 80 bytes

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

Experimente online! Vagamente baseado na minha resposta a Será que chegarei a tempo? Explicação: Quaisquer Bs imediatamente acima ou abaixo de As são transformados em as. Isso reduz o problema à verificação de Bs à esquerda ou direita de As ou as. Eles atambém precisam ser transformados em +s, é claro, mas, felizmente, a ibandeira Tafeta apenas a correspondência de regex, não a transliteração real, para que eles Anão sejam afetados.


1

05AB1E , 29 bytes

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

As matrizes não são realmente o ponto forte de 05AB1E (nem são o meu ponto forte) .. No entanto, pode definitivamente ser mais um jogo de golfe.
Inspirado na resposta K (ngn / k) de @ngn , também usa E / S de uma matriz inteira 2D com 012for AB+respectivamente.

Experimente online . (O rodapé no TIO é para imprimir bastante a saída. Sinta-se à vontade para removê-lo e ver a saída da matriz.)

Explicação:

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

1

C # (compilador interativo do 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;}))

Em vez de encadeamento Take()s, Skip()s, eSelect() vez disso, usa double para loops para encontrar vizinhos. ENORME diminuição de bytes, de 392 bytes para 187. Linq nem sempre é o mais curto!

Experimente online!


1

Perl 5, 58 46 bytes

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

TIO

-12 bytes graças a @Grimy

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

TIO

  • -p gostar -n mas imprima também
  • -00 modo de parágrafo
  • para obter a largura-1 /.\n/corresponde ao último caractere da primeira linha
  • @{-} array especial a posição do início da partida dos grupos correspondentes anteriores, coagidos como string (primeiro elemento)
  • s/../+/s&&redosubstituir partida por +enquanto partidas
    • /ssinalizador, para que .também corresponda ao caractere de nova linha
  • A(|.{@{-}}.?.?)\KB fósforos
    • ABou Aseguido por (largura-1) a (largura + 1) caracteres seguidos porB
    • \Kpara manter a esquerda da Binalterada
  • B(?=(?1)A),
    • (?1) dirverting recursive, para referenciar a expressão anterior (|.{$m,$o})
    • (?=..) lookahead, para corresponder sem consumir entrada

-9 bytes com /. /,@m=@-while s/A(|.{@m}.?.?)\KB|B(?=(?1)A)/+/s(nova linha literal no primeiro regex). TIO
Grimmy 18/01

1
Down to 46: /. /;s/A(|.{@{-}}.?.?)\KB|B(?=(?1)A)/+/s&&redo. TIO
Grimmy 18/01

obrigado, eu também tive a idéia, mas descartado porque estava pensando em voltar atrás catastróficamente, no entanto, para o desempenho do código de golfe não é importante
Nahuel Fouilleul 18/01

1

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 graças a @ OlivierGrégoire .

Usos 0 vez de Ae em 1vez de B, com a entrada sendo uma matriz inteira 2D. Modifica a matriz de entrada em vez de retornar uma nova para salvar bytes.

As células são verificadas da mesma forma que em minha resposta para o desafio Todos os oitavos .

Experimente online.

Explicação:

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)

1
Não verifiquei muito, mas há algo errado m[i+k/3-1][j+k%3-1]? 145 bytes
Olivier Grégoire

@ OlivierGrégoire Dang, isso é muito mais fácil .. Obrigado!
Kevin Cruijssen 18/01

Eu acho que também é válido para suas respostas de desafios anteriores, uma vez que eles parecem ter a mesma estrutura
Olivier Grégoire

@ OlivierGrégoire Sim, eu estava prestes a jogar golfe com sua sugestão, mas outro comentário (e uma pergunta no trabalho) apareceu. Fará isso em um momento.
Kevin Cruijssen 18/01

1

PowerShell , 86 80 bytes

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

Experimente online!

O mapa é uma sequência com novas linhas. Este script substituiB a +com regexp (?<=A(.?.?.{$MapWidth-1})?)B|B(?=(.?.?.{$MapWidth-1})?A).

Script de teste com menos golfe:

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

Resultado:

True
True
True

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

Experimente online!

entrada / saída como uma sequência separada por nova linha


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

Experimente online!

E / S é uma lista de listas


0

TSQL, 252 bytes

Dividir a string é muito caro, se a string já estiver dividida e já estiver em uma tabela, a contagem de bytes terá 127 caracteres. Script incluído na parte inferior e completamente diferente. Desculpe por ocupar tanto espaço.

Golfe:

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 @

Experimente

TSQL, 127 bytes (Usando a variável de tabela como entrada)

Execute esse script no estúdio de gerenciamento - use "query" - "result to text" para torná-lo legível

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

Experimente - a saída de aviso está selecionada e não pode ser lida. Seria legível com impressão, mas isso não é possível usando este método


O que faz você pensar que não pode tomar uma mesa como argumento?
Adám 18/01

@ Adám não é uma má idéia criar o código usando uma tabela como argumento também - eu vou entender direito
t-clausen.dk 18/01

@ Adám Acho que estava errado, para fazer o script funcionar para 120 caracteres, eu precisaria da tabela e do varchar como entrada, reescrevi-o. Foram necessários 151 caracteres
t-clausen.dk 18/01
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.