4
\$\begingroup\$

Write a program which takes a 3x3 matrix on stdin and prints its transpose along the anti-diagonal to stdout. You may assume that all elements of the matrix will be integers. Columns are space-separated and rows are newline-separated.

Example

Input:

1 2 3
3 4 5
1 2 3

Output:

3 5 3
2 4 2
1 3 1

Input:

1 2 3
4 5 6
7 8 9

Output:

9 6 3
8 5 2
7 4 1
\$\endgroup\$
7
  • \$\begingroup\$ Your example output seems incorrect; it has only been transposed along the second diagonal. \$\endgroup\$ Mar 26, 2014 at 4:34
  • \$\begingroup\$ Also, what are the matrix elements? Digits? Positive integers? Any integers? Floats? Any strings? If numbers, is there an upper limit? \$\endgroup\$ Mar 26, 2014 at 4:36
  • \$\begingroup\$ @IlmariKaronen edited \$\endgroup\$ Mar 26, 2014 at 4:46
  • 1
    \$\begingroup\$ So, you're effectively saying that the matrix should be transposed twice along the first diagonal (once in step 1, then again in step 2) as well as along the second diagonal (in step 2)? That's the only way I can make sense of your example output. \$\endgroup\$ Mar 26, 2014 at 4:49
  • \$\begingroup\$ @IlmariKaronen well yes \$\endgroup\$ Mar 26, 2014 at 4:51

16 Answers 16

7
\$\begingroup\$

APL - 7

⌽⍉⌽3 3⍴

Example input:

⌽⍉⌽3 3⍴1 2 3 3 4 5 1 2 9
> 9 5 3
  2 4 2
  1 3 1

ngn APL demo

\$\endgroup\$
6
  • \$\begingroup\$ Could the downvoter please explain themself? Thanks. \$\endgroup\$
    – mniip
    Mar 26, 2014 at 6:57
  • \$\begingroup\$ God love APL. Nice solution! \$\endgroup\$
    – alvonellos
    Mar 28, 2014 at 3:49
  • \$\begingroup\$ @mniip ANy chance you can explain how this works? It's so... concise! I love it! \$\endgroup\$ Mar 28, 2014 at 6:17
  • \$\begingroup\$ 3 3⍴ converts input to a 3x3 matrix. reverses it along first dimension, transposes it, and then reverses it again. \$\endgroup\$
    – mniip
    Mar 28, 2014 at 17:14
  • 2
    \$\begingroup\$ Function (4 bytes in Dyalog Unicode): ⌽∘⍉⌽, Full program (4): ⌽⍉⌽⎕, Full program (8, raveled input): ⌽⍉⌽3 3⍴⎕. \$\endgroup\$ Jul 19, 2018 at 15:37
4
\$\begingroup\$

GolfScript, 18 / 15 / 11 chars

~]-1%3/zip{' '*n}%

This is the straightforward implementation, following pretty much the exact steps given in the question. There's a clever arithmetic trick one could use instead, but it turns out to need more characters.

Sample input:

1 2 3
3 4 5
1 2 9

Sample output:

9 5 3
2 4 2
1 3 1

Ps. If I can use the same output format as in ace's answer (i.e. extra with square brackets around each row), I can save three chars for a total of 15 chars:

~]-1%3/zip{`n}%

If a one-line output format like [[9 5 3] [2 4 2] [1 3 1]] is allowed, I can shrink that further to just 11 chars:

~]-1%3/zip`
\$\endgroup\$
4
  • \$\begingroup\$ If I understand your code correctly, I think you misinterpreted the question. For the matrix [[1,2,3],[4,5,6],[7,8,9]], your program should output [[9,6,3],[8,5,2],[7,4,1]], not [[3,6,9],[2,5,8],[1,4,7]]. \$\endgroup\$
    – user12205
    Mar 26, 2014 at 5:14
  • \$\begingroup\$ @ace: Yeah, I noticed that. Stupid symmetric example. Fixed. \$\endgroup\$ Mar 26, 2014 at 5:15
  • \$\begingroup\$ You may save one character in each of the first two cases if you include the newline in the map, e.g. {' '*n}%. \$\endgroup\$
    – Howard
    Mar 26, 2014 at 5:54
  • \$\begingroup\$ @Howard: Edited, thanks! That'll give me an extra blank line at the end of the output, but I suppose that's acceptable. \$\endgroup\$ Mar 26, 2014 at 5:56
4
\$\begingroup\$

Mathematica, 31 28 20 bytes

(r=Reverse)[r@#]&

The is Mathematica's transpose operator (which is displayed as a superscript T in Mathematica).

\$\endgroup\$
0
3
\$\begingroup\$

Sage, 39

Runs in the interactive prompt

matrix(input()[::-1]).transpose()[::-1]

Sample input:

[[1,2,3],[3,4,5],[1,2,3]]

Sample output:

[3 5 3]
[2 4 2]
[1 3 1]
\$\endgroup\$
3
\$\begingroup\$

J - 16 (?) char

Taking the 3x3 matrix as a grid from stdin, we get the 16 character:

|:&.|.".1!:1]3#1

This can be made shorter if the input is made more flexible, as in the Sage and APL answers:

|:&.|.".1!:1]1   NB. if stdin input form can be  1 2 3, 4 5 6,: 7 8 9
|:&.|.           NB. if used as an expression like the APL answer

The key is in the |:&.|. portion: this is what transposes the matrix. It reads Transpose (|:) Under (&.) Reverse (|.), meaning you reverse the matrix, transpose it, and then undo your initial reverse.

Demo:

   |:&.|.".1!:1]3#1          NB. three lines input, three output
1 2 3
4 5 6
7 8 9
9 6 3
8 5 2
7 4 1

   1 2 3,3 4 5,:1 2 9        NB. a matrix
1 2 3
3 4 5
1 2 9
  |:&.|. 1 2 3,3 4 5,:1 2 9  NB. the logic
9 5 3
2 4 2
1 3 1
\$\endgroup\$
2
\$\begingroup\$

K, 3/7/20(?) bytes

K is similar enough to APL that a character-for-character transliteration of @mniip's solution works:

|+|3 3#

In action:

  |+|3 3#1 2 3 3 4 5 1 2 9
(9 5 3
 2 4 2
 1 3 1)

This behaves identically, modulo the way output is prettyprinted. However, I should note that neither this solution nor the solution it is based on actually operate on stdin/stdout. To implement this as per a stricter interpretation of the spec in Kona-compatible K3 it's necessary to use 0: and jump through some hoops:

`0:,/'2$|+|3 3#. 0:`

Write to stdout (`0:) the join over each (,/') of the two-wide string format (2$) of the anti-diagonal transpose (|+|) of the 3x3 reshape (3 3#) of the eval (.) of stdin (0:`).

In action:

indigo:kona je$ ./k antidiag.k 
K Console - Enter \ for help

  1 2 3 3 4 5 1 2 9
 9 5 3
 2 4 2
 1 3 1

There's a pretty good reason that APL-family programmers tend to avoid problems that force the use of stdin/stdout. Arguably, with flexible IO requirements, this could be solved with simply |+|:

  |+|(1 2 3;3 4 5;1 2 9)
(9 5 3
 2 4 2
 1 3 1)
\$\endgroup\$
2
\$\begingroup\$

MATLAB, 15 bytes

Rotate the matrix 180 degrees, and transpose it. This takes the input where columns are space separated and rows are newline separated. Outputs on the same format.

@(A)rot90(A,2)'

ans([1 2 3
4 5 6
7 8 9])

ans =

     9     6     3
     8     5     2
     7     4     1
\$\endgroup\$
1
\$\begingroup\$

R, 78

write.table(matrix(rev(unlist(strsplit(readLines(),' '),' ')),3),qu=F,r=F,c=F)
# Copy and paste the input
# If the prompt is not on a new line, press `enter` after the last line
# Type `Ctrl+D`

I discovered the rev() function on SO, it helped me to understand than the transformation is just reversing the input and putting it in the matrix from top to bottom, and left to right.

I also discovered that the argument row.names=T (T for true) can be shortened to r=T, saving 16 chars.

Explanations:

  • readLines() reads STDIN and return a vector with 3 elements (each one is a string)
  • strsplit() splits the strings in the vector by using space as a separator
  • unlist() makes a flat list from a vector
  • rev() puts the list in reverse order
  • matrix([list], 3) creates a matrix from the list, the argument 3 indicates that there is 3 elements per row
  • write.table([matrix], qu=F, r=F, c=F) prints the matrix without quotes, rows and columns labels
\$\endgroup\$
1
\$\begingroup\$

TI-BASIC, 50

Input A:rowSwap(A,1,dim(A
AnsT→A:rowSwap(A,1,dim(A
\$\endgroup\$
2
  • \$\begingroup\$ This will throw an error when you try to store a matrix to the real variable A. \$\endgroup\$
    – lirtosiast
    May 17, 2015 at 4:37
  • \$\begingroup\$ In addition, it doesn't take input in the right format, which should be space-separated numbers. \$\endgroup\$
    – lirtosiast
    May 17, 2015 at 4:44
1
\$\begingroup\$

CJam, 13 bytes

q~]W%3/zSf*N*

Test it here.

CJam is newer than this challenge. This solution is very similar to the GolfScript one.

Explanation

q~   e# Read input and evaluate, pushing all 9 numbers on the stack.
]    e# Wrap them in an array.
W%   e# Reverse it - this performs a 180° rotation.
3/   e# Split into rows of length 3.
z    e# Transpose.
Sf*  e# Join integers in each row with spaces.
N*   e# Join the rows with linefeeds.

If there was no constraint on 3x3 inputs, we could either compute the line width with a square root:

q~]W%_,mQ/zSf*N*

Or we could perform the anti-diagonal transpose as vertical flip, transpose, vertical flip (like my Mathematica answer does):

qN/Sf/W%zW%Sf*N*

In either case, we'd have 16 bytes.

\$\endgroup\$
1
\$\begingroup\$

R, 37 bytes

write(scan()[rep(9:7,e=3)-3*0:2],1,3)

Try it online!

Simply changes the order of the elements of the input vector.

Well, actually a basic approach is shorter:

R, 35 bytes

write(matrix(rev(scan()),3,,T),1,3)

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Jelly, 3 bytes

ṚZṚ

Try it online!

Uses Python list format for I/O.

\$\endgroup\$
1
\$\begingroup\$

Vyxal, 4 bytes

RÞTR

Try it Online!

R    # Vectorised reverse
 ÞT  # Transpose
   R # Vectorised reverse
\$\endgroup\$
1
\$\begingroup\$

Japt, 3 bytes

yÔÔ

Try it

yÔÔ     :Implicit input of 2D array
y       :Transpose
 Ô      :Reverse rows
  Ô     :Reverse array
\$\endgroup\$
1
\$\begingroup\$

Factor + math.matrices, 27 bytes

[ anti-flip simple-table. ]

anti-flip postdates build 1525, the one TIO uses, so here's a picture of running this in Factor's REPL:

enter image description here

Note that in a standard output context, simple-table. outputs its elements with spaces in between. In the REPL, it's a little fancier.

\$\endgroup\$
1
\$\begingroup\$

05AB1E, 7 (or 3) bytes

|€#øRí»

Try it online.

With less strict I/O rules it would be 3 bytes instead, with I/O being a 3x3 matrix of integers:

øRí

Try it online.

Explanation:

         #  e.g. input = "1 2 3\n4 5 6\n7 8 9"
|        # Take all input-lines as a list of strings
         #  STACK: ["1 2 3","4 5 6","7 8 9"]
 €#      # Split each line by spaces
         #  STACK: [["1","2","3"],["4","5","6"],["7","8","9"]]
   ø     # Zip the matrix, swapping rows with columns
         #  STACK: [["1","4","7"],["2","5","8"],["3","6","9"]]
    R    # Reverse the order of rows in the matrix
         #  STACK: [["3","6","9"],["2","5","8"],["1","4","7"]]
     í   # Reverse each row of the matrix
         #  STACK: [["9","6","3"],["8","5","2"],["7","4","1"]]
      »  # Join each row by spaces, and then everything by newlines
         #  STACK: "9 6 3\n8 5 2\n7 4 1"
         # (after which it is output implicitly)

Here some alternatives with different order of operations:

øíR
Ríø
íRø
íøí
RøR
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.