Bir görüntü verildiğinde, [bir tam dikey bölümün piksel cinsinden genişliği] ¹ (varsa) çıktısını alın . Dikey bölüm yoksa, çıktı 0.

Giriş, yerel bir dosya veya iç içe geçmiş bir dizi olarak sağlanabilir. İç içe bir dizi olarak girdi almayı seçerseniz, beyaz olmayan piksellerin bir falsey değeriyle gösterilmesi gerekirken beyaz piksellerin bir gerçeğe uygun değerle gösterilmesi gerekir.

^{1. bitişik, tamamen beyaz sütun sayısı}

Bunu varsayabilirsin

• görüntü 1000 kare pikselden büyük olamaz

• görüntü başına birden fazla dikey bölüm olmayacak

Örnekler

girişler:

Çıktılar:

50
57
0
0

İşte bölümlerini göstermek için (sarı renkte) vurgulanan ilk iki örnek:

Jöle, 2 bayt

PS

Burada dene!

Eğer böyle bir görüntüyü kodlarsam:

0000111111111100000
0000000111111111000
0000000001111100000
0000000011111000000
0001111111111111100
0000001111110000000
0000000111111110000
0000111111111100000

Bunun gibi iç içe geçmiş bir diziye:

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

Daha sonra P, bütün sıra vektörlerinin eleman şeklinde ürününü alır ve Ssonuçtaki tümleri toplar, dikey dilimin uzunluğunu verir. (Bu sadece işe yarar, çünkü yalnızca bir bitişik dilim olması garanti edilir.) Bizim durumumuzda cevap 3.

APL, 4 bayt

+/×⌿

Try it here.

Bu benim ilk APL cevabım!

Bayt kaydetmek için @ jimmy23013 ve @ NBZ için teşekkürler!

Bash + ortak yardımcı programları, 17

rs -Tc|grep -vc 0

Görüntü işlemegrep için kullanmıyorsanız , o zaman yanlış yapıyorsunuz ;-).

Bu rsaktarma yapmak için yardımcı programını kullanır . rsolduğu OSX içinde paketlenmiş , ancak böyle bir şeyle en linux yüklemeyi gerekecektir sudo apt-get install rs.

Giriş sütunları TABayrılmış ve satırlar yeni satır ayrılmış:

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

İsterseniz, örnek giriş görüntülerini imagemagick ve (GNU) sed ile bu formata hazırlayabilirsiniz. Örneğin:

$ 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 bayt

Sabit sürüm

İçin +2'yi içerir -lp( -lihmal edilebilir ve hala geçerli bir çözüm olabilir, ancak son satır olmadan çirkin)

STDIN'de 0 veya daha fazla satırda 1 ve 0 dizileri verin. Kullanım tüm satırlarda tutarsız olduğu sürece boşluk veya virgül veya rakamlar arasında ne varsa ekleyebilirsiniz.

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

Bu gösterildiği gibi çalışır, ancak \xceiddia edilen puanı almak için değişmez bayt değeri ile değiştirin

Birden çok dikey bölüm varsa, bu, tüm bölüm genişliklerinin toplamını döndürür. Eğer genişliğini istiyorsanız bir düşey kesit kullanımı

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

Eski versiyon

Başlangıçta bu sorunu yanlış anladım ve dikey bir çizginin olup olmadığına bağlı olarak doğru veya yanlış veren bir program uyguladım. Kod ve açıklama burada eski sürüm içindir

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

Keşke neredeyse mükemmel bir simetri için 1 = ~ solda ekleyebilseydim ... en yakınının sanırım

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

açıklama

$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 bayt

Birlikte zincirlenmiş en sevdiğim yerleşik işlevlerin çoğunu kullanarak şaşırtıcı derecede zarif bir çözüm var.

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

@Lynn'deki test görüntüsünü kullanarak:

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

Burada dene

Bu Lynn'in algoritmasını kullanır, ancak Pyth'taki vektör işlemlerinin nasıl yapıldığını göstermek için göndermeye karar verdim. Hüner burada "şeker" sözdizimi yardımcıları zincire bağlanmış Vve Fkat için bir vektör işlemi olarak uygulanmaktadır, böylece. Katlanan operatör elbette çarpımdır ve sonuç son cevabı elde etmek için toplanır.

JavaScript (ES6), 54 45 43 bayt

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

@ Lynn's Jelly cevabına dayanarak, rağmen everyya da someyerine kullanarak golf oynadı reduce. İlk sürüm siyah = 0, ikinci sürüm siyah = 1 kodlanır.

Düzenleme: @ edc65 sayesinde 2 bayt daha kaydedildi.

J , 5 6 bayt

Boolean matrisini argüman olarak alır.

[:+/*/

Bu benim ilk J cevabım! (1½ yıl boyunca yanlıştı…)

*/ sütunlu ürün

+/ toplam

[: sınır ( +/sol argüman almaması gerektiğinden yer tutucu işlevi görür )

Çevrimiçi deneyin!

CJam, 7 bayt

q~:.*:+

Çevrimiçi deneyin!

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

Aşağıdaki biçimde bir dizi alır:

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

Ve bu durumda çıktılar:

1

7, 7 karakter / 9 bayt

⨭МƟïⓜ⨴$

Try it here (Firefox only).

Bu @ Lynn'in harika algoritması, fakat bağımsız olarak buldum. (Bunun için bir yerleşik var sanıyordum, hala bakıyordum: P)

açıklama

МƟïgiriş dizisini dönüştürür, ⓜ⨴$her bir iç vektörü ürününe dönüştürür ve ⨭elde edilen diziyi toplar.

Japt , 6 4 bayt

Girdiyi bir dizi dizisi olarak alır, 1beyaz ve 0siyah olur.

y xe

• ETH sayesinde 2 bayt kaydedildi .

Dene

açıklama

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.