From fbed0bcba284f8c6ed8308d60df496b15fbd0888 Mon Sep 17 00:00:00 2001
From: Grace Shea <grace.m.shea@gmail.com>
Date: Tue, 19 Feb 2019 15:48:00 -0800
Subject: [PATCH 01/19] first version of wave 1 utilizing 26 times loops to gen
 array

---
 adagrams.rb | 45 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 adagrams.rb

diff --git a/adagrams.rb b/adagrams.rb
new file mode 100644
index 0000000..29af09b
--- /dev/null
+++ b/adagrams.rb
@@ -0,0 +1,45 @@
+require 'pry'
+
+def draw_letters 
+
+# set up all characters for adagram use
+    avail_letters = []
+    9.times {avail_letters << "A"}
+    2.times {avail_letters << "B"}
+    2.times {avail_letters << "C"}
+    4.times {avail_letters << "D"}
+    12.times {avail_letters << "E"}
+    2.times {avail_letters << "F"}
+    3.times {avail_letters << "G"}
+    2.times {avail_letters << "H"}
+    9.times {avail_letters << "I"}
+    1.times {avail_letters << "J"}
+    1.times {avail_letters << "K"}
+    4.times {avail_letters << "L"}
+    2.times {avail_letters << "M"}
+    6.times {avail_letters << "N"}
+    8.times {avail_letters << "O"}
+    2.times {avail_letters << "P"}
+    1.times {avail_letters << "Q"}
+    6.times {avail_letters << "R"}
+    4.times {avail_letters << "S"}
+    6.times {avail_letters << "T"}
+    4.times {avail_letters << "U"}
+    2.times {avail_letters << "V"}
+    2.times {avail_letters << "W"}
+    1.times {avail_letters << "X"}
+    2.times {avail_letters << "Y"}
+    1.times {avail_letters << "Z"}
+
+    used_letters = []
+
+    10.times do
+        curr_letter = avail_letters[rand(0...avail_letters.length)]
+        binding.pry
+        used_letters << curr_letter
+        avail_letters.delete(curr_letter)
+    end
+    return used_letters
+end
+
+draw_letters
\ No newline at end of file

From 541805b150c9f52abc02eff60e8953e9efeb91ef Mon Sep 17 00:00:00 2001
From: Grace Shea <grace.m.shea@gmail.com>
Date: Tue, 19 Feb 2019 16:11:00 -0800
Subject: [PATCH 02/19] second version of wave 1, so much prettier

---
 adagrams.rb | 76 +++++++++++++++++++++++++++++++----------------------
 1 file changed, 45 insertions(+), 31 deletions(-)

diff --git a/adagrams.rb b/adagrams.rb
index 29af09b..7b0e560 100644
--- a/adagrams.rb
+++ b/adagrams.rb
@@ -1,45 +1,59 @@
 require 'pry'
+require 'terminal-table'
 
-def draw_letters 
+def array_gen(hash, array)
+    hash.each do |key, value|
+        value.times do
+            array << key.to_s
+        end
+    end
+end
 
+def draw_letters 
 # set up all characters for adagram use
-    avail_letters = []
-    9.times {avail_letters << "A"}
-    2.times {avail_letters << "B"}
-    2.times {avail_letters << "C"}
-    4.times {avail_letters << "D"}
-    12.times {avail_letters << "E"}
-    2.times {avail_letters << "F"}
-    3.times {avail_letters << "G"}
-    2.times {avail_letters << "H"}
-    9.times {avail_letters << "I"}
-    1.times {avail_letters << "J"}
-    1.times {avail_letters << "K"}
-    4.times {avail_letters << "L"}
-    2.times {avail_letters << "M"}
-    6.times {avail_letters << "N"}
-    8.times {avail_letters << "O"}
-    2.times {avail_letters << "P"}
-    1.times {avail_letters << "Q"}
-    6.times {avail_letters << "R"}
-    4.times {avail_letters << "S"}
-    6.times {avail_letters << "T"}
-    4.times {avail_letters << "U"}
-    2.times {avail_letters << "V"}
-    2.times {avail_letters << "W"}
-    1.times {avail_letters << "X"}
-    2.times {avail_letters << "Y"}
-    1.times {avail_letters << "Z"}
+   
 
-    used_letters = []
+    # 9.times {avail_letters << "A"}
+    # 2.times {avail_letters << "B"}
+    # 2.times {avail_letters << "C"}
+    # 4.times {avail_letters << "D"}
+    # 12.times {avail_letters << "E"}
+    # 2.times {avail_letters << "F"}
+    # 3.times {avail_letters << "G"}
+    # 2.times {avail_letters << "H"}
+    # 9.times {avail_letters << "I"}
+    # 1.times {avail_letters << "J"}
+    # 1.times {avail_letters << "K"}
+    # 4.times {avail_letters << "L"}
+    # 2.times {avail_letters << "M"}
+    # 6.times {avail_letters << "N"}
+    # 8.times {avail_letters << "O"}
+    # 2.times {avail_letters << "P"}
+    # 1.times {avail_letters << "Q"}
+    # 6.times {avail_letters << "R"}
+    # 4.times {avail_letters << "S"}
+    # 6.times {avail_letters << "T"}
+    # 4.times {avail_letters << "U"}
+    # 2.times {avail_letters << "V"}
+    # 2.times {avail_letters << "W"}
+    # 1.times {avail_letters << "X"}
+    # 2.times {avail_letters << "Y"}
+    # 1.times {avail_letters << "Z"}
 
+    letter_freq = { 
+        A: 9, N: 6, B: 2, O: 8, C: 2, P: 2, D: 4, Q: 1, E: 12, R: 6, F: 2, S: 4,
+        G: 3, T: 6, H: 2, U: 4, I: 9, V: 2, J: 1, W: 2, K: 1, X: 1, L: 4, Y: 2, M: 2, Z: 1
+    }
+    avail_letters = []
+    array_gen(letter_freq, avail_letters)
+    
+    used_letters = []
     10.times do
         curr_letter = avail_letters[rand(0...avail_letters.length)]
-        binding.pry
         used_letters << curr_letter
         avail_letters.delete(curr_letter)
     end
     return used_letters
 end
 
-draw_letters
\ No newline at end of file
+puts draw_letters
\ No newline at end of file

From 86b08b6e49fcf1f923d7eeaf9c65e46dec89fcbc Mon Sep 17 00:00:00 2001
From: Grace Shea <grace.m.shea@gmail.com>
Date: Tue, 19 Feb 2019 16:33:33 -0800
Subject: [PATCH 03/19] first version of wave 2, succesful return of true and
 false

---
 adagrams.rb | 55 ++++++++++++++++++++++++-----------------------------
 1 file changed, 25 insertions(+), 30 deletions(-)

diff --git a/adagrams.rb b/adagrams.rb
index 7b0e560..cfb5946 100644
--- a/adagrams.rb
+++ b/adagrams.rb
@@ -10,35 +10,6 @@ def array_gen(hash, array)
 end
 
 def draw_letters 
-# set up all characters for adagram use
-   
-
-    # 9.times {avail_letters << "A"}
-    # 2.times {avail_letters << "B"}
-    # 2.times {avail_letters << "C"}
-    # 4.times {avail_letters << "D"}
-    # 12.times {avail_letters << "E"}
-    # 2.times {avail_letters << "F"}
-    # 3.times {avail_letters << "G"}
-    # 2.times {avail_letters << "H"}
-    # 9.times {avail_letters << "I"}
-    # 1.times {avail_letters << "J"}
-    # 1.times {avail_letters << "K"}
-    # 4.times {avail_letters << "L"}
-    # 2.times {avail_letters << "M"}
-    # 6.times {avail_letters << "N"}
-    # 8.times {avail_letters << "O"}
-    # 2.times {avail_letters << "P"}
-    # 1.times {avail_letters << "Q"}
-    # 6.times {avail_letters << "R"}
-    # 4.times {avail_letters << "S"}
-    # 6.times {avail_letters << "T"}
-    # 4.times {avail_letters << "U"}
-    # 2.times {avail_letters << "V"}
-    # 2.times {avail_letters << "W"}
-    # 1.times {avail_letters << "X"}
-    # 2.times {avail_letters << "Y"}
-    # 1.times {avail_letters << "Z"}
 
     letter_freq = { 
         A: 9, N: 6, B: 2, O: 8, C: 2, P: 2, D: 4, Q: 1, E: 12, R: 6, F: 2, S: 4,
@@ -56,4 +27,28 @@ def draw_letters
     return used_letters
 end
 
-puts draw_letters
\ No newline at end of file
+# puts draw_letters
+curr_in_hand = draw_letters
+puts curr_in_hand
+
+def uses_available_letters? (input, letters_in_hand)
+    if input.length > letters_in_hand.length
+        puts "Whoa, buddy. You used more letters than you have in your hand! Try again. "
+        return false
+    else
+        possible_letters = letters_in_hand
+        input_array = input.split(//)
+        input_array.each do |char|
+            if possible_letters.include?(char)
+               possible_letters.delete(char)
+            else
+                "Oh nooooo. You used a letter, #{char}, that's not in your hand"
+                return false
+            end
+        end
+    end
+    return true
+end
+
+input = gets.chomp.upcase
+puts uses_available_letters?(input, curr_in_hand)

From c626fff18ea935548f374430ed55a53385646acc Mon Sep 17 00:00:00 2001
From: Grace Shea <grace.m.shea@gmail.com>
Date: Tue, 19 Feb 2019 16:46:19 -0800
Subject: [PATCH 04/19] first version partial wave 3

---
 adagrams.rb | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/adagrams.rb b/adagrams.rb
index cfb5946..5f6cb01 100644
--- a/adagrams.rb
+++ b/adagrams.rb
@@ -15,6 +15,7 @@ def draw_letters
         A: 9, N: 6, B: 2, O: 8, C: 2, P: 2, D: 4, Q: 1, E: 12, R: 6, F: 2, S: 4,
         G: 3, T: 6, H: 2, U: 4, I: 9, V: 2, J: 1, W: 2, K: 1, X: 1, L: 4, Y: 2, M: 2, Z: 1
     }
+
     avail_letters = []
     array_gen(letter_freq, avail_letters)
     
@@ -52,3 +53,11 @@ def uses_available_letters? (input, letters_in_hand)
 
 input = gets.chomp.upcase
 puts uses_available_letters?(input, curr_in_hand)
+
+
+def score_word(word)
+    letter_score = { 
+        A: 1, N: 1, B: 3, O: 1, C: 3, P: 3, D: 2, Q: 10, E: 1, R: 1, F: 4, S: 1,
+        G: 2, T: 1, H: 4, U: 1, I: 1, V: 4, J: 8, W: 4, K: 5, X: 8, L: 1, Y: 4, M: 3, Z: 10
+    }
+    word_score = 0
\ No newline at end of file

From 347ac6afdd1e4d547c27c0a282e486931ed81b06 Mon Sep 17 00:00:00 2001
From: Shubha Rajan <shubharajan94@gmail.com>
Date: Wed, 20 Feb 2019 15:05:36 -0800
Subject: [PATCH 05/19] Moved adagrams.rb into lib folder

---
 adagrams.rb     | 63 -------------------------------------------------
 lib/adagrams.rb | 63 +++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 63 insertions(+), 63 deletions(-)
 delete mode 100644 adagrams.rb

diff --git a/adagrams.rb b/adagrams.rb
deleted file mode 100644
index 5f6cb01..0000000
--- a/adagrams.rb
+++ /dev/null
@@ -1,63 +0,0 @@
-require 'pry'
-require 'terminal-table'
-
-def array_gen(hash, array)
-    hash.each do |key, value|
-        value.times do
-            array << key.to_s
-        end
-    end
-end
-
-def draw_letters 
-
-    letter_freq = { 
-        A: 9, N: 6, B: 2, O: 8, C: 2, P: 2, D: 4, Q: 1, E: 12, R: 6, F: 2, S: 4,
-        G: 3, T: 6, H: 2, U: 4, I: 9, V: 2, J: 1, W: 2, K: 1, X: 1, L: 4, Y: 2, M: 2, Z: 1
-    }
-
-    avail_letters = []
-    array_gen(letter_freq, avail_letters)
-    
-    used_letters = []
-    10.times do
-        curr_letter = avail_letters[rand(0...avail_letters.length)]
-        used_letters << curr_letter
-        avail_letters.delete(curr_letter)
-    end
-    return used_letters
-end
-
-# puts draw_letters
-curr_in_hand = draw_letters
-puts curr_in_hand
-
-def uses_available_letters? (input, letters_in_hand)
-    if input.length > letters_in_hand.length
-        puts "Whoa, buddy. You used more letters than you have in your hand! Try again. "
-        return false
-    else
-        possible_letters = letters_in_hand
-        input_array = input.split(//)
-        input_array.each do |char|
-            if possible_letters.include?(char)
-               possible_letters.delete(char)
-            else
-                "Oh nooooo. You used a letter, #{char}, that's not in your hand"
-                return false
-            end
-        end
-    end
-    return true
-end
-
-input = gets.chomp.upcase
-puts uses_available_letters?(input, curr_in_hand)
-
-
-def score_word(word)
-    letter_score = { 
-        A: 1, N: 1, B: 3, O: 1, C: 3, P: 3, D: 2, Q: 10, E: 1, R: 1, F: 4, S: 1,
-        G: 2, T: 1, H: 4, U: 1, I: 1, V: 4, J: 8, W: 4, K: 5, X: 8, L: 1, Y: 4, M: 3, Z: 10
-    }
-    word_score = 0
\ No newline at end of file
diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index e69de29..5f6cb01 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -0,0 +1,63 @@
+require 'pry'
+require 'terminal-table'
+
+def array_gen(hash, array)
+    hash.each do |key, value|
+        value.times do
+            array << key.to_s
+        end
+    end
+end
+
+def draw_letters 
+
+    letter_freq = { 
+        A: 9, N: 6, B: 2, O: 8, C: 2, P: 2, D: 4, Q: 1, E: 12, R: 6, F: 2, S: 4,
+        G: 3, T: 6, H: 2, U: 4, I: 9, V: 2, J: 1, W: 2, K: 1, X: 1, L: 4, Y: 2, M: 2, Z: 1
+    }
+
+    avail_letters = []
+    array_gen(letter_freq, avail_letters)
+    
+    used_letters = []
+    10.times do
+        curr_letter = avail_letters[rand(0...avail_letters.length)]
+        used_letters << curr_letter
+        avail_letters.delete(curr_letter)
+    end
+    return used_letters
+end
+
+# puts draw_letters
+curr_in_hand = draw_letters
+puts curr_in_hand
+
+def uses_available_letters? (input, letters_in_hand)
+    if input.length > letters_in_hand.length
+        puts "Whoa, buddy. You used more letters than you have in your hand! Try again. "
+        return false
+    else
+        possible_letters = letters_in_hand
+        input_array = input.split(//)
+        input_array.each do |char|
+            if possible_letters.include?(char)
+               possible_letters.delete(char)
+            else
+                "Oh nooooo. You used a letter, #{char}, that's not in your hand"
+                return false
+            end
+        end
+    end
+    return true
+end
+
+input = gets.chomp.upcase
+puts uses_available_letters?(input, curr_in_hand)
+
+
+def score_word(word)
+    letter_score = { 
+        A: 1, N: 1, B: 3, O: 1, C: 3, P: 3, D: 2, Q: 10, E: 1, R: 1, F: 4, S: 1,
+        G: 2, T: 1, H: 4, U: 1, I: 1, V: 4, J: 8, W: 4, K: 5, X: 8, L: 1, Y: 4, M: 3, Z: 10
+    }
+    word_score = 0
\ No newline at end of file

From 0c8ca9e1d8d6e47c08ef697587d34637c0b7a47b Mon Sep 17 00:00:00 2001
From: Grace Shea <grace.m.shea@gmail.com>
Date: Wed, 20 Feb 2019 15:47:58 -0800
Subject: [PATCH 06/19] Wave 3 Partially Complete

---
 .DS_Store       | Bin 0 -> 6148 bytes
 lib/adagrams.rb |   9 +++++++--
 2 files changed, 7 insertions(+), 2 deletions(-)
 create mode 100644 .DS_Store

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..1d28fc392e92579aea2d5e58e9871f92cc9e50c0
GIT binary patch
literal 6148
zcmeHKyH3L}6g{Q|1u9TC7&EefR2~ycsM>*n1%3e17pN&kEsr$||G+QseS83%Yg>?{
zX}chV(7o05ah!YX>(kn<0hs1vw*k}v1a!gb28$At_u@0Q;#)R}#`ZD6HAa|XACsAA
zZBPYNfxo7Jtlb({ZI?das{LNS@mVtN#K|~jglrEd^xY3@tO09`o$}Me1Ez)8w?b?U
zea7`TN=#M<L+%hGbn`6pQeXwR!7c8j|I+yPLVN`Y<ID1X&Ey^6f;kMCO`p*Tdig9M
zxo6|o8Q;b!S~w?`<-J{CtTNww_TMS$VrQ7`dkfFZ<%zL-XwV0I8u3Z?&%!*6%yu64
zU@=#|I}>Cy$c}rsgiAf<a*q~s4V9V8Jzm1)uOY|f^woY;0iM}nLCv9-s(>n>3VbOb
z`$I?<j69|e?bgA<UIB<zHd|v|{wxS5^cZ<e9r6v$I4aRmjlW_TM`wHJ<06l#Lq~`4
zmk;AdHvWcU?C9)2wBaz3LoHPSRUofG#XZ*L{BO^{|K~~iqzb44|4IQ<ZC$pSoRU9V
yXC^0SZAibOi%DGS&{A0V<JeZ@DBhu4<GWBQ#K>dnkS#R*BVc9FLKXN`1wH}ycD`5u

literal 0
HcmV?d00001

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 5f6cb01..7925fd6 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -28,7 +28,7 @@ def draw_letters
     return used_letters
 end
 
-# puts draw_letters
+puts draw_letters
 curr_in_hand = draw_letters
 puts curr_in_hand
 
@@ -60,4 +60,9 @@ def score_word(word)
         A: 1, N: 1, B: 3, O: 1, C: 3, P: 3, D: 2, Q: 10, E: 1, R: 1, F: 4, S: 1,
         G: 2, T: 1, H: 4, U: 1, I: 1, V: 4, J: 8, W: 4, K: 5, X: 8, L: 1, Y: 4, M: 3, Z: 10
     }
-    word_score = 0
\ No newline at end of file
+    word_score = 0
+    split_word = word.upcase.split(//)
+    split_word.reduce("") do |memo, char|
+        
+
+        
\ No newline at end of file

From 287aecc179987cbf092217a6fdb8dc7844ed2041 Mon Sep 17 00:00:00 2001
From: Shubha Rajan <shubharajan94@gmail.com>
Date: Wed, 20 Feb 2019 15:53:34 -0800
Subject: [PATCH 07/19] adds up point totals without accounting for word length

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

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 7925fd6..904cce4 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -60,9 +60,13 @@ def score_word(word)
         A: 1, N: 1, B: 3, O: 1, C: 3, P: 3, D: 2, Q: 10, E: 1, R: 1, F: 4, S: 1,
         G: 2, T: 1, H: 4, U: 1, I: 1, V: 4, J: 8, W: 4, K: 5, X: 8, L: 1, Y: 4, M: 3, Z: 10
     }
-    word_score = 0
+
     split_word = word.upcase.split(//)
-    split_word.reduce("") do |memo, char|
+    word_score = split_word.reduce(0) do |memo, char|
+        memo += letter_score[char.to_sym]
+    end
+    return word_score
+end
         
 
         
\ No newline at end of file

From 89fe603c37ba63df0ea8897e738365d230259587 Mon Sep 17 00:00:00 2001
From: Shubha Rajan <shubharajan94@gmail.com>
Date: Wed, 20 Feb 2019 15:56:25 -0800
Subject: [PATCH 08/19] score_word(word) is functional with no failures

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

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 904cce4..531f1b4 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -65,6 +65,9 @@ def score_word(word)
     word_score = split_word.reduce(0) do |memo, char|
         memo += letter_score[char.to_sym]
     end
+    if word.length >= 7
+        word_score += 8
+    end
     return word_score
 end
         

From 4007f5ad61eb2d43beb80954f714a3e0bd159630 Mon Sep 17 00:00:00 2001
From: Grace Shea <grace.m.shea@gmail.com>
Date: Wed, 20 Feb 2019 16:28:35 -0800
Subject: [PATCH 09/19] Working on Wave 4

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

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 531f1b4..630da20 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -71,5 +71,18 @@ def score_word(word)
     return word_score
 end
         
+# find highest score - check
+# preference to shortest words UNLESS word is 10 letters
+# 10 letters wins over same score/fewer letters
+# if same score AND same length, pick first in index
 
-        
\ No newline at end of file
+def highest_score_from(words)
+    words_with_scores = words.map do |word|
+        {word: word, score: score_word(word)}
+    end
+    
+    # highest_score = words_with_scores.max_by {|hash| hash[:score]}
+    # return highest_score
+    highest_score_from = [0]
+    if highest_score_from
+end
\ No newline at end of file

From b8864b581540d579ec90e25e14ea4d845fb8498e Mon Sep 17 00:00:00 2001
From: Grace Shea <grace.m.shea@gmail.com>
Date: Wed, 20 Feb 2019 16:54:07 -0800
Subject: [PATCH 10/19] wave 4 complete- accurately handles ties

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

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 630da20..49e8339 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -80,9 +80,20 @@ def highest_score_from(words)
     words_with_scores = words.map do |word|
         {word: word, score: score_word(word)}
     end
-    
-    # highest_score = words_with_scores.max_by {|hash| hash[:score]}
-    # return highest_score
-    highest_score_from = [0]
-    if highest_score_from
+
+    winner = {
+        word: "",
+        score: 0
+    }
+
+    words_with_scores.each do |hash|
+        if hash[:score] > winner[:score]
+            winner = hash
+        elsif hash[:score] == winner[:score]
+            if ((hash[:word].length < winner[:word].length)  || (hash[:word].length == 10)) && (winner[:word].length != 10)
+                winner = hash
+            end
+        end
+    end
+    return winner
 end
\ No newline at end of file

From e6d41129536345e9522ee13685f423c8ad54efd5 Mon Sep 17 00:00:00 2001
From: Shubha Rajan <shubharajan94@gmail.com>
Date: Wed, 20 Feb 2019 17:04:12 -0800
Subject: [PATCH 11/19] Added comments

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

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 49e8339..6edded0 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -1,6 +1,6 @@
 require 'pry'
-require 'terminal-table'
 
+# Helper method that creates array of letters that are available to be drawn
 def array_gen(hash, array)
     hash.each do |key, value|
         value.times do
@@ -9,6 +9,7 @@ def array_gen(hash, array)
     end
 end
 
+# Returns an array of 10 letters chosen at random from available letters
 def draw_letters 
 
     letter_freq = { 
@@ -28,10 +29,7 @@ def draw_letters
     return used_letters
 end
 
-puts draw_letters
-curr_in_hand = draw_letters
-puts curr_in_hand
-
+# Validates input word by determining if it can be formed with letters in hand
 def uses_available_letters? (input, letters_in_hand)
     if input.length > letters_in_hand.length
         puts "Whoa, buddy. You used more letters than you have in your hand! Try again. "
@@ -51,10 +49,7 @@ def uses_available_letters? (input, letters_in_hand)
     return true
 end
 
-input = gets.chomp.upcase
-puts uses_available_letters?(input, curr_in_hand)
-
-
+# Scores each word
 def score_word(word)
     letter_score = { 
         A: 1, N: 1, B: 3, O: 1, C: 3, P: 3, D: 2, Q: 10, E: 1, R: 1, F: 4, S: 1,
@@ -71,11 +66,8 @@ def score_word(word)
     return word_score
 end
         
-# find highest score - check
-# preference to shortest words UNLESS word is 10 letters
-# 10 letters wins over same score/fewer letters
-# if same score AND same length, pick first in index
 
+# Returns a single hash that represents the data of a winning word and its score.
 def highest_score_from(words)
     words_with_scores = words.map do |word|
         {word: word, score: score_word(word)}

From c58b935c685bd6915eee95ca843ccba1c5df216f Mon Sep 17 00:00:00 2001
From: Shubha Rajan <shubharajan94@gmail.com>
Date: Thu, 21 Feb 2019 14:54:53 -0800
Subject: [PATCH 12/19] Cleaned up and refactored code

---
 .DS_Store           | Bin 6148 -> 6148 bytes
 .vscode/launch.json |  15 ++++++
 lib/adagrams.rb     | 125 ++++++++++++++++++++------------------------
 3 files changed, 73 insertions(+), 67 deletions(-)
 create mode 100644 .vscode/launch.json

diff --git a/.DS_Store b/.DS_Store
index 1d28fc392e92579aea2d5e58e9871f92cc9e50c0..72bf4d380c9f64635f9ca9ac397b67f109794ced 100644
GIT binary patch
delta 48
zcmZoMXfc@JFUrHfz`)4BAi%&-!cgp)lb@WFlb^I%kYhPBBhO|hmZQuQ8_YJdbNuB8
E02X)*-~a#s

delta 99
zcmZoMXfc@JFUrfnz`)4BAi%&-#E{64%TUaq$56CckYhQsIY^2dD3}7o>B!OyNuD|R
h$w@i+NkA1qoeb7MtnnWV7#KG5upDLH%+B$b9{|#C7r_7k

diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 0000000..10f2f39
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,15 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Debug Local File",
+            "type": "Ruby",
+            "request": "launch",
+            "cwd": "${workspaceRoot}",
+            "program": "${file}"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 6edded0..a96cf27 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -1,91 +1,82 @@
-require 'pry'
+require "pry"
 
 # Helper method that creates array of letters that are available to be drawn
-def array_gen(hash, array)
-    hash.each do |key, value|
-        value.times do
-            array << key.to_s
-        end
+def array_gen(hash)
+  array = []
+  hash.each do |key, value|
+    value.times do
+      array << key.to_s
     end
+  end
+  return array
 end
 
 # Returns an array of 10 letters chosen at random from available letters
-def draw_letters 
+def draw_letters
+  letter_freq = {
+    A: 9, N: 6, B: 2, O: 8, C: 2, P: 2, D: 4, Q: 1, E: 12, R: 6, F: 2, S: 4,
+    G: 3, T: 6, H: 2, U: 4, I: 9, V: 2, J: 1, W: 2, K: 1, X: 1, L: 4, Y: 2, M: 2, Z: 1,
+  }
 
-    letter_freq = { 
-        A: 9, N: 6, B: 2, O: 8, C: 2, P: 2, D: 4, Q: 1, E: 12, R: 6, F: 2, S: 4,
-        G: 3, T: 6, H: 2, U: 4, I: 9, V: 2, J: 1, W: 2, K: 1, X: 1, L: 4, Y: 2, M: 2, Z: 1
-    }
+  avail_letters = array_gen(letter_freq)
+  used_letters = avail_letters.sample(10)
 
-    avail_letters = []
-    array_gen(letter_freq, avail_letters)
-    
-    used_letters = []
-    10.times do
-        curr_letter = avail_letters[rand(0...avail_letters.length)]
-        used_letters << curr_letter
-        avail_letters.delete(curr_letter)
-    end
-    return used_letters
+  return used_letters
 end
 
 # Validates input word by determining if it can be formed with letters in hand
-def uses_available_letters? (input, letters_in_hand)
-    if input.length > letters_in_hand.length
-        puts "Whoa, buddy. You used more letters than you have in your hand! Try again. "
+def uses_available_letters?(input, letters_in_hand)
+  if input.length > letters_in_hand.length
+    #puts "Whoa, buddy. You used more letters than you have in your hand! Try again. "
+    return false
+  else
+    possible_letters = letters_in_hand
+    input_array = input.split(//)
+    input_array.each do |char|
+      if possible_letters.include?(char)
+        possible_letters.delete(char)
+      else
+        #puts "Oh nooooo. You used a letter, #{char}, that's not in your hand"
         return false
-    else
-        possible_letters = letters_in_hand
-        input_array = input.split(//)
-        input_array.each do |char|
-            if possible_letters.include?(char)
-               possible_letters.delete(char)
-            else
-                "Oh nooooo. You used a letter, #{char}, that's not in your hand"
-                return false
-            end
-        end
+      end
     end
-    return true
+  end
+  return true
 end
 
 # Scores each word
 def score_word(word)
-    letter_score = { 
-        A: 1, N: 1, B: 3, O: 1, C: 3, P: 3, D: 2, Q: 10, E: 1, R: 1, F: 4, S: 1,
-        G: 2, T: 1, H: 4, U: 1, I: 1, V: 4, J: 8, W: 4, K: 5, X: 8, L: 1, Y: 4, M: 3, Z: 10
-    }
+  letter_score = {
+    A: 1, N: 1, B: 3, O: 1, C: 3, P: 3, D: 2, Q: 10, E: 1, R: 1, F: 4, S: 1,
+    G: 2, T: 1, H: 4, U: 1, I: 1, V: 4, J: 8, W: 4, K: 5, X: 8, L: 1, Y: 4, M: 3, Z: 10,
+  }
 
-    split_word = word.upcase.split(//)
-    word_score = split_word.reduce(0) do |memo, char|
-        memo += letter_score[char.to_sym]
-    end
-    if word.length >= 7
-        word_score += 8
-    end
-    return word_score
+  word_score = word.upcase.split(//).reduce(0) do |memo, char|
+    memo += letter_score[char.to_sym]
+  end
+
+  if word.length >= 7
+    word_score += 8
+  end
+
+  return word_score
 end
-        
 
 # Returns a single hash that represents the data of a winning word and its score.
 def highest_score_from(words)
-    words_with_scores = words.map do |word|
-        {word: word, score: score_word(word)}
-    end
+  winner = {
+    word: "",
+    score: 0,
+  }
 
-    winner = {
-        word: "",
-        score: 0
-    }
-
-    words_with_scores.each do |hash|
-        if hash[:score] > winner[:score]
-            winner = hash
-        elsif hash[:score] == winner[:score]
-            if ((hash[:word].length < winner[:word].length)  || (hash[:word].length == 10)) && (winner[:word].length != 10)
-                winner = hash
-            end
-        end
+  words.each do |word|
+    if score_word(word) > winner[:score]
+      winner = { word: word, score: score_word(word) }
+    elsif score_word(word) == winner[:score]
+      if ((word.length < winner[:word].length) || (word.length == 10)) && (winner[:word].length != 10)
+        winner = { word: word, score: score_word(word) }
+      end
     end
-    return winner
-end
\ No newline at end of file
+  end
+  return winner
+end

From d000c4d9805d40e50e48fba2f25f276c99e59ad4 Mon Sep 17 00:00:00 2001
From: Grace Shea <grace.m.shea@gmail.com>
Date: Thu, 21 Feb 2019 16:06:29 -0800
Subject: [PATCH 13/19] Wave 5 complete. Now can test valid English word
 against external CSV file.

---
 lib/adagrams.rb        |   7 +++
 specs/adagrams_spec.rb | 101 ++++++++++++++++++++++-------------------
 2 files changed, 62 insertions(+), 46 deletions(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index a96cf27..b24c9f6 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -1,4 +1,5 @@
 require "pry"
+require "csv"
 
 # Helper method that creates array of letters that are available to be drawn
 def array_gen(hash)
@@ -80,3 +81,9 @@ def highest_score_from(words)
   end
   return winner
 end
+
+def is_in_english_dict?(input)
+  dictionary = CSV.read("assets/dictionary-english.csv")
+  valid_word = dictionary.include?(input) ? true : false
+  return valid_word
+end
diff --git a/specs/adagrams_spec.rb b/specs/adagrams_spec.rb
index ae2ccd0..361c577 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
@@ -167,5 +165,16 @@
       expect(best_word[:word]).must_equal words.first
       expect(best_word[:score]).must_equal 18
     end
+
+    it "is a valid English word" do
+      # Arrange
+      word = "tyuzxy"
+
+      # Act
+      result = is_in_english_dict?(word)
+
+      # Assert
+      expect(result).must_equal false
+    end
   end
 end

From 04366afebfd75b4f03c6d8dd3a177a12508e4ebb Mon Sep 17 00:00:00 2001
From: Grace Shea <grace.m.shea@gmail.com>
Date: Thu, 21 Feb 2019 16:18:42 -0800
Subject: [PATCH 14/19] All Waves reviewed, minute adjustments to syntax

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

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index b24c9f6..59032d9 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -28,16 +28,14 @@ def draw_letters
 # Validates input word by determining if it can be formed with letters in hand
 def uses_available_letters?(input, letters_in_hand)
   if input.length > letters_in_hand.length
-    #puts "Whoa, buddy. You used more letters than you have in your hand! Try again. "
     return false
   else
+    # reassigning letters_in_hand to new variable in order to avoid destruction of original array
     possible_letters = letters_in_hand
-    input_array = input.split(//)
-    input_array.each do |char|
+    input.split(//).each do |char|
       if possible_letters.include?(char)
         possible_letters.delete(char)
       else
-        #puts "Oh nooooo. You used a letter, #{char}, that's not in your hand"
         return false
       end
     end
@@ -56,10 +54,7 @@ def score_word(word)
     memo += letter_score[char.to_sym]
   end
 
-  if word.length >= 7
-    word_score += 8
-  end
-
+  word_score += 8 if word.length >= 7
   return word_score
 end
 
@@ -82,6 +77,7 @@ def highest_score_from(words)
   return winner
 end
 
+# Verifies input word is in the English language CSV file
 def is_in_english_dict?(input)
   dictionary = CSV.read("assets/dictionary-english.csv")
   valid_word = dictionary.include?(input) ? true : false

From b8f677fff4946a72d7e13ac7c06242ca404760bb Mon Sep 17 00:00:00 2001
From: Shubha Rajan <shubharajan94@gmail.com>
Date: Thu, 21 Feb 2019 16:35:42 -0800
Subject: [PATCH 15/19] added conditions to raise exceptions and wrote test for
 is_an_english_word? method

---
 lib/adagrams.rb        | 5 +++++
 specs/adagrams_spec.rb | 3 ++-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 59032d9..4ee3814 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -27,6 +27,11 @@ def draw_letters
 
 # Validates input word by determining if it can be formed with letters in hand
 def uses_available_letters?(input, letters_in_hand)
+  if !(input.is_a?(String))
+    raise ArgumentError "Ummmmmm the value for input needs to be a string, ok?"
+  elsif !(letters_in_hand.is_a?(Array))
+    raise ArgumentError "letters_in_hand should be an array. That doesn't look right..."
+  end
   if input.length > letters_in_hand.length
     return false
   else
diff --git a/specs/adagrams_spec.rb b/specs/adagrams_spec.rb
index 361c577..9440a5f 100644
--- a/specs/adagrams_spec.rb
+++ b/specs/adagrams_spec.rb
@@ -165,7 +165,8 @@
       expect(best_word[:word]).must_equal words.first
       expect(best_word[:score]).must_equal 18
     end
-
+  end
+  describe "is_in_english_dict method" do
     it "is a valid English word" do
       # Arrange
       word = "tyuzxy"

From 76687c7bfe9737715cc33886604ff85c6fbb2c3f Mon Sep 17 00:00:00 2001
From: Grace Shea <grace.m.shea@gmail.com>
Date: Thu, 21 Feb 2019 16:46:46 -0800
Subject: [PATCH 16/19] Added conditional argument errors to adagrams.rb and
 added corresponding tests to spec file

---
 lib/adagrams.rb        |  4 ++--
 specs/adagrams_spec.rb | 10 ++++++++++
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 4ee3814..785fafe 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -28,9 +28,9 @@ def draw_letters
 # Validates input word by determining if it can be formed with letters in hand
 def uses_available_letters?(input, letters_in_hand)
   if !(input.is_a?(String))
-    raise ArgumentError "Ummmmmm the value for input needs to be a string, ok?"
+    raise ArgumentError, "Ummmmmm the value for input needs to be a string, ok?"
   elsif !(letters_in_hand.is_a?(Array))
-    raise ArgumentError "letters_in_hand should be an array. That doesn't look right..."
+    raise ArgumentError, "letters_in_hand should be an array. That doesn't look right..."
   end
   if input.length > letters_in_hand.length
     return false
diff --git a/specs/adagrams_spec.rb b/specs/adagrams_spec.rb
index 9440a5f..4d7233c 100644
--- a/specs/adagrams_spec.rb
+++ b/specs/adagrams_spec.rb
@@ -53,6 +53,16 @@
 
       expect(is_valid).must_equal false
     end
+
+    it "raises exception if arguments are invalid type" do
+      expect {
+        uses_available_letters?("A", :key)
+      }.must_raise ArgumentError
+
+      expect {
+        uses_available_letters?(8, ["A", "B", "C", "D", "E", "A", "B", "C", "D", "E"])
+      }.must_raise ArgumentError
+    end
   end
 
   describe "score_word method" do

From f1581d553a0601d913530d0e8cc1ee1d28d2a590 Mon Sep 17 00:00:00 2001
From: Shubha Rajan <shubharajan94@gmail.com>
Date: Thu, 21 Feb 2019 16:51:15 -0800
Subject: [PATCH 17/19] Edited error messages

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

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 785fafe..47db9b9 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -1,4 +1,3 @@
-require "pry"
 require "csv"
 
 # Helper method that creates array of letters that are available to be drawn
@@ -28,9 +27,9 @@ def draw_letters
 # Validates input word by determining if it can be formed with letters in hand
 def uses_available_letters?(input, letters_in_hand)
   if !(input.is_a?(String))
-    raise ArgumentError, "Ummmmmm the value for input needs to be a string, ok?"
+    raise ArgumentError, "Ummmmmm the value for the first argument needs to be a string, ok? Given value: #{input}"
   elsif !(letters_in_hand.is_a?(Array))
-    raise ArgumentError, "letters_in_hand should be an array. That doesn't look right..."
+    raise ArgumentError, "The second argument should be an array. That doesn't look right...Given value: #{letters_in_hand}"
   end
   if input.length > letters_in_hand.length
     return false

From 85f3740013187225faeeb9aee5f6ba8f1a6226e5 Mon Sep 17 00:00:00 2001
From: Shubha Rajan <shubharajan94@gmail.com>
Date: Tue, 26 Feb 2019 01:00:56 -0800
Subject: [PATCH 18/19] added case insensitivity to is_in_english_dict? and
 uses_available_letters?

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

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 47db9b9..45ce820 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -36,7 +36,7 @@ def uses_available_letters?(input, letters_in_hand)
   else
     # reassigning letters_in_hand to new variable in order to avoid destruction of original array
     possible_letters = letters_in_hand
-    input.split(//).each do |char|
+    input.upcase.split(//).each do |char|
       if possible_letters.include?(char)
         possible_letters.delete(char)
       else
@@ -84,6 +84,6 @@ def highest_score_from(words)
 # Verifies input word is in the English language CSV file
 def is_in_english_dict?(input)
   dictionary = CSV.read("assets/dictionary-english.csv")
-  valid_word = dictionary.include?(input) ? true : false
+  valid_word = dictionary.include?(input.downcase) ? true : false
   return valid_word
 end

From b323c73510cb129df3a584804fdedd53f981076b Mon Sep 17 00:00:00 2001
From: Shubha Rajan <shubharajan94@gmail.com>
Date: Thu, 28 Feb 2019 11:43:54 -0800
Subject: [PATCH 19/19] used clone method to make uses_available_letters
 non-destructive

---
 lib/adagrams.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/adagrams.rb b/lib/adagrams.rb
index 45ce820..d538385 100644
--- a/lib/adagrams.rb
+++ b/lib/adagrams.rb
@@ -35,7 +35,7 @@ def uses_available_letters?(input, letters_in_hand)
     return false
   else
     # reassigning letters_in_hand to new variable in order to avoid destruction of original array
-    possible_letters = letters_in_hand
+    possible_letters = letters_in_hand.clone
     input.upcase.split(//).each do |char|
       if possible_letters.include?(char)
         possible_letters.delete(char)