Diberikan gambar, hasilkan [lebar dalam piksel bagian vertikal penuh] ¹ (jika ada). Jika tidak ada bagian vertikal, output 0.

Input dapat diberikan sebagai file lokal atau array bersarang. Jika Anda memilih untuk mengambil input sebagai array bertingkat, piksel putih harus diwakili oleh nilai yang benar sementara piksel yang bukan putih harus diwakili oleh nilai falsey.

^{1. jumlah kolom yang berdekatan dan serba putih}

Anda bisa berasumsi itu

• tidak ada gambar yang lebih besar dari 1000 piksel persegi

• tidak akan ada lebih dari satu bagian vertikal penuh per gambar

Contohnya

Input:

Output:

50
57
0
0

Berikut adalah dua contoh pertama, disorot (berwarna kuning) untuk menunjukkan bagian mereka:

Jelly, 2 byte

PS

Coba di sini!

Jika saya menyandikan gambar seperti ini:

0000111111111100000
0000000111111111000
0000000001111100000
0000000011111000000
0001111111111111100
0000001111110000000
0000000111111110000
0000111111111100000

Ke dalam array bersarang seperti ini:

[[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],...]

Kemudian Pambil produk elemen-bijaksana dari semua vektor baris, dan Sjumlah semua yang ada di hasilnya, menghasilkan panjang irisan vertikal. (Ini hanya berfungsi karena dijamin hanya ada satu irisan yang berdekatan.) Dalam kasus kami, jawabannya adalah 3.

APL, 4 byte

+/×⌿

Try it here.

Ini adalah jawaban APL pertama saya!

Terima kasih kepada @ jimmy23013 dan @NBZ untuk menghemat byte!

Bash + utilitas umum, 17

rs -Tc|grep -vc 0

Jika Anda tidak menggunakan grepuntuk pemrosesan gambar , maka Anda salah melakukannya ;-).

Ini menggunakan rs utilitas untuk melakukan transposisi. rsadalah dibundel di OSX , tapi perlu menginstal di sebagian besar linux dengan sesuatu seperti sudo apt-get install rs.

Kolom input TABdipisahkan, dan baris dipisahkan baris baru:

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

Jika suka, Anda dapat memproses contoh input gambar ke dalam format ini dengan imagemagick dan (GNU) sed. Misalnya:

$ 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

Versi tetap

Termasuk +2 untuk -lp( -ldapat dihilangkan dan masih akan menjadi solusi yang valid, tetapi jelek tanpa baris akhir final)

Berikan urutan 1 dan 0 pada 0 atau lebih baris pada STDIN. Anda dapat menambahkan spasi atau koma atau apa pun di antara digit jika Anda inginkan selama penggunaannya. Konsisten pada semua baris.

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

Ini berfungsi seperti yang ditunjukkan, tetapi ganti \xcedengan nilai byte literal untuk mendapatkan skor yang diklaim

Jika ada beberapa bagian vertikal, ini mengembalikan jumlah semua lebar bagian. Jika Anda ingin lebar sebuah penggunaan bagian vertikal

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

Versi lama

Saya awalnya salah memahami tantangan dan mengimplementasikan program yang memberi benar atau salah berdasarkan jika ada garis vertikal sama sekali. Kode dan penjelasan di sini adalah untuk versi lama ini

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

Kalau saja saya bisa menambahkan 1 = ~ di sebelah kiri untuk simetri yang hampir sempurna ... Saya kira yang terdekat adalah

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

Penjelasan

$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

Ada solusi elegan yang mengejutkan dengan menggunakan banyak fungsi bawaan favorit saya yang dirantai bersama.

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

Menggunakan gambar uji dari @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

Coba di sini

Ini menggunakan algoritma Lynn, tetapi saya memutuskan untuk mempostingnya hanya untuk menunjukkan cara melakukan operasi vektor golf di Pyth. Kuncinya di sini adalah untuk rantai pembantu sintaks "gula" Vdan Fsehingga lipatan diterapkan sebagai operasi vektor. Operator yang dilipat tentu saja adalah perkalian, dan kemudian hasilnya dijumlahkan untuk mendapatkan jawaban akhir.

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

Berdasarkan jawaban @ Lynn's Jelly, meskipun sejak golf dengan menggunakan everyatau somebukanreduce . Versi pertama mengkodekan hitam = 0 sedangkan yang kedua mengkode hitam = 1.

Sunting: Disimpan 2 byte lebih lanjut berkat @ edc65.

J , 5 6 byte

Membawa matriks Boolean sebagai argumen.

[:+/*/

Ini adalah jawaban J pertama saya! (salah selama 1½ tahun ...)

*/ produk berbentuk kolom

+/ jumlah

[: cap (berfungsi sebagai pengganti sejak +/ tidak boleh mengambil argumen kiri)

Cobalah online!

CJam, 7 byte

q~:.*:+

Cobalah 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]&

Mengambil array dalam bentuk berikut:

{{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}}

Dan dalam hal ini keluaran:

1

𝔼𝕊𝕄𝕚𝕟, 7 karakter / 9 byte

⨭МƟïⓜ⨴$

Try it here (Firefox only).

Ini adalah algoritma hebat Lynn, tetapi saya menemukannya secara mandiri. (Saya pikir ada builtin untuk suatu tempat ini, masih mencari: P)

Penjelasan

МƟïmentranspos array input, ⓜ⨴$mengubah setiap vektor bagian dalam menjadi produknya, dan ⨭menjumlahkan array yang dihasilkan.

Japt , 6 4 byte

Mengambil input sebagai array baris, dengan 1menjadi putih dan 0menjadi hitam.

y xe

• 2 byte disimpan berkat ETH .

Menguji

Penjelasan

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.