Sfida

Dato un input grafico di una forma, determina quanti buchi ci sono in essa.

Non duplicato

Questa domanda è stata contrassegnata come possibile duplicato di Count Islands . Credo che questa sfida sia diversa dalla sfida Count Island perché in questa devi capire come eliminare i blocchi che toccano il confine.

Ingresso

L'input verrà fornito come una forma 2D di input, una stringa multilinea, una matrice di stringhe o una matrice di array di caratteri. Questo rappresenta la forma. La forma è garantita in un solo pezzo, collegata da un bordo. Si prega di specificare come si desidera ricevere l'input.

Produzione

L'output è un singolo intero che indica quanti buchi ci sono nella forma. È consentita una nuova riga finale, ma nessun altro spazio bianco iniziale o finale. In altre parole, l'output deve corrispondere all'espressione regolare^\d+\n?$ .

Che cos'è un buco?

Questi sono fori singoli:

####
#  #
#  #
####

####
#  #
# ##
###

#####
# # #
#   #
#####

Questi non sono buchi:

########
########
#   ####
#   ####
# ######
#       
########

###
#  
###

##########
#         
# ########
# #      #
# # #### #
# #   ## #
# ###### #
#        #
##########

Praticamente, se lo spazio si unisce al bordo esterno, non è un buco.

Casi test

#####
# # # -> 2
#####

#####
#    
# ### -> 1
# # #
#####

####
## # -> 1 (things are connected by edges)
# ##
####

###
### -> 0 (You must handle shapes with no holes, but input will always contain at least one filled space)
###

Puoi usare qualsiasi carattere al posto del '#' e al posto degli spazi.

Criteri di punteggio obiettivo

Il punteggio viene assegnato come numero di byte nel programma.

vincente

Il vincitore sarà l'invio con il punteggio più basso, entro il 4 aprile.

MATLAB / Ottava, 18 byte

@(g)1-bweuler(g,4)

Provalo online!

Questa è una funzione anonima che accetta una matrice logica come input. L'oggetto è formato dalle truevoci (con la connettività specificata), lo spazio vuoto sono le falsevoci.

bweuler quindi calcola il numero di eulero dell'immagine binaria rappresentata da quella matrice, ovvero il numero di oggetti meno il numero di fori.

Mathematica, 59 57 byte

1/.ComponentMeasurements[#,"Holes",CornerNeighbors->0>1]&

C'è un built-in per questo. Accetta input come una matrice 2D di 1s (muri) e 0s (fori). Per comodità, ecco tutti i casi di test in questo formato di input:

{{{1,1,1,1},{1,0,0,1},{1,0,0,1},{1,1,1,1}},
 {{1,1,1,1},{1,0,0,1},{1,0,1,1},{1,1,1,0}},
 {{1,1,1,1,1},{1,0,1,0,1},{1,0,0,0,1},{1,1,1,1,1}},
 {{1,1,1,1,1,1,1,1},{1,1,1,1,1,1,1,1},{1,0,0,0,1,1,1,1},{1,0,0,0,1,1,1,1},{1,0,1,1,1,1,1,1},{1,0,0,0,0,0,0,0},{1,1,1,1,1,1,1,1}},
 {{1,1,1},{1,0,0},{1,1,1}},
 {{1,1,1,1,1,1,1,1,1,1},{1,0,0,0,0,0,0,0,0,0},{1,0,1,1,1,1,1,1,1,1},{1,0,1,0,0,0,0,0,0,1},{1,0,1,0,1,1,1,1,0,1},{1,0,1,0,0,0,1,1,0,1},{1,0,1,1,1,1,1,1,0,1},{1,0,0,0,0,0,0,0,0,1},{1,1,1,1,1,1,1,1,1,1}},
 {{1,1,1,1,1},{1,0,1,0,1},{1,1,1,1,1}},
 {{1,1,1,1,1},{1,0,0,0,0},{1,0,1,1,1},{1,0,1,0,1},{1,1,1,1,1}},
 {{1,1,1,1},{1,1,0,1},{1,0,1,1},{1,1,1,1}}}

Soluzione alternativa, 59 byte

Questo era il mio approccio originale. Si basa anche sui componenti integrati relativi ai componenti, ma non conta direttamente i fori (invece tratta i fori stessi come componenti).

Max@*MorphologicalComponents@*DeleteBorderComponents@*Image

Utilizza lo stesso formato di input di cui sopra, ma con i ruoli di 0s e 1s scambiati.

Il motivo per cui ho bisogno di convertire questo in un Imageprimo è che, altrimenti, Mathematica considererebbe tutte le 1celle come parte di un singolo componente (perché tratta la matrice come una matrice di etichetta componente). Quindi, se una qualsiasi 1cella delimita il margine, eliminerebbe tutti. quandoDeleteBorderComponents viene invece utilizzato su un'immagine, eseguirà un controllo di connettività implicito per trovare i componenti.

In alternativa, potrei chiamare per MorphologicalComponents primo , il che trasformerebbe l'input in una matrice di etichette adatta, ma se lo faccioDeleteBorderComponents secondo luogo non è più garantito che l'etichetta massima del componente corrisponda al numero di componenti (perché potrei eliminare un componente più piccolo).

Perl 5 , 154 byte

152 byte di codice + 2 byte per -p0flag.

s/^ | $/A/gm;s/^.*\K | (?=.*$)/A/&&redo;/.*/;$@="@+"-1;for$%(A,X){$~="(.?.?.{$@})?";(s/$%$~ /$%$1$%/s||s/ $~$%/$%$1$%/s)&&redo}s/ /X/&&++$\&&redo}{$\|=0

Provalo online!

Penso che il codice sia abbastanza esplicativo.

Se hai bisogno di alcune spiegazioni per capire, ecco alcuni passaggi delle trasformazioni fatte dal programma su un semplice input (proveniente da qui ), seguito da alcune spiegazioni qui sotto:

######
#     
# ####
# # #
#### #
######

######
# A
# ####
# # #
#### #
######

######
#AAAAA
#UN####
# A # #
#### #
######

######
#AAAAA
#UN####
#ASCIA #
#### #
######

######
#AAAAA
#UN####
# A # XX #
####X#
######

In primo luogo, s/^ | $/A/gm;s/^.*\K | (?=.*$)/A/&&redosostituirà gli spazi nel bordo (1a regex per sinistra / destra, 2a per fondo / alto) con A(scelgo quel personaggio abbastanza arbitrario).
Quindi, otteniamo la larghezza con la forma /.*/;$@="@+"-1;.
Ora, vogliamo sostituire ogni spazio collegato a un Acon un A(perché se uno spazio è collegato a un A, significa che non può far parte di un buco. È fatto da for$%(A,X){(s/$%(.?.?.{$@})? /$%$1$%/s||s/ (.?.?.{$@})?$%/$%$1$%/s)&&redo}. (Noterai che questo è fatto una volta per la As e una per le Xs - spiegazioni per la Xmuggito) Ci sono due regex qui: si s/$%(.?.?.{$@})? /$%$1$%/stratta degli spazi che sono a destra o in fondo a a A. E s/ (.?.?.{$@})?$%/$%$1$%/scon gli spazi in alto o a sinistra di a A.
A questo punto, gli unici spazi rimasti nella stringa fanno parte dei fori.
Mentre ci sono ancora spazi, ripetiamo:
- Per sapere quanti buchi ci sono, sostituiamo uno spazio con un X( s/ /X/) e incrementiamo il contatore dei buchi ( $\++), e ripetiamo l'intero programma (in realtà, vogliamo solo ripetere il forciclo , ma è meno byte per ripetere l'intero programma).
- Quindi, il forloop sostituirà ogni spazio collegato a Xcon a X, in quanto fanno parte dello stesso foro.
Alla fine, $\|=0assicura che se non ci sono buchi, 0viene stampato a anziché una stringa vuota. Ed $\è implicitamente stampato grazie alla -pbandiera.

Python 2, 282 byte

+100 per gestire i tocchi diagonali TT_TT (ne abbiamo davvero bisogno?)
-119 grazie alla guida @Rod :)

Provalo online . Accetta array di matrici di caratteri '#' e spazi bianchi come input.

A=input()
c=0
X=len(A[0])-1
Y=len(A)-1
def C(T):
 x,y=T
 global g
 if A[y][x]<'#':
    if y<1or y==Y or x<1or x==X:g=0
    A[y][x]='#';map(C,zip([x]*3+[min(x+1,X)]*3+[max(x-1,0)]*3,[y,min(y+1,Y),max(y-1,0)]*3))
while' 'in sum(A,[]):i=sum(A,[]).index(' ');g=1;C((i%-~X,i/-~X));c+=g
print c

Cerca il primo spazio bianco e contrassegnalo come non vuoto ('#'). Controlla ricorsivamente tutto ciò che lo circonda, riempiendo tutte le celle vuote. Se una cella vuota dell'attuale "buco" sembra trovarsi sul bordo del confine non cambierà, altrimenti aumenterebbe di 1. Ripetere il processo, fino a quando non ci sono più spazi bianchi.

Python 2, 233 225 222 byte

math_junkie : -8 byte

Prende 2d array di valori booleani / interi (0/1) come input

s=input()
o=[-1,0,1]
m=lambda x,y:0if x in[-1,len(s[0])]or y in[-1,len(s)]else 1if s[y][x]else(s[y].__setitem__(x,1),all([m(x+a,y+b)for a in o for b in o]))[1]
e=enumerate
print sum(m(x,y)-c for y,l in e(s)for x,c in e(l))

Provalo online!

Versione formattata:

s = input()
o = [-1, 0, 1]
m = lambda x,y:
    0 if x in [-1, len(s[0])] or y in [-1, len(s)]
      else
        1 if s[y][x]
          else
            (s[y].__setitem__(x, 1),
             all([m(x + a, y + b) for a in o for b in o]))[1]
e = enumerate
print sum(m(x, y) - c for y, l in e(s) for x, c in e(l))

C # 7, 364 byte

Meno che soddisfatto di questo ... forse qualcun altro può risolverlo ... Se avrò l'energia in seguito, invertirò il primo ciclo e vedrò se ciò può aiutare a tagliare i limiti.

using C=System.Console;class P{static void Main(){string D="",L;int W=0,H=0,z;for(;(L=C.ReadLine())!=null;H+=W=L.Length)D+=L;int[]S=new int[H*9];int Q(int p)=>S[p]<p?Q(S[p]):p;void R(int r)=>S[Q(r+=z)]=S[r]>0?z:0;for(z=H;z-->0;)if(D[z]<33){S[z]=z;R(1);R(W);R(W+1);R(W-1);}for(;++z<H;)S[Q(z)]*=z>H-W-2|z%W<1|z%W>W-2?0:1;for(;W<H;)z+=Q(W)<W++?0:1;C.WriteLine(z-H);}}

Provalo online

Programma completo, accetta input a standard in, output a standard out. Usa set disgiunti per determinare buchi provvisori e quando uccide qualsiasi tocco tocca i bordi (con un po 'di confusione per il bordo superiore).

Codice formattato e commentato:

using C=System.Console;

class P
{
    static void Main()
    {
        string D="", // the whole map
            L; // initally each line of the map, later each line of output

        // TODO: some of thse might be charable
        int W=0, // width, later position
            H=0, // length (width * height)
            z; // position, later counter

        // read map and width
        for(;(L=C.ReadLine())!=null; // read a line, while we can
                H+=W=L.Length) // record the width, and increment height
            D+=L; // add the line to the map

        // disjoint sets
        int[]S=new int[H*9]; // generousness (relieve some bounds checking)
        // note that S[x] <= x, because we call R with decending values of z

        // returns whatever p points to
        int Q(int p)=>S[p]<p?Q(S[p]):p;
        // points whatever r points to at z if r is empty
        void R(int r)=>S[Q(r+=z)]=S[r]>0?z:0; // note that is never called when z=0

        // fill out disjoint sets
        for(z=H;z-->0;)
            if(D[z]<33) // if cell is empty
            {
                S[z]=z; // point it at itself

                // point the things next  to z at z
                R(1);
                R(W);
                R(W+1);
                R(W-1);
            }

        // zero sets which are against the left, bottom, or right edges
        for(;++z<H;)
            S[Q(z)]*=z>H-W-2|z%W<1|z%W>W-2?0:1; // TODO?: this suggests inverting the first loop (NOTE: would break S[x]<=x)

        // starting from the second row, count all the sets that point to this cell (ignores any non-zeros pointing to first row)
        for(;W<H;)
            z+=Q(W)<W++?0:1;

        C.WriteLine(z-H);
    }
}

Lumache , 48 byte

!{\ z`+~}\ {t\ z!.!~=((lu|u.+r)!(.,~},!{t\ z!.!~

Ungolfed:

!{
    (\   z)+
    ~
}
\ 
{
    t \ 
    z !.!~
    ={
        (lu|u.+r)
        !(.,~)
    }
},
!{
    t \ 
    z !.!~
}

JavaScript (ES6), 192 byte

v=a=>Math.min(...a=a.map(s=>s.length))==Math.max(...a);
f=(s,t=(u=` `.repeat(w=s.search`
`+1))+`
`+s.replace(/^|$/gm,` `)+`
`+u,v=t.replace(RegExp(`( |@)([^]{${w},${w+2}})?(?!\\1)[ @]`),`@$2@`))=>t!=v?f(s,v):/ /.test(t)?f(s,t.replace(` `,`@`))+1:-1

<textarea id=i rows=10 cols=10></textarea><input type=button value=Count onclick=o.textContent=/^[\s#]+$/.test(i.value)*v(i.value.split`\n`)?f(i.value):`Invalid_Entry`><span id=o>

Sulla base della mia risposta a Rileva castelli falliti . Innanzitutto la stringa è riempita con spazi per creare un'area attorno alla forma. RegExp quindi cerca due quadrati adiacenti, uno contenente un @, uno contenente uno spazio e li sostituisce entrambi con un @. Se non può farlo, riempie uno spazio con un @e lo considera come un nuovo buco. Alla fine uno viene sottratto per tenere conto dell'area circostante.