Biorąc pod uwagę obraz, wypisz [szerokość w pikselach pełnej sekcji pionowej] ¹ (jeśli taki istnieje). Jeśli nie ma przekroju pionowego, wyjście0 .

Dane wejściowe mogą być dostarczane jako plik lokalny lub tablica zagnieżdżona. Jeśli wybierzesz opcję wprowadzania jako tablicę zagnieżdżoną, białe piksele powinny być reprezentowane przez prawdziwą wartość, podczas gdy niebiałe piksele powinny być reprezentowane przez wartość falsey.

^{1. liczba sąsiadujących, całkowicie białych kolumn}

Możesz to założyć

• żaden obraz nie będzie większy niż 1000 pikseli kwadratowych

• na obrazie będzie nie więcej niż jedna pełna sekcja pionowa

Przykłady

Wejścia:

Wyjścia:

50
57
0
0

Oto dwa pierwsze przykłady, podświetlone (na żółto), aby pokazać ich sekcje:

Galaretka, 2 bajty

PS

Wypróbuj tutaj!

Jeśli koduję taki obraz:

0000111111111100000
0000000111111111000
0000000001111100000
0000000011111000000
0001111111111111100
0000001111110000000
0000000111111110000
0000111111111100000

W zagnieżdżoną tablicę:

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

Następnie Ppobiera iloczyn elementarny wszystkich wektorów rzędowych i Ssumuje wszystkie z nich, uzyskując długość pionowego wycinka. (Działa to tylko dlatego, że jest gwarancją tylko jeden przylegający plaster). W naszym przypadku, odpowiedź brzmi 3.

APL, 4 bajty

+/×⌿

Try it here.

To jest moja pierwsza odpowiedź APL!

Dzięki @ jimmy23013 i @NBZ za oszczędzanie bajtów!

Bash + wspólne narzędzia, 17

rs -Tc|grep -vc 0

Jeśli nie używasz grepdo przetwarzania obrazu , robisz to źle ;-).

Wykorzystuje to rsnarzędzie do transpozycji. rsjest zawarty w OSX , ale będzie wymagał instalacji w większości systemów Linux z czymś takimsudo apt-get install rs .

Kolumny wejściowe są TABrozdzielone, a wiersze są oddzielone znakiem nowej linii:

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

Jeśli chcesz, możesz wstępnie przetworzyć przykładowe obrazy wejściowe do tego formatu za pomocą imagemagick i (GNU) sed. Na przykład:

$ 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 bajtów

Naprawiona wersja

Obejmuje +2 za -lp (-l można pominąć i nadal byłoby poprawnym rozwiązaniem, ale jest brzydkie bez ostatniej linii)

Podaj sekwencje 1 i 0 na 0 lub więcej liniach na STDIN. Możesz dodawać spacje, przecinki lub cokolwiek między cyframi, jeśli chcesz tak długo, jak jest to użycie. Spójne na wszystkich liniach.

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

Działa to jak pokazano, ale zamień \xce literalną wartością bajtu, aby uzyskać deklarowany wynik

Jeśli jest wiele przekrojów pionowych, to zwraca sumę wszystkich szerokości przekroju. Jeśli chcesz szerokość w pionie użytku odcinek

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

Stara wersja

Pierwotnie źle zrozumiałem wyzwanie i wdrożyłem program, który podaje wartość prawda lub fałsz na podstawie tego, czy w ogóle istnieje linia pionowa. Kod i objaśnienie tutaj dotyczą tej starej wersji

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

Gdybym tylko mógł dodać 1 = ~ po lewej stronie dla prawie idealnej symetrii ... Przypuszczam, że najbliższa byłaby

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

Wyjaśnienie

$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 bajtów

Istnieje zaskakująco eleganckie rozwiązanie wykorzystujące wiele moich ulubionych wbudowanych funkcji połączonych razem.

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

Używając obrazu testowego z @ 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

Wypróbuj tutaj

Wykorzystuje algorytm Lynna, ale postanowiłem go opublikować, aby pokazać, jak grać w golfa w wektorach w Pyth. Sztuką jest tu Łańcuch „cukier” pomocnicy składniowe Vi Ftak, że klapka jest stosowana jako operacja wektorowych. Operator, który jest złożony, jest oczywiście mnożeniem, a następnie wynik jest sumowany, aby uzyskać ostateczną odpowiedź.

JavaScript (ES6), 54 45 43 bajtów

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

Na podstawie odpowiedzi Jelly @ Lynn, ale ponieważ grał w golfa za pomocą everylub somezamiastreduce . Pierwsza wersja koduje kolor czarny = 0, a druga koduje kolor czarny = 1.

Edycja: Zapisano 2 kolejne bajty dzięki @ edc65.

J , 5 6 bajtów

Jako argument przyjmuje macierz boolowską.

[:+/*/

To jest moja pierwsza odpowiedź J! (mylił się przez 1,5 roku…)

*/ produkt kolumnowy

+/ suma

[: cap (służy jako symbol zastępczy, ponieważ +/nie powinien przyjmować lewego argumentu)

Wypróbuj online!

CJam, 7 bajtów

q~:.*:+

Wypróbuj 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]&

Przyjmuje tablicę w następującej formie:

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

I w tym przypadku wyniki:

1

𝔼𝕊𝕄𝕚𝕟, 7 znaków / 9 bajtów

⨭МƟïⓜ⨴$

Try it here (Firefox only).

To świetny algorytm @ Lynn, ale znalazłem go niezależnie. (Myślałem, że gdzieś tam jest wbudowane, wciąż wyglądające: P)

Wyjaśnienie

МƟï transponuje tablicę wejściową, ⓜ⨴$ zamienia każdy wektor wewnętrzny w jego iloczyn i ⨭sumuje wynikową tablicę.

Japt , 6 4 bajtów

Pobiera dane wejściowe jako tablicę wierszy, 1będąc białymi i0 czarnym.

y xe

• 2 bajty zapisane dzięki ETH .

Sprawdź to

Wyjaśnienie

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.