Weighted voting exercise

exercises/anagram.livemd

@@ -67,6 +67,7 @@ defmodule Anagram do
     true
   """
   def anagram?(string1, string2) do
+    String.to_charlist(string1) |> Enum.sort() == String.to_charlist(string2) |> Enum.sort()
   end
 
   @doc """
@@ -84,6 +85,7 @@ defmodule Anagram do
     []
   """
   def filter_anagrams(word_list, anagram) do
+    Enum.filter(word_list, fn word -> anagram?(word, anagram) end)
   end
 end
 ```

exercises/animal_generator.livemd

@@ -57,7 +57,13 @@ end
 Enter your solution below.
 
 ```elixir
+names = ["Clifford", "Zoboomafoo", "Leonardo"]
+animal_types = ["dog", "lemur", "turtle"]
+ages = 1..14
 
+for name <- names, animal_type <- animal_types, age <- ages do
+  %{name: name, animal_type: animal_type, age: age}
+end
 ```
 
 ## Mark As Completed

exercises/book_search.livemd

@@ -30,6 +30,7 @@ defmodule Book do
     iex> %Book{title: "My Book Title"}
     %Book{title: "My Book Title"}
   """
+  defstruct [:title]
 
   @doc """
   Search a list of Book structs. Search should match any book that includes the
@@ -38,6 +39,7 @@ defmodule Book do
   ## Examples
 
   Include books that exactly match the search query.
+  # Map.get(map, :title) == query
 
     iex> book1 = %Book{title: "A"}
     iex> book2 = %Book{title: "B"}
@@ -46,6 +48,8 @@ defmodule Book do
     [%Book{title: "A"}]
 
   Include books that partially match the search query.
+  # does the query match any letter of the title?
+  # use String.contains(book, query)
 
     iex> Book.search([%Book{title: "ABC"}], "A")
     [%Book{title: "ABC"}]
@@ -54,15 +58,36 @@ defmodule Book do
     [%Book{title: "BAC"}]
 
   Search should be case insensitive.
+  # lowercase the input and title
 
     iex> Book.search([%Book{title: "ABC"}], "a")
     [%Book{title: "ABC"}]
   """
+
+  # def fuzzy_match(string, char) do
+  #   mysplit = String.split(string, "", trim: true)
+  #   Enum.filter(mysplit, fn element -> element == char end) && string
+  # end
+
   def search(books, query) do
+    # books that match one letter
+    Enum.filter(books, fn book -> String.contains?(book, query) end)
+
+    # books that exactly match   
+    Enum.filter(books, fn book -> Map.get(book, :title) end)
   end
 end
 ```
 
+```elixir
+book = "ABC"
+query = "D"
+String.contains?(book, query)
+
+test = %{mybook: "mytitle"}
+Map.get(test, )
+```
+
 ## Mark As Completed
 
 <!-- livebook:{"attrs":{"source":"file_name = Path.basename(Regex.replace(~r/#.+/, __ENV__.file, \"\"), \".livemd\")\n\nsave_name =\n  case Path.basename(__DIR__) do\n    \"reading\" -> \"book_search_reading\"\n    \"exercises\" -> \"book_search_exercise\"\n  end\n\nprogress_path = __DIR__ <> \"/../progress.json\"\nexisting_progress = File.read!(progress_path) |> Jason.decode!()\n\ndefault = Map.get(existing_progress, save_name, false)\n\nform =\n  Kino.Control.form(\n    [\n      completed: input = Kino.Input.checkbox(\"Mark As Completed\", default: default)\n    ],\n    report_changes: true\n  )\n\nTask.async(fn ->\n  for %{data: %{completed: completed}} <- Kino.Control.stream(form) do\n    File.write!(\n      progress_path,\n      Jason.encode!(Map.put(existing_progress, save_name, completed), pretty: true)\n    )\n  end\nend)\n\nform","title":"Track Your Progress"},"chunks":null,"kind":"Elixir.HiddenCell","livebook_object":"smart_cell"} -->

exercises/counting_votes.livemd

@@ -80,6 +80,7 @@ defmodule Votes do
     0
   """
   def count(votes, vote) do
+    Enum.count(Enum.filter(votes, fn item -> item == vote end))
   end
 end
 ```
@@ -120,6 +121,10 @@ defmodule VoterTally do
     %{dog: 2, cat: 3, bird: 1}
   """
   def tally(votes) do
+    dogs = Enum.count(Enum.filter(votes, fn item -> item == :dog end))
+    cats = Enum.count(Enum.filter(votes, fn item -> item == :cat end))
+    birds = Enum.count(Enum.filter(votes, fn item -> item == :bird end))
+    %{dog: dogs, cat: cats, bird: birds}
   end
 end
 ```

exercises/filter_values_by_type.livemd

@@ -82,7 +82,10 @@ defmodule Filter do
     iex> Filter.integers([1, 2, %{}, {}, []])
     [1, 2]
   """
+
+  # filter list using is_integer  
   def integers(list) do
+    Enum.filter(list, fn element -> is_integer(element) end)
   end
 
   @doc """
@@ -94,6 +97,7 @@ defmodule Filter do
     [1.2, 3.2]
   """
   def floats(list) do
+    Enum.filter(list, fn element -> is_float(element) end)
   end
 
   @doc """
@@ -105,6 +109,7 @@ defmodule Filter do
     [1, 2, 1.2, 3.2]
   """
   def numbers(list) do
+    Enum.filter(list, fn element -> is_integer(element) or is_float(element) end)
   end
 
   @doc """
@@ -116,6 +121,7 @@ defmodule Filter do
     [:first_atom, :second_atom]
   """
   def atoms(list) do
+    Enum.filter(list, fn element -> is_atom(element) end)
   end
 
   @doc """
@@ -127,6 +133,7 @@ defmodule Filter do
     [[1, 2], [4, 5, 6]]
   """
   def lists(list) do
+    Enum.filter(list, fn element -> is_list(element) && element != [] end)
   end
 
   @doc """
@@ -138,6 +145,7 @@ defmodule Filter do
     [%{}, %{key: "value"}]
   """
   def maps(list) do
+    Enum.filter(list, fn element -> is_map(element) end)
   end
 
   @doc """
@@ -149,6 +157,7 @@ defmodule Filter do
     [[], [key: "value"]]
   """
   def keyword_lists(list) do
+    Enum.filter(list, fn element -> Keyword.keyword?(element) end)
   end
 end
 ```

exercises/fizzbuzz.livemd

@@ -77,8 +77,18 @@ defmodule FizzBuzz do
     ["buzz", 11, "fizz", 13, 14, "fizzbuzz"]
   """
   def run(range) do
+    Enum.map(range, fn int ->
+      cond do
+        rem(int, 15) == 0 -> "fizzbuzz"
+        rem(int, 3) == 0 -> "fizz"
+        rem(int, 5) == 0 -> "buzz"
+        true -> int
+      end
+    end)
   end
 end
+
+FizzBuzz.run(1..15)
 ```
 
 ## Mark As Completed

exercises/named_number_lists.livemd

@@ -75,7 +75,22 @@ flowchart
 Enter your solution below.
 
 ```elixir
-
+rando = Enum.map(1..10, fn _ -> Enum.random(0..9) end)
+
+Enum.map(rando, fn int ->
+  case int do
+    0 -> "zero"
+    1 -> "one"
+    2 -> "two"
+    3 -> "three"
+    4 -> "four"
+    5 -> "five"
+    6 -> "six"
+    7 -> "seven"
+    8 -> "eight"
+    9 -> "nine"
+  end
+end)
 ```
 
 ## Mark As Completed

exercises/naming_numbers.livemd

@@ -72,7 +72,22 @@ naming_numbers.(1)
 Enter your solution below.
 
 ```elixir
+naming_numbers = fn integer ->
+  case integer do
+    0 -> "zero"
+    1 -> "one"
+    2 -> "two"
+    3 -> "three"
+    4 -> "four"
+    5 -> "five"
+    6 -> "six"
+    7 -> "seven"
+    8 -> "eight"
+    9 -> "nine"
+  end
+end
 
+naming_numbers.(1)
 ```
 
 ## Numbering Names
@@ -169,7 +184,22 @@ flowchart
 </details>
 
 ```elixir
+numbering_names = fn int_str ->
+  case String.downcase(int_str) do
+    "zero" -> 0
+    "one" -> 1
+    "two" -> 2
+    "three" -> 3
+    "four" -> 4
+    "five" -> 5
+    "six" -> 6
+    "seven" -> 7
+    "eight" -> 8
+    "nine" -> 9
+  end
+end
 
+numbering_names.("Nine")
 ```
 
 ## Mark As Completed

exercises/number_finder.livemd

@@ -37,12 +37,21 @@ defmodule NumberFinder do
 
     iex> NumberFinder.smallest([2, 3, 1])
     1
+
     iex> NumberFinder.smallest([2, 2, 3, 4])
     2
+
     iex> NumberFinder.smallest([2, 2, 3, 4, 10, 20, -3])
     -3
   """
   def smallest(number_list) do
+    Enum.reduce(number_list, fn elem, acc ->
+      if acc < elem do
+        acc
+      else
+        elem
+      end
+    end)
   end
 
   @doc """
@@ -52,12 +61,21 @@ defmodule NumberFinder do
 
     iex> NumberFinder.largest([2, 3, 1])
     3
+
     iex> NumberFinder.largest([2, 2, 3, 4, 4])
     4
+
     iex> NumberFinder.largest([2, 2, 3, 4, 10, 20, -3])
     20
   """
   def largest(number_list) do
+    Enum.reduce(number_list, fn elem, acc ->
+      if acc > elem do
+        acc
+      else
+        elem
+      end
+    end)
   end
 end
 ```

exercises/palindrome.livemd

@@ -70,6 +70,7 @@ defmodule Palindrome do
     false
   """
   def palindrome?(string) do
+    string == String.reverse(string)
   end
 end
 ```

exercises/rock_paper_scissors.livemd

@@ -54,7 +54,15 @@ Then, return the winning choice of either `:rock`, `:paper`, or `:scissors` that
 Enter your solution below.
 
 ```elixir
+player_choice = Enum.random([:rock, :paper, :scissors])
+
+IO.puts(player_choice)
 
+case player_choice do
+  :rock -> :paper
+  :paper -> :scissors
+  :scissors -> :rock
+end
 ```
 
 ## Create Two Player Rock Paper Scissors
@@ -107,7 +115,21 @@ Bind a `player1_choice` and `player2_choice` variable to `:rock`, `:paper`, or `
 Enter your solution below.
 
 ```elixir
-
+player1 = Enum.random([:rock, :paper, :scissors])
+IO.inspect(player1: player1)
+
+player2 = Enum.random([:rock, :paper, :scissors])
+IO.inspect(player2: player2)
+
+case {player1, player2} do
+  {:rock, :scissors} -> "Player 1 Wins!"
+  {:paper, :rock} -> "Player 1 Wins!"
+  {:scissors, :paper} -> "Player 1 Wins!"
+  {:rock, :paper} -> "Player 2 Wins!"
+  {:paper, :scissors} -> "Player 2 Wins!"
+  {:scissors, :rock} -> "Player 2 Wins!"
+  {same, same} -> "Draw"
+end
 ```
 
 ## Mark As Completed

exercises/rock_paper_scissors_lizard_spock.livemd

@@ -83,6 +83,17 @@ defmodule RockPaperScissorsLizardSpock do
     false
   """
   def beats?(guess1, guess2) do
+    {guess1, guess2} in [
+      {:rock, :scissors},
+      {:rock, :lizard},
+      {:paper, :rock},
+      {:paper, :spock},
+      {:scissors, :paper},
+      {:scissors, :lizards},
+      {:lizard, :paper},
+      {:lizard, :spock},
+      {:spock, :scissors}
+    ]
   end
 
   @doc """
@@ -99,9 +110,20 @@ defmodule RockPaperScissorsLizardSpock do
     iex> RockPaperScissorsLizardSpock.play(:lizard, :lizard)
     "Player 2 Wins!"
   """
+
   def play(player1, player2) do
+    cond do
+      beats?(player1, player2) -> "Player 1 Wins!"
+      not beats?(player1, player2) -> "Player 2 Wins!"
+    end
   end
 end
+
+RockPaperScissorsLizardSpock.play(:rock, :paper)
+```
+
+```elixir
+
 ```
 
 ## Mark As Completed