Non è fastidioso quando si scatta una foto, ma lo sfondo toglie la sostanza reale dell'immagine? Direi che lo è. Devo sapere quanto dovrei ritagliare per sbarazzarmi di questo problema! Ma - come al solito - sono abbastanza pigro, quindi ho bisogno di qualcuno che lo faccia per me ...

Compito e regole

Data una matrice binaria che rappresenta l'immagine, genera le dimensioni (larghezza e altezza) della matrice secondaria più piccola che contiene tutti gli $1$ s nella matrice originale. Una matrice secondaria è un blocco di voci adiacenti dalla matrice originale. Equivalentemente, è una nuova matrice formata sovrapponendo un sottoinsieme di righe adiacenti e un sottoinsieme di colonne adiacenti dell'originale.

• È consentito prendere anche la larghezza e l'altezza della matrice come input.
• L'ingresso è garantito per contenere almeno un $1$ .
• Puoi prendere input e fornire output attraverso qualsiasi metodo standard , tenendo presente che queste scappatoie sono vietate per impostazione predefinita. Questo è code-golf , quindi prova a completare l'attività nel minor numero di byte che puoi gestire nella tua lingua preferita.

Esempio

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

Casi test

Input | Produzione

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

[[0,0,0,0,0], [0,1,0,1,0], [0,0,1,0,0]]
-> (3,2) o (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) o (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) o (3,5)

MATL , 5 byte

JYaZy

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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

APL (Dyalog Unicode) , 10 byte ^SBCS

Funzione prefisso tacito anonimo.

(1+⌈/-⌊/)⍸

Provalo online!

⍸ indici di 1s.

(... ) applica la seguente funzione tacita a quella:

 ⌊/ il minimo ( coordinata y più bassa e coordinata x più bassa )

 ⌈/- il massimo meno che (questo ci dà la gamma)

 1+ uno più quello (per essere inclusivo)

Ottava , 57 56 45 byte

Qui findfa il sollevamento pesante: indica gli findsindici di fila e di colonna delle voci diverse da zero. Quindi non ci resta che trovare la differenza tra il massimo e il minimo (più uno) per ciascuno di essi separatamente.

Grazie @beaker e @AndrasDeak per -1 byte e @LuisMendo per -11 byte!

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

Provalo online!

Python 2 , 92 86 byte

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)

Provalo online!

Gelatina , 7 byte

S,§t€0Ẉ

Provalo online!

Come funziona

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 byte

-8 con l'aiuto di Vincent (prendi la matrice di input come un array Numpy)

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

Una funzione senza nome accettare un 2-d Numpy array di interi (a {0,1}), che restituisce un elenco di numeri interi, [width,height].

Provalo online!

---

Versione non numpy in 63 byte (accettando un elenco di elenchi di numeri interi in {0,1}):

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

Provalo online!

Come?

Data una matrice, a, forognuna ( v) della trasposizione, zip(*a)e asi troviamo all'altezza desiderata (data la trasposta è la larghezza).

La mappatura maxtra vproduce un elenco di zeri e di uno, che rappresenta se ogni riga vcontiene uno qualsiasi. La rappresentazione in forma di stringa di questo elenco si trova usando backticks ( `...`), questo fornisce una stringa con un carattere iniziale [, quindi gli zeri e quelli delimitati da , (virgola + spazio). Tagliamo questa stringa iniziando dall'indice uno in tre passaggi usando [1::3]ottenendoci una stringa di soli zeri e quelli, che ci consente di usare la funzione stringa stripper rimuovere gli zeri esterni ( strip('0')).

Per esempio:

      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 byte

+`^0+¶|¶0+$

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

Provalo online! Spiegazione:

+`^0+¶|¶0+$

Elimina le righe zero iniziali e finali.

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

Rimuovi tutte le 0s sulle righe sopra l'ultima. Rimuovi tutti 1i due, ma cambia la cifra sottostante nella riga successiva in a 1in quel caso. Questo bit per bit o sono le righe insieme.

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

Contare il numero di righe come il numero di newline più 1 e il numero di colonne come il numero di cifre tra il primo e l'ultimo 1.

J , 31 byte

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

Provalo online!

Spiegazione:

                            ^:_ - 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 byte

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

Mathematica, 34 byte

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

Funzione pura. Accetta un elenco nidificato di numeri interi come input e restituisce un elenco di due numeri interi (l'altezza seguita dalla larghezza) come output. Il carattere Unicode è U + F3C7 per \[Transpose].

R , 48 46 byte

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

Provalo online!

-2 byte salvati da Giuseppe.

05AB1E , 11 9 byte

ζ‚Oε0Û0Üg

-2 byte grazie a @ Mr.Xcoder .

Provalo online o verifica tutti i casi di test .

Spiegazione:

ζ            # 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

Gelatina , 9 byte

ŒṪZṀ_ṂƊ€‘

Provalo online!

Haskell , 76 byte

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

Provalo online!

Japt, 16 15 byte

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

Provalo o esegui tutti i casi di test

---

Spiegazione

[   ]               :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

Rubino , 60 byte

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

Provalo online!