ให้ภาพเอาท์พุท [ความกว้างเป็นพิกเซลของส่วนแนวตั้งเต็ม] ¹ (ถ้ามี) 0ถ้าไม่มีส่วนแนวตั้งที่มีอยู่เอาท์พุท

อินพุตอาจถูกจัดเตรียมเป็นไฟล์โลคัลหรืออาร์เรย์ที่ซ้อนกัน หากคุณเลือกที่จะรับอินพุตเป็นอาร์เรย์ซ้อนกันพิกเซลสีขาวควรแสดงด้วยค่าความจริงในขณะที่พิกเซลที่ไม่ใช่สีขาวควรแสดงด้วยค่าเท็จ

^{1. จำนวนคอลัมน์ที่ต่อเนื่องและมีสีขาวทั้งหมด}

คุณสามารถสันนิษฐานได้ว่า

• ไม่มีภาพจะมีขนาดใหญ่กว่า 1,000 ตารางพิกเซล

• จะมีส่วนแนวตั้งเต็มต่อหนึ่งภาพไม่เกินหนึ่งภาพ

ตัวอย่าง

ปัจจัยการผลิต:

ขาออก:

50
57
0
0

นี่คือสองตัวอย่างแรกที่เน้น (สีเหลือง) เพื่อแสดงส่วนของพวกเขา:

เยลลี่ 2 ไบต์

PS

ลองที่นี่!

หากฉันเข้ารหัสภาพเช่นนั้น:

0000111111111100000
0000000111111111000
0000000001111100000
0000000011111000000
0001111111111111100
0000001111110000000
0000000111111110000
0000111111111100000

เป็นอาร์เรย์ซ้อนกันเช่นนี้

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

จากนั้นPนำผลคูณองค์ประกอบที่ชาญฉลาดของเวกเตอร์แถวทั้งหมดแล้วนำSผลบวกทั้งหมดมารวมกันเพื่อให้ได้ความยาวของชิ้นส่วนแนวตั้ง (นี้ทำงานเพียงเพราะมีการรับประกันว่าจะมีเพียงหนึ่งชิ้นที่อยู่ติดกัน.) 3ในกรณีของเราคำตอบคือ

APL, 4 ไบต์

+/×⌿

Try it here.

นี่เป็นคำตอบ APL แรกของฉัน!

ขอบคุณ @ jimmy23013 และ @NBZ สำหรับการบันทึกไบต์!

Bash + ยูทิลิตี้ทั่วไป, 17

rs -Tc|grep -vc 0

หากคุณไม่ได้ใช้grepในการประมวลผลภาพแสดงว่าคุณทำผิด ;-)

สิ่งนี้ใช้rsยูทิลิตีเพื่อทำการขนย้าย rsจะถูกรวมใน OSXsudo apt-get install rsแต่จะต้องติดตั้งในลินุกซ์มากที่สุดกับสิ่งที่ชอบ

คอลัมน์อินพุตถูกTABแยกออกและแถวจะถูกขึ้นบรรทัดใหม่:

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

หากคุณต้องการคุณสามารถประมวลผลตัวอย่างภาพอินพุตในรูปแบบนี้ด้วย imagemagick และ (GNU) sed เช่น:

$ 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 ไบต์

รุ่นที่แก้ไขแล้ว

รวมถึง +2 สำหรับ-lp( -lสามารถละเว้นได้และจะยังคงเป็นโซลูชันที่ถูกต้อง แต่มันน่าเกลียดโดยไม่มีบรรทัดใหม่สุดท้าย)

ให้ลำดับของ 1 และ 0 ใน 0 หรือมากกว่าบรรทัดบน STDIN คุณสามารถเพิ่มช่องว่างหรือเครื่องหมายจุลภาคหรืออะไรก็ได้ระหว่างตัวเลขหากคุณต้องการตราบใดที่การใช้ is.consistent ในทุกบรรทัด

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

สิ่งนี้ทำงานได้ตามที่แสดง แต่แทนที่\xceด้วยค่าไบต์ตามตัวอักษรเพื่อรับคะแนนที่อ้างสิทธิ์

หากมีส่วนแนวตั้งหลายส่วนจะส่งคืนผลรวมของความกว้างของส่วนทั้งหมด หากคุณต้องการความกว้างของใช้ส่วนแนวตั้ง

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

เวอร์ชั่นเก่า

เดิมทีฉันเข้าใจผิดความท้าทายและนำโปรแกรมที่ให้จริงหรือเท็จมาใช้โดยขึ้นอยู่กับว่ามีเส้นแนวตั้งอยู่หรือเปล่า รหัสและคำอธิบายที่นี่สำหรับรุ่นเก่านี้

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

ถ้าเพียง แต่ฉันสามารถเพิ่ม 1 = ~ ที่ด้านซ้ายสำหรับสมมาตรที่สมบูรณ์แบบเกือบ ... ฉันคิดว่าใกล้เคียงที่สุดจะเป็น

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

คำอธิบาย

$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 ไบต์

มีวิธีการแก้ปัญหาที่สง่างามอย่างน่าประหลาดใจโดยใช้ฟังก์ชั่นในตัวที่ฉันโปรดปรานไว้ด้วยกัน

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

ใช้ภาพทดสอบจาก @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

ลองที่นี่

สิ่งนี้ใช้อัลกอริธึมของ Lynn แต่ฉันตัดสินใจโพสต์เพื่อแสดงวิธีการดำเนินงานเวกเตอร์กอล์ฟใน Pyth เคล็ดลับที่นี่คือการโยงผู้ช่วยทางไวยากรณ์ "น้ำตาล" เข้าด้วยกันVและFเพื่อให้การพับถูกใช้เป็นการดำเนินการเวกเตอร์ ตัวดำเนินการที่ถูกพับเป็นการคูณแน่นอนแล้วผลลัพธ์จะถูกรวมเพื่อให้ได้คำตอบสุดท้าย

JavaScript (ES6), 54 45 43 ไบต์

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

ขึ้นอยู่กับลินน์ @ คำตอบของวุ้นแม้ว่าตั้งแต่แข็งแรงเล่นกอล์ฟโดยใช้everyหรือแทนsome reduceรุ่นแรกเข้ารหัสสีดำ = 0 ในขณะที่รุ่นที่สองเข้ารหัสสีดำ = 1

แก้ไข: บันทึกเพิ่มเติมอีก 2 ไบต์ด้วย @ edc65

J , 5 6 ไบต์

ใช้เมทริกบูลีนเป็นอาร์กิวเมนต์

[:+/*/

นี่เป็นคำตอบ J แรกของฉัน! (ผิด1½ปี…)

*/ ผลิตภัณฑ์ในแนวตั้ง

+/ รวม

[: cap (ทำหน้าที่เป็นตัวยึดตำแหน่งเนื่องจาก+/ไม่ควรใช้อาร์กิวเมนต์ซ้าย)

ลองออนไลน์!

CJam, 7 ไบต์

q~:.*:+

ลองออนไลน์!

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

รับอาร์เรย์ในรูปแบบต่อไปนี้:

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

และในกรณีนี้ผลลัพธ์:

1

𝔼𝕊𝕄𝕚𝕟, 7 ตัวอักษร / 9 ไบต์

⨭МƟïⓜ⨴$

Try it here (Firefox only).

นี่เป็นอัลกอริทึมที่ยอดเยี่ยมของ @ Lynn แต่ฉันพบว่าเป็นอิสระ (ฉันคิดว่ามันมี builtin สำหรับบางแห่งนี้ยังคงมองหา: P)

คำอธิบาย

МƟï สลับอินพุตอาร์เรย์ ⓜ⨴$เปลี่ยนเวกเตอร์ภายในแต่ละตัวเป็นผลิตภัณฑ์และ⨭สรุปผลอาร์เรย์

Japt , 6 4 ไบต์

รับอินพุตเป็นอาร์เรย์ของแถวโดย1เป็นสีขาวและ0สีดำ

y xe

• บันทึก 2 ไบต์ด้วยขอบคุณ ผลประโยชน์ทับซ้อน

ทดสอบมัน

คำอธิบาย

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.