Borders of a Rectangular Matrix

Question

Although it's done a few times as sub-challenge of a larger challenge, and we also have a challenge to remove the borders of a square matrix, I couldn't find a challenge to output the borders of a given matrix, so here it is.

Challenge:

Given a rectangular-shaped matrix containing integers as input, output its borders.

Challenge rules:

• The input is guaranteed to be a rectangular-shaped matrix (or empty)
• The input can contain negative and duplicated integers
• The output format and type is flexible and can be in any order (e.g. [[1,2,3],[4,5,6],[7,8,9]] may result in [1,2,3,4,6,7,8,9]; or [[1,2,3],[6,9],[8,7],[4]]; or 9\n8\n7\n6\n4\n3\n2\n1\n; etc.). As long as it's clear that just the border of the input-matrix is output, almost every output-format is allowed. (If you're unsure whether an output format is allowed, feel free to ask in the comments.)

General Rules:

• This is code-golf, so the shortest answer in bytes wins.
  Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
• Standard rules apply for your answer with default I/O rules, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
• Default Loopholes are forbidden.
• If possible, please add a link with a test for your code (e.g. TIO).
• Also, adding an explanation for your answer is highly recommended.

Test Cases:

Input	Output	Visualized
[[1,2,3], [4,5,6], [7,8,9]]	[1,2,3,4,6,7,8,9]
[[]]	[]	N/A
[[0]]	[0]
[[ 9, 2,-5, 3], [18, 3, 8, 0], [ 2, 7,21,-3], [ 9,-5,10,99]]	[9,2,-5,3,18,0,2,-3,9,-5,10,99]
[[1,2,3]]	[1,2,3]
[[9], [8], [8], [9]]	[9,8,8,9]
[[ 10, 20, 30, 40, 50, 60], [ 70, 80, 90,-90,-80,-70], [-60,-50,-40,-30,-20,-10]]	[10,20,30,40,50,60,70, -70,-60,-50,-40,-30,-20,-10]
[[ 1, 2, 3, 4, 5, 6], [ 7, 8, 9,10,11,12], [13,14,15,16,17,18], [19,20,21,22,23,24], [25,26,27,28,29,30], [31,32,33,34,35,36], [37,38,39,40,41,42], [43,44,45,46,47,48], [49,50,51,52,53,54], [55,56,57,58,59,60]]	[1,2,3,4,5,6,7,12,13,18, 19,24,25,30,31,36,37,42,43, 48,49,54,55,56,57,58,59,60]
[[-11, 18, 3,-40,123], [ 18,-33, 9,765,100]]	[-11,18,3,-40,123,18,-33,9,765,100]
[[14, 3], [ 3,14], [14, 3], [ 3,14], [14, 3]]	[14,3,3,14,14,3,3,14,14,3]

Answer 1

Python 3, 38 bytes

def f(x):
 for c in x[1:-1]:c[1:-1]=[]

Outputs by modifying arguments. The code also works on Python 2.

Explanation: deletes the center part of each center row by modifying the original input.

Attempt This Online! (additional test cases taken from loopy walt's answer)

Answer 2

jq, 57 46 20 bytes

del(.[1:-1][][1:-1])

Online demo

Answer 3

Japt, 10 8 bytes

I/O as a 2D array of integers, with output sorted anti-clockwise starting in the bottom right corner.

4Æ=z)oÃf

Try it

4Æ=z)oÃf     :Implicit input of 2D array U
4Æ           :Map the range [0,4)
  =          :  Reassign to U
   z         :   Rotate U 90° clockwise
    )        :  End reassignment
     o       :  Pop last sub-array, mutating the array
      Ã      :End map
       f     :Filter, removing null elements

Answer 4

Rust, 81 bytes

|a,b,c|(0..).zip(a).filter(move|(d,_)|d%b<1||d%b>b-2||d/b<1||d/b>c-2).map(|a|a.1)

Attempt This Online!

Takes input as a flattened matrix with size given as b and c

Answer 5

JavaScript (ES6), 54 bytes

m=>m.map((r,y)=>r.filter((_,x)=>x*y/r[x+1]?!m[y+1]:1))

Try it online!

Or 58 bytes (ES10) if we want to flatten the output:

m=>m.flatMap((r,y)=>r.filter((_,x)=>x*y/r[x+1]?!m[y+1]:1))

Try it online!

Commented

m =>                 // m[] = input matrix
m.map((r, y) =>      // for each row r[] in m[] at index y:
  r.filter((_, x) => //   for each value in r[] at index x:
    x * y            //     if neither x nor y is equal to 0 and there's
    / r[x + 1] ?     //     at least one more column after this one:
      !m[y + 1]      //       keep the value only if this is the last row
    :                //     else:
      1              //       keep the value
  )                  //   end of filter()
)                    // end of map()

Answer 6

Vyxal, 62 bits^v1, 7.75 bytes

4(∩ḣṘ)_W'

Try it Online!

Port of pyth messed up by the fact that ḣ and ṫ return 0 on an empty list instead of erroring (which has its use, but is annoying here)

Explained

4(∩ḣṘ)_W'
4(   )    # 4 times
  ∩       #   transpose top of stack
   ḣ      #   separate the head from the rest
    Ṙ     #   and reverse
      _W  # pop the remaining list and wrap the stack in a list
        ' # remove 0s and empty lists

Answer 7

Jelly, 8 bytes

With the lax output requirements I was expecting to find terser in Jelly!

ŒDị@Ḋ¡€.

A monadic Link that accepts the rectangular matrix and yields a list of lists of border values.

Try it online! Or see the test-suite.

How?

ŒDị@Ḋ¡€. - Link: list of lists, M
ŒD       - all NW-SE diagonals of M
       . - set the right argument to 0.5
      €  - for each diagonal:
     ¡   -   repeat...
    Ḋ    -   ...number of times: dequeue (i.e. once if diagonal length > 1)
   @     -   ...action: with swapped arguments - f(0.5, diagonal)
  ị      -                index into*
             
             * fractional indices give the two neighbours in the 
               case of 0.5 that's 0 (the last) and 1 (the first)

Answer 8

Wolfram Language (Mathematica), 47 45 bytes

-2 bytes thanks to @alephalpha

Try it online!

If[Tr[1^#]>2,{#[[t={1,-1}]],#[[2;;-2,t]]},#]&

Explanation

Tr[1^#] returns the length of the shortest dimension by computing the Trace of a matrix of 1's with the same dimensions as the input, i.e., Min@Dimensions@#. If we have an edge case with a dimension of 0, 1, or 2, we return the input in its original form.

If Tr[1^#]>2 is true, then we use Mathematica's [[a;;b, c;;d]] syntax to access different parts of the matrix: #[[{1,-1}]] returns the first and last rows, #[[2;;-2,{1,-1}]] returns the first and last columns while excluding the "corners." We return a ragged array as the output: if the input is mxn with m,n>2, the output will be of the format {(2 x n array), ((m-2) x 2 array)}

Answer 9

J, ²⁴ 20 bytes

#~&,_>_(<,~<<0 _1)}]

Try it online!

• _(<,~<<0 _1)}] Convert all interior points to infinity, by specifying "not first and last (0 and -1)" elements of first axis, and "not first and last" elements of second axis.
• _> Where is that matrix less than infinity? Returns a 1-0 mask selecting the border
• #~&, Flatten and filter the input with that mask

alternative, 20 bytes

#~&,]+./&(#\e.1,#)|:

Try it online!

diagonal rotation, 24 bytes

#~&,_=[:+/,.~@1 _1|.!._]

Try it online!

Looks like this may be related to Adam's APL answer, but was discovered independently. See alternate below for a different approach.

1. Diagonally rotate the matrix up-left using infinity as fill.
2. Same thing down-right
3. Add the two together (now the borders will all have the value infinity)
4. Create a border-selecting 1-0 mask with 1 wherever infinity is
5. Use that mask to filter the input, flattening both the mask and the input

original, 24 bytes

#~&,0=<:@$*/@:|"1$#:i.@$

Try it online!

Answer 10

Excel, 77 bytes

=TOCOL(B2#/(MAP(B2#,LAMBDA(b,SUM(SUBTOTAL(2,OFFSET(b,{-1;1},{-1,1})))))<4),2)

Input is spilled range deliberately set to have its top-leftmost cell as B2, rather than the customary A1, such that the four cells above, below, to the right and to the left of that cell exist.

Answer 11

R, 44 34 bytes

\(m)m[rev(d<-row(m)<2|col(m)<2)|d]

Attempt This Online!

Footer stolen from pajonk's answer, and -10 thanks to them!

Answer 12

SAS IML, 88 70

Input is a rectangular matrix M e.g.,

M1={
 1  2  3  4  5  6,
 7  8  9 10 11 12,
13 14 15 16 17 18,
19 20 21 22 23 24,
25 26 27 28 29 30,
31 32 33 34 35 36,
37 38 39 40 41 42,
43 44 45 46 47 48,
49 50 51 52 53 54,
55 56 57 58 59 60
};

[EDIT:] According to comments below I updated the answer.

The code (an IML module):

start d(M);if 2<nrow(M)><ncol(M) then M[2:nrow(M)-1,2:ncol(M)-1]=.;M=M[loc(M>.)];finish;

Human readable:

start d(M);
  if 2 < nrow(M)><ncol(M) then 
    M[ 2:nrow(M)-1, 2:ncol(M)-1 ] = .; 
  M = M[ loc(M > .) ];
finish;

To execute the IML module d run the following:

call d(M);

The process:

1. For a Matrix M with at least 3 rows and columns (2 < nrow(M)><ncol(M), where nrow(M) is number of rows, ncol(M) is number of columns, and >< is operator of minimum of two numbers) replace "everytnig inside" (2:nrow(M)-1, 2:ncol(M)-1) with missing data (.),
2. select those elements of M where value is not missing.

To print out result, i.e. elements extracted from M, run the following line:

if type(M)="U" then print "M is Empty";
else print M;

---

Answer 13

Jelly, 7 bytes

ŒDµżṪḢ)

Try it online!

No shot I could have thought of using diagonals if @Jonathan Allan hadn't first, so go upvote his solution! (Also, two bonus 8-byters: ŒDµṙ-ḣ2), ŒDµḊṖœ^))

ŒDµ   )    For each diagonal of the input:
    Ṫ      take and remove the last element,
   ż       zip with the remaining elements,
     Ḣ     and take the first of those pairs.

My original solutions, to laugh at:

Jelly, 9 bytes

ḊṖ$⁺€Fœ^F

Try it online!

ḊṖ           Remove the first and last rows
  $⁺€        and columns.
     F       Flatten the result,
        F    flatten the input,
      œ^     symmetric multiset difference.

Can't decide if this feels worse...:

Jelly, 9 bytes

ḊUZƊ3СZḢ

Try it online!

   Ɗ3С      Repeat [0, 1, 2, 3] times:
Ḋ            Remove the first row,
 U           reverse each row,
  Z          transpose.
       Z     Transpose the results
        Ḣ    and return the first row of that.

Answer 14

JavaScript (Node.js), 47 bytes

m=>m.slice(1,-1).map(x=>x.splice(1,x.length-2))

Try it online!

Modify the input

Answer 15

Uiua ^SBCS, 13 12 bytes

⊡⊚↥⇌≡⇌.≡∊0°⊡

Try it!

Port of Adám's APL answer.

-1 now that °⊡ is equivalent to ⇡△..

⊡⊚↥⇌≡⇌.≡∊0°⊡­⁡​‎‎⁡⁠⁤⁡‏‏​⁡⁠⁡‌⁢​‎‎⁡⁠⁣⁣‏⁠‎⁡⁠⁣⁤‏‏​⁡⁠⁡‌⁣​‎‎⁡⁠⁢⁤‏⁠‎⁡⁠⁣⁡‏⁠‎⁡⁠⁣⁢‏‏​⁡⁠⁡‌⁤​‎‎⁡⁠⁤‏⁠‎⁡⁠⁢⁡‏⁠‎⁡⁠⁢⁢‏⁠‎⁡⁠⁢⁣‏‏​⁡⁠⁡‌⁢⁡​‎‎⁡⁠⁣‏‏​⁡⁠⁡‌⁢⁢​‎‎⁡⁠⁡‏⁠‎⁡⁠⁢‏‏​⁡⁠⁡‌­
          °⊡   # ‎⁢coordinate matrix
       ≡∊0     # ‎⁣mask of coordinates that contain zero
   ⇌≡⇌.        # ‎⁤duplicate and reverse both axes
  ↥            # ‎⁢⁡max (logical or the masks together)
⊡⊚             # ‎⁢⁢select values from input according to mask

Answer 16

Pyth, 7 bytes

V4.)=_C

Try it online!

Prints each side as lists separated by newlines. Goes clockwise starting with the left side.

Explanation

V4.)=_CQ    # implicitly add Q
            # implicitly assign Q = eval(input())
V4          # loop 4 times
    =  Q    #   assign Q to
      CQ    #   Q transposed
     _      #   and reversed
  .)        #   pop the last element of Q and print it

Answer 17

Python 2, 48 bytes

f=lambda a:a[:1]+a[1:][-1:]+map(f,a[1:-(a>[f])])

Attempt This Online!

Takes a LOL and returns a ragged LOL. Output for non degenerate inputs is [top row,bottom row,[1st,last]of 2nd row,[1st,last]of 3rd row,...

Answer 18

APL (Dyalog Unicode), 23 22 18 bytes

Thanks to ovs for −4 bytes.

Anonymous prefix lambda.

{⍵[⍸∨∘⌽∘⊖⍨1∊¨⍳⍴⍵]}

Try it online!

{…} "dfn"; argument is ⍵:

 ⍵[…] select from the argument:

  ⍸ where indicated by

  ∨∘⌽∘⊖⍨ the following mask when ORed with its mirrored flipped version…

  1∊¨ true only where 1 is a member of

  ⍳ the indices for an array that has the shape

  ⍴⍵ the shape of the argument

Answer 19

Haskell, 48 bytes

b=zipWith($)[head,map last,last,map head].repeat

Try it online!

Haskell, 74 bytes

import Data.List;(o:t)#(r:s)=r++t#(reverse$transpose$s);_#_=[];b=("1234"#)

Try it online!

At each of the four or less iterations, # peels the top row r from the matrix, and rotates it i-wise by transpose sending corner 2 to 3 and reverse sending corner 2 from 3 to 1 before reiterating for one side o less than before.

Answer 20

Vyxal 3, 15 bytes

∥Þhϩf₌[|⁰ḢṪᵛÞhJ

Try it Online!

accounting for depth-one lists takes 9 extra bytes for proper output

Answer 21

R, 52 bytes

\(m)m[row(m)%in%c(1,nrow(m))|col(m)%in%c(1,ncol(m))]

Attempt This Online!

Answer 22

Charcoal, 18 bytes

ＩΣＥθΦι¬∧﹪κ⊖Ｌθ﹪μ⊖Ｌι

Attempt This Online! Link is to verbose version of code. Explanation: Uses a filter to keep elements in the first or last row or column i.e. those that are not both in an interior row and in an interior column.

   θ                Input array
  Ｅ                 Map over rows
     ι              Current row
    Φ               Filtered where
         κ          Current row
        ﹪           Modulo
            θ       Input array
           Ｌ        Length
          ⊖         Decremented
       ∧            Logical And
              μ     Current column
             ﹪      Modulo
                 ι  Current row
                Ｌ   Length
               ⊖    Decremented
      ¬             Logical Not
 Σ                  Flatten
Ｉ                   Cast to string
                    Implicitly print

Answer 23

julia, 59 bytes

Expects a Matrix{Any} and returns a Vector{Any} of the border entries.

Each call of this function pops the top row of the matrix, rotates the resulting matrix to the right and recurses. Terminates after 4 iterations or when the resulting matrix is empty.

f(M,c=4)=length(M)c>0 ? [M[1,:];f(M[end:-1:2,:]',c-1)] : []

Attempt This Online!

Answer 24

Scala, 98 bytes

Golfed version. Try it online!

(o,q)=>(o,q)match{case (Nil,_)|(_,Nil)=>Seq[Int]()case (_,r::s)=>r++f(o.tail,s.transpose.reverse)}

Ungolfed version. Try it online!

object Main extends App {
  def f(o: List[Int], rs: List[List[Int]]): List[Int] = (o, rs) match {
    case (Nil, _) | (_, Nil) => List[Int]()
    case (_, r :: s) => r ++ f(o.tail, s.transpose.reverse)
  }

  println(f((1 to 4).toList, List(List(1,2,3), List(4,5,6), List(7,8,9))))
  println(f((1 to 4).toList, List(List(9, 2,-5, 3), List(18, 3, 8, 0), List(2, 7,21,-3), List(9,-5,10,99))))
  println(f((1 to 4).toList, List(List(10, 20, 30, 40, 50, 60), List(70, 80, 90,-90,-80,-70), List(-60,-50,-40,-30,-20,-10))))
}

Answer 25

Retina, 23 bytes

(?<=¶.+)\b\S+\b(?=.+¶)

Try it online!

Expects a matrix as having columns separated by spaces and rows separated by newlines. Works by removing numbers that have a newline more than immediately before and after them. The boundaries are required to avoid deleting digits/signs elsewhere in the boundary numbers since there isn't a way to make lookahead/behind non-greedy/backtrack (at least in fewer than 4 bytes).

Seems shorter than listing all boundary numbers, for the same reason. I've found a slightly crazy version that is a byte shorter, but is also far more abusive of the lax I/O.

L`^.+|.+$|\w+¶|\G[^,]+

Answer 26

Ruby, 31 29 bytes

Very similar to SuperStormer’s Python 3 answer. Outputs by modifying the given array.

->a{a[r=1..-2].map{_1[r]=[]}}

Attempt This Online!

Answer 27

Perl 5, 55 bytes

sub{grep/./,@{shift@_},@{pop@_},map{(pop@$_),$$_[0]}@_}

Try it online!

Answer 28

Pip -xp, 11 bytes

L4PDQ R:Z:a

Outputs (up to) four lists: down the left border, then right-to-left along the top border, then up the right border, and finally left-to-right along the bottom border.

Attempt This Online!

Explanation

L4PDQ R:Z:a
             ; a is command-line argument, eval'd as a Pip object (implicit, -x flag)
L4           ; Loop 4 times:
        Z:a  ;  Transpose a in place
      R:     ;  Reverse a in place
             ;  Together, these operations amount to a 90° counterclockwise rotation
   DQ        ;  Remove and return the last row of a
  P          ;  Print that value (formatted as a list, -p flag)

Answer 29

Java (JDK), 148 117 112 106 bytes

• -31 bytes by Kevin Cruijssen (see the comments below)
• -5 and -6 bytes by @ceilingcat

a->{for(int R=a.length,C=a[0].length,j=R*C;j-->0;)if(j<C|j/C>R-2|-~j%C<2)System.out.println(a[j/C][j%C]);}

Try it online!

I think this solution is pretty self-explanatory.