Rebuild a rectangular array from a corner

Question

I once had a beautiful rectangular array. It was very symmetrical, but unfortunately it has fallen apart and now I only have the top left corner. Your task will be to rebuild the original array.

Your program will receive a 2 dimensional array of integers. For ease of parsing, you may assume they are all between 1 and 9. Your task is to reverse the array's columns, its rows, and both, stitch together the resulting corners, and return the resulting array.

You can assume the array dimensions will be at least 1x1.

Test cases:

Input:
1 2 3
4 5 6
Output:
1 2 3 3 2 1
4 5 6 6 5 4
4 5 6 6 5 4
1 2 3 3 2 1

---

Input:
1
Output:
1 1
1 1

---

Input:
9
9
9
Output:
9 9
9 9
9 9
9 9
9 9
9 9

This is code-golf, fewest bytes wins!

• qqq: I'll bet charcoal can do this in under 10
• Pavel: @tbfninja chat.stackexchange.com/transcript/message/43184083#43184083 but could maybe be shorter with a different input format.
• Pavel: @MagicOctopusUrn yes
• Neil: @tfbninja WS⟦ι⟧‖M→↓ perhaps? 5 bytes to read the input and 4 to reflect it.
• Rod: I'm 99% sure that there is a lang that do this with ╬ (or some similar character) just can't remember which one :c

Answer 1

Canvas, 1 byte

╬

Try it here!

Outputs as a multiline string

• Magic Octopus Urn: Nice, @Rod called that one hah! Is this your language too Dzaima?
• totallyhuman: Damn... I should've remembered...
• ASCII-only: @MagicOctopusUrn Yeah, IIRC it's meant to basically be S.O.G.L. II: Electric Boogaloo?

Answer 2

Haskell, (削除) 25 (削除ここまで) 24 bytes

r=(++)<*>reverse
r.map r

Try it online!

Answer 3

Python 3, 38 bytes

lambda a:[b+b[::-1]for b in a+a[::-1]]

Try it online!

Takes a list of lists and returns a list of lists.

Explanation:

lambda a: # anonymous lambda function
 for b in a+a[::-1] # for each row in the array and the upside-down array
 b+b[::-1] # the row with its reverse appended
 [ ] # return in a list

Answer 4

Husk, (削除) 7 (削除ここまで) 6 bytes

Coincidentally, Erik had posted the exact same code in the Husk chatroom about a minute before I posted this.

!!oTS+↔

Try it online!

Pervious version, 7 bytes:

mS+↔S+↔

Answer 5

Retina, 13 bytes

\%`$
$^$`
Vs`

Try it online!

Explanation

\%`$
$^$`

On each line (%), match the end of the line ($), and insert the reverse ($^) of the entire line ($`) and print the result with a trailing linefeed (\). This does the reflection along the vertical axis and prints the first half of the output.

Vs`

This just reverses the entire string, which is equivalent to a 180° degree rotation, or in our case (due to the horizontal symmetry) a reflection along the horizontal axis. This way this works is that V's (reverse) default regex is (?m:^.*$), which normally matches each line of the string. However, we activate the singleline option s, which makes . match linefeeds as well and therefore this default regex actually matches the entire string.

The result of this is printed automatically at the end of the program, giving us the second half of the output.

• Pavel: This doesn't look like any regex flavor I know of :P
• Erik the Outgolfer: @Pavel Because Retina isn't just regex. :)
• Martin Ender: @Pavel the only part of that code that is an actual regex is the $ on the first line. ;) I'll add an explanation later.

Answer 6

05AB1E, 2 bytes

∞∊

Try it online!

---

 # Input:Array of String | ['12','34']
---#-----------------------+------------------------------------------
∞ # Mirror horizontally. | [12,34] -> [1221,3443]
 ∊ # Mirror vertically. | [1221,3443] -> [1221\n3443\n3443\n1221]

---

Credit for Mr. Xcoder pointing out that arrays of string may count as 2D arrays and Pavel for confirming it.

• Mr. Xcoder: ... 2 bytes
• Mr. Xcoder: For ease of parsing, you may assume they are all between 1 and 9 – So I think this is valid. Awaiting Pavel's confirmation, I guess
• Magic Octopus Urn: @Mr.Xcoder that was what I had initially, then the TIO 2D arrays as input was weird... so had to come up with that header stuff.
• Pavel: A string is an array of characters, so a list of strings is still a 2d array. @Mr.Xcoder's solution is valid.
• Magic Octopus Urn: Coolio, works for me.

Answer 7

MATL, 5 bytes

,tPv!

Try it online!

Explanation:

(implicit input)
, # do twice:
 t # dup top of stack
 P # flip vertically
 v # vertically concatenate
 ! # transpose
(implicit output)

Answer 8

Jelly, 5 bytes

m0ドルm0

Try it online!

• Pavel: Also 5 bytes: m0Z$+ (by Hyper Neutrino).

Answer 9

Japt, 6 bytes

mê1 ê1

Try it here

---

Explanation

 :Implicit input of 2D array
m :Map
 ê1 : Mirror sub array
 ê1 :Mirror main array

Answer 10

Octave, (削除) 33 (削除ここまで) 29 bytes

Thanks to @Giuseppe for golfing four bytes!

@(A)[B=[A;flip(A)] fliplr(B)]

Try it online!

• Giuseppe: 29 bytes

Answer 11

Ruby, 35 bytes

->a{r=->b{b+b.reverse}
r[a].map &r}

Try it online!

A lambda accepting a 2D array and returning a 2D array. It's straightforward, but here's the ungolfed version anyway:

->a{
 r=->b{ b+b.reverse } # r is a lambda that returns the argument and its reverse
 r[a].map &r # Add the array's reverse, then add each row's reverse
}

Answer 12

JavaScript (Node.js), (削除) 62 (削除ここまで) (削除) 55 (削除ここまで) (削除) 49 (削除ここまで) 46 bytes

A=>(j=x=>[...x,...[...x].reverse()])(A).map(j)

Try it online!

Because Array.prototype.reverse() reverses the array in place, I have to make a shallow copy somewhere first. A=>(j=x=>[...x,...x.reverse()])(A).map(j) does not work.

Answer 13

J, 12 bytes

(,|.)@,.|."1

Try it online!

Explanation

 |."1 - reverse each row
 ,. - and stitch them to the input
 ( )@ - and 
 ,|. - append the rows in reversed order 

Answer 14

awk, 88 bytes

{s="";for(i=NF;i>0;i--)s=" "$i s" "$i;a[FNR]=s;print s}END{for(i=NR;i>0;i--)print a[i]}

• hyperneutrino: Welcome to PPCG! Nice first answer :)

Answer 15

Uiua, 9 bytes

⍥(⍉⊂∶⇌.)2

Try it!

⍥(⍉⊂∶⇌.)2
⍥( )2 # run a function twice
 . # duplicate
 ⇌ # reverse
 ⊂∶ # prepend
 ⍉ # transpose

Answer 16

Triangularity, 31 bytes

...)...
..IEM..
.DRs+}.
DRs+...

Try it online!

Explanation

Removing the characters that make up for the padding, here is what the program does:

)IEMDRs+}DRs+ – Full program. Takes a matrix as a 2D list from STDIN.
) – Push a 0 onto the stack.
 I – Take the input at that index.
 E – Evaluate it.
 M } – For each row...
 DR – Duplicate and replace the second copy by its reverse.
 s+ – Swap and append.
 DR – Duplicate the result and replace the second copy by its reverse.
 s+ – Swap and append.

Answer 17

R, 57 bytes

function(m)rbind(N<-cbind(m,m[,ncol(m):1]),N[nrow(N):1,])

Try it online!

Answer 18

APL+WIN, 11 bytes

Prompts for a 2d array of integers.

m⍪⊖m←m,⌽m←⎕

Answer 19

Stax, 5 bytes

:mm:m

Run and debug it online

:m means mirror, which is input.concat(reverse(input)). m, in this context means output each line after applying...

So, mirror the array of rows, and then mirror each row and output.

Answer 20

Mathematica, 29 bytes

(g=#~Join~Reverse@#&)@*Map[g]

Try it online!

Answer 21

SOGL V0.12, 2 bytes

-1 byte thanks to dzaima.

╬ø

Try it here!

Answer 22

APL (Dyalog Classic), 7 bytes

⍪∘⊖⍨⊢,⌽

Try it online!

Answer 23

Java 8, (削除) 140 (削除ここまで) 131 bytes

m->{String r="";for(int a=m.length,b=m[0].length,i=a+a,j;i-->0;r+="\n")for(j=b+b;j-->0;)r+=m[i<a?i:a+a+~i][j<b?j:b+b+~j];return r;}

Explanation:

Try it online.

m->{ // Method with integer-matrix parameter and String return-type
 String r=""; // Result-String, starting empty
 for(int a=m.length, // Amount of rows of the input-matrix
 b=m[0].length, // Amount of columns of the input-matrix
 i=a+a,j; // Index integers
 i-->0; // Loop over double the rows
 r+="\n") // After every iteration: append a new-line to the result
 for(j=b+b;j-->0;) // Inner loop over double the columns
 r+= // Append the result with:
 m[i<a? // If `i` is smaller than the amount of rows
 i // Use `i` as index in the input-matrix
 : // Else:
 a+a+~i] // Use `a+a+i-1` as index instead
 [j<b? // If `j` is smaller than the amount of columns
 j // Use `j` as index in the input-matrix
 : // Else:
 b+b+~j]; // Use `b+b+j-1` as index instead
 return r;} // Return the result-String

Answer 24

J, 11 bytes

Anonymous tacit prefix function.

|:@(,|.)^:2

Try it online!

|: transpose

@(...) the result of:

, the argument followed by

|. its reverse

^:2 and all this done twice

Answer 25

SNOBOL4 (CSNOBOL4), (削除) 119 (削除ここまで) 113 bytes

	T =TABLE()
I	X =X + 1
	I =INPUT	:F(D)
	OUTPUT =T<X> =I REVERSE(I)	:(I)
D	X =X - 1
	OUTPUT =GT(X) T<X>	:S(D)
END	

Try it online!

Takes input as strings on STDIN, without spaces. This only works because the digits are 1-9 and would fail otherwise.

• Pavel: I can see why people don't use this language anymore. This is so weird.
• Giuseppe: @Pavel SNOBOL is truly a terrible language to work with. this is a more modern C implementation of it which has additional builtin functions like REVERSE; the original only supported integer arithmetic as well, as far as I can tell.

Answer 26

C (gcc), (削除) 114 (削除ここまで) 111 bytes

• Saved three bytes thanks to Kevin Cruijssen; inverting the loops.

j,i;f(A,w,h)int*A;{for(i=h+h;i-->0;puts(""))for(j=w+w;j-->0;)printf("%d,",A[(i<h?i:h+h+~i)*w+(j<w?j:w+w+~j)]);}

Try it online!

C (gcc), 109 bytes (abusing ease of parsing)

• Thanks to Kevin Cruijssen for suggesting to only allow one-digit input integers; saved two bytes.

j,i;f(A,w,h)int*A;{for(i=h+h;i-->0;puts(""))for(j=w+w;j-->0;)putchar(A[(i<h?i:h+h+~i)*w+(j<w?j:w+w+~j)]+48);}

Try it online!

• Kevin Cruijssen: You can save 3 bytes by inverting the loops. for(i=h+h;i-->0;puts(""))for(j=w+w;j-->0;)
• user77406: Does not fulfill spec; prints the array, rather than returning it.
• Kevin Cruijssen: "For ease of parsing, you may assume they are all between 1 and 9.", so you can remove the comma in the printf("%d" for an additional -1 byte.
• Jonathan Frech: @Rogem I would say printing the array falls under accepted i/o.
• Jonathan Frech: @KevinCruijssen Thanks a lot; using the ease of parsing I managed to shave off another byte.

Answer 27

Charcoal, 5 bytes

θ‖C→↓

Try it online!

Thanks to ASCII-only for a better input format.

• Erik the Outgolfer: I wonder if this input format is valid, since I'm afraid Charcoal can't handle input otherwise. If it isn't, I'll happily delete this answer.
• Pavel: This is valid I/o.
• Erik the Outgolfer: @Pavel I just wondered because you had said that "Your program will receive a 2 dimensional array of integers", while a string is 1-dimensional (and no, the outer [] don't exactly make it 2D).
• Neil: @ASCII-only Charcoal really needs a better I/O method...
• Erik the Outgolfer: @Neil He didn't get pinged here, but I pinged him over TNB. :)

Answer 28

Clojure, 56 bytes

(fn[i](map #(concat %(reverse %))(concat i(reverse i))))

Creates an anonymous function which takes the two dimensional list and returns the fixed rectangle as two dimensional list.

Try it online!

Answer 29

Add++, 30 bytes

D,f,@,bU€{r}B]{r}
D,r,@,dbR+

Try it online!

The footer simply transforms the nested array into the format in the question. Defines a function f, which expects a matrix (nested array) as an argument.

Answer 30

Proton, 29 bytes

a=>[b+b[by-1]for b:a+a[by-1]]

Try it online!

There are a few other interesting approaches though:

Proton, 29 bytes

a=>map(g,(g=x=>x+x[by-1])(a))

Try it online!

You can define the mirror sub-function g in-line, because Proton. It's not shorter though.

Proton, 36 bytes

(a=>[x[0]for x:zip(*(a+a[by-1]))])*2

Try it online!

This should be (a=>zip(*(a+a[by-1])))*2 which is 24 bytes, but the zip function is completely broken. Basically, you mirror it and zip, and then do that twice (you can multiply a function by a positive integer to apply the function multiple times).