Eliminar ceros circundantes de una matriz 2d

Esta es una versión bidimensional de esta pregunta .

Dada una matriz/matriz bidimensional no vacía que contiene solo enteros no negativos:

$$ \begin{bmatrix} {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & {\color{Red}0} & 0 & 1 & 0 \\ {\color{Red}0} & {\color{Red}0} & 0 & 0 & 1 \\ {\color{Red}0} & {\color{Red}0} & 1 & 1 & 1 \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \end{bmatrix} $$

Genere la matriz con los ceros circundantes eliminados, es decir, el mayor subconjunto contiguo sin los ceros circundantes:

$$ \begin{bmatrix} 0 & 1 & 0 \\ 0 & 0 & 1 \\ 1 & 1 & 1 \end{bmatrix} $$

Ejemplos:

$$ \begin{bmatrix} {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & {\color{Red}0} & 0 & 1 & 0 \\ {\color{Red}0} & {\color{Red}0} & 0 & 0 & 1 \\ {\color{Red}0} & {\color{Red}0} & 1 & 1 & 1 \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \end{bmatrix} \mapsto \begin{bmatrix} 0 & 1 & 0 \\ 0 & 0 & 1 \\ 1 & 1 & 1 \end{bmatrix} $$

Input:
[[0, 0, 0, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1], [0, 0, 1, 1, 1], [0, 0, 0, 0, 0]]

Output:
[[0, 1, 0], [0, 0, 1], [1, 1, 1]]

$$ \begin{bmatrix} {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & 0 & 0 & 3 \\ {\color{Red}0} & 0 & 0 & 0 \\ {\color{Red}0} & 5 & 0 & 0 \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \end{bmatrix} \mapsto \begin{bmatrix} 0 & 0 & 3 \\ 0 & 0 & 0 \\ 5 & 0 & 0 \end{bmatrix} $$

Input:
[[0, 0, 0, 0], [0, 0, 0, 3], [0, 0, 0, 0], [0, 5, 0, 0], [0, 0, 0, 0]]

Output:
[[0, 0, 3], [0, 0, 0], [5, 0, 0]]

$$ \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{bmatrix} \mapsto \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{bmatrix} $$

Input:
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Output:
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

$$ \begin{bmatrix} {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \end{bmatrix} \mapsto \begin{bmatrix} \end{bmatrix} $$

Input:
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Output:
[]

$$ \begin{bmatrix} {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \\ 1 & 1 & 1 & 1 \\ {\color{Red}0} & {\color{Red}0} & {\color{Red}0} & {\color{Red}0} \end{bmatrix} \mapsto \begin{bmatrix} 1 & 1 & 1 & 1 \end{bmatrix} $$

Input:
[[0, 0, 0, 0], [1, 1, 1, 1], [0, 0, 0, 0]]

Output:
[[1, 1, 1, 1]]

$$ \begin{bmatrix} {\color{Red}0} & 1 & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & 1 & {\color{Red}0} & {\color{Red}0} \\ {\color{Red}0} & 1 & {\color{Red}0} & {\color{Red}0} \end{bmatrix} \mapsto \begin{bmatrix} 1 \\ 1 \\ 1 \end{bmatrix} $$

Input:
[[0, 1, 0, 0], [0, 1, 0, 0], [0, 1, 0, 0]]

Output:
[[1], [1], [1]]

$$ \begin{bmatrix} 1 & 1 & 1 & 1 \\ 1 & 2 & 3 & 1 \\ 1 & 1 & 1 & 1 \end{bmatrix} \mapsto \begin{bmatrix} 1 & 1 & 1 & 1 \\ 1 & 2 & 3 & 1 \\ 1 & 1 & 1 & 1 \end{bmatrix} $$

Input:
[[1, 1, 1, 1], [1, 2, 3, 1], [1, 1, 1, 1]]

Output:
[[1, 1, 1, 1], [1, 2, 3, 1], [1, 1, 1, 1]]
37
Oye, ¿es posible agregar el caso de prueba $$ \ begin {bmatrix} 1 & 1 & 1 & 1 \\ 1 & 2 & 3 & 1 \\ 1 & 1 & 1 & 1 \ end {bmatrix} $$
agregado el autor Todd Hoff, fuente
@sundar ¿Cómo se ve ese valor falsey? Si solo es false , creo que está bien.
agregado el autor Michael Levy, fuente
¿Podemos dar una salida falsey en lugar de una matriz vacía para el último caso de prueba?
agregado el autor Mark, fuente
Además, si la salida puede ser una matriz no cuadrada, agregue un caso de prueba para eso.
agregado el autor Mark, fuente
Un caso de prueba que rompió mi envío anterior: [[0, 0, 0, 0], [0, 0, 0, 0], [1, 1, 1, 1], [0, 0, 0, 0]] (el resultado tiene un ancho/alto de 1 )
agregado el autor Conor O'Brien, fuente
@MattH Nada es difícil en un lenguaje no esotérico. :) Es difícil hacerlo corto.
agregado el autor user202729, fuente
También sugeriría agregar un caso de prueba como este: $$ \ begin {bmatrix} {\ color {Red} 0} & 1 & {\ color {Red} 0} & {\ color {Red} 0} \\ { \ color {Rojo} 0} & 1 & {\ color {Rojo} 0} & {\ color {Rojo} 0} \\ {\ color {Rojo} 0} & 1 & {\ color {Rojo} 0} & { \ color {Rojo} 0} \ fin {bmatrix} $$
agregado el autor Steven Evers, fuente
Esto es muy difícil en JavaScript. Estoy esperando una respuesta concisa en ese idioma.
agregado el autor MattH, fuente

28 Respuestas

Wolfram Language (Mathematica), 42 bytes

#&@@CellularAutomaton[{,{},0{,}},{#,0},0]&

Pruébalo en línea!

Cellular automata are indeed the answer to life, the universe, and everything.1

¿Cómo?

CellularAutomaton accepts an input array and an optional background value. Thus, {#,0} specifies that a cellular automaton rule should be applied to the input, assuming a background of 0s.

Una cosa interesante aquí es que CellularAutomaton recorta la salida para que no haya un borde de celdas de fondo (porque de lo contrario, la salida se encuentra en un plano infinito).

El código aplica la regla {Null, {}, {0, 0}} - aplicando el encabezado Null al vecino de radio 0 de cada celda (es decir, solo el centro: la propia celda) - exactamente 0 veces. El resultado de esto es la entrada original, pero con el fondo eliminado (es decir, recortar los alrededores de 0 ).


1. ¿Ves el recuento de mi respuesta? ;)

31
agregado
¿No hay referencia de XKCD 505 ?
agregado el autor Esolanging Fruit, fuente
Niza abuso incorporado ... bueno Mathematica tiene un incorporado, simplemente no expuesto directamente.
agregado el autor user202729, fuente

JavaScript (ES6), 98 bytes

(a,z)=>(g=A=>A.slice(A.map(m=M=(r,i)=>M=(z?a:r).some(n=>z?n[i]:n)?1/m?i:m=i:M)|m,M+1))(a).map(z=g)

¡Pruébelo en línea!

¿Cómo?

To overcome the lack of a zip built-in, we define a function g() that is able to operate on either the rows or the columns of the input matrix a[ ], depending on the value of the global flag z.

g() looks for the minimum index m and maximum index M of either non-empty rows (if z is undefined) or non-empty columns (if z is defined) and returns the corresponding slice of either the matrix itself or a given row of the matrix.

Para resumir:

  • we first remove rows by invoking g() on the matrix with z undefined
  • we then remove columns by invoking g() on each row with z defined, which leads to this rather unusual .map(z=g)

Comentado

(a, z) => (              //a[] = input matrix; z is initially undefined
  g = A =>               //g() = function taking A = matrix or row
    A.slice(             //  eventually return A.slice(m, M + 1)
      A.map(m = M =      //    initialize m and M to non-numeric values
        (r, i) =>        //    for each row or cell r at position i in A:
        M = (z ? a : r)  //      iterate on either the matrix or the row
        .some(n =>       //      and test whether there's at least one
          z ? n[i] : n   //      non-zero cell in the corresponding column or row
        ) ?              //      if so:
          1/m ? i      //        update the maximum index M (last matching index)
                : m = i  //        and minimum index m (first matching index)
        :                //      otherwise:
          M              //        let M (and m) unchanged
      ) | m,             //    end of map(); use m as the first parameter of slice()
      M + 1              //    use M+1 as the second parameter of slice()
    )                    //  end of slice()
  )(a)                   //invoke g() on the matrix with z undefined
  .map(z = g)            //invoke g() on each row of the matrix with z defined
14
agregado
@Jek, Arnauld vive en una dimensión completamente diferente. Pero si tiene extremadamente suerte, ocasionalmente puede encontrar un truco que no pudo encontrar y publicar una solución más breve. En el proceso, desarrollarás una comprensión muy profunda de JavaScript.
agregado el autor Rick Hitchcock, fuente
@RickHitchcock No soy tan bueno en el reconocimiento de patrones de código y regularmente me pierdo muchas cosas, incluso si las he visto antes. En este ejemplo particular, me centré en la reutilización de g() y perdí una optimización bastante obvia en la forma de actualizar m y M (-9 bytes). Estoy totalmente de acuerdo en que el código de golf es una manera excelente (y divertida) de aprender mucho sobre las sutilezas de un idioma.
agregado el autor Arnauld, fuente
Eso es impresionante.
agregado el autor Jek, fuente

MATL, 3 bytes

JYa

Try it online! Or verify all test cases.

Explicación

J      % Push 1j
Ya     % With complex 2nd input, this unpads the matrix in the
       % 1st input (implicit). The unpad value is 0 by default
       % Display (implicit)
12
agregado
agregado el autor Cain, fuente
Me gusta cómo la mitad del código es solo (implícito) .
agregado el autor JungHwan Min, fuente

Pyth, 13 bytes

V2=.sCQ]m0Q;Q

Pruébalo en línea !

6
agregado
Yo pienso = _CQ funcionaría en lugar de = Q_CQ .
agregado el autor Mr. Xcoder, fuente

R, 96 bytes

function(m)m[g(rowSums(m)),g(colSums(m))]
g=function(x,y=which(x>0),z=seq(x))z>=min(y)&z<=max(y)

Pruébalo en línea!

El helper g toma un vector no negativo y devuelve un vector con FALSE para el "exterior" 0 s del vector y VERDADERO para positivos y cualquier "interior" 0 s. Esta función se aplica a las sumas de filas y columnas de la matriz de entrada.

5
agregado
Creo que debería agregar drop = F como lo hice, de lo contrario, estas 2 pruebas devolverán un vector en lugar de una fila y una columna: Pruébelo en línea !
agregado el autor Stanley Watson, fuente

Brachylog, 24 22 20 19 bytes

{s.h+>0∧.t+>0∧}\↰₁\

Try it online!

Muestra la matriz de resultados como una matriz de matrices, o falsa para una salida vacía.

(Gracias a @Fatalize por sugerir predicado en línea y guardar 1 byte)

Explicación

Predicate 0 (Main):

{...}     Define and call predicate 1 to remove all-zero rows
  \       Transpose the result
   ↰₁     Call pred 1 again, now to remove all-zero columns
     \    Transpose the result to have correct output orientation

Predicado 1:

?s.h+>0∧.t+>0∧
  .           output is
 s              a subsequence of the rows of
?              the input (implicit)
   h          also, output's head element (first row)
    +>0        has a sum > 0 (i.e. has at least one non-zero value)
       ∧.t+>0  and similarly the output's tail element (last row)
∧              (don't implicitly unify that 0 with the output)
5
agregado
Gracias @Fatalize, actualizado (¡por fin!). Nunca pensé en cómo la sintaxis de predicados en línea es una aplicación de definición y predicado, bastante bien.
agregado el autor Mark, fuente
Escribir el primer predicado en línea es 1 byte más corto: {s.h +> 0∧.t +> 0∧} \ ↰₁ \ . (Esto es cierto para casi cualquier respuesta de Brachylog, los predicados sobre nuevas líneas realmente solo se implementan si desea escribir cosas más legibles).
agregado el autor Fatalize, fuente

Jelly, 10 bytes

œr€0z0Uµ4¡

Try it online!

5
agregado

APL (Dyalog Classic), 17 bytes

{⍉⌽⍵↓⍨0=⊃+/⍵}⍣4⍣≡

¡Pruébalo en línea!

4
agregado

Haskell, 62 61 bytes

f.f.f.f
f=reverse.foldr(zipWith(:))e.snd.span(all(<1))
e=[]:e

Try it online!

foldr(zipWith(:))e with e=[]:e is a slightly shorter transpose, and snd.span(all(<1)) drops leading lists of zeros from a list of list. As transpose followed by reverse on a 2D list equals an rotation by 90°, the code f.f.f.f is just four times drop leading lists of zeros and rotate.

4
agregado

Wolfram Language (Mathematica), 66 bytes

If[[email protected]#>0,[email protected][#~ArrayPad~1,r="Real"]~ImageData~r,{}]&

Pruébalo en línea!

¡Ahora funciona rellenando la matriz con ceros (gracias @JungHwanMin)!

Un segundo gracias a @JungHwanMin por guardar 4 bytes

3
agregado

R, 89 bytes

function(m,y=apply(which(m>0,T),2,fivenum)){y[is.na(y)]=0;m[y:y[5,],y[,2]:y[5,2],drop=F]}

¡Pruébelo en línea!

Gracias a @ngm por el código de casos de prueba.

  • Tuve que agregar el parámetro drop = F debido a que el comportamiento predeterminado de R convirtió la matriz de fila/columna en vectores ...
3
agregado
Desearía poder hacer +2 en esto. Muy buen uso de fivenum.
agregado el autor JayCe, fuente
No me di cuenta de que mi código anterior estaba fallando en los casos de todo cero ... ahora, por desgracia, se ha corregido con muchos más bytes :(
agregado el autor Stanley Watson, fuente

Retina, 87 bytes

/.\[(?!0,)/^+`\[0, 
[
/(?

Try it online! Explanation:

/.\[(?!0,)/^+`

Hasta que al menos una fila no comience con cero ...

\[0, 
[

... eliminar el cero inicial de cada fila.

/(?

Hasta que al menos una fila no termina con cero ...

, 0]
]

... eliminar el cero final de cada fila.

\[(\[0(, 0)*], )+
[

Elimina las filas iniciales de ceros.

(, \[0(, 0)*])+]|\[0]]
]

Elimine las filas de ceros al final, o el último cero restante.

2
agregado
@RickHitchcock Es sensible formato, añadir en los espacios: ¡Pruébalo en línea!
agregado el autor Luke Bennett, fuente

K (ngn/k), 22 bytes

{4{+|(+/&\~+/x)_'x}/x}

¡Pruébalo en línea!

2
agregado

Python 2, 118 116 bytes

f=lambda a,n=4,s=sum:n and f(zip(*a[max(i for i in range(len(a))if s(s(a[:i],()))<1):][::-1]),n-1)or(s(s(a,()))>0)*a

¡Pruébalo en línea!


Salvado:

  • -2 bytes, gracias a shooqie
2
agregado
@shooqie Gracias :)
agregado el autor myroslav, fuente
Puede guardar dos bytes asignando s = sum en la definición de lambda
agregado el autor shooqie, fuente

Wolfram Language (Mathematica), 48 bytes

Nest[[email protected]@#//.{{0..},a___}->{a}&,#,4]&

Pruebe en línea!

Haciéndolo de la manera normal.

2
agregado
Desafortunadamente, \ [Transpose] no puede funcionar aquí.
agregado el autor user202729, fuente

Jelly, 12 bytes

Ṗ§Ṫ¬ȧƲ¿UZµ4¡

Pruébalo en línea

Como una función.

2
agregado

Python 2, 71 bytes

Vuelve modificando la entrada. Una lista se debe pasar como entrada.

def f(a):exec'while a and 1>sum(a[-1]):a.pop()\na[:]=zip(*a)[::-1]\n'*4

Pruébalo en línea!


Python 2, 77 bytes

Esto también modifica la entrada, pero funciona ....

def f(a):exec'while a and 1>sum(a[-1]):a.pop()\na=zip(*a)[::-1]\n'*4;return a

Pruébelo en línea!

2
agregado

Husk, 11 bytes

!5¡(T0mo↔↓¬

Pruébalo en línea!

Siento que algunos bytes se pueden recortar acortando la parte ! 5¡ .

Cómo funciona

!5¡(

Aplique repetidamente la función que se explica a continuación, recopilando los resultados en una lista infinita. Luego, recupere el elemento \ $ 5 ^ {\ text {th}} \ $. En otras palabras, aplique la función a la entrada 4 veces.

mo↔↓¬

Haga un mapa sobre la versión actual de la entrada y: invierta cada una, después de haber eliminado el prefijo más largo que solo contiene ceros (la eliminación de este prefijo se realiza utilizando el > de Husk, que es una función que recorta el plazo más largo de elementos consecutivos desde el principio de la lista que producen resultados verídicos cuando se ejecutan a través de una función, a saber, ¬ , lógico no).

T0

Transponer, reemplazando las entradas faltantes con 0 .

2
agregado

PHP (>=5.4), 200 194 186 184 bytes

(-6 bytes devolviendo null en lugar de una matriz vacía)

(-8 bytes gracias a Titus )

(-2 bytes con llamadas por referencia gracias a Titus )

function R(&$a){$m=$n=1e9;foreach($a as$r=>$R)foreach($R as$c=>$C)if($C){$m>$r&&$m=$r;$M>$r||$M=$r;$n>$c&&$n=$c;$N>$c||$N=$c;}for(;$m<=$M;)$o[]=array_slice($a[$m++],$n,$N-$n+1);$a=$o;}

Pruébelo en línea

¿Cómo?

Finds min and max index for rows ($m & $M) and columns ($n & $N) and replaces the input with a sub array from $m,$n to $M,$N (this is a call by reference).

2
agregado
... y dos bytes con while ($ m <= $ M) $ o [] = array_slice ($ a [$ m ++], $ n, $ N- $ n + 1);
agregado el autor Titus, fuente
Ahorre 6 bytes con si ($ C) {$ m> $ r && $ m = $ r; $ M> $ r || $ M = $ r; $ n> $ c && $ n = $ c; $ N > $ c || $ N = $ c;}
agregado el autor Titus, fuente
Puede guardar otros dos bytes con la llamada por referencia: $ a = en lugar de return .
agregado el autor Titus, fuente
@Titus: Gracias por los grandes consejos. Me encantó el truco de usar && y || y estoy seguro de que también podré usar ese truco en otros lugares.
agregado el autor Steven Evers, fuente

Octava, 48 49 bytes

@(a)sparse(1-min([x y v]=find(a))+x,1-min(y)+y,v)

Try it online!

Encuentre puntos distintos de cero y reorganícelos en una nueva matriz dispersa.

2
agregado
@alephalpha Respuesta actualizada!
agregado el autor rahnema1, fuente

JavaScript, 144 140 129 127 bytes

w=>(t=w=>(q=(s=w=>w.some((r,j)=>r.find(e=>e,i=j))?w.slice(i).reverse():[[]])(s(w)))[0].map((e,j)=>q.map((e,i)=>q[i][j])))(t(w))

140 -> 129 bytes, thanks @Arnauld

Algoritmo

  • Do twice:
    • Find first non-zero row
    • Slice off preceding rows
    • Reverse
    • Find first non-zero row
    • Slice off preceding rows
    • Reverse
    • Transpose

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false"> <div class="snippet-code">

f = w=>(t=w=>(q=(s=w=>w.some((r,j)=>r.find(e=>e,i=j))?w.slice(i).reverse():[[]])(s(w)))[0].map((e,j)=>q.map((e,i)=>q[i][j])))(t(w));

w1 = [[0, 0, 0, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1], [0, 0, 1, 1, 1], [0, 0, 0, 0, 0]];
w2 = [[0, 0, 0, 0], [0, 0, 0, 3], [0, 0, 0, 0], [0, 5, 0, 0], [0, 0, 0, 0]];
w3 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
w4 = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]];

console.log(f(w1).join("\n"));
console.log(f(w2).join("\n"));
console.log(f(w3).join("\n"));
console.log(f(w4));
</div> </div>
2
agregado
Puede salvar a 7 bytes utilizando some/some en lugar de findIndex/find y reorganizando las declaraciones de la función auxiliar para eliminar el paréntesis alrededor del argumento de la función principal (ahora único).
agregado el autor Arnauld, fuente
I que puede guarda 4 bytes más al tener s return [[]] para que t tenga la garantía de poder operar en w [0] .
agregado el autor Arnauld, fuente

Charcoal, 48 bytes

F⁴«W∧θ¬Σ§θ±¹Σ⊟θ¿θ≔⮌E§θ⁰E觧θνλθ»⪫[]⪫Eθ⪫[]⪫ι, ¦, 

Try it online! Link is to verbose version of code. Includes 15 bytes for formatting. Explanation:

F⁴«

Repita 4 veces.

W∧θ¬Σ§θ±¹

Repita mientras la matriz no está vacía pero su última fila se suma a cero ...

Σ⊟θ

Elimine la última fila de la matriz e imprima una línea de la longitud de su suma, es decir, nada.

¿θ≔⮌E§θ⁰E觧θνλθ»

Si la matriz no está vacía, entonces transpóntela.

⪫[]⪫Eθ⪫[]⪫ι, ¦, 

Formato de la matriz muy bien para su visualización. (La salida estándar sería en su lugar).

1
agregado

PHP, 188 bytes

function f(&$a){for($s=array_shift;!max($a[0]);)$s($a);for($p=array_pop;!max(end($a));)$p($a);for($w=array_walk;!max(($m=array_map)(reset,$a));)$w($a,$s);while(!max($m(end,$a)))$w($a,$p);}

llamar por referencia.

desglose

// call by reference
function f(&$a)
{
   //while first row is all zeroes, remove it
    while(!max($a[0]))array_shift($a);
   //while last row is all zeroes, remove it
    while(!max(end($a)))array_pop($a);
   //while first column is all zeroes, remove it
    while(!max(array_map(reset,$a)))array_walk($a,array_shift);
   //while last column is all zeroes, remove it
    while(!max(array_map(end,$a)))array_walk($a,array_pop);
}
1
agregado

Attache, 68 bytes

Fixpoint[{[email protected][email protected][{[email protected]!in~-n'0or [email protected]}\[email protected]_<:0]}//2]

Pruébalo en línea!

Dos veces: Esto elimina cualquier primera o última fila cuya suma es 0 , luego transpone la matriz. Luego, este proceso se repite hasta que el resultado no cambia.

1
agregado

Ruby, 73 63 bytes

->a{4.times{_,*a=a while a[0]&.sum==0;a=a.reverse.transpose};a}

Pruébalo en línea!

Edición: simplificada, también la versión anterior se bloqueó para todos los 0 s

Cómo funciona:

  • do 4 times:
    • remove the first line while there is a first line and it's full of 0s
    • rotate the array clockwise by 90°
  • return the array
1
agregado

Stax, 14 bytes

Ç·W≈y§╗♦º{¬║8•

Run and debug it

Alternative, also 14 bytes

Ç·W≈x≈ƒHq♣☻»íÅ

Run and debug it

1
agregado

Clean, 73 bytes

import StdEnv,StdLib
$ =dropWhile(all((>)1))o reverse o transpose
$o$o$o$

Pruebe en línea!

Muy similar a respuesta Haskell de Laikoni .

1
agregado