Find the walls!

Question

This is a simpler variant of my previous challenge Don't touch the walls!, as suggested by Jonah.

Given a multi-dimensional rectangular array of integers between 0 and 9, output all the elements which are "touching the edges".

Output is very flexible: it can be in any order, and may be flattened or partially nested, but must contain every edge element the correct number of times, and may not contain any others.

Specification

"Touching the edges" is a hopefully fairly intuitive concept, but here is a specification:

Let's use this array, with shape 4, 3.

[[1, 3, 0],
 [2, 6, 7],
 [4, 0, 2],
 [0, 0, 0]]

Using one-based indexing, we can index any element of the array using two integers in the ranges \$ [1, 4] \$ and \$ [1, 3] \$.

The elements which are touching the edge are those with coordinates of the form 1, y, 4, y, x, 1, or x, 3.

So, formally, we can say, for an element to be "touching the edge", at least one part of its multidimensional indices is either 1 (the minimum possible coordinate), or the maximum possible coordinate (which is the size of the array in the respective dimension).

Here is the same array with the elements which are "touching the edge" highlighted:

[[1, 3, 0],
 [2, 6, 7],
 [4, 0, 2],
 [0, 0, 0]]

The output could be anything like:

1 3 0 2 7 4 2 0 0 0

[1, 2, 4, 0, [0, 0, [2, 7, 0], [3]]]

[[[[[[4]]]]], [[[0, 0, 0, 0]]], [[2, 2]], [1, 7, 3]]

---

For the 1-dimensional array [3, 4, 9, 0, 0], the edges are [3, 4, 9, 0, 0], so the output is [3, 0].

---

For this 3-dimensional array:

[[[4, 0, 4, 1],
  [0, 0, 5, 8],
  [6, 0, 0, 0],
  [0, 3, 7, 0]],

 [[4, 9, 8, 5],
  [0, 6, 4, 0],
  [0, 0, 0, 3],
  [0, 9, 6, 1]],

 [[0, 4, 7, 9],
  [0, 2, 0, 6],
  [0, 0, 0, 0],
  [7, 0, 3, 0]],

 [[0, 5, 3, 5],
  [0, 0, 0, 0],
  [6, 5, 3, 0],
  [4, 6, 0, 8]]]

the edges are:

[[[4, 0, 4, 1],
  [0, 0, 5, 8],
  [6, 0, 0, 0],
  [0, 3, 7, 0]],

 [[4, 9, 8, 5],
  [0, 6, 4, 0],
  [0, 0, 0, 3],
  [0, 9, 6, 1]],

 [[0, 4, 7, 9],
  [0, 2, 0, 6],
  [0, 0, 0, 0],
  [7, 0, 3, 0]],

 [[0, 5, 3, 5],
  [0, 0, 0, 0],
  [6, 5, 3, 0],
  [4, 6, 0, 8]]]

The output is something like:

[4, 0, 4, 1, 0, 0, 5, 8, 6, 0, 0, 0, 0, 3, 7, 0, 4, 9, 8, 5, 0, 0, 0, 3, 0, 9, 6, 1, 0, 4, 7, 9, 0, 6, 0, 0, 7, 0, 3, 0, 0, 5, 3, 5, 0, 0, 0, 0, 6, 5, 3, 0, 4, 6, 0, 8]

Imagine each inner 2-dimensional array as a cross-section of a 3-dimensional box. The only elements which are not touching the edges are the ones on the inside of the box.

Note that arrays which have one of their dimensions as only 1, such as [4] or [[3, 6, 5]], may need to be treated with care. Their respective outputs should be [4] and [3, 6, 5].

Rules

• You do not need to handle empty arrays, e.g. [] or [[[], [], []], [[], [], []]]
• You may use any standard I/O method
• Standard loopholes are forbidden
• This is code-golf, so the shortest code in bytes wins

Answer 1

Python 2, 38 bytes

def f(a):a[1:-1]*=a>[f];map(f,a[1:-1])

Try it online!

Expects a nested list and removes all non surface elements inplace.

How?

a>[f] uses that in Python 2 every list is greater than every function is greater than every number to check whether a is a nested or flat list.

If nested the middle of a is multiplied by one, in other words, nothing changes. The recursion will then descend one level.

If flat the middle of a is multiplied by zero, in other words, excised. This will stop the recursion because map will run over an empty list.

Answer 2

J, ²⁵ 24 bytes

#~&,(<:0&e.@:|"1]#:i.)@$

Try it online!

• Create multidimensional indices for each element using mixed base binary
• Mod each of those by the (input dimensions- 1)
• Check if the multidimensional index has a 0. If so, keep that element. Otherwise, remove it.

Answer 3

Wolfram Language (Mathematica), 38 bytes

MapAt[#0,#,2;;-2]~Check~#/._MapAt->{}&

Try it online!

Replaces non-edge elements with {}.

Answer 4

JavaScript, 44 bytes

f=a=>a.at?[a.shift(),a.pop()??a,a.map(f)]:[]

f=a=>a.at?[a.shift(),a.pop()??a,a.map(f)]:[]

test = a => console.log(JSON.stringify(f(a)))
test([[[4, 0, 4, 1],
  [0, 0, 5, 8],
  [6, 0, 0, 0],
  [0, 3, 7, 0]],

 [[4, 9, 8, 5],
  [0, 6, 4, 0],
  [0, 0, 0, 3],
  [0, 9, 6, 1]],

 [[0, 4, 7, 9],
  [0, 2, 0, 6],
  [0, 0, 0, 0],
  [7, 0, 3, 0]],

 [[0, 5, 3, 5],
  [0, 0, 0, 0],
  [6, 5, 3, 0],
  [4, 6, 0, 8]]])
test([[1, 3, 0],
 [2, 6, 7],
 [4, 0, 2],
 [0, 0, 0]])
test([4])
test([[3, 6, 5]])

Answer 5

R, 60 59 bytes

Edit: -1 byte thanks to @Giuseppe.

\(a,i=which(a|1,T))a[i[apply(i,1,\(x)!all(x-1&x-dim(a))),]]

Attempt This Online!

Answer 6

Factor, 73 72 83 bytes

: f ( x -- ) dup real? [ drop ] [ 1 cut 1 short cut* rot append . [ f ] each ] if ;

Try it online!

Recursive function that (maybe) slices both ends off the input, prints them, then calls itself on all the remaining elements until an atom (real number) is reached. ((Now handles arrays with a single element properly at the cost of 11 bytes...))

Answer 7

APL (dzaima/APL), 20 bytes

⊢⌿⍥,⍨1∊¨⍳∘⍴∊¨¨∘⊂1,¨⍴

Try it online!

⍴ shape (length along each dimension) of the array

1,¨ prepend 1 to each

…∊¨¨∘⊂ for each of each of the following, is it a member of the corresponding element of that?

 ⍳∘⍴ the indices of an array of the shape of the argument

1∊¨ for each of those, is 1 a member?

…⌿⍥,⍨ use that flattened, to filter the flattened…

 ⊢ argument

Answer 8

BQN, 19 bytes^SBCS

1¨⌾⊏⟜⍉⟜⌽⍟=⍟2∘≠˜⥊⊸/⥊

1¨ one for each

⌾⊏ of the elements of the first major cells (n−1 dimensional sub-array)

⟜⍉ of the single-step-rotated-axes version

⟜⌽ of the reverse

⍟= done as many times as there are dimensions

⍟2 done twice

∘≠˜ of the self-inequality (an all-zero array of same shape)

⥊⊸/ when flattened, filters

⥊ the flattened argument

Run online!

Answer 9

Retina, 84 bytes

L`(?<=\[(\[(?(3)$)((])|(?<-3>\[)|\d|,)+)*)\d|\d(?=(((\[)|(?<-6>])|\d|,)+(?(6)^)])*])

Try it online! Outputs each edge element on its own line but link is to test suite that joins on commas for convenience. Explanation:

L`

List matches.

(?<=\[(\[(?(3)$)((])|(?<-3>\[)|\d|,)+)*)\d|

Similar to the following, but using a lookbehind to find whether the element is the first in any of its dimensions. Due to the way lookbehinds are evaluated, this version is harder to explain, so you'll just have to take my word for it that it's the mirror image of the following test.

\d(?=

Match a digit. In Retina 1 it's possible to use overlapping matches and captures to avoid using a lookahead but it costs 7 bytes to do that and you only save 4 so it's not worth it.

(((\[)|(?<-6>])|\d|,)+(?(6)^)

Match any number of brackets, digits, or commas, but there must be the same number of opening and closing brackets.

])*

Match the close bracket at the end of this subarray, thus considering the parent subarray. Go out as many dimensions as necessary.

])

Match an extra close bracket, showing that this element or one of its container subarrays was the last in its parent.

Replacing the L with ! results in a version that works in Retina 0.8.2 but in this case it's no longer possible to use the same test suite.

Answer 10

Python3, 95 bytes:

f=lambda x,t=0:[x]*t if x*0==0 else f(x[0],1)+[j for k in x[1:-1]if(j:=f(k,t or 0))]+f(x[-1],1)

Try it online!

Answer 11

Jelly,  12  11 bytes

ŒJ%þ`ṪỊ§TịF

A monadic Link that accepts a rectangular multi-dimensional list and yields the elements that are on its "surface".

Try it online!

How?

ŒJ%þ`ṪỊ§TịF - Link: rectangular multi-dimensional list, M
ŒJ          - multi-dimensional indices of M -> [[1,1,1,...],...,[height,width,depth,...]]
    `       - use as both arguments of:
   þ        -   make a table of:
  %         -     modulo (vectorises)
     Ṫ      - tail -> [...[x%height,y%width,z%depth,...]...]
      Ị     - abs(x)<=1? (vectorises)
       §    - sums (of those)
        T   - truthy indices (of that)
          F - flatten (M) (N.B. same order as the indices produced by ŒJ)
         ị  - index-into

Answer 12

05AB1E, 26 bytes

˜s"DdiëdƶZ%2‹εZ≠i®.V"©.V˜Ï

05AB1E is very verbose with recursive approaches, and it's also not too good in most matrix-based challenges, so the combination ends up as this horrendously long program (although can probably still be golfed a bit).

Try it online or verify all test cases.

Explanation:

˜            # Flatten the (implicit) multi-dimensional input-list
 s           # Swap to get the actual input again
  "..."      # Push the recursive string explained below
       ©     # Store it in variable `®` (without popping)
        .V   # Evaluate and execute it as 05AB1E code,
             # using the multi-dimensional list as argument
          ˜  # Flatten the result as well
           Ï # Keep all values of the flattened input at the truthy (==1) indices
             # (after which the result is output implicitly)

D            # Copy the current list or integer
 dië         # If it's a list:
  i          #  If
 d           #  the current value is truthy after a >=0 check:
             #  (only a non-negative integer would be truthy, and lists falsey)
             #   Do nothing
   ë         #  Else (it's a list):
    d        #   Transform each integer to a 1 with a >=0 check
     ƶ       #   Multiply each 1 by its 1-based index
      Z      #   Push the flattened maximum integer (without popping)
       %     #   Modulo
        2‹   #   Check which are smaller than 2 (first row=1s; last row=0s)
             #   (all first and last items are now 1s)
    ε        #   Then map over each inner list:
     Z       #    Push the flattened maximum (without popping)
      ≠i     #    If this maximum is NOT 1:
        ®.V  #     Do a recursive call with the current inner list