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)                                               
     Assertion with == failed                                                                                            
     code:  assert SecretHandshake.commands(1) == ["wink"]                                                               
     left:  ["wink", nil]                                                                                                
     right: ["wink"]                                                                                                     
       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

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

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

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
|> 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.