Data un'immagine, genera la [larghezza in pixel di una sezione completamente verticale] ¹ (se presente). Se non esiste una sezione verticale, emettere0 .

L'input può essere fornito come file locale o array nidificato. Se si sceglie di accettare l'input come una matrice nidificata, i pixel bianchi dovrebbero essere rappresentati da un valore di verità mentre i pixel non bianchi dovrebbero essere rappresentati da un valore di falsa.

^{1. il numero di colonne contigue, tutte bianche}

Puoi presumere che

• nessuna immagine sarà più grande di 1000 pixel quadrati

• non ci sarà più di una sezione verticale completa per immagine

Esempi

ingressi:

Uscite:

50
57
0
0

Ecco i primi due esempi, evidenziati (in giallo) per mostrare le loro sezioni:

Gelatina, 2 byte

PS

Provalo qui!

Se codifico un'immagine in questo modo:

0000111111111100000
0000000111111111000
0000000001111100000
0000000011111000000
0001111111111111100
0000001111110000000
0000000111111110000
0000111111111100000

In un array nidificato come questo:

[[0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0],...]

Quindi Pprende il prodotto saggio elemento di tutti i vettori di riga e Ssomma tutti quelli nel risultato, producendo la lunghezza della sezione verticale. (Funziona solo perché è garantito che sia solo una sezione contigua.) Nel nostro caso, la risposta è 3.

APL, 4 byte

+/×⌿

Try it here.

Questa è la mia prima risposta APL!

Grazie a @ jimmy23013 e @NBZ per il salvataggio di byte!

Bash + utility comuni, 17

rs -Tc|grep -vc 0

Se non si utilizza grepper l' elaborazione delle immagini , allora stai sbagliando ;-).

Questo utilizza l' rsutilità per eseguire la trasposizione. rsè raggruppato in OSX , ma dovrà essere installato nella maggior parte di Linux con qualcosa del generesudo apt-get install rs .

Le colonne di input sono TABseparate e le righe sono separate da newline:

0   0   0   0   1   1   1   1   1   1   1   1   1   1   0   0   0   0   0   
0   0   0   0   0   0   0   1   1   1   1   1   1   1   1   1   0   0   0   
0   0   0   0   0   0   0   0   0   1   1   1   1   1   0   0   0   0   0   
0   0   0   0   0   0   0   0   1   1   1   1   1   0   0   0   0   0   0   
0   0   0   1   1   1   1   1   1   1   1   1   1   1   1   1   1   0   0   
0   0   0   0   0   0   1   1   1   1   1   1   0   0   0   0   0   0   0   
0   0   0   0   0   0   0   1   1   1   1   1   1   1   1   0   0   0   0   
0   0   0   0   1   1   1   1   1   1   1   1   1   1   0   0   0   0   0

Se lo desideri, puoi preelaborare le immagini di input di esempio in questo formato con imagemagick e (GNU) sed. Per esempio:

$ for img in "AmXiR.jpg" "vb2Yt.jpg" "1V7QD.jpg" "MqcDJ.jpg" ; do
>     convert -depth 1 "$img" xpm:- | \
>     sed -nr '/pixels/{:l;n;/}/q;s/^"(.*)",?$/\1/;y/ ./01/;s/./&\t/g;p;bl}' | \
>     rs -Tc|grep -vc 0
> done
50
57
0
0
$

Perl, 21 22 byte

Versione fissa

Include +2 per -lp( -lpuò essere omesso e sarebbe comunque una soluzione valida, ma è brutto senza la nuova riga finale)

Fornisci sequenze di 1 e 0 su 0 o più righe su STDIN. Puoi aggiungere spazi o virgole o qualsiasi altra cosa tra le cifre se lo desideri purché l'utilizzo sia coerente su tutte le righe.

$a|=~$_}{$_=$a=~y;\xce;

Funziona come mostrato, ma sostituisce \xce con il valore letterale in byte per ottenere il punteggio richiesto

Se sono presenti più sezioni verticali, viene restituita la somma di tutte le larghezze di sezione. Se si desidera la larghezza di una sezione verticale, utilizzare

$a|=~$_}{$a=~/\xce+/;$_="@+"-"@-"

Vecchia versione

Inizialmente ho frainteso la sfida e implementato un programma che dà vero o falso basato sull'esistenza di una linea verticale. Il codice e la spiegazione qui sono per questa vecchia versione

$a|=~$_}{$_|=~$a=~1

Se solo potessi aggiungere 1 = ~ a sinistra per una simmetria quasi perfetta ... Suppongo che sarebbe il più vicino

1=>$a|=~$_}{$_|=~$a=~1

Spiegazione

$a|=~$_     The bitwise operators in perl (&, |, ^, ~) also work on strings by 
            working on the sequence of byte values. The digits "0" and "1" happen
            to have the same ASCII value differing only in the last bit which is
            0 for "0" and 1 for "1". So I would really like to do an "&" here.
            Unfortunately "&" of two different length strings shortens the result
            to the shortest of the strings and my accumulator starts as an empty 
            string. The "|" of two strings however extends to the longest string.
            So instead I will apply De Morgan's law and use "|" on the
            complemented byte string 
}{          Standard perl golf trick. "-p code" transforms to (simplified)
            "while (<>) { code; print }". So if code is "code1 } { code2" this
            becomes "while (<>) { code1 } {code2; print }". So you can use code1
            for the loop operation, use code2 for the final calculation and get a
            free print by assigning to $_
$_|=~$a=~1  I would like to match the accumulator with the bit complement of "1",
            but $a=~~1 doesn't work because the 1 is not a string but a number.
            $a=~~"1" would work but is too long. Next up is complementing $a back
            and matching with 1, so $_=~$a=~1. That also doesn't work since the
            first =~ will be interpreted as a string match insteads of equals
            followed by complement. Easily solved by writing it as $_= ~a=~1. But
            if I am going to give up a byte I can at least have some fun with it.
            Using $_|= also makes the parse work and has the advantage that the
            failure case will give 0 instead of an empty string, which looks
            nicer. It also makes the code look very symmetric. I can also bring
            out the symmetry more by putting 1=> in front (which evaluates 1
            before the assignment and then immediately discards it)

Python 2, 30 byte

C'è una soluzione sorprendentemente elegante che utilizza molte delle mie funzioni integrate preferite concatenate.

lambda c:sum(map(all,zip(*c)))

Utilizzando l'immagine di prova da @Lynn:

>>> image = [[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0]]
>>> func = lambda c:sum(map(all,zip(*c)))
>>> func(image)
3

Pyth, 5

s*VFQ

Provalo qui

Questo utilizza l'algoritmo di Lynn, ma ho deciso di pubblicarlo solo per mostrare come golfare le operazioni vettoriali in Pyth. Il trucco qui è quello di concatenare gli helper della sintassi "zucchero" Ve di Fapplicare la piega come operazione vettoriale. L'operatore che viene piegato è ovviamente una moltiplicazione, quindi il risultato viene sommato per ottenere la risposta finale.

JavaScript (ES6), 54 45 43 byte

a=>a[s=0].map((_,i)=>s+=a.every(b=>b[i]))|s
a=>a[s=0].map((_,i)=>s+=!a.some(b=>b[i]))|s

Basato sulla risposta Jelly di @ Lynn, anche se da quando ho giocato a golf usando everyo someinvece direduce . La prima versione codifica black = 0 mentre la seconda codifica black = 1.

Modifica: salvato altri 2 byte grazie a @ edc65.

J , 5 6 byte

Prende la matrice booleana come argomento.

[:+/*/

Questa è la mia prima risposta J! (era sbagliato per 1 anno e mezzo ...)

*/ prodotto a colonne

+/ somma

[: cap (serve come segnaposto poiché +/non dovrebbe prendere un argomento sinistro)

Provalo online!

CJam, 7 byte

q~:.*:+

Provalo online!

q~      e# read input and evaluate: push nested array
:.*     e# fold vectorized product over nested array: element-wise product of rows
:+      e# fold addition over array: compute its sum

Mathematica 24

Length@Cases[Total@#,0]&

Accetta un array nella forma seguente:

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

E in questo caso output:

1

𝔼𝕊𝕄𝕚𝕟, 7 caratteri / 9 byte

⨭МƟïⓜ⨴$

Try it here (Firefox only).

Questo è il grande algoritmo di @ Lynn, ma l'ho trovato in modo indipendente. (Ho pensato che ci fosse un builtin per questo da qualche parte, ancora cercando: P)

Spiegazione

МƟïtraspone l'array di input, ⓜ⨴$trasforma ogni vettore interno nel suo prodotto e ⨭somma l'array risultante.

Japt , 6 4 byte

Accetta input come una matrice di righe, con l' 1essere bianco e l' 0essere nero.

y xe

• 2 byte salvati grazie a ETH .

Provalo

Spiegazione

y xe
          :Implicit input of array U.
y         :Transpose.
   e      :Map over each sub-array, checking if every element is truthy.
  x       :Reduce by summing, converting booleans to 1 or 0.
          :Implicit output of resulting integer.