what editor/IDE setup are you using?
also, in this particular case, how would the trailing whitespace characters affect your parsing of the input string?
stevensonmt
0
IloSophiep
I’m using VS Code. My test case looks / looked like this:
test "parse_stacks 1b" do
input = """
[D]
[N] [C]
[Z] [M] [P]
1 2 3
"""
actual = Day.parse_stacks(input)
expected = [
["N", "Z"],
["D", "C", "M"],
["P"]
]
assert actual == expected
end
and my implementation is
def parse_stacks(input) do
input
|> String.split("\n", trim: true)
|> Enum.reverse()
|> Enum.drop(1)
|> Enum.map(&String.graphemes/1)
|> Enum.map(&Enum.chunk_every(&1, 4))
|> Enum.map(&Enum.map(&1, fn chunks -> Enum.join(chunks) end))
|> Enum.zip()
|> Enum.map(&Tuple.to_list/1)
|> Enum.map(&Enum.reverse/1)
|> Enum.map(&to_proper_names/1)
|> dbg()
end
as you can see i placed a dbg there for now to show where the problem is because when zipping it’s missing the last stack because the lists do not have enough elements:
input #=> " [D]\n[N] [C]\n[Z] [M] [P]\n 1 2 3\n"
|> String.split("\n", trim: true) #=> [" [D]", "[N] [C]", "[Z] [M] [P]", " 1 2 3"]
|> Enum.reverse() #=> [" 1 2 3", "[Z] [M] [P]", "[N] [C]", " [D]"]
|> Enum.drop(1) #=> ["[Z] [M] [P]", "[N] [C]", " [D]"]
|> Enum.map(&String.graphemes/1) #=> [
["[", "Z", "]", " ", "[", "M", "]", " ", "[", "P", "]"],
["[", "N", "]", " ", "[", "C", "]"],
[" ", " ", " ", " ", "[", "D", "]"]
]
|> Enum.map(&Enum.chunk_every(&1, 4)) #=> [
[["[", "Z", "]", " "], ["[", "M", "]", " "], ["[", "P", "]"]],
[["[", "N", "]", " "], ["[", "C", "]"]],
[[" ", " ", " ", " "], ["[", "D", "]"]]
]
|> Enum.map(&Enum.map(&1, fn chunks -> Enum.join(chunks) end)) #=> [["[Z] ", "[M] ", "[P]"], ["[N] ", "[C]"], [" ", "[D]"]]
|> Enum.zip() #=> [{"[Z] ", "[N] ", " "}, {"[M] ", "[C]", "[D]"}]
|> Enum.map(&Tuple.to_list/1) #=> [["[Z] ", "[N] ", " "], ["[M] ", "[C]", "[D]"]]
|> Enum.map(&Enum.reverse/1) #=> [[" ", "[N] ", "[Z] "], ["[D]", "[C]", "[M] "]]
|> Enum.map(&to_proper_names/1) #=> [["N", "Z"], ["D", "C", "M"]]
(And thanks for the help 
!)
0
mudasobwa
Creator of Cure
Technically, once we know the length is 3, we might do
Enum.reduce(input, ..., fn
<<?[, c1, ?], ?\s, ?[, c2, ?], ?\s, ?[, c3, ?]>> -> [c1, c2, c3]
end)
This might be generated, and it might be generated for different numbers of crates (say, up to 10 plus a slow fallback with String.split/2.)
0
stevensonmt
Yeah, that’s basically how I did it with Enum.take_every(4). Not sure if that addresses the issue @IloSophiep is having. I think the issue they are having has to do with the Enum.chunk_every(&1, 4) call. If instead they used Enum.drop(&1, 1) |> Enum.take_every(4) without the join, then I think the zip would be accurate.
0
IloSophiep
I tried to change my code to use what you suggested, but even then i get to the point where my list for the stacks end up with different sizes. Basically i end up with
after_take_every = [["Z", "M", "P"], ["N", "C"], ["", "D"]]
instead of
after_take_every = [["Z", "M", "P"], ["N", "C", ""], ["", "D", ""]]
so my `Enum.zip/1) leaves out the last stack, because my input string does not have the trailing whitespaces. My workaround was writing
input =
"" <>
" [D] \n" <>
"[N] [C] \n" <>
"[Z] [M] [P]\n" <>
" 1 2 3 \n"
and it works.. - i just figured there might be some smart way that i’m missing.
0
stevensonmt
Yeah, I don’t guess there’s a better way to handle that. I don’t use VSCode but it seems likely that there is some autoformat setting that is removing trailing whitespace.
0
stefanluptak
Parsing the stacks/crates was the difficult part here. I was sure that I will find out here that there’s some clever solution for that, but it looks like there’s not. 
I used something like this to get a crate from a line for a specific stack:
grapheme_position = fn
1 -> 1
pos -> (pos - 1) * 4 + 1
end
grapheme_position = grapheme_position.(stack_index)
crate = String.at(line, grapheme_position)
0
bmitc
If you are using the ElixirLS extension, it might be the Elixir formatter removing the spaces. But VS Code may be doing it as well, although I would have guessed that this is a setting that needs to be opted into.
I personally just hand coded the stacks part of the input, as I didn’t have the patience to parse such a poor format. I hope it’s not a sign of things to come where parsing gets more and more annoying. In this case, the stacks could have been listed horizontally instead.
0
dams
Attempt at a compact but straightforward code. Parsing included 
defmodule Day5 do
def run(callback) do
# split the input in the lines for the initial state, and the moves
[state_str, moves_str] = File.read!("input") |> String.split("\n\n", trim: true)
# split the lines for the initial state stacks, drop the last one
state_lines = state_str |> String.split("\n") |> Enum.drop(-1)
# compute how many stacks we have (divide length of one line by 4)
stacks_count = (String.length(hd(state_lines)) + 1) / 4 |> trunc()
# reduce the states lines in a Map, key = stack id, value = list of letters, top at the start
stacks = Enum.reduce(state_lines, %{}, fn line, acc ->
# go over all the positions where we might find a letter in the line string
Enum.reduce((0..stacks_count-1), acc, fn key, acc ->
pos = key*4+1 # compute letter position from the key (stack index)
case String.at(line, pos) do
" " -> acc # space, no letter, don't add anything to the Map
char -> acc |> Map.update(key, [char], fn stack -> stack ++ [ char ] end) # found a letter, append it in the stack
end
end)
end)
# now, go over the moves lines
stacks = moves_str |> String.split("\n") |> Enum.reduce(stacks, fn line, acc ->
# parse the line string, get how much should be moved from where to where
[count, from, to] = ~r/move (\d+) from (\d+) to (\d+)/
|> Regex.run(line, capture: :all_but_first)
|> Enum.map(&String.to_integer/1)
# take from one stack to the other, reversing on the go if needed
{to_move, acc} = acc |> Map.get_and_update!(from-1, & Enum.split(&1, count) )
acc |> Map.update!(to-1, & callback.(to_move) ++ &1)
end)
stacks |> Map.values() |> Enum.map_join(&hd/1) |> IO.inspect()
end
end
Day5.run(&Enum.reverse/1) # part 1, reverse when moving over
Day5.run(& &1) # part 2, don't reverse
0
