이미지가 주어지면 [전체 세로 섹션의 너비 (픽셀 단위)] ¹ (있는 경우)을 출력합니다. 세로 섹션이 없으면을 출력하십시오 0.

입력은 로컬 파일 또는 중첩 배열로 제공 될 수 있습니다. 중첩 배열로 입력을 선택하면 흰색 픽셀은 정확한 값으로 표시되고 흰색이 아닌 픽셀은 잘못된 값으로 표시해야합니다.

^{1. 연속적인 모든 흰색 열의 수}

당신은 가정 할 수 있습니다

• 1000 제곱 픽셀보다 큰 이미지는 없습니다

• 이미지 당 하나의 전체 수직 섹션이 없습니다.

예

입력 :

출력 :

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에게 감사합니다!

배쉬 + 공통 유틸리티, 17

rs -Tc|grep -vc 0

당신이 사용하지 않는 경우 grep에 대한 이미지 처리 , 당신은 ;-) 잘못하고 있습니다.

이 rs유틸리티를 사용하여 조옮김을 수행합니다. rs되는 OSX에 번들 하지만, 같은 대부분의 리눅스의 설치가 필요합니다 sudo 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
$

펄, 21 22 바이트

고정 버전

에 +2 포함 -lp( -l생략 가능하고 여전히 유효한 솔루션이지만 최종 개행 문자가 없으면 추악합니다)

STDIN의 0 개 이상의 행에 1과 0의 시퀀스를 제공하십시오. 사용량이 모든 행에서 일관된 한 원하는 경우 숫자 사이에 공백이나 쉼표 또는 기타 숫자를 추가 할 수 있습니다.

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

파이썬 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

피스, 5

s*VFQ

여기 사용해보십시오

이것은 Lynn의 알고리즘을 사용하지만 Pyth에서 벡터 연산을 골프하는 방법을 보여주기 위해 게시하기로 결정했습니다. 여기에 트릭은 "설탕"구문 헬퍼 체인 인 V과 F겹는 벡터 연산으로 적용됩니다 그래서. 접힌 연산자는 물론 곱셈이며 결과는 합산되어 최종 답변을 얻습니다.

자바 스크립트 (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

사용하여 golfed 이후하지만, 린의 젤리 대답 @ 기반으로 every또는 some대신 reduce. 첫 번째 버전은 black = 0을 인코딩하고 두 번째 버전은 black = 1을 인코딩합니다.

편집 : @ edc65 덕분에 2 바이트를 더 절약했습니다.

J , 5 6 바이트

부울 행렬을 인수로 사용합니다.

[:+/*/

이것이 나의 첫 J 답변입니다! (1 년 반 동안 잘못되었다…)

*/ 열별 제품

+/ 합집합

[: 한도 ( +/좌측 인수를 취하지 않아야하기 때문에 자리 표시 자로 사용 )

온라인으로 사용해보십시오!

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

매스 매 티카 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의 훌륭한 알고리즘이지만 독립적으로 찾았습니다. (나는 여전히 찾고있는 곳이 내장되어 있다고 생각했다. : P)

설명

МƟï입력 배열을 전치하고 ⓜ⨴$각 내부 벡터를 곱으로 바꾸고 ⨭결과 배열을 합합니다.

Japt , 6 4 바이트

1흰색과 0검은 색으로 입력을 행의 배열로 가져옵니다 .

y xe

• ETH 덕분에 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.