Il tuo compito è trovare la lunghezza della costa di una mappa delle isole fornita in una mappa ASCII. La mappa di input sarà composta da 1 o più #caratteri che indicano la terra e spazi che indicano l'acqua. La costa è considerata qualsiasi confine tra terra e acqua, compresi i laghi e le isole interne.

La tua soluzione dovrebbe essere un programma completo che legge in un file, una stringa o un array di stringhe e genera un singolo numero intero sullo schermo o sullo stdout. Ogni riga di input può avere spazio iniziale o finale e zero o più caratteri hash. I bordi della mappa sono considerati spazio (acqua).

Le linee possono avere lunghezze diverse.

Esempi:

Input:
##
##
Output: 8

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

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

Questo è il golf del codice, quindi vince il numero di byte più piccolo.

code-golf ascii-art counting

— Logic Knight
fonte

Possiamo supporre che l'input sia riempito con un rettangolo con spazi?

— Martin Ender,

Perché un programma completo? Di solito sono consentite anche funzioni e non vedo una buona ragione per cui questa sfida sia restrittiva.

— nimi,

@ MartinBüttner, sì. Speravo che "I confini della mappa siano considerati spazio (acqua)" lo coprissero. Fammi sapere se dovrei chiarirlo.

— Logic Knight,

@nimi, capisco la tua preoccupazione, ma dato che la sfida ha 12 ore, ci sono 4 risposte e altre persone potrebbero lavorarci su adesso, sono riluttante a cambiarla.

— Logic Knight,

@CarpetPython no Intendo se possiamo supporre che tutte le linee dell'input abbiano la stessa lunghezza.

— Martin Ender,

14

Lumache , 8 byte

A
\#o!\#

L' Aopzione significa contare tutti i percorsi corrispondenti piuttosto che i punti di partenza da cui una partita ha successo. \#consuma a #, ogira in una direzione cardinale ed !\#è un'asserzione negativa che ha successo se non c'è un #davanti a noi.

— feersum
fonte

4

Pyth - 25 23 byte

Per prima cosa imbottisce l'input in un rettangolo. Quindi conta le occorrenze di " #"oltre le 4 permutazioni di trasposizioni e inversioni di input + spazio.

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

Provalo online qui .

— Maltysen
fonte

In che modo può rilevare le coste ai margini dell'ingresso?

— feersum

L'ho riempito per primo, mi sono dimenticato di dirlo.

— Maltysen,

3

ES6, 123 115 114 byte

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

Modifica: salvato 9 byte grazie a @ edc65.

— Neil
fonte

Non sono sicuro che questo sia un programma completo che scrive su stdout o sullo schermo. A parte questo: dovresti usare param della funzione di sostituzione. 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 meglioa=>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, ovviamente, perdo due byte dovendo acquisire il valore dell'array interno. Inoltre, bella cattura su quel parametro di sostituzione.

— Neil,

2

MATL , 42 byte

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

Questo accetta l'input come una matrice di celle di stringhe, del modulo

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

Converte prima l'input in un array di caratteri 2D, riempiendo gli spazi, quindi in una matrice di zero e uno. La convoluzione 2D viene quindi applicata due volte, con due diverse maschere: la prima per espandere la matrice, la seconda per rilevare i bordi.

Provalo online!

— Luis Mendo
fonte

0

Japt, 22 19 byte

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

Suppone che l'input sia riempito di spazi per formare un rettangolo. Provalo online!

Come funziona

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

Trova la costa