Étant donné une image, affichez la [largeur en pixels d'une section verticale complète] ¹ (si elle existe). Si aucune section verticale n'existe, sortie 0.

L'entrée peut être fournie sous forme de fichier local ou de tableau imbriqué. Si vous choisissez de prendre l'entrée comme un tableau imbriqué, les pixels blancs doivent être représentés par une valeur véridique tandis que les pixels non blancs doivent être représentés par une valeur falsey.

^{1. le nombre de colonnes contiguës entièrement blanches}

Vous pouvez supposer que

• aucune image ne dépassera 1000 pixels carrés

• il n'y aura pas plus d'une section verticale complète par image

Exemples

Contributions:

Les sorties:

50
57
0
0

Voici les deux premiers exemples, surlignés (en jaune) pour montrer leurs sections:

Gelée, 2 octets

PS

Essayez-le ici!

Si j'encode une image comme ceci:

0000111111111100000
0000000111111111000
0000000001111100000
0000000011111000000
0001111111111111100
0000001111110000000
0000000111111110000
0000111111111100000

Dans un tableau imbriqué comme celui-ci:

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

Prend ensuite Ple produit élément par élément de tous les vecteurs de ligne et Sadditionne tous ceux du résultat, donnant la longueur de la tranche verticale. (Cela ne fonctionne que parce qu'il est garanti qu'il n'y aura qu'une seule tranche contiguë.) Dans notre cas, la réponse est 3.

APL, 4 octets

+/×⌿

Try it here.

Ceci est ma première réponse APL!

Merci à @ jimmy23013 et @NBZ pour avoir économisé des octets!

Bash + utilitaires communs, 17

rs -Tc|grep -vc 0

Si vous n'utilisez pas greppour le traitement d' image , vous vous trompez ;-).

Cela utilise l' rsutilitaire pour effectuer la transposition. rsest intégré dans OSX , mais devra être installé dans la plupart des linux avec quelque chose comme sudo apt-get install rs.

Les colonnes d'entrée sont TABséparées et les lignes sont séparées par des sauts de ligne:

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

Si vous le souhaitez, vous pouvez prétraiter les images d'entrée d'exemple dans ce format avec imagemagick et (GNU) sed. Par exemple:

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

Version fixe

Comprend +2 pour -lp( -lpeut être omis et serait toujours une solution valide, mais c'est moche sans la nouvelle ligne finale)

Donnez des séquences de 1 et de 0 sur 0 ou plusieurs lignes sur STDIN. Vous pouvez ajouter des espaces ou des virgules ou quoi que ce soit entre les chiffres si vous le souhaitez tant que l'utilisation est cohérente sur toutes les lignes.

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

Cela fonctionne comme indiqué, mais remplacez \xcepar la valeur d'octet littérale pour obtenir le score revendiqué

S'il y a plusieurs sections verticales, cela renvoie la somme de toutes les largeurs de section. Si vous voulez la largeur d' une section verticale, utilisez

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

Ancienne version

À l'origine, j'ai mal compris le défi et mis en œuvre un programme qui donne vrai ou faux en fonction de l'existence d'une ligne verticale. Le code et l'explication sont ici pour cette ancienne version

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

Si seulement je pouvais ajouter 1 = ~ à gauche pour une symétrie presque parfaite ... Je suppose que le plus proche serait

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

Explication

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

Il existe une solution étonnamment élégante utilisant plusieurs de mes fonctions intégrées préférées enchaînées.

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

Utilisation de l'image de test de @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

Essayez-le ici

Cela utilise l'algorithme de Lynn, mais j'ai décidé de le poster juste pour montrer comment jouer au golf des opérations vectorielles en Pyth. L'astuce consiste ici à enchaîner les assistants de syntaxe "sucre" Vet à Fappliquer le pli comme une opération vectorielle. L'opérateur qui est plié est bien sûr la multiplication, puis le résultat est additionné pour obtenir la réponse finale.

JavaScript (ES6), 54 45 43 octets

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

Basé sur la réponse de @ Lynn's Jelly, bien que depuis joué au golf en utilisant everyou someau lieu de reduce. La première version code noir = 0 tandis que la seconde code noir = 1.

Edit: enregistré 2 octets supplémentaires grâce à @ edc65.

J , 5 6 octets

Prend la matrice booléenne comme argument.

[:+/*/

Ceci est ma première réponse J! (a eu tort pendant 1½ ans…)

*/ produit en colonne

+/ somme

[: cap (sert d'espace réservé car +/ne doit pas prendre un argument de gauche)

Essayez-le en ligne!

CJam, 7 octets

q~:.*:+

Essayez-le en ligne!

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

Prend un tableau sous la forme suivante:

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

Et dans ce cas, les sorties:

1

𝔼𝕊𝕄𝕚𝕟, 7 caractères / 9 octets

⨭МƟïⓜ⨴$

Try it here (Firefox only).

C'est le grand algorithme de @ Lynn, mais je l'ai trouvé indépendamment. (Je pensais qu'il y avait une fonction intégrée pour cela quelque part, toujours à la recherche: P)

Explication

МƟïtranspose le tableau d'entrée, ⓜ⨴$transforme chaque vecteur intérieur en son produit et ⨭additionne le tableau résultant.

Japt , 6 4 octets

Prend les entrées sous forme de tableau de lignes, 1blanc et 0noir.

y xe

• 2 octets économisés grâce à ETH .

Essaye-le

Explication

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.