N'est-ce pas gênant lorsque vous prenez une photo, mais l'arrière-plan nuit à la substance réelle de l'image? Je dirais que oui. J'ai besoin de savoir combien je dois recadrer pour me débarrasser de ce problème! Mais - comme d'habitude - je suis assez paresseux, j'ai donc besoin de quelqu'un pour faire ça pour moi ...

Tâche et règles

Étant donné une matrice binaire représentant l'image, affichez les dimensions (largeur et hauteur) de la plus petite sous-matrice qui contient tous les $1$ s de la matrice d'origine. Une sous-matrice est un bloc d'entrées adjacentes de la matrice d'origine. De manière équivalente, il s'agit d'une nouvelle matrice formée en chevauchant un sous-ensemble de lignes adjacentes et un sous-ensemble de colonnes adjacentes de l'original.

• Il est également permis de prendre la largeur et la hauteur de la matrice en entrée.
• L'entrée est garantie de contenir au moins un $1$ .
• Vous pouvez prendre des entrées et fournir des sorties par n'importe quelle méthode standard , tout en prenant note que ces failles sont interdites par défaut. Il s'agit de code-golf , essayez donc de terminer la tâche dans le moins d'octets possible dans la langue de votre choix.

Exemple

$$\left[\begin{matrix} \color{red}0&\color{red}0&\color{red}0&\color{red}0&\color{red}0&\color{red}0\\ \color{red}0&\color{blue}1&\color{blue}0&\color{blue}1&\color{blue}0&\color{blue}0\\ \color{red}0&\color{blue}1&\color{blue}1&\color{blue}0&\color{blue}1&\color{blue}1\\ \color{red}0&\color{blue}0&\color{blue}1&\color{blue}0&\color{blue}1&\color{blue}0\\ \color{red}0&\color{red}0&\color{red}0&\color{red}0&\color{red}0&\color{red}0\end{matrix}\right] \longrightarrow \left[\begin{matrix}1&0&1&0&0\\1&1&0&1&1\\0&1&0&1&0\end{matrix}\right]\longrightarrow(5,3)$$

Cas de test

Entrée | Production

[[0,1,0,0,0,1,0]]
-> (5,1) ou (1,5)

[[0,0,0,0,0], [0,1,0,1,0], [0,0,1,0,0]]
-> (3,2) ou (2,3)

[[1,1,1,1], [0,0,0,0], [0,0,0,0], [1,0,0,0]]
-> (4,4)

[[0,0,0,0,0,0], [0,1,0,1,0,1], [0,0,0,0,0,0]]
-> (5,1) ou (1,5)

[[0,0,0,0,0], [0,1,0,1,0], [0,0,1,0,0], [0,1,0,1,0], [ 0,0,0,0,0]]
-> (3,3)

[[0,0,0,0,0,0], [0,1,0,1,0,0], [0,1,1,0,1,1], [0,0,1, 0,1,0], [0,0,0,0,0,0]]
-> (5,3) ou (3,5)

MATL , 5 octets

JYaZy

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

JYa   % Implicit input. Unpad matrix. This removes outer zeros
Zy    % Size. Implicit display

APL (Dyalog Unicode) , 10 octets ^SBCS

Fonction de préfixe tacite anonyme.

(1+⌈/-⌊/)⍸

Essayez-le en ligne!

⍸ indices de 1s.

(… ) Appliquer à cela la fonction tacite suivante:

 ⌊/ le minimum ( coordonnée y la plus basse et coordonnée x la plus basse )

 ⌈/- le maximum moins que (cela nous donne la gamme)

 1+ un plus que (pour être inclus)

Octave , 57 56 45 octets

Voici findle gros du travail: il findss'agit des indices de ligne et de colonne des entrées non nulles. Il suffit ensuite de trouver la différence entre le maximum et le minimum (plus un) pour chacun de ceux-ci séparément.

Merci @beaker et @AndrasDeak pour -1 octet, et @LuisMendo pour -11 octets!

@(a){[I{1:2}]=find(a),cellfun(@range,I)}{2}+1

Essayez-le en ligne!

Python 2 , 92 86 octets

def f(a,L=len):exec"a=zip(*a[1-any(a[0]):])[::-1];"*4*L(a[0])*L(a);return L(a[0]),L(a)

Essayez-le en ligne!

Gelée , 7 octets

S,§t€0Ẉ

Essayez-le en ligne!

Comment ça fonctionne

S,§t€0Ẉ  Main link. Argument: M (matrix)

S        Take the columnwise sum. Let's call the resulting array A.
  §      Take the sum of each row. Let's call the resulting array B.
 ,       Pair; yield [A, B].
   t€0   Trim surrounding zeroes of A and B.
      Ẉ  Widths; yields the lengths of the trimmed arrays.

Python 2 ,  63  55 octets

-8 avec l'aide de Vincent (prenez la matrice d'entrée comme un tableau Numpy)

lambda a:[len(`a.max(x)`[7::3].strip('0'))for x in 0,1]

Une fonction anonyme acceptant un réseau Numpy 2-d des entiers (en {0,1}) , qui renvoie une liste de nombres entiers, [width,height].

Essayez-le en ligne!

---

Version non Numpy en 63 octets (acceptant une liste de listes d'entiers en {0,1}):

lambda a:[len(`map(max,v)`[1::3].strip('0'))for v in zip(*a),a]

Essayez-le en ligne!

Comment?

Compte tenu d' une matrice, a, forchaque ( v) de la transposition, zip(*a)et alui - même , nous trouvons la hauteur requise (compte tenu de la Transpose est la largeur).

Le mappage à maxtravers vproduit une liste de zéros et de uns, indiquant si chaque ligne de vcontient des zéros . La représentation sous forme de chaîne de cette liste se trouve à l'aide de backticks ( `...`), cela donne une chaîne avec un interligne [, puis les zéros et les délimités par , (virgule + espace). Nous découpons cette chaîne à partir de l'index un par étapes de trois en utilisant [1::3]une chaîne contenant uniquement les zéros et les uns, ce qui nous permet d'utiliser la fonction de chaîne strippour supprimer les zéros externes ( strip('0')).

Par exemple:

      a = [[0,0,0,0,0]           map(max,a)                    = [0,1,1]
          ,[0,1,0,0,0]          `map(max,a)`[1::3]             = '011'
          ,[0,0,0,1,0]]         `map(max,a)`[1::3].strip('0')  = '11'
                            len(`map(max,a)`[1::3].strip('0')) = 2

zip(*a) = [(0,0,0)         map(max,zip(*a))                    = [0,1,0,1,0]
          ,(0,1,0)        `map(max,zip(*a))`[1::3]             = '01010'
          ,(0,0,0)        `map(max,zip(*a))`[1::3].strip('0')  = '101'
          ,(0,0,1)    len(`map(max,zip(*a))`[1::3].strip('0')) = 3
          ,(0,0,0)]

    --> [len(`map(max,v)`[1::3].strip('0'))for v in zip(*a),a] = [3,2]

Retina 0.8.2 , 83 octets

+`^0+¶|¶0+$

+1`((.)*).(¶(?<-2>.)*).(?<=(1)¶.*|(.))
$1$3$4$5
(¶?)*0*(.*1)0*
$#1 $.2

Essayez-le en ligne! Explication:

+`^0+¶|¶0+$

Supprimez les lignes nulles de début et de fin.

+1`((.)*).(¶(?<-2>.)*).(?<=(1)¶.*|(.))
$1$3$4$5

Supprimez tous les 0s sur les lignes au-dessus du dernier. Supprimez tous les 1deux, mais changez le chiffre en dessous sur la ligne suivante en1 dans ce cas. Ce bit ou les lignes ensemble.

(¶?)*0*(.*1)0*
$#1 $.2

Comptez le nombre de lignes comme le nombre de sauts de ligne plus 1 et le nombre de colonnes comme le nombre de chiffres entre le premier et le dernier 1.

J , 31 octets

[:$([:|.@|:}.^:(0=1#.{.))^:4^:_

Essayez-le en ligne!

Explication:

                            ^:_ - repeat until the result stops changing
   (                    )^:4    - repeat 4 times
             ^:(        )       - is
                  1#.           - the sum of
                      {.        - the first row
                 =              - equal 
                0               - to 0
           }.                   - if yes, drop the first row
    [:|.@|:                     - transpose and reverse (rotate 90 degrees) 
[:$                             - what's the shape of the result?

q / kdb +, 16 octets

sum@'(|/;|/')@\:

Mathematica, 34 octets

Max@#-Min@#+1&/@(#~Position~1)&

Fonction pure. Prend une liste imbriquée d'entiers en entrée et renvoie une liste de deux entiers (la hauteur suivie de la largeur) en sortie. Le caractère Unicode est U + F3C7 pour \[Transpose].

R , 48 46 octets

function(m)1+diff(apply(which(m>0,T),2,range))

Essayez-le en ligne!

-2 octets enregistrés par Giuseppe.

05AB1E , 11 9 octets

ζ‚Oε0Û0Üg

-2 octets grâce à @ Mr.Xcoder .

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

ζ            # Swap the rows and columns of the (implicit) input-list
 ‚           # Pair it with the (implicit) input-list
  O          # Take the sum of each column and row
   ε         # Map Both the list of column-sums and list of row-sums to:
    0Û       #  Remove all leading zeros
      0Ü     #  Remove all trailing zeros
        g    #  Take the length of the remaining lists

Gelée , 9 octets

ŒṪZṀ_ṂƊ€‘

Essayez-le en ligne!

Haskell , 76 octets

f x=length.s.reverse.s<$>[foldr(zipWith(:))e x,x]
e=[]:e
s=snd.span(all(<1))

Essayez-le en ligne!

Japt, 16 15 octets

[UUy]®=ðd)ÎaZÌÄ

Essayez-le ou exécutez tous les cas de test

---

Explication

[   ]               :Create an array containing
 U                  : The input and
  Uy                : The input transposed
     ®              :Map each Z
       ð            : Indices of elements where
        d           :  Any element is truthy (not 0)
      =  )          : Reassign to Z
          Î         : First element
           a        : Absolute difference with
            ZÌ      :  Last element
              Ä     :   Plus 1

Rubis , 60 octets

->m{[m,m.transpose].map{|x|x.map(&:max).join[/1.*/]=~/0*$/}}

Essayez-le en ligne!