Détermination des tranches verticales


23

Étant donné une image, affichez la [largeur en pixels d'une section verticale complète] 1 (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:


Peut-il y avoir des îlots noirs au milieu pour qu'il y ait plusieurs sections verticales?
xnor

@xnor: Il n'y aura qu'une seule section verticale complète par image. Je vais ajouter cela à la spécification.
Zach Gates

Mon code génère 50 pour le premier cas de test, mais des nombres corrects pour les 3 derniers, avec la tranche verticale des colonnes 233 à 282 (= 50 pixels de diamètre). Pouvez-vous confirmer que 48 est le bon numéro?
David

@David: Je vois la tranche correcte des colonnes 232 à 282 (exclusif). Je crois que tu as raison.
Zach Gates

2
Je ne pense pas que quiconque ait des problèmes, mais il vaut peut-être la peine de mentionner explicitement que vous recherchez le nombre de colonnes contiguës entièrement blanches. Cela ressort clairement de l'exemple, mais il est généralement préférable de ne pas s'appuyer sur des exemples ou des cas de test.
MichaelS

Réponses:


36

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.


21
ಠ_ಠ Ce niveau de golf m'étonne.
Addison Crump

À quoi sert la sortie lorsqu'il n'y a pas de tranches contiguës? (entrée valide)
Addison Crump

3
psfonctionne aussi en MATL!
David

Ensuite, il n'y aura pas de colonne de tous les 1s, ce qui signifie que le résultat de Psera [0,0,0...0], dont le Sum est 0, comme prévu.
Lynn

@David Le poste alors? Vous pourriez avoir besoin Xps, cependant, si l'image peut être une seule ligne (ou demander à l'OP s'il y a une taille minimale)
Luis Mendo

7

APL, 4 octets

+/×⌿

Try it here.

Ceci est ma première réponse APL!

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


Ce n'est pas une fonction. (+/×/⍉)ne fonctionne pas.
jimmy23013

1
Mais vous pouvez utiliser (+/×⌿)et c'est 1 octet plus court.
jimmy23013

Enregistrez encore 2 octets en supprimant les parenthèses. Beaucoup d'autres réponses APL ont juste un train de fonctions anonyme qui doit être nommé ou entre parenthèses pour être utilisé:+/×⌿ f←+/×⌿ f picture
Adám

6

Bash + utilitaires communs, 17

rs -Tc|grep -vc 0

Si vous n'utilisez pas greppour d' , 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
$

6

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)

4

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

4

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.


4

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.


3
Essayez d'utilisermap
CalculatorFeline

C'est 45 dans mon compte. Et vous n'avez pas essayé assez fort car il pourrait y en avoir 43.
edc65

a => a [s = 0] .map ((_, i) => s + =! a.some (b => b [i])) | s
edc65

1
@ edc65 Eh bien, vous savez que les deux problèmes difficiles de l'informatique sont l'invalidation du cache, la dénomination et les erreurs hors-ligne ...
Neil

4

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!


3

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

2

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

Ou Length[Total@#~Cases~0]&mais le même nombre d'octets
CalculatorFeline

1 et 0 ne sont pas véridiques ou fausses dans Mathematica (et s'ils l'étaient, l'affectation serait probablement l'inverse).
Martin Ender

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.


1

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.

Je pense que vous pouvez le faire y x_×pour 5. En fait, efonctionne aussi bien ×, donc y xepour 4 :-)
ETHproductions

Vous avez manqué ce commentaire ce week-end, @ETHproductions - merci :)
Shaggy
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.