# Exercism secred_handshake help list

I’ve built the following code (reverse not implemented) to solve the `secret_handshake` problem at exercism.io.

But the first test fails…

``````test Create a handshake for a number wink for 1 (SecretHandshakeTest)
secret_handshake_test.exs:13
Assertion with == failed
code:  assert SecretHandshake.commands(1) == ["wink"]
left:  ["wink", nil]
right: ["wink"]
stacktrace:
secret_handshake_test.exs:14: (test)
``````

There’s a `["wink", nil]` instead of a `["wink"]` for the `1` case, and I can’t figure out why this is happening.

``````defmodule SecretHandshake do
@doc """
Determine the actions of a secret handshake based on the binary
representation of the given `code`.

If the following bits are set, include the corresponding action in your list
of commands, in order from lowest to highest.

1 = wink
10 = double blink
100 = close your eyes
1000 = jump

10000 = Reverse the order of the operations in the secret handshake
"""
@spec commands(code :: integer) :: list(String.t())
def commands(code) do
in_binary = decimalToBinary code
to_reverse = true and rem(code, 10000)
commands = []

commands = if div(in_binary, 1000) == 1, do: [getAction(1000)] ++ commands
commands = if div(in_binary, 100) == 1, do: [getAction(100)] ++ commands
commands = if div(in_binary, 10) == 1, do: [getAction(10)] ++ commands
commands = if rem(in_binary, 2) == 1, do: [getAction(1)] ++ commands
end

defp getAction(dec) do
case dec do
1 -> "wink"
10 -> "double blink"
100 -> "close your eyes"
1000 -> "jump"
end
end

defp decimalToBinary(dec) do
dec
|> Integer.to_string(2)
|> String.to_integer
end
end``````

Each of this lines will return `nil` from its implicit `else` branch.

I am not sure though, why your result is `["wink", nil]`, it should be `["wink" | nil]`.

You should try to do some other approach by creating a list of tuples, where the first element is the bit that has to be set, the other is the word to put in the command. Then you simply fold over that list.

Something like this:

``````[{0, "wink"}, {1, "double blink"}, {2, "close your eyes"}, {3, "jump"}]
|> Enum.fold([], fn {bit, cmd}, acc ->
if bit_set?(code, bit), do: [cmd | acc], else: acc
end)
|> Enum.reverse()
``````

`bit_set?/2` is easily implementable using the `Bitwise` module.

1 Like

You’re right @NobbZ, it’s `["wink" | nil]`.

Since the input is in decimal, converted the commands’ codes to that scale as well.
Your solution is generalist and functional, mine not so much. Will going to try yours now.
Thanks.