10

Considera la seguente griglia standard di cruciverba 15 × 15 .

Griglia cruciverba

Possiamo rappresentarlo nell'arte ASCII usando #per i blocchi e (spazio) per i quadrati bianchi.

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

     ##   #    
   #       #   
    #   ##     

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

Data una griglia di parole crociate nel formato di arte ASCII sopra, determinare quante parole contiene. (La griglia sopra ha 78 parole. Capita di essere il puzzle del New York Times dello scorso lunedì .)

Una parola è un gruppo di due o più spazi consecutivi che corrono verticalmente o orizzontalmente. Una parola inizia e termina con un blocco o il bordo della griglia e scorre sempre dall'alto verso il basso o da sinistra a destra, mai in diagonale o all'indietro. Nota che le parole possono estendersi per l'intera larghezza del puzzle, come nella sesta riga del puzzle sopra. Non è necessario che una parola sia connessa a un'altra parola.

Dettagli

L'input sarà sempre un rettangolo contenente i caratteri #o (spazio), con le righe separate da una nuova riga ( \n). Si può presumere che la griglia sia composta da 2 caratteri ASCII stampabili distinti anziché #e .
Si può presumere che esista una nuova riga finale opzionale. I caratteri spazio finale contano, poiché influiscono sul numero di parole.
La griglia non sarà sempre simmetrica e potrebbe essere costituita da tutti gli spazi o tutti i blocchi.
Il tuo programma dovrebbe teoricamente essere in grado di funzionare su una griglia di qualsiasi dimensione, ma per questa sfida non sarà mai più grande di 21 × 21.
È possibile prendere la griglia stessa come input o come nome di un file contenente la griglia.
Prendi l'input dagli argomenti stdin o della riga di comando e l'output su stdout.
Se preferisci, puoi usare una funzione con nome invece di un programma, prendendo la griglia come argomento stringa e producendo un numero intero o una stringa tramite stdout o return di funzione.

Casi test

Ingresso:
```
    #
    #
    #
```
Output: 7(Ci sono quattro spazi prima di ciascuno #. Il risultato sarebbe lo stesso se ogni segno numerico fosse rimosso, ma Markdown rimuove gli spazi da righe altrimenti vuote.)
Ingresso:
```
##
 #
##
```
Output: 0(le parole di una lettera non contano.)

Ingresso:

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

Produzione: 4

Input: ( puzzle del Sunday NY Times del 10 maggio )

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

Produzione: 140

punteggio

Vince il codice più breve in byte . Tiebreaker è il post più vecchio.

— NinjaBearMonkey
fonte

7

CJam, 18 17 13 11 byte

2 byte salvati da Dennis.

Utilizza spazi per celle riempite e 1per celle vuote:

qN/_z+:~1-,

Provalo qui.

Spiegazione

q    e# Read the entire input.
N/   e# Split into lines.
_z   e# Make a copy and transpose it.
+    e# Add the lines of the two grids together.
:~   e# Evaluate each line which will push a rep-digit number for each empty-cell chunk.
1-   e# Remove all the 1s as these correspond to individual empty cells.
,    e# Get the length of the array.

— Martin Ender
fonte

9

Slip , 18 + 3 = 21 byte

>? ( +(X|$^)<<){2}

Corri con i flag no(da qui +3) e usa space / Xinvece di space / #. È fastidioso che questo sia più lungo di CJam / Pyth, ma immagino che Slip non sia stato progettato per essere particolare

Provalo online . Si noti che nel primo esempio mancano spazi su alcune righe.

Spiegazione

>?           Optionally turn right, hence matching either horizontally or vertically
[space]      Match a space
(    ){2}    Group, twice:
[space]+       Match 1+ spaces
(X|$^)         Either an X or the boundary of the grid
<<             Reverse the match pointer by turning left twice

Il nflag fa stampare in uscita il numero di corrispondenze e il oflag abilita le corrispondenze sovrapposte a partire dallo stesso quadrato. Il motivo del avanti e indietro è perché Slip prova le partite a partire da ogni quadrato e vogliamo assicurarci di abbinare solo una riga intera anziché una parziale. Slip restituisce solo partite uniche, anche se sono iniziate da posizioni diverse.

Nota: originariamente avevo >?( +(X|$^)<<){2}, con il primo spazio all'interno. Questo perderebbe alcuni casi con 2 parole lunghe nello spazio sul bordo, poiché il puntatore andrebbe così:

XXX       XXX       XXX       XXX
X>        X >       X<        <
XXX       XXX       XXX       XXX

[sp]    [sp]+$^    <<[sp]    [sp]+   (uh oh match fails)

— SP3000
fonte

Perché i due flag sono tre byte?

— lirtosiast,

@ThomasKwa Penso che l'attuale politica con flag della riga di comando sia questa meta post , che conta il numero di byte come la differenza dalla solita invocazione del codice. Quindi qui la differenza è tra py -3 slip.py regex.txt input.txte py -3 slip.py regex.txt input.txt no, che è di tre byte (incluso lo spazio precedente n)

— Sp3000

Questo ha senso. Ci stavo pensando da una prospettiva entropica; a volte dimentico che sono i personaggi che contiamo.

— lirtosiast,

4

Haskell, 81 byte

import Data.List
m x=sum[1|(_:_:_)<-words x]
f x=m x+m(unlines$transpose$lines x)

Utilizza gli spazi come caratteri a blocchi e qualsiasi altro carattere (non bianco) come cella vuota.

Come funziona: dividi l'input in un elenco di parole negli spazi. Prendi un 1per ogni parola con 2 caratteri in affitto e somma quei 1s. Applicare la stessa procedura alla trasposizione (suddivisa in \n) dell'ingresso. Aggiungi entrambi i risultati.

— Nome del modello
fonte

4

JavaScript ( ES6 ) 87 121 147

Costruisci la trasposizione della stringa di input e aggiungila all'input, quindi conta le stringhe di 2 o più spazi.

Esegui lo snippet in Firefox per testarlo.

Crediti @IsmaelMiguel, una soluzione per ES5 (122 byte):

function F(z){for(r=z.split(/\n/),i=0;i<r[j=0][L='length'];i++)for(z+='#';j<r[L];)z+=r[j++][i];return~-z.split(/  +/)[L]};

F=z=>
(
  r=z.split(/\n/),
  [r.map(r=>z+=r[i],z+='#')for(i in r[0])],
  ~-z.split(/  +/).length
)

// TEST
out=x=>O.innerHTML += x + '\n';

[
'     #    #    \n     #    #    \n          #    \n   #   #       \n###     ##   ##\n               \n     ##   #    \n   #       #   \n    #   ##     \n               \n##   ##     ###\n       #   #   \n    #          \n    #    #     \n    #    #     ', '##\n #\n##', '    #\n    #\n    #',
 '######\n#    #\n  ####\n# ## #\n# ## #\n#### #',
 '   #    ##   #       \n   #    #    #       \n   #         #       \n       #     ###   ##\n    #       #        \n##   #   #           \n        #       ##   \n      #   ##         \n   #        ##      #\n         #   ###   ##\n#   ##         ##   #\n##   ###   #         \n#      ##        #   \n         ##   #      \n   ##       #        \n           #   #   ##\n        #       #    \n##   ###     #       \n       #         #   \n       #    #    #   \n       #   ##    #   '  
].forEach(x=>out(x.replace(/ /g,'.')+'\n'+F(x)+'\n'))

<pre id=O></pre>

Espandi frammento

— edc65
fonte

1

Che dire F=z=>{for(r=z.split(/\n/),i=0;i<r[j=0][L='length'];i++)for(z+='#';j<r[L];)z+=r[j++][i];return~-z.split(/ +/)[L]}? È lungo 113 byte. La tua regex è stata sostituita con / +/(2 spazi), La è j=0stata aggiunta nel forciclo 'parent' e invece di usare la sintassi obj.length, ho cambiato per usare L='length'; ... obj[L], che si ripete 3 volte.

— Ismael Miguel,

L'ho fatto funzionare su es6fiddle.net/iakdcpdh (invece di F=z=>, ho dovuto usare var F=(z,i,L,j,r)=>). L'ho provato su IE11 e funziona!

— Ismael Miguel,

@IsmaelMiguel ben fatto! e adatto per ES5. Guardandolo di nuovo, ho trovato qualcosa di più ES6 e più breve. Forse potresti pubblicare la tua soluzione per ES5.

— edc65,

No, va tutto bene. Era la tua soluzione, l'ho appena ridotta. Non trovo giusto rispondere come se fosse il mio.

— Ismael Miguel,

Ora che ci penso, puoi sostituirlo /\n/con una stringa di modello con una nuova riga tra. Ciò consente di risparmiare 1 byte poiché non è necessario scrivere la sequenza di escape.

— Ismael Miguel,

3

Pyth, 15 14 13 byte

lftTcjd+.zC.z

Sto usando come separatore e #come caratteri di riempimento anziché il loro significato opposto rispetto al PO. Provalo online: dimostrazione

Invece di #come carattere di riempimento, accetta anche lettere. Quindi potresti effettivamente prendere il cruciverba risolto e stampare il numero di parole. E se rimuovi il lcomando, stampa anche tutte le parole. Provalo qui: puzzle del Sunday NY Times del 10 maggio

Spiegazione

        .z      all input rows
          C.z   all input columns (C transposes)
       +        add them (all rows and columns)
     jd         join by spaces
    c           split by spaces
 f              filter for pieces T, which satisfy:
  tT              len(T) > 1
l               length, implicitly printed

— Jakube
fonte

Conta le parole incrociate

Dettagli

Casi test

punteggio

CJam, 18 17 13 11 byte

Spiegazione

Slip , 18 + 3 = 21 byte

Spiegazione

Haskell, 81 byte

JavaScript ( ES6 ) 87 121 147

Pyth, 15 14 13 byte

Spiegazione