Cho một hình ảnh, xuất [chiều rộng tính bằng pixel của một phần dọc đầy đủ] ¹ (nếu có tồn tại). Nếu không có phần dọc tồn tại, đầu ra 0.

Đầu vào có thể được cung cấp dưới dạng tệp cục bộ hoặc mảng lồng nhau. Nếu bạn chọn lấy đầu vào là một mảng lồng nhau, các pixel trắng sẽ được biểu thị bằng một giá trị trung thực trong khi các pixel không trắng sẽ được biểu thị bằng một giá trị falsey.

^{1. số lượng cột liền kề, toàn màu trắng}

Bạn có thể cho rằng

• không có hình ảnh nào sẽ lớn hơn 1000 pixel vuông

• sẽ không có nhiều hơn một phần dọc đầy đủ cho mỗi hình ảnh

Ví dụ

Đầu vào:

Đầu ra:

50
57
0
0

Dưới đây là hai ví dụ đầu tiên, được tô sáng (màu vàng) để hiển thị các phần của chúng:

Thạch, 2 byte

PS

Hãy thử nó ở đây!

Nếu tôi mã hóa một hình ảnh như vậy:

0000111111111100000
0000000111111111000
0000000001111100000
0000000011111000000
0001111111111111100
0000001111110000000
0000000111111110000
0000111111111100000

Trong một mảng lồng nhau như thế này:

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

Sau đó Plấy sản phẩm phần tử khôn ngoan của tất cả các vectơ hàng và tính Stổng tất cả các vectơ trong kết quả, thu được chiều dài của lát cắt dọc. (Điều này chỉ hoạt động vì có đảm bảo chỉ là một lát liền kề.) Trong trường hợp của chúng tôi, câu trả lời là 3.

APL, 4 byte

+/×⌿

Try it here.

Đây là câu trả lời APL đầu tiên của tôi!

Cảm ơn @ jimmy23013 và @NBZ vì đã lưu byte!

Bash + tiện ích chung, 17

rs -Tc|grep -vc 0

Nếu bạn không sử dụng grepđể xử lý ảnh , thì bạn đã làm sai ;-).

Điều này sử dụng các rstiện ích để làm chuyển vị. rsđược gói trong OSX , nhưng sẽ cần cài đặt trong hầu hết linux với một cái gì đó như sudo apt-get install rs.

Các cột đầu vào được TABphân tách và các hàng được phân tách dòng mới:

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

Nếu bạn thích, bạn có thể xử lý trước các hình ảnh đầu vào mẫu ở định dạng này bằng hình ảnh tưởng tượng và (GNU) sed. Ví dụ:

$ 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

Phiên bản cố định

Bao gồm +2 cho -lp( -lcó thể bỏ qua và vẫn sẽ là một giải pháp hợp lệ, nhưng thật xấu nếu không có dòng mới cuối cùng)

Đưa ra các chuỗi 1 và 0 trên 0 hoặc nhiều dòng trên STDIN. Bạn có thể thêm dấu cách hoặc dấu phẩy hoặc bất cứ thứ gì giữa các chữ số nếu bạn muốn miễn là việc sử dụng is.consistent trên tất cả các dòng.

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

Điều này hoạt động như được hiển thị, nhưng thay thế \xce bằng giá trị byte bằng chữ để có được điểm số được yêu cầu

Nếu có nhiều phần dọc, nó sẽ trả về tổng của tất cả các chiều rộng của phần. Nếu bạn muốn chiều rộng của một phần dọc sử dụng

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

Phiên bản cũ

Ban đầu, tôi đã hiểu nhầm thách thức và thực hiện một chương trình đưa ra đúng hoặc sai dựa trên việc có tồn tại một đường thẳng đứng hay không. Mã và giải thích ở đây là dành cho phiên bản cũ này

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

Giá như tôi có thể thêm 1 = ~ ở bên trái để có sự đối xứng gần như hoàn hảo ... Tôi cho rằng gần nhất sẽ là

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

Giải trình

$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ó một giải pháp tao nhã đáng ngạc nhiên khi sử dụng nhiều chức năng tích hợp yêu thích của tôi kết nối với nhau.

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

Sử dụng hình ảnh thử nghiệm từ @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

Bình thường, 5

s*VFQ

Hãy thử nó ở đây

Điều này sử dụng thuật toán của Lynn, nhưng tôi quyết định đăng nó chỉ để cho thấy cách vận hành vectơ golf trong Pyth. Mẹo ở đây là xâu chuỗi các trình trợ giúp cú pháp "đường" Vvà Fđể nếp gấp được áp dụng như một phép toán vectơ. Toán tử được gấp tất nhiên là nhân, và sau đó kết quả được tính tổng để có câu trả lời cuối cùng.

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

Dựa trên câu trả lời của Jelly Lynn, mặc dù kể từ khi chơi golf bằng cách sử dụng everyhoặcsome thay vì reduce. Phiên bản đầu tiên mã hóa màu đen = 0 trong khi phiên bản thứ hai mã hóa màu đen = 1.

Chỉnh sửa: Đã lưu thêm 2 byte nhờ @ edc65.

J , 5 6 byte

Lấy ma trận Boolean làm đối số.

[:+/*/

Đây là câu trả lời J đầu tiên của tôi! (đã sai trong 1 năm rưỡi)

*/ sản phẩm cột

+/ tổng

[: cap (đóng vai trò giữ chỗ vì +/không nên lấy đối số bên trái)

Hãy thử trực tuyến!

CJam, 7 byte

q~:.*:+

Hãy thử trực tuyến!

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

Toán học 24

Length@Cases[Total@#,0]&

Có một mảng ở dạng sau:

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

Và trong trường hợp này đầu ra:

1

, 7 ký tự / 9 byte

⨭МƟïⓜ⨴$

Try it here (Firefox only).

Đây là thuật toán tuyệt vời của @ Lynn, nhưng tôi đã tìm thấy nó một cách độc lập. (Tôi nghĩ rằng đã có một nội dung cho điều này ở đâu đó, vẫn đang tìm kiếm: P)

Giải trình

МƟïhoán chuyển mảng đầu vào, ⓜ⨴$biến từng vectơ bên trong thành sản phẩm của nó và tính ⨭tổng mảng kết quả.

Japt , 6 4 byte

Đưa đầu vào thành một mảng các hàng, với 1màu trắng và 0màu đen.

y xe

• Lưu 2 byte nhờ ETH .

Kiểm tra nó

Giải trình

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.