# paulfioravanti's solution

## to Transpose in the Elixir Track

Published at Aug 11 2019 · 0 comments
Instructions
Test suite
Solution

Given an input text output it transposed.

Roughly explained, the transpose of a matrix:

``````ABC
DEF
``````

is given by:

``````AD
BE
CF
``````

Rows become columns and columns become rows. See https://en.wikipedia.org/wiki/Transpose.

If the input has rows of different lengths, this is to be solved as follows:

• Pad to the left with spaces.
• Don't pad to the right.

Therefore, transposing this matrix:

``````ABC
DE
``````

results in:

``````AD
BE
C
``````

And transposing:

``````AB
DEF
``````

results in:

``````AD
BE
F
``````

In general, all characters from the input should also be present in the transposed output. That means that if a column in the input text contains only spaces on its bottom-most row(s), the corresponding output row should contain the spaces in its right-most column(s).

## Running tests

Execute the tests with:

``````\$ mix test
``````

### Pending tests

In the test suites, all but the first test have been skipped.

Once you get a test passing, you can unskip the next one by commenting out the relevant `@tag :pending` with a `#` symbol.

For example:

``````# @tag :pending
test "shouting" do
assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
end
``````

Or, you can enable all the tests by commenting out the `ExUnit.configure` line in the test suite.

``````# ExUnit.configure exclude: :pending, trace: true
``````

If you're stuck on something, it may help to look at some of the available resources out there where answers might be found.

## Source

Reddit r/dailyprogrammer challenge #270 [Easy]. https://www.reddit.com/r/dailyprogrammer/comments/4msu2x/challenge_270_easy_transpose_the_input_text

## Submitting Incomplete Solutions

It's possible to submit an incomplete solution so you can see how others have completed the exercise.

### test_helper.exs

``````ExUnit.start()
ExUnit.configure(exclude: :pending, trace: true)``````

### transpose_test.exs

``````defmodule TransposeTest do
use ExUnit.Case

test "empty string" do
input = ""
expected = ""

assert Transpose.transpose(input) == expected
end

@tag :pending
test "two characters in a row" do
input = "AB"
expected = "A\n" <> "B"

assert Transpose.transpose(input) == expected
end

@tag :pending
test "two characters in one column" do
input = "A\n" <> "B"

expected = "AB"

assert Transpose.transpose(input) == expected
end

@tag :pending
test "single line" do
input = "Single line."

expected =
"S\n" <>
"i\n" <>
"n\n" <> "g\n" <> "l\n" <> "e\n" <> " \n" <> "l\n" <> "i\n" <> "n\n" <> "e\n" <> "."

assert Transpose.transpose(input) == expected
end

@tag :pending
test "first line longer than second line" do
input = "The fourth line.\n" <> "The fifth line."

expected =
"TT\n" <>
"hh\n" <>
"ee\n" <>
"  \n" <>
"ff\n" <>
"oi\n" <>
"uf\n" <>
"rt\n" <> "th\n" <> "h \n" <> " l\n" <> "li\n" <> "in\n" <> "ne\n" <> "e.\n" <> "."

assert Transpose.transpose(input) == expected
end

@tag :pending
test "second line longer than first line" do
input = "The first line.\n" <> "The second line."

expected =
"TT\n" <>
"hh\n" <>
"ee\n" <>
"  \n" <>
"fs\n" <>
"ie\n" <>
"rc\n" <>
"so\n" <> "tn\n" <> " d\n" <> "l \n" <> "il\n" <> "ni\n" <> "en\n" <> ".e\n" <> " ."

assert Transpose.transpose(input) == expected
end

@tag :pending
test "square" do
matrix = "HEART\n" <> "EMBER\n" <> "ABUSE\n" <> "RESIN\n" <> "TREND"

expected = "HEART\n" <> "EMBER\n" <> "ABUSE\n" <> "RESIN\n" <> "TREND"

assert Transpose.transpose(matrix) == expected
end

@tag :pending
test "rectangle" do
matrix = "FRACTURE\n" <> "OUTLINED\n" <> "BLOOMING\n" <> "SEPTETTE"

expected =
"FOBS\n" <> "RULE\n" <> "ATOP\n" <> "CLOT\n" <> "TIME\n" <> "UNIT\n" <> "RENT\n" <> "EDGE"

assert Transpose.transpose(matrix) == expected
end

@tag :pending
test "triangle" do
matrix = "T\n" <> "EE\n" <> "AAA\n" <> "SSSS\n" <> "EEEEE\n" <> "RRRRRR"

expected = "TEASER\n" <> " EASER\n" <> "  ASER\n" <> "   SER\n" <> "    ER\n" <> "     R"

assert Transpose.transpose(matrix) == expected
end

@tag :pending
test "many lines" do
matrix =
"Chor. Two households, both alike in dignity,\n" <>
"In fair Verona, where we lay our scene,\n" <>
"From ancient grudge break to new mutiny,\n" <>
"Where civil blood makes civil hands unclean.\n" <>
"From forth the fatal loins of these two foes\n" <>
"A pair of star-cross'd lovers take their life;\n" <>
"Doth with their death bury their parents' strife.\n" <>
"The fearful passage of their death-mark'd love,\n" <>
"And the continuance of their parents' rage,\n" <>
"Which, but their children's end, naught could remove,\n" <>
"Is now the two hours' traffic of our stage;\n" <>
"The which if you with patient ears attend,\n" <>
"What here shall miss, our toil shall strive to mend."

expected =
"CIFWFAWDTAWITW\n" <>
"hnrhr hohnhshh\n" <>
"o oeopotedi ea\n" <>
"rfmrmash  cn t\n" <>
".a e ie fthow \n" <>
" ia fr weh,whh\n" <>
"Trnco miae  ie\n" <>
"w ciroitr btcr\n" <>
"oVivtfshfcuhhe\n" <>
" eeih a uote  \n" <>
"hrnl sdtln  is\n" <>
"oot ttvh tttfh\n" <>
"un bhaeepihw a\n" <>
"saglernianeoyl\n" <>
"e,ro -trsui ol\n" <>
"h uofcu sarhu \n" <>
"owddarrdan o m\n" <>
"lhg to'egccuwi\n" <>
"deemasdaeehris\n" <>
"sr als t  ists\n" <>
",ebk 'phool'h,\n" <>
"  reldi ffd   \n" <>
"bweso tb  rtpo\n" <>
"oea ileutterau\n" <>
"t kcnoorhhnatr\n" <>
"hl isvuyee'fi \n" <>
" atv es iisfet\n" <>
"ayoior trr ino\n" <>
"l  lfsoh  ecti\n" <>
"ion   vedpn  l\n" <>
"erwaharrar,fas\n" <>
"   nekt te  rh\n" <>
"ismdsehphnnosa\n" <>
"ncuse ra-tau l\n" <>
" et  tormsural\n" <>
"dniuthwea'g t \n" <>
"iennwesnr hsts\n" <>
"g,ycoi tkrttet\n" <>
"n ,l r s'a anr\n" <>
"i  ef  'dgcgdi\n" <>
"t  aol   eoe,v\n" <>
"y  nei sl,u; e\n" <>
",  .sf to l   \n" <>
"     e rv d  t\n" <>
"     ; ie    o\n" <>
"       f, r   \n" <>
"       e  e  m\n" <>
"       .  m  e\n" <>
"          o  n\n" <> "          v  d\n" <> "          e  .\n" <> "          ,"

assert Transpose.transpose(matrix) == expected
end
end``````
``````defmodule Transpose do
@doc """
Given an input text, output it transposed.

Rows become columns and columns become rows. See https://en.wikipedia.org/wiki/Transpose.

If the input has rows of different lengths, this is to be solved as follows:
* Pad to the left with spaces.
* Don't pad to the right.

## Examples
iex> Transpose.transpose("ABC\nDE")

iex> Transpose.transpose("AB\nDEF")
"""

@spec transpose(String.t()) :: String.t()
def transpose(""), do: ""

def transpose(input) do
rows = String.split(input, "\n")
max_row_width = max_row_width(rows)

rows
|> transpose_rows()
|> Enum.join("\n")
|> String.trim_trailing()
end

defp max_row_width(rows) do
rows
|> Enum.map(&String.length/1)
|> Enum.max()
end

row
|> String.codepoints()
end

defp transpose_rows(rows) do
rows
|> Enum.zip()
|> Enum.map(&Tuple.to_list/1)
end
end``````