Perfect Squares Without Borders

Question

Given n=m^2, return a list of integers that do not border the m x m grid of integers from 1 to n.

Examples

n=1 (m=1)

Grid:

[1]

Return:

[]

n=4 (m=2)

Grid:

[1,2]
[3,4]

Return:

[]

n=9 (m=3)

Grid:

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

Return:

[5]

n=16 (m=4)

Grid:

[ 1, 2, 3, 4]
[ 5, 6, 7, 8]
[ 9,10,11,12]
[13,14,15,16]

Return:

[6,7,10,11]

---

For higher values of m, this answer does a great visualization.

---

Rules:

• You may take in either m or n (where n = m*m).
  • If taking in n you are allowed to have undefined behavior where there exists no m for n (E.G. 15).
  • n > 0, m > 0: Both must be integer values.
• The output may be as a 1D/2D array, matrix or whitespace delimited
• The output must be in order from least to greatest.
  • If outputting as a matrix this means it must be as it would be in the grid.
• This is code-golf, lowest byte-count wins.

Answer 1

C, 50 bytes

i;f(m){for(i=m;++i<m*m-m;)i%m>1&&printf("%d ",i);}

Try it online!

Answer 2

Octave, 31 bytes

@(m)vec2mat(1:m*m,m--)(2:m,2:m)

Returns a matrix.

Try it online!

Answer 3

Octave, 26 bytes

@(m)find((t=[0:m-2 0])'*t)

The code defines an anonymous function that inputs m and outputs a (possibly empty) column vector.

Try it online!

Explanation

@(m)                          % Define anonymous function of m
          t=[0:m-2 0]         % Build row vector [0 1 2 ... m-2 0] and assign it
                              % to variable t
         (           )'       % Complex-conjugate transpose into a column vector
                       *t     % Matrix-multiply that column vector times the row
                              % vector t. This gives an m×m matrix with zeros in
                              % the border and nonzeros in the other entries.
    find(                )    % Linear indices of nonzero entries. The result is
                              % in increasing order

Answer 4

Jelly, 8 bytes

’Ṗ×+€ṖḊ€

A monadic link taking m and returning a list of lists (the inner rows).

Try it online!

How?

’Ṗ×+€ṖḊ€ - Link m                    e.g. 5
’        - decrement                      4
 Ṗ       - pop (implicit range of input)  [1,2,3]
  ×      - multiply by m                  [5,10,15]
     Ṗ   - pop m                          [1,2,3,4]
   +€    - add €ach                       [[6,7,8,9],[11,12,13,14],[16,17,18,19]]
      Ḋ€ - dequeue €ach                   [[7,8,9],[12,13,14],[17,18,19]]

Answer 5

Haskell, 31 bytes

f m=[i|i<-[m..m*m-m],mod i m>1]

Try it online!

Math version:

f(m) = {i : i ∈ (m, m² - m), i mod m < 1}

:P

Answer 6

R, 44 43 32 bytes

function(n)(x=n:(n^2-n))[x%%n>1]

Try it online!

Returns a vector.

Answer 7

Pure Bash, 49

The boring answer:

for((i=$1;i++<$1*$1-$1;));{ ((i%$1>1))&&echo $i;}

Try it online.

---

Or the interesting answer for 52:

(($1>2))&&eval echo \$[$1*{1..$[$1-2]}+{2..$[$1-1]}]

Try it online.

Answer 8

Jelly, 8 bytes

sƽḊṖ$⁺€

Try it online!

Answer 9

Proton, 28 bytes

k=>filter(u=>1<u%k,k..k*~-k)

Try it online!

Takes m as input.

How?

Filters the integers in [k, k²-k) that, when divided by k, yield a remainder higher than 1. This ensures that both ends are trimmed, because the first one yields 0 and the last one yields 1. It is also guaranteed to return a higher value for any valid integer, because they are consecutive.

Answer 10

Wolfram Language (Mathematica), 31 bytes

Table[# i+j+1,{i,#-2},{j,#-2}]&

Try it online!

Answer 11

05AB1E, 9 bytes

LItä¦¨ε¦¨

Try it online!

Answer 12

Bash + GNU utilities, 35

seq $1 $[$1*$1-$1]|sed 1~$1d\;2~$1d

Try it online.

Answer 13

J, 23 19 bytes

-4 bytes thanks to FrownyFrog!

1 1}:@}.-@%:}:\1+i.

Try it online!

My original olution:

J, 23 bytes

[:|:@}:@}.^:2-@%:]\1+i.

Takes n as input, returns a matrix

How it works

1+i. - generates a list 1..n

-@%: - finds the square root of n and negates it (m)

]\ - makes a table (matrix) m x m from the list

^:2 - do the following twice:

|:@}:@}. - drop the first row, then drop the last row, then transpose

[: - cap the fork

Try it online!

Answer 14

Python 2, 44 bytes

lambda t:[k for k in range(t,~-t*t)if k%t>1]

Try it online!

I promise this is my last answer (to this challenge) today. Takes m as input.

Answer 15

Julia 0.6, 36 bytes

m->reshape(1:m*m,(m,m))[2:m-1,2:m-1]

Try it online!

Answer 16

Ruby, 32 bytes

->m{(m..m*m-m).reject{|e|e%m<2}}

Takes m, returns a one-dimensional array.

Try it online!

Answer 17

MATL, 8 bytes

:G\1>&*f

Input is m. Output is the numbers in increasing order.

Try it online!

Explanation

Consider input 4 as an example.

:     % Implicit input: m. Push range [1 2 ... m-1 m]
      % STACK: [1 2 3 4]
G\    % Modulo m, element-wise
      % STACK: [1 2 3 0]
1>    % Greater than 1, element-wise.
      % STACK: [0 1 1 0]
&*    % Matrix of pair-wise products
      % STACK: [0 0 0 0;
                0 1 1 0;
                0 1 1 0;
                0 0 0 0]
f     % Column vector of linear indices of nonzeros. Implicit display
      % STACK: [ 6;
                 7;
                10;
                11]

Answer 18

APL (Dyalog Classic), 14 bytes

1+⊢⊥¨∘⍳2⍴0⌈-∘2

Try it online!

Answer 19

Japt, 14 bytes

²õ òU ÅkJ ®ÅkJ

Takes m as input

Explanation

 ²õ òU ÅkJ ®ÅkJ                                      
                // U = input                         | 3
U²              // U squared                         | 9
  õ             // Range [1...U²]                    | [1,2,3,4,5,6,7,8,9]
    òU          // Cut into slices of U              | [[1,2,3],[4,5,6],[7,8,9]]
       Å        // Remove the first item             | [[4,5,6],[7,8,9]]
        kJ      // Remove the last item              | [[4,5,6]]
           ®    // Map:                              |
            ÅkJ //   Remove the first and last items | 5     

Try it online!

---

The solution that takes n is also 14 bytes:

õ òU¬ ÅkJ ®ÅkJ

Try it online!

Answer 20

Batch, 85 bytes

@for /l %%i in (3,1,%1)do @for /l %%j in (3,1,%1)do @cmd/cset/a(%%i-2)*%1+%%j-1&echo(

I can't easily loop from 2 to m-1 so I loop from 3 to m and adjust in the calculation.

Answer 21

Pari/GP, 26 bytes

n->[x|x<-[n..n^2-n],x%n>1]

Try it online!

Answer 22

Japt, 12 bytes

I spent so long golfing the extraction of elements that I ran out of time to golf the array generation. I'm also only now noticing that we can take n as input instead so I may be able to save something there. To be revisited ...

òUnU²)òU m¤c

Try it

---

Explanation

                 :Implicit input of integer U=m     :e.g., 4
   U²            :U squared                         :16
 Un              :Minus U                           :12
ò                :Range [U,U**2-U]                  :[4,5,6,7,8,9,10,11,12]
      òU         :Partitions of length U            :[[4,5,6,7],[8,9,10,11],[12]]
         m       :Map
          ¤      :  Remove first 2 elements         :[[6,7],[10,11],[]]
           c     :Flatten                           :[6,7,10,11]

Answer 23

Husk, 9 bytes

‼ȯTthS↑CN

Try it online!

Explanation

‼ȯTthS↑CN  Implicit input, say m=4.
       CN  Cut the natural numbers by m: [[1,2,3,4],[5,6,7,8],[9,10,11,12],..
     S↑    Take first m lists: [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
‼ȯ         Do this twice:
    h       Remove last row,
   t        remove first row,
  T         transpose.
           Result is [[6,7],[10,11]]; print it implicitly.

Answer 24

TI-BASIC, 44 43 bytes (tokenized)

DC 4D 3F CE 4D 6D 32 3F CF 3F DE 2A 08 09 3F D0 3F 4D 71 32 3F 23 4D 70 32 70 58 70 32 B1 58 83 72 11 2B 58 2B 30 2B 72 0D 71 31

Readable version:

:Input M
:If M≤2
:Then
:Disp "{}
:Else
:M-2
:seq(M+2+X+2int(X/Ans),X,0,Ans²-1

---

It was unfortunately necessary to print empty lists manually since TI-BASIC does not normally allow that. If m were given greater than two, the code could be reduced to just 29 bytes.

Answer 25

Pyth, 10 bytes

mtPdtPcQS*

Try it here!

Takes m as input.

Answer 26

Java 8, 241 183 170 162 160 132 122 bytes

j->{if(j<3)return new int[1];int e[]=new int[j*j-4*j+4],x=0,i=0;for(;++i<=j*j;)if(!(i<j|i>j*j-j|i%j<2))e[x++]=i;return e;}

Try it online!

Java makes it very tough(lots of bytes) when you have to create an array of somewhat "unknown" size.

• -8 bytes thanks to Magic Octopus Urn
• -28 bytes thanks to Mr. Xcoder
• -10 bytes thanks to Kevin Cruijssen

Answer 27

Red, 63 62 bytes

f: func[n][repeat i(n - 2 * n)[if(a: n + i)// n > 1[print a]]]

Try it online!

This is a Red port of totallyhuman's Haskell / Mr. Xcoder's Python 2 solution

Answer 28

Javascript (63 55 bytes)

m=>[...Array((m-2)*m)].map((x,i)=>i+m).filter(x=>x%m>1)

Explanation

m =>                    // function signature is m
    [...Array((m-2)*m)] // create an array of size m^2 - 2m,
                        // m^2 is the full array size, taking out 2m removes the top and bottom edges
                        // filled with undefined
    .map((x,i)=>i+m)    // fill with values m to n-m
                        // (skips the top and bottom edges of the square)
    .filter(x=>x%m>1)   // filter out x%m < 2, the left and right sides of the square

Answer 29

Pyt, 13 bytes

ĐĐ⁻⁻ř*⇹⁻⁻ř⁺ɐ+

Port of Jonathan Allan's Jelly answer

Explanation:

                    Implicit input (takes m)
ĐĐ                  Triplicate the input (push it on the stack two more times)
  ⁻⁻                Decrement top of stack twice
    ř               Push [1,2,...,m-2]
     *              Multiplies by m
      ⇹             Swaps top two items on stack
       ⁻⁻           Decrement (m-2 is now on top)
         ř          Push [1,2,...,m-2]
          ⁺         Increment each element by 1
           ɐ+       Add [2,3,...,m-1] to each element of [m,2m,...,m(m-2)]
                    Implicit print

Try it online!

Answer 30

Perl, 30 29 bytes

perl -E 'say$_+=@a+2for(@a=2..~-<>)x@a' <<< 4

Answer 31

JavaScript, 47 bytes

  m=>{for(i=m;++i<m*m-m;)if(i%m>1)console.log(i)} // here's the 47-byte script

Also, 49 bytes:

  m=>{for(i=m;(i%m>1&&console.log(i))|++i<m*m-m;);} // here's the 49-byte script

Answer 32

Clean, 45 bytes

import StdEnv
$m=[i\\i<-[m..m*m-m]|i rem m>1]

Try it online!

This is just totallyhuman's Haskell answer but in Clean.

Answer 33

Python, 111 bytes

def f(s):
 r=[]
 for i in[i[1:-1]for i in[[(j*s)+i+1 for i in range(s)]for j in range(s)][1:-1]]:r+=i
 return r

Answer 34

APL, 28 Bytes

Will run given value for m

1 1↓¯1 ¯1↓m m⍴⍳m*2

Try it...

Explanation

m*2 squares m

⍳m*2 gets list from 1 to m*2

m m⍴⍳m*2 wraps list to m by m matrix

¯1 ¯1↓m m⍴⍳m*2 drops -last row an column

1 1↓¯1 ¯1↓m m⍴⍳m*2 drops first row and column