From dbd1a3300657ef2fa6ea589666842803a39da1db Mon Sep 17 00:00:00 2001
From: Nara <naraa_520@yahoo.com>
Date: Wed, 20 Feb 2019 14:32:47 -0800
Subject: [PATCH 01/17] Added draw_letters method

---
 lib/adagrams.rb | 22 ++++++++++++++++++++++
 wave-1-game.rb  |  1 +
 2 files changed, 23 insertions(+)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index e69de29..a7069d9 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -0,0 +1,22 @@
+def draw_letters
+  letter_pool = { A: 9, B: 2, C: 2, D: 4, E: 12, F: 2, G: 3, H: 2, I: 9, J: 1, K: 1, L: 4, M: 2, N: 6, O: 8, P: 2, Q: 1, R: 6, S: 4, T: 6, U: 4, V: 2, W:2, X: 1, Y: 2, Z: 1 }
+  letter_array = []
+  letter_pool.each do |letter, quantity|
+    quantity.times do
+      letter_array << letter
+    end
+  end
+  return letter_array.sample(10)
+end
+
+def uses_available_letters? (input, letters_in_hand)
+  input.split(//).each do |i|
+    if letters_in_hand.include?(i)
+      return true
+    else 
+      return false
+    end
+  end
+end
+
+uses_available_letters?('word', draw_letters)
\ No newline at end of file
diff --git a/wave-1-game.rb b/wave-1-game.rb
index 159f620..5e94554 100644
--- a/wave-1-game.rb
+++ b/wave-1-game.rb
@@ -1,4 +1,5 @@
 require_relative 'lib/adagrams'
+require 'pry'
 
 def display_welcome_message
   puts "Welcome to Adagrams!"

From 16f1e16dcfd906e3439feac2d4fdd5b6d476c94a Mon Sep 17 00:00:00 2001
From: hanalways <hanalways@gmail.com>
Date: Wed, 20 Feb 2019 15:05:54 -0800
Subject: [PATCH 02/17] Added uses available letters method

---
 lib/adagrams.rb | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index a7069d9..b5ed09e 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -1,22 +1,30 @@
+require "pry"
+
 def draw_letters
-  letter_pool = { A: 9, B: 2, C: 2, D: 4, E: 12, F: 2, G: 3, H: 2, I: 9, J: 1, K: 1, L: 4, M: 2, N: 6, O: 8, P: 2, Q: 1, R: 6, S: 4, T: 6, U: 4, V: 2, W:2, X: 1, Y: 2, Z: 1 }
+  letter_pool = { A: 9, B: 2, C: 2, D: 4, E: 12, F: 2, G: 3, H: 2, I: 9, J: 1, K: 1, L: 4, M: 2, N: 6, O: 8, P: 2, Q: 1, R: 6, S: 4, T: 6, U: 4, V: 2, W: 2, X: 1, Y: 2, Z: 1 }
   letter_array = []
   letter_pool.each do |letter, quantity|
     quantity.times do
-      letter_array << letter
+      letter_array << letter.to_s
     end
   end
   return letter_array.sample(10)
 end
 
-def uses_available_letters? (input, letters_in_hand)
-  input.split(//).each do |i|
-    if letters_in_hand.include?(i)
-      return true
-    else 
-      return false
+def uses_available_letters?(input, letters_in_hand)
+  size = 0
+
+  input.split(//).each do |letter|
+    if letters_in_hand.include?(letter)
+      size += 1
     end
   end
+
+  if size == input.length
+    return true
+  else
+    return false
+  end
 end
 
-uses_available_letters?('word', draw_letters)
\ No newline at end of file
+uses_available_letters?("word", draw_letters)

From b70dd109900d5420a1ec7170a9b6a99b4caed1cb Mon Sep 17 00:00:00 2001
From: Nara <naraa_520@yahoo.com>
Date: Wed, 20 Feb 2019 15:45:50 -0800
Subject: [PATCH 03/17] Updated uses available letters method

---
 lib/adagrams.rb | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index b5ed09e..b5c8f95 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -1,11 +1,11 @@
-require "pry"
+require 'pry'
 
 def draw_letters
   letter_pool = { A: 9, B: 2, C: 2, D: 4, E: 12, F: 2, G: 3, H: 2, I: 9, J: 1, K: 1, L: 4, M: 2, N: 6, O: 8, P: 2, Q: 1, R: 6, S: 4, T: 6, U: 4, V: 2, W: 2, X: 1, Y: 2, Z: 1 }
   letter_array = []
   letter_pool.each do |letter, quantity|
     quantity.times do
-      letter_array << letter.to_s
+      letter_array << letter.to_s.downcase
     end
   end
   return letter_array.sample(10)
@@ -14,17 +14,18 @@ def draw_letters
 def uses_available_letters?(input, letters_in_hand)
   size = 0
 
-  input.split(//).each do |letter|
+  input.downcase.split(//).each_with_index do |letter, index|
     if letters_in_hand.include?(letter)
       size += 1
+      letters_in_hand.delete(index)
     end
   end
-
+  
   if size == input.length
     return true
-  else
+  elsif size != input.length
     return false
   end
 end
 
-uses_available_letters?("word", draw_letters)
+uses_available_letters?("word", draw_letters)
\ No newline at end of file

From fe83c7b4d6553eec5cf911c473f09bfd867b1289 Mon Sep 17 00:00:00 2001
From: hanalways <hanalways@gmail.com>
Date: Wed, 20 Feb 2019 16:29:45 -0800
Subject: [PATCH 04/17] Created/updated score_word method

---
 lib/adagrams.rb | 49 +++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 45 insertions(+), 4 deletions(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index b5c8f95..a73794d 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -1,4 +1,4 @@
-require 'pry'
+require "pry"
 
 def draw_letters
   letter_pool = { A: 9, B: 2, C: 2, D: 4, E: 12, F: 2, G: 3, H: 2, I: 9, J: 1, K: 1, L: 4, M: 2, N: 6, O: 8, P: 2, Q: 1, R: 6, S: 4, T: 6, U: 4, V: 2, W: 2, X: 1, Y: 2, Z: 1 }
@@ -20,12 +20,53 @@ def uses_available_letters?(input, letters_in_hand)
       letters_in_hand.delete(index)
     end
   end
-  
+
   if size == input.length
     return true
-  elsif size != input.length
+  else
     return false
   end
 end
 
-uses_available_letters?("word", draw_letters)
\ No newline at end of file
+def score_word(word)
+  # score_chart = {
+  #   ["A", "E", "I", "O", "U", "L", "N", "R", "S", "T"] => 1,
+  #   ["D", "G"] => 2,
+  #   ["B", "C", "M", "P"] => 3,
+  #   ["F", "H", "V", "W", "Y"] => 4,
+  #   ["K"] 5,
+  #   ["J", "X"]: 8,
+  #   ["Q", "Z"]: 10
+  # }
+  points = 0
+  word.upcase.split(//).each do |letter|
+    case letter
+    when "A", "E", "I", "O", "U", "L", "N", "R", "S", "T"
+      points += 1
+    when "D", "G"
+      points += 2
+    when "B", "C", "M", "P"
+      points += 3
+    when "F", "H", "V", "W", "Y"
+      points += 4
+    when "K"
+      points += 5
+    when "J", "X"
+      points += 8
+    when "Q", "Z"
+      points += 10
+    end
+  end
+
+  # word.each do |letter|
+  #   score_chart.map do |k, v|
+  #     if k.include?(letter)
+  #       return v
+  #     end
+  #   end
+  # end
+  # return points as an array of values
+  return points
+end
+
+puts score_word("word")

From cf9a5371e78a1c0b57c4e873cebe1556e873df2f Mon Sep 17 00:00:00 2001
From: hanalways <hanalways@gmail.com>
Date: Wed, 20 Feb 2019 16:43:00 -0800
Subject: [PATCH 05/17] Updated bonus points for word length

---
 lib/adagrams.rb | 21 ++++-----------------
 1 file changed, 4 insertions(+), 17 deletions(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index a73794d..fe74e5d 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -29,15 +29,6 @@ def uses_available_letters?(input, letters_in_hand)
 end
 
 def score_word(word)
-  # score_chart = {
-  #   ["A", "E", "I", "O", "U", "L", "N", "R", "S", "T"] => 1,
-  #   ["D", "G"] => 2,
-  #   ["B", "C", "M", "P"] => 3,
-  #   ["F", "H", "V", "W", "Y"] => 4,
-  #   ["K"] 5,
-  #   ["J", "X"]: 8,
-  #   ["Q", "Z"]: 10
-  # }
   points = 0
   word.upcase.split(//).each do |letter|
     case letter
@@ -58,14 +49,10 @@ def score_word(word)
     end
   end
 
-  # word.each do |letter|
-  #   score_chart.map do |k, v|
-  #     if k.include?(letter)
-  #       return v
-  #     end
-  #   end
-  # end
-  # return points as an array of values
+  if word.length > 6 && word.length < 11
+    points += 8
+  end
+
   return points
 end
 

From e78ae6a44c9505c2d77007beba5a1148a20070b6 Mon Sep 17 00:00:00 2001
From: hanalways <hanalways@gmail.com>
Date: Wed, 20 Feb 2019 17:12:44 -0800
Subject: [PATCH 06/17] Created highest score from method

---
 lib/adagrams.rb | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index fe74e5d..8a9cc71 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -56,4 +56,19 @@ def score_word(word)
   return points
 end
 
-puts score_word("word")
+def highest_score_from(array_of_words)
+  highest_score_hash = Hash.new(0)
+  highest_score = Hash.new(0)
+
+  array_of_words.each do |word|
+    highest_score_hash[word] = score_word(word)
+  end
+
+  highest_score = highest_score_hash.max_by { |k, v| v }
+
+  binding.pry
+end
+
+words_array = ["banana", "apple", "oraddnge"]
+
+puts highest_score_from(words_array)

From 58e4dcca3c1f28475e23d7ea853d212edcd67fd9 Mon Sep 17 00:00:00 2001
From: Nara <naraa_520@yahoo.com>
Date: Thu, 21 Feb 2019 15:19:24 -0800
Subject: [PATCH 07/17] Updated highest score from method to return a hash

---
 lib/adagrams.rb | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 8a9cc71..6f22697 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -56,19 +56,16 @@ def score_word(word)
   return points
 end
 
-def highest_score_from(array_of_words)
+def highest_score_from(words)
   highest_score_hash = Hash.new(0)
   highest_score = Hash.new(0)
 
-  array_of_words.each do |word|
+  words.each do |word|
     highest_score_hash[word] = score_word(word)
   end
 
-  highest_score = highest_score_hash.max_by { |k, v| v }
-
-  binding.pry
+  max_words = highest_score_hash.select{|k,v| v == highest_score_hash.values.max}
 end
-
-words_array = ["banana", "apple", "oraddnge"]
+words_array = ["banana", "nabana", "orae"]
 
 puts highest_score_from(words_array)

From fc8a4c2886b8198a78496283c77ed66feecf9fc7 Mon Sep 17 00:00:00 2001
From: hanalways <your_email@whatever.com>
Date: Thu, 21 Feb 2019 15:37:48 -0800
Subject: [PATCH 08/17] Max words length

---
 lib/adagrams.rb | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 6f22697..6474e0e 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -64,8 +64,21 @@ def highest_score_from(words)
     highest_score_hash[word] = score_word(word)
   end
 
-  max_words = highest_score_hash.select{|k,v| v == highest_score_hash.values.max}
+  max_words = highest_score_hash.select { |k, v| v == highest_score_hash.values.max }
+
+  winner = {}
+  max_length = 0
+
+  # tiebreakers
+  if max_words.length > 1
+    max_words.each do |k, v|
+      if k.length > max_length
+        max_length = k.length
+      end
+      binding.pry
+      puts max_length
+    end
+  end
 end
-words_array = ["banana", "nabana", "orae"]
 
-puts highest_score_from(words_array)
+highest_score_from(["banana", "bc", "orange"])

From 5d73196ffd6bbb402e125ebef652a42e475b6c53 Mon Sep 17 00:00:00 2001
From: Nara <naraa_520@yahoo.com>
Date: Thu, 21 Feb 2019 16:17:03 -0800
Subject: [PATCH 09/17] Min length winner update

---
 lib/adagrams.rb | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 6474e0e..2520df4 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -65,20 +65,22 @@ def highest_score_from(words)
   end
 
   max_words = highest_score_hash.select { |k, v| v == highest_score_hash.values.max }
-
   winner = {}
-  max_length = 0
-
+  
+  
   # tiebreakers
-  if max_words.length > 1
-    max_words.each do |k, v|
-      if k.length > max_length
-        max_length = k.length
-      end
-      binding.pry
-      puts max_length
-    end
+  if max_words.length == 1
+    winner = max_words
+    puts winner
+  else
+    min_length_winner = max_words.min_by {|k,v| k.length}
+    # winner = min_length_winner.to_h
+    winner[:word] = min_length_winner[0]
+    winner[:score] = min_length_winner[1]
+    puts winner
+   
   end
 end
 
 highest_score_from(["banana", "bc", "orange"])
+

From b0afcff051f7c11af290c9d2d3e4125ed382180b Mon Sep 17 00:00:00 2001
From: hanalways <your_email@whatever.com>
Date: Thu, 21 Feb 2019 16:50:17 -0800
Subject: [PATCH 10/17] Word length == 10

---
 lib/adagrams.rb | 58 ++++++++++++++++++++++++++++++++++---------------
 1 file changed, 41 insertions(+), 17 deletions(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 2520df4..5b82c23 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -57,30 +57,54 @@ def score_word(word)
 end
 
 def highest_score_from(words)
-  highest_score_hash = Hash.new(0)
   highest_score = Hash.new(0)
 
   words.each do |word|
-    highest_score_hash[word] = score_word(word)
+    highest_score[word] = score_word(word)
   end
 
-  max_words = highest_score_hash.select { |k, v| v == highest_score_hash.values.max }
-  winner = {}
-  
-  
-  # tiebreakers
-  if max_words.length == 1
+  max_words = {
+    words: [],
+    score: [],
+  }
+
+  highest_score.each do |k, v|
+    if v == highest_score.values.max
+      max_words[:words] << k
+      max_words[:score] = v
+    end
+  end
+
+  puts max_words
+
+  if max_words[:words].length == 1
     winner = max_words
-    puts winner
   else
-    min_length_winner = max_words.min_by {|k,v| k.length}
-    # winner = min_length_winner.to_h
-    winner[:word] = min_length_winner[0]
-    winner[:score] = min_length_winner[1]
-    puts winner
-   
+    max_words[:words].each do |word|
+      if word.length == 10
+        winner[:word] = word
+        winner[:score] = max_words[:score]
+      else
+      end
+    end
   end
-end
+  winner = {}
 
-highest_score_from(["banana", "bc", "orange"])
+  # tiebreakers
+  # if max_words.length == 1
+  #   winner = {
+  #     word: max_words.keys[0],
+  #     score: max_words.values[0],
+  #   }
+  #   puts winner
+  # elsif max_words.== 10
+  # else
+  #   min_length_winner = max_words.min_by { |k, v| k.length }
+  #   # winner = min_length_winner.to_h
+  #   winner[:word] = min_length_winner[0]
+  #   winner[:score] = min_length_winner[1]
+  #   puts winner
+  # end
+end
 
+highest_score_from(["bananaa", "aaaaaaaaaa", "ora"])

From f0036b5910fc18f50523d88345f139a1e535beb0 Mon Sep 17 00:00:00 2001
From: Nara <naraa_520@yahoo.com>
Date: Thu, 21 Feb 2019 17:03:42 -0800
Subject: [PATCH 11/17] Finished tie-breaker

---
 lib/adagrams.rb | 31 +++++++++----------------------
 1 file changed, 9 insertions(+), 22 deletions(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 5b82c23..acf00e4 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -74,9 +74,9 @@ def highest_score_from(words)
       max_words[:score] = v
     end
   end
-
-  puts max_words
-
+  winner = {}
+  
+  min_length = 10
   if max_words[:words].length == 1
     winner = max_words
   else
@@ -84,27 +84,14 @@ def highest_score_from(words)
       if word.length == 10
         winner[:word] = word
         winner[:score] = max_words[:score]
-      else
+      elsif word.length < min_length
+        min_length = word.length
+        winner[:word] = word
+        winner[:score] = max_words[:score]
       end
     end
   end
-  winner = {}
-
-  # tiebreakers
-  # if max_words.length == 1
-  #   winner = {
-  #     word: max_words.keys[0],
-  #     score: max_words.values[0],
-  #   }
-  #   puts winner
-  # elsif max_words.== 10
-  # else
-  #   min_length_winner = max_words.min_by { |k, v| k.length }
-  #   # winner = min_length_winner.to_h
-  #   winner[:word] = min_length_winner[0]
-  #   winner[:score] = min_length_winner[1]
-  #   puts winner
-  # end
+  return winner
 end
 
-highest_score_from(["bananaa", "aaaaaaaaaa", "ora"])
+puts highest_score_from(["banana", "aaaaaaaaaa", "bcd", "cbd", "ora"])

From a522553e80eb8311aeb15c53d54f744977218cfa Mon Sep 17 00:00:00 2001
From: hanalways <your_email@whatever.com>
Date: Fri, 22 Feb 2019 13:39:37 -0800
Subject: [PATCH 12/17] Creating input array

---
 lib/adagrams.rb | 27 ++++++++++++++++-----------
 1 file changed, 16 insertions(+), 11 deletions(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index acf00e4..47256b7 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -13,19 +13,16 @@ def draw_letters
 
 def uses_available_letters?(input, letters_in_hand)
   size = 0
+  input_array = input.upcase.split(//)
 
-  input.downcase.split(//).each_with_index do |letter, index|
-    if letters_in_hand.include?(letter)
-      size += 1
-      letters_in_hand.delete(index)
+  letters_in_hand.each input.upcase.split(//) do |letter|
+    if input_array.include?(letter)
+      # input_array delete
+      
     end
   end
 
-  if size == input.length
-    return true
-  else
-    return false
-  end
+  input_array == 0 ? return true : return false
 end
 
 def score_word(word)
@@ -75,7 +72,7 @@ def highest_score_from(words)
     end
   end
   winner = {}
-  
+
   min_length = 10
   if max_words[:words].length == 1
     winner = max_words
@@ -94,4 +91,12 @@ def highest_score_from(words)
   return winner
 end
 
-puts highest_score_from(["banana", "aaaaaaaaaa", "bcd", "cbd", "ora"])
+# test_0001_returns true if the submitted letters are valid against the drawn letters FAIL
+
+#  test_0002_accurately finds best scoring word even if not sorted FAIL (0.00s)
+
+#  test_0001_returns a hash that contains the word and score of best word in an array FAIL (0.00s)
+
+#  test_0007_in case of tied score and same length words, prefers the first word FAIL (0.00s)
+
+#   test_0005_in case of tied score, prefers most the word with 10 letters FAIL (0.00s)

From e848c9d7e7abfb353f1e0d7c99ca1b2dacb03cd2 Mon Sep 17 00:00:00 2001
From: Nara <naraa_520@yahoo.com>
Date: Fri, 22 Feb 2019 13:41:56 -0800
Subject: [PATCH 13/17] Updated uses available letters method

---
 lib/adagrams.rb | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index acf00e4..be4fd5d 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -13,19 +13,19 @@ def draw_letters
 
 def uses_available_letters?(input, letters_in_hand)
   size = 0
-
   input.downcase.split(//).each_with_index do |letter, index|
     if letters_in_hand.include?(letter)
       size += 1
       letters_in_hand.delete(index)
     end
   end
-
+  
   if size == input.length
     return true
   else
     return false
   end
+  
 end
 
 def score_word(word)
@@ -94,4 +94,4 @@ def highest_score_from(words)
   return winner
 end
 
-puts highest_score_from(["banana", "aaaaaaaaaa", "bcd", "cbd", "ora"])
+puts highest_score_from(["banana", "nabana", "ora"])

From b55c355e442f28e4f35d0e84241132939649fcf4 Mon Sep 17 00:00:00 2001
From: Nara <naraa_520@yahoo.com>
Date: Fri, 22 Feb 2019 14:06:36 -0800
Subject: [PATCH 14/17] Changed the uses available letters method

---
 lib/adagrams.rb | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 6c0dc22..87e1931 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -12,18 +12,23 @@ def draw_letters
 end
 
 def uses_available_letters?(input, letters_in_hand)
-  # size = 0
+  size = 0
   input_array = input.upcase.split(//)
 
-  letters_in_hand.each do |letter|
+  letters_in_hand.each_with_index do |letter, index|
     if input_array.include?(letter)
-      # input_array delete
-      input_array.delete(letter)
+      size += 1
+      letters_in_hand.delete(index)
     end
   end
+  if size == input_array.length
+    return true
+  else 
+    return false
+  end
 
-  input_array.length == 0 ? true : false
 end
+uses_available_letters?('dog', ["D","O","G","x","X","x","X""x","X"])
 
 def score_word(word)
   points = 0

From 002b7649166051ef63aca1de86fc27e328b9bde4 Mon Sep 17 00:00:00 2001
From: hanalways <your_email@whatever.com>
Date: Fri, 22 Feb 2019 14:29:22 -0800
Subject: [PATCH 15/17] Updates, still 4 errors

---
 lib/adagrams.rb        | 39 +++++++-----------
 specs/adagrams_spec.rb | 90 +++++++++++++++++++++---------------------
 2 files changed, 58 insertions(+), 71 deletions(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 87e1931..764cdac 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -23,12 +23,10 @@ def uses_available_letters?(input, letters_in_hand)
   end
   if size == input_array.length
     return true
-  else 
+  else
     return false
   end
-
 end
-uses_available_letters?('dog', ["D","O","G","x","X","x","X""x","X"])
 
 def score_word(word)
   points = 0
@@ -65,43 +63,34 @@ def highest_score_from(words)
     highest_score[word] = score_word(word)
   end
 
-  max_words = {
+  score_word = {
     words: [],
     score: [],
   }
 
   highest_score.each do |k, v|
     if v == highest_score.values.max
-      max_words[:words] << k
-      max_words[:score] = v
+      score_word[:words] << k
+      score_word[:score] = v
     end
   end
-  winner = {}
+
+  best_word = {}
 
   min_length = 10
-  if max_words[:words].length == 1
-    winner = max_words
+  if score_word[:words].length == 1
+    best_word = score_word
   else
-    max_words[:words].each do |word|
+    score_word[:words].each do |word|
       if word.length == 10
-        winner[:word] = word
-        winner[:score] = max_words[:score]
+        best_word[:word] = word
+        best_word[:score] = score_word[:score]
       elsif word.length < min_length
         min_length = word.length
-        winner[:word] = word
-        winner[:score] = max_words[:score]
+        best_word[:word] = word
+        best_word[:score] = score_word[:score]
       end
     end
   end
-  return winner
+  return best_word
 end
-
-# test_0001_returns true if the submitted letters are valid against the drawn letters FAIL
-
-#  test_0002_accurately finds best scoring word even if not sorted FAIL (0.00s)
-
-#  test_0001_returns a hash that contains the word and score of best word in an array FAIL (0.00s)
-
-#  test_0007_in case of tied score and same length words, prefers the first word FAIL (0.00s)
-
-#   test_0005_in case of tied score, prefers most the word with 10 letters FAIL (0.00s)
diff --git a/specs/adagrams_spec.rb b/specs/adagrams_spec.rb
index ae2ccd0..b1adf14 100644
--- a/specs/adagrams_spec.rb
+++ b/specs/adagrams_spec.rb
@@ -1,20 +1,20 @@
-require 'minitest/autorun'
-require 'minitest/reporters'
-require 'minitest/skip_dsl'
+require "minitest/autorun"
+require "minitest/reporters"
+require "minitest/skip_dsl"
 
-require_relative '../lib/adagrams'
+require_relative "../lib/adagrams"
 
 # Get that nice colorized output
 Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
 
-describe 'Adagrams' do
-  describe 'draw_letters method' do
-    it 'draws ten letters from the letter pool' do
+describe "Adagrams" do
+  describe "draw_letters method" do
+    it "draws ten letters from the letter pool" do
       drawn_letters = draw_letters
       expect(drawn_letters.size).must_equal 10
     end
 
-    it 'returns an array, and each item is a single-letter string' do
+    it "returns an array, and each item is a single-letter string" do
       drawn_letters = draw_letters
       expect(drawn_letters.size).must_equal 10
 
@@ -26,81 +26,79 @@
     end
   end
 
-  describe 'uses_available_letters? method' do
-
-    it 'returns true if the submitted letters are valid against the drawn letters' do
-      drawn_letters = ['D', 'O', 'G', 'X', 'X', 'X', 'X', 'X', 'X', 'X']
-      test_word = 'DOG'
+  describe "uses_available_letters? method" do
+    it "returns true if the submitted letters are valid against the drawn letters" do
+      drawn_letters = ["D", "O", "G", "X", "X", "X", "X", "X", "X", "X"]
+      test_word = "DOG"
 
       is_valid = uses_available_letters? test_word, drawn_letters
 
       expect(is_valid).must_equal true
     end
 
-    it 'returns false word contains letters not in the drawn letters' do
-      drawn_letters = ['D', 'O', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X']
-      test_word = 'DOG'
+    it "returns false word contains letters not in the drawn letters" do
+      drawn_letters = ["D", "O", "X", "X", "X", "X", "X", "X", "X", "X"]
+      test_word = "DOG"
 
       is_valid = uses_available_letters? test_word, drawn_letters
 
       expect(is_valid).must_equal false
     end
 
-    it 'returns false word contains repeated letters more than in the drawn letters' do
-      drawn_letters = ['A', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X']
-      test_word = 'AAA'
+    it "returns false word contains repeated letters more than in the drawn letters" do
+      drawn_letters = ["A", "X", "X", "X", "X", "X", "X", "X", "X", "X"]
+      test_word = "AAA"
 
       is_valid = uses_available_letters? test_word, drawn_letters
 
       expect(is_valid).must_equal false
     end
-
   end
 
-  describe 'score_word method' do
-    it 'returns an accurate numerical score according to the score chart' do
+  describe "score_word method" do
+    it "returns an accurate numerical score according to the score chart" do
       expect(score_word("A")).must_equal 1
       expect(score_word("DOG")).must_equal 5
       expect(score_word("WHIMSY")).must_equal 17
     end
 
-    it 'returns a score regardless of input case' do
+    it "returns a score regardless of input case" do
       expect(score_word("a")).must_equal 1
       expect(score_word("dog")).must_equal 5
       expect(score_word("wHiMsY")).must_equal 17
     end
 
-    it 'returns a score of 0 if given an empty input' do
+    it "returns a score of 0 if given an empty input" do
       expect(score_word("")).must_equal 0
     end
 
-    it 'adds an extra 8 points if the word is 7 or more characters long' do
+    it "adds an extra 8 points if the word is 7 or more characters long" do
       expect(score_word("XXXXXXX")).must_equal 64
       expect(score_word("XXXXXXXX")).must_equal 72
       expect(score_word("XXXXXXXXX")).must_equal 80
     end
   end
 
-  describe 'highest_score_from method' do
-    it 'returns a hash that contains the word and score of best word in an array' do
-      words = ['X', 'XX', 'XXX', 'XXXX']
+  describe "highest_score_from method" do
+    it "returns a hash that contains the word and score of best word in an array" do
+      words = ["X", "XX", "XXX", "XXXX"]
       best_word = highest_score_from words
 
-      expect(best_word[:word]).must_equal 'XXXX'
+      expect(best_word[:word]).must_equal "XXXX"
       expect(best_word[:score]).must_equal 32
     end
 
-    it 'accurately finds best scoring word even if not sorted' do
-      words = ['XXX', 'XXXX', 'XX', 'X']
+    it "accurately finds best scoring word even if not sorted" do
+      words = ["XXX", "XXXX", "XX", "X"]
       best_word = highest_score_from words
 
-      expect(best_word[:word]).must_equal 'XXXX'
+      expect(best_word[:word]).must_equal "XXXX"
       expect(best_word[:score]).must_equal 32
     end
 
-    it 'in case of tied score, prefers the word with fewer letters' do
+    it "in case of tied score, prefers the word with fewer letters" do
       # the character 'M' is worth 3 points, 'W' is 4 points
-      words = ['MMMM', 'WWW']
+      words = ["MMMM", "WWW"]
 
       # verify both have a score of 12
       expect(score_word(words.first)).must_equal 12
@@ -108,13 +106,13 @@
 
       best_word = highest_score_from words
 
-      expect(best_word[:word]).must_equal 'WWW'
+      expect(best_word[:word]).must_equal "WWW"
       expect(best_word[:score]).must_equal 12
     end
 
-    it 'in case of tied score, prefers the word with fewer letters regardless of order' do
+    it "in case of tied score, prefers the word with fewer letters regardless of order" do
       # the character 'M' is worth 3 points, 'W' is 4 points
-      words = ['WWW', 'MMMM']
+      words = ["WWW", "MMMM"]
 
       # verify both have a score of 12
       expect(score_word(words.first)).must_equal 12
@@ -122,13 +120,13 @@
 
       best_word = highest_score_from words
 
-      expect(best_word[:word]).must_equal 'WWW'
+      expect(best_word[:word]).must_equal "WWW"
       expect(best_word[:score]).must_equal 12
     end
 
-    it 'in case of tied score, prefers most the word with 10 letters' do
+    it "in case of tied score, prefers most the word with 10 letters" do
       # the character 'A' is worth 1 point, 'B' is 3 points
-      words = ['AAAAAAAAAA', 'BBBBBB']
+      words = ["AAAAAAAAAA", "BBBBBB"]
 
       # verify both have a score of 10
       expect(score_word(words.first)).must_equal 18
@@ -136,13 +134,13 @@
 
       best_word = highest_score_from words
 
-      expect(best_word[:word]).must_equal 'AAAAAAAAAA'
+      expect(best_word[:word]).must_equal "AAAAAAAAAA"
       expect(best_word[:score]).must_equal 18
     end
 
-    it 'in case of tied score, prefers most the word with 10 letters regardless of order' do
+    it "in case of tied score, prefers most the word with 10 letters regardless of order" do
       # the character 'A' is worth 1 point, 'B' is 3 points
-      words = ['BBBBBB', 'AAAAAAAAAA']
+      words = ["BBBBBB", "AAAAAAAAAA"]
 
       # verify both have a score of 10
       expect(score_word(words.first)).must_equal 18
@@ -150,13 +148,13 @@
 
       best_word = highest_score_from words
 
-      expect(best_word[:word]).must_equal 'AAAAAAAAAA'
+      expect(best_word[:word]).must_equal "AAAAAAAAAA"
       expect(best_word[:score]).must_equal 18
     end
 
-    it 'in case of tied score and same length words, prefers the first word' do
+    it "in case of tied score and same length words, prefers the first word" do
       # the character 'A' is worth 1 point, 'E' is 1 point
-      words = ['AAAAAAAAAA', 'EEEEEEEEEE']
+      words = ["AAAAAAAAAA", "EEEEEEEEEE"]
 
       # verify both have a score of 10
       expect(score_word(words.first)).must_equal 18

From 87e7a36ef9dba0e09c07297b4b7360c265f109c0 Mon Sep 17 00:00:00 2001
From: Nara <naraa_520@yahoo.com>
Date: Fri, 22 Feb 2019 15:03:12 -0800
Subject: [PATCH 16/17] Passed all the tests

---
 lib/adagrams.rb | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 764cdac..6e285cc 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -63,34 +63,36 @@ def highest_score_from(words)
     highest_score[word] = score_word(word)
   end
 
-  score_word = {
-    words: [],
+  max_words = {
+    word: [],
     score: [],
   }
 
   highest_score.each do |k, v|
     if v == highest_score.values.max
-      score_word[:words] << k
-      score_word[:score] = v
+      max_words[:word] << k
+      max_words[:score] = v
     end
   end
-
+puts max_words
   best_word = {}
 
   min_length = 10
-  if score_word[:words].length == 1
-    best_word = score_word
+  if max_words[:word].length == 1
+    best_word[:word] = max_words[:word][0]
+    best_word[:score] = max_words[:score]
   else
-    score_word[:words].each do |word|
+    max_words[:word].each do |word|
       if word.length == 10
         best_word[:word] = word
-        best_word[:score] = score_word[:score]
+        best_word[:score] = max_words[:score]
+        return best_word
       elsif word.length < min_length
         min_length = word.length
         best_word[:word] = word
-        best_word[:score] = score_word[:score]
+        best_word[:score] = max_words[:score]
       end
     end
   end
   return best_word
-end
+end
\ No newline at end of file

From 0320bab2faae87374a69fab6cc3ebca1c84763c1 Mon Sep 17 00:00:00 2001
From: Nara <naraa_520@yahoo.com>
Date: Fri, 22 Feb 2019 15:09:47 -0800
Subject: [PATCH 17/17] Cleaned up the code

---
 lib/adagrams.rb | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 6e285cc..d512ce8 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -1,5 +1,3 @@
-require "pry"
-
 def draw_letters
   letter_pool = { A: 9, B: 2, C: 2, D: 4, E: 12, F: 2, G: 3, H: 2, I: 9, J: 1, K: 1, L: 4, M: 2, N: 6, O: 8, P: 2, Q: 1, R: 6, S: 4, T: 6, U: 4, V: 2, W: 2, X: 1, Y: 2, Z: 1 }
   letter_array = []
@@ -21,6 +19,7 @@ def uses_available_letters?(input, letters_in_hand)
       letters_in_hand.delete(index)
     end
   end
+
   if size == input_array.length
     return true
   else
@@ -74,7 +73,7 @@ def highest_score_from(words)
       max_words[:score] = v
     end
   end
-puts max_words
+
   best_word = {}
 
   min_length = 10