Sua tarefa é encontrar o comprimento da costa de um mapa de ilhas fornecido em um mapa ASCII. O mapa de entrada será composto por 1 ou mais #caracteres que indicam terra e espaços que indicam água. O litoral é considerado qualquer margem entre a terra e a água, incluindo lagos e ilhas do interior.

Sua solução deve ser um programa completo que leia um arquivo, uma string ou uma matriz de strings e produza um único inteiro na tela ou no stdout. Cada linha de entrada pode ter espaço à esquerda ou à direita e zero ou mais caracteres hash. As bordas do mapa são assumidas como espaço (água).

As linhas podem ter comprimentos diferentes.

Exemplos:

Input:
##
##
Output: 8

Input:
    ###    ###
  #####     #
   ##
Output: 26

Input:
  #####
  #   #
  # # #
  #   #
  #####
Output: 36

Isso é código de golfe, portanto, a menor contagem de bytes vence.

code-golf ascii-art counting Cavaleiro Lógico
fonte

Podemos assumir que a entrada é preenchida com um retângulo com espaços?

Martin Ender

Por que um programa completo? Normalmente, as funções também são permitidas e não vejo uma boa razão para esse desafio ser restritivo.

nimi

@ MartinBüttner, sim. Eu esperava que as "margens do mapa fossem consideradas espaço (água)" cobrissem isso. Deixe-me saber se devo esclarecer isso.

Logic Knight

@nimi, entendo sua preocupação, mas como o desafio tem 12 horas, há 4 respostas e outras pessoas podem estar trabalhando nisso agora, relutarei em mudar isso.

Logic Knight

@CarpetPython não, quero dizer se podemos assumir que todas as linhas da entrada têm o mesmo comprimento.

Martin Ender

14

Caracóis , 8 bytes

A
\#o!\#

A Aopção significa contar todos os caminhos correspondentes em vez de quais pontos de partida os resultados são bem-sucedidos. \#consome a #, ovira na direção cardinal e !\#é uma afirmação negativa que obtém sucesso se não houver uma #na nossa frente.

feersum
fonte

4

Pitão - 25 23 bytes

Primeiro, a entrada é retificada. Em seguida, conta as ocorrências " #"acima das 4 permutações de transposições e reversões da entrada + espaço.

/ssm_B++;j;d;CB.t.zd" #

Experimente online aqui .

Maltysen
fonte

Como isso pode detectar linhas de costa na borda da entrada?

feersum

Eu toco primeiro, esqueci de dizer isso.

Maltysen 6/02/16

3

ES6, 123 115 114 bytes

a=>a.map((s,i)=>s.replace(/#/g,(h,j)=>r+=(s[j-1]!=h)+(s[j+1]!=h)+((a[i-1]||'')[j]!=h)+((a[i+1]||'')[j]!=h)),r=0)|r

Editar: salvou 9 bytes graças a @ edc65.

Neil
fonte

Não tenho certeza de que este seja um programa completo que grave em stdout ou na tela. Além disso: você deve usar os parâmetros da função de substituição. a=>['',...a,''].map((s,i,a)=>s.replace(/#/g,(_,j)=>r+=(s[j-1]!=_)+(s[j+1]!=_)+(a[i-1][j]!=_)+(a[i+1][j]!=_)),r=0)|r

Edc65

E melhora=>a.map((s,i)=>s.replace(/#/g,(_,j)=>r+=(s[j-1]!=_)+(s[j+1]!=_)+((a[i-1]||'')[j]!=_)+((a[i+1]||'')[j]!=_)),r=0)|r

edc65

@ edc65 Ah, é claro, perco dois bytes ao capturar o valor interno da matriz. Além disso, boa captura desse parâmetro de substituição.

Neil

2

MATL , 42 bytes

c2\FTFt!*Y+2*qFTFtl-4lhhbvv_2X53$Y+t0>)s2/

Isso aceita a entrada como uma matriz de células de cadeias, no formato

{'#####', '#   #', '# # #', '#   #', '#####'}

Primeiro, converte a entrada em uma matriz de caracteres 2D, preenchendo espaços, e depois em uma matriz de zeros e uns. A convolução 2D é aplicada duas vezes, com duas máscaras diferentes: primeiro para expandir a matriz, depois para detectar arestas.

Experimente online!

Luis Mendo
fonte

0

Japonês, 22 19 bytes

4o £UzX è"#%s|#$} x

Assume que a entrada é preenchida com espaços para formar um retângulo. Teste online!

Como funciona

          // Implicit: U = input string, S = a space
4o £    } // Create the array [0,1,2,3], and map each item X to:
UzX       //  Rotate U by 90 degrees X times.
è"#%s|#$  //  Count the number of "#"s followed by a space, newline, or end-of-string.
x         // Sum the resulting array.

ETHproductions
fonte

Encontre o litoral