From 2e149335643751bc4578077b5ed658987967ff63 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Wed, 21 Dec 2022 09:22:43 -0700
Subject: [PATCH 01/45] Add unicorn.rb

---
 mythical-creatures/lib/unicorn.rb       | 17 +++++++++++++++++
 mythical-creatures/spec/unicorn_spec.rb |  4 ++--
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/mythical-creatures/lib/unicorn.rb b/mythical-creatures/lib/unicorn.rb
index e69de29b..480d2676 100644
--- a/mythical-creatures/lib/unicorn.rb
+++ b/mythical-creatures/lib/unicorn.rb
@@ -0,0 +1,17 @@
+class Unicorn
+  attr_reader :name, 
+              :color
+
+  def initialize(name, color = "silver")
+    @name = name
+    @color = color
+  end
+
+	def silver? 
+		@color == "silver"
+	end
+
+	def say(text)
+		"**;* #{text} **;*"
+	end
+end
diff --git a/mythical-creatures/spec/unicorn_spec.rb b/mythical-creatures/spec/unicorn_spec.rb
index 477028c2..5d98343c 100644
--- a/mythical-creatures/spec/unicorn_spec.rb
+++ b/mythical-creatures/spec/unicorn_spec.rb
@@ -11,14 +11,14 @@
     unicorn = Unicorn.new('Margaret')
     expect(unicorn.color).to eq('silver')
     expect(unicorn.silver?).to eq(true)
-    expect(unicorn.silver?).to be true
+    # expect(unicorn.silver?).to be true
   end
 
   it 'doesnt have to be silver' do
     unicorn = Unicorn.new('Barbara', 'purple')
     expect(unicorn.color).to eq('purple')
     expect(unicorn.silver?).to eq(false)
-    expect(unicorn.silver?).to be false
+    # expect(unicorn.silver?).to be false
   end
 
   it 'says sparkly stuff' do

From a74ba85a7a7b714347650a0e5fb9ad25fa12e030 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Wed, 21 Dec 2022 09:33:43 -0700
Subject: [PATCH 02/45] Add vampire.rb

---
 mythical-creatures/lib/vampire.rb | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 mythical-creatures/lib/vampire.rb

diff --git a/mythical-creatures/lib/vampire.rb b/mythical-creatures/lib/vampire.rb
new file mode 100644
index 00000000..f5ef6fae
--- /dev/null
+++ b/mythical-creatures/lib/vampire.rb
@@ -0,0 +1,19 @@
+class Vampire
+	attr_reader :name,
+							:pet,
+							:thirsty
+
+	def initialize(name, pet = "bat")
+		# pet in paramaters above are a default-optional argument
+		# but pet is change-able cuz it's ALSO below too: 
+		@name = name
+		@pet = pet
+		@thirsty = true
+		#thirsty here is good cuz as an argument (above) you wouldn't know WHAT is true
+	end
+
+	def drink
+		@thirsty = false
+	end
+
+end
\ No newline at end of file

From 0964a4df355e3dcb8fe28d637fb38efffd47ea27 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Wed, 21 Dec 2022 09:46:26 -0700
Subject: [PATCH 03/45] Add dragon.rb

---
 mythical-creatures/lib/dragon.rb | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 mythical-creatures/lib/dragon.rb

diff --git a/mythical-creatures/lib/dragon.rb b/mythical-creatures/lib/dragon.rb
new file mode 100644
index 00000000..5f6dbdce
--- /dev/null
+++ b/mythical-creatures/lib/dragon.rb
@@ -0,0 +1,27 @@
+class Dragon
+	attr_reader :name,
+							:color, 
+							:rider, 
+							:hungry,
+							:meals
+
+	def initialize(name, color, rider)
+		@name = name
+		@color = color
+		@rider = rider
+		@hungry = true
+		@meals = 0
+	end
+
+	def hungry?
+		@hungry
+	end
+
+	def eat
+		@meals += 1
+		if @meals >=3
+			@hungry = false
+		end
+	end
+
+end
\ No newline at end of file

From 4632428c501c7bba8c73a4a348e2188e8b481b10 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Wed, 21 Dec 2022 09:50:09 -0700
Subject: [PATCH 04/45] Add class files

---
 mythical-creatures/lib/centaur.rb     | 0
 mythical-creatures/lib/direwolf.rb    | 0
 mythical-creatures/lib/hobbit.rb      | 0
 mythical-creatures/lib/medusa.rb      | 0
 mythical-creatures/lib/ogre.rb        | 0
 mythical-creatures/lib/pirate.rb      | 0
 mythical-creatures/lib/the_journey.rb | 0
 mythical-creatures/lib/werewolf.rb    | 0
 mythical-creatures/lib/wizard.rb      | 0
 9 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 mythical-creatures/lib/centaur.rb
 create mode 100644 mythical-creatures/lib/direwolf.rb
 create mode 100644 mythical-creatures/lib/hobbit.rb
 create mode 100644 mythical-creatures/lib/medusa.rb
 create mode 100644 mythical-creatures/lib/ogre.rb
 create mode 100644 mythical-creatures/lib/pirate.rb
 create mode 100644 mythical-creatures/lib/the_journey.rb
 create mode 100644 mythical-creatures/lib/werewolf.rb
 create mode 100644 mythical-creatures/lib/wizard.rb

diff --git a/mythical-creatures/lib/centaur.rb b/mythical-creatures/lib/centaur.rb
new file mode 100644
index 00000000..e69de29b
diff --git a/mythical-creatures/lib/direwolf.rb b/mythical-creatures/lib/direwolf.rb
new file mode 100644
index 00000000..e69de29b
diff --git a/mythical-creatures/lib/hobbit.rb b/mythical-creatures/lib/hobbit.rb
new file mode 100644
index 00000000..e69de29b
diff --git a/mythical-creatures/lib/medusa.rb b/mythical-creatures/lib/medusa.rb
new file mode 100644
index 00000000..e69de29b
diff --git a/mythical-creatures/lib/ogre.rb b/mythical-creatures/lib/ogre.rb
new file mode 100644
index 00000000..e69de29b
diff --git a/mythical-creatures/lib/pirate.rb b/mythical-creatures/lib/pirate.rb
new file mode 100644
index 00000000..e69de29b
diff --git a/mythical-creatures/lib/the_journey.rb b/mythical-creatures/lib/the_journey.rb
new file mode 100644
index 00000000..e69de29b
diff --git a/mythical-creatures/lib/werewolf.rb b/mythical-creatures/lib/werewolf.rb
new file mode 100644
index 00000000..e69de29b
diff --git a/mythical-creatures/lib/wizard.rb b/mythical-creatures/lib/wizard.rb
new file mode 100644
index 00000000..e69de29b

From ebb9550bfc7e4d827c2b0a0ea4f9f3f9318fd90b Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Wed, 21 Dec 2022 10:19:22 -0700
Subject: [PATCH 05/45] Add hobbit.rb

---
 mythical-creatures/lib/hobbit.rb       | 35 ++++++++++++++++++++++++++
 mythical-creatures/spec/hobbit_spec.rb | 23 ++++++++++++++---
 2 files changed, 55 insertions(+), 3 deletions(-)

diff --git a/mythical-creatures/lib/hobbit.rb b/mythical-creatures/lib/hobbit.rb
index e69de29b..0a053458 100644
--- a/mythical-creatures/lib/hobbit.rb
+++ b/mythical-creatures/lib/hobbit.rb
@@ -0,0 +1,35 @@
+class Hobbit
+	attr_reader :name,
+							:disposition,
+							:age,
+							:is_short
+
+	def initialize(name, disposition = "homebody")
+		@name = name
+		@disposition = disposition
+		@age = 0
+		@is_short = true
+	end
+
+	def celebrate_birthday
+		@age += 1
+	end
+
+	def adult?
+		@age > 32 
+		# doesn't need an if statement because adult? will return a boolean
+	end
+
+	def old?
+		@age > 100
+	end
+
+	def has_ring?
+		@name == "Frodo"
+	end
+
+	def is_short?
+		@is_short
+	end
+
+end
\ No newline at end of file
diff --git a/mythical-creatures/spec/hobbit_spec.rb b/mythical-creatures/spec/hobbit_spec.rb
index f49faed3..beb08ad0 100644
--- a/mythical-creatures/spec/hobbit_spec.rb
+++ b/mythical-creatures/spec/hobbit_spec.rb
@@ -58,21 +58,38 @@
     expect(hobbit.adult?).to be true
   end
 
-  xit 'is old at the age of 101' do
+  it 'is old at the age of 101' do
     # create a hobbit
     # have hobbit age 101 years
     # check that hobbit.old? returns true
+    hobbit = Hobbit.new('Otho')
+
+    expect(hobbit.old?).to eq(false)
+
+    101.times do
+      hobbit.celebrate_birthday
+    end
+
+    expect(hobbit.old?).to eq(true)
   end
 
-  xit 'it has the ring if its name is Frodo' do
+  it 'it has the ring if its name is Frodo' do
     # create a hobbit named Frodo
     # create a second hobbit named Sam
     # check that .has_ring? for Frodo returns true
     # check that .has_ring? for Sam returns false
+    sam = Hobbit.new('Samwise')
+    frodo = Hobbit.new('Frodo')
+
+    expect(frodo.has_ring?).to be true
+    expect(sam.has_ring?).to be false
   end
 
-  xit 'they are short' do
+  it 'they are short' do
     # create a hobbit
     # check that is_short? returns true
+    sam = Hobbit.new('Samwise')
+
+    expect(sam.is_short?).to be true
   end
 end

From ffd46510ec5faf6a20f6d6b84f58914c205f5162 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Wed, 21 Dec 2022 10:36:28 -0700
Subject: [PATCH 06/45] Add pirate.rb

---
 mythical-creatures/lib/pirate.rb       | 30 ++++++++++++++++++++++++++
 mythical-creatures/spec/pirate_spec.rb | 13 +++++++++++
 2 files changed, 43 insertions(+)

diff --git a/mythical-creatures/lib/pirate.rb b/mythical-creatures/lib/pirate.rb
index e69de29b..a9e96db4 100644
--- a/mythical-creatures/lib/pirate.rb
+++ b/mythical-creatures/lib/pirate.rb
@@ -0,0 +1,30 @@
+class Pirate
+	attr_reader :name,
+							:job,
+							:cursed,
+							:heinous_acts,
+							:booty
+
+	def initialize(name, job = "Scallywag")
+		@name = name
+		@job = job
+		@cursed = false
+		@heinous_acts = 0
+		@booty = 0
+	end
+
+	def cursed?
+		@cursed
+	end
+
+	def commit_heinous_act
+		@heinous_acts += 1
+		if @heinous_acts >= 3
+			@cursed = true
+		end
+	end
+
+	def rob_ship
+		@booty += 100
+	end
+end
\ No newline at end of file
diff --git a/mythical-creatures/spec/pirate_spec.rb b/mythical-creatures/spec/pirate_spec.rb
index ec2c086e..28c87f9a 100644
--- a/mythical-creatures/spec/pirate_spec.rb
+++ b/mythical-creatures/spec/pirate_spec.rb
@@ -40,12 +40,25 @@
   it 'has a booty' do
     # create a pirate
     # check that the pirate starts with 0 booty
+    pirate = Pirate.new('Jack')
+
+    expect(pirate.booty).to eq(0)
   end
 
   it 'gets 100 booty for robbing a ship' do
     # create a pirate
     # rob some ships
     # check that the pirate got 100 booty for each ship it robbed
+    pirate = Pirate.new('Jack')
+
+    pirate.rob_ship
+    expect(pirate.booty).to eq(100)
+
+    pirate.rob_ship
+    expect(pirate.booty).to eq(200)
+
+    pirate.rob_ship
+    expect(pirate.booty).to eq(300)
   end
 
 end

From a20d30909ef78012c0a112c0c070d652da7ce724 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Wed, 21 Dec 2022 11:07:59 -0700
Subject: [PATCH 07/45] Add wizard.rb

---
 mythical-creatures/lib/pirate.rb       |  1 -
 mythical-creatures/lib/wizard.rb       | 47 ++++++++++++++++++++++++++
 mythical-creatures/spec/wizard_spec.rb | 18 ++++++++--
 3 files changed, 63 insertions(+), 3 deletions(-)

diff --git a/mythical-creatures/lib/pirate.rb b/mythical-creatures/lib/pirate.rb
index a9e96db4..5eaa568e 100644
--- a/mythical-creatures/lib/pirate.rb
+++ b/mythical-creatures/lib/pirate.rb
@@ -2,7 +2,6 @@ class Pirate
 	attr_reader :name,
 							:job,
 							:cursed,
-							:heinous_acts,
 							:booty
 
 	def initialize(name, job = "Scallywag")
diff --git a/mythical-creatures/lib/wizard.rb b/mythical-creatures/lib/wizard.rb
index e69de29b..c8f32524 100644
--- a/mythical-creatures/lib/wizard.rb
+++ b/mythical-creatures/lib/wizard.rb
@@ -0,0 +1,47 @@
+class Wizard
+  attr_reader :name,
+							:bearded
+							# don't need rested here because we don't call it outside the class file
+
+	def initialize(name, bearded: true)
+		@name = name
+		@bearded = bearded
+		@rested = true
+		@spells = 0
+	end
+
+	def bearded?
+		@bearded
+	end
+
+	def incantation(input)
+		"sudo #{input}"
+	end
+
+	def rested?
+		@rested
+	end
+
+	def cast
+		if @spells < 2
+			@spells += 1
+			"MAGIC MISSILE!"
+		else
+			@rested = false
+		end
+		# this method doesn't allow the wizard to cast any spells 
+		# AFTER the wizard is tired!
+
+		# OPTIONS 2 #	
+	
+		# @spells += 1
+		# if @spells < 3
+		# else
+		# 	@rested = false
+		# end
+		# "MAGIC MISSILE!"
+		# this last line is the return so it MUST go at the end
+	end
+
+
+end
\ No newline at end of file
diff --git a/mythical-creatures/spec/wizard_spec.rb b/mythical-creatures/spec/wizard_spec.rb
index fbd73b71..fe0d03dd 100644
--- a/mythical-creatures/spec/wizard_spec.rb
+++ b/mythical-creatures/spec/wizard_spec.rb
@@ -3,8 +3,8 @@
 
 RSpec.describe Wizard do
   it 'has a name' do
-    wizard = Wizard.new('Eric')
-    expect(wizard.name).to eq('Eric')
+    wizard = Wizard.new('Erik')
+    expect(wizard.name).to eq('Erik')
   end
 
   it 'has a different name' do
@@ -35,11 +35,17 @@
   it 'starts rested' do
     # create wizard
     # .rested? returns true
+    wizard = Wizard.new('Stella', bearded: false)
+
+    expect(wizard.rested?).to be true
   end
 
   it 'can cast spells' do
     # create wizard
     # .cast returns "MAGIC MISSILE!"
+    wizard = Wizard.new('Sal', bearded: true)
+
+    expect(wizard.cast).to eq("MAGIC MISSILE!")
   end
 
   it 'gets tired after casting three spells' do
@@ -48,5 +54,13 @@
     # check if wizard is rested
     # casts spell
     # check wizard is not rested
+    wizard = Wizard.new('Sal', bearded: true)
+   
+    wizard.cast
+    wizard.cast
+    expect(wizard.rested?).to be true
+
+    wizard.cast
+    expect(wizard.rested?).to be false
   end
 end

From f0d5a4094fdf5f983b92bd5cb1e2db434c283ba0 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Wed, 21 Dec 2022 16:02:53 -0700
Subject: [PATCH 08/45] Add data-types, strings

---
 data-types/strings/spec/strings_spec.rb | 187 ++++++++++++------------
 1 file changed, 96 insertions(+), 91 deletions(-)

diff --git a/data-types/strings/spec/strings_spec.rb b/data-types/strings/spec/strings_spec.rb
index 55ab4928..8ab42ea8 100644
--- a/data-types/strings/spec/strings_spec.rb
+++ b/data-types/strings/spec/strings_spec.rb
@@ -3,210 +3,215 @@
     name = "alice"
     # In place of the line below, call a method on the name variable
     # defined above to acheive the expected output.
-    actual = name._____
-    expected = "Alice"
+    # actual = name._____
+    # expected = "Alice"
 
-    expect(actual).to eq(expected)
+    expect(name.capitalize).to eq("Alice")
   end
 
-  xit 'test 2' do
+  it 'test 2' do
     name = "aLiCe"
     # In place of the line below, call a method to achieve the expected output.
-    actual = name._____
-    expected = "ALICE"
+    # actual = name._____
+    # expected = "ALICE"
 
-    expect(actual).to eq(expected)
+    expect(name.upcase).to eq("ALICE")
   end
 
-  xit 'test 3' do
+  it 'test 3' do
     name = "AlIcE"
     # In place of the line below, call a method to achieve the expected output.
-    actual = name._____
-    expected = "alice"
+    # actual = name._____
+    # expected = "alice"
 
-    expect(actual).to eq(expected)
+    expect(name.downcase).to eq("alice")
   end
 
-  xit 'test 4' do
+  it 'test 4' do
     rhyme = "peter piper picked a peck of picked peppers"
     # In place of the line below, call a method to achieve the expected output.
-    actual = rhyme._____
-    expected = "sreppep dekcip fo kcep a dekcip repip retep"
+    # actual = rhyme._____
+    # expected = "sreppep dekcip fo kcep a dekcip repip retep"
 
-    expect(actual).to eq(expected)
+    expect(rhyme.reverse).to eq("sreppep dekcip fo kcep a dekcip repip retep")
   end
 
-  xit 'test 5' do
+  it 'test 5' do
     word = "ticking"
     # In place of the line below, call a method to achieve the expected output.
-    actual = word.______
-    expected = "kicking"
+    # actual = word.______
+    # expected = "kicking"
 
-    expect(actual).to eq(expected)
+    expect(word.replace("kicking")).to eq("kicking")
+    expect(word.gsub(/t/, "k")).to eq("kicking")
   end
 
-  xit 'test 6' do
+  it 'test 6' do
     word = "ticking"
     # In place of the line below, call a method to achieve the expected output.
-    actual = word.______
-    expected = "clocking"
+    # actual = word.______
+    # expected = "clocking"
 
-    expect(actual).to eq(expected)
+    expect(word.gsub(/ti/, "clo")).to eq("clocking")
+    expect(word.gsub(/i/, "*")).to eq("t*ck*ng")
   end
 
-  xit 'test 7' do
+  it 'test 7' do
     words = "five sleepy kittens"
     # In place of the line below, call a method to achieve the expected output.
-    actual = words.______
-    expected = "fiv* sl**py kitt*ns"
+    # actual = words.______
+    # expected = "fiv* sl**py kitt*ns"
 
-    expect(actual).to eq(expected)
+    expect(words.gsub(/e/, "*")).to eq("fiv* sl**py kitt*ns")
   end
 
-  xit 'test 8' do
+  it 'test 8' do
     greeting = "Hello!!"
     # In place of the line below, call a method to achieve the expected output.
-    actual = greeting._____
-    expected = "Hello!"
+    # actual = greeting._____
+    # expected = "Hello!"
 
-    expect(actual).to eq(expected)
+    expect(greeting.chop).to eq("Hello!")
   end
 
-  xit 'test 9' do
+  it 'test 9' do
     greeting = "Hello!!\n"
     # In place of the line below, call a method to achieve the expected output.
-    actual = greeting._____
-    expected = "Hello!!"
+    # actual = greeting._____
+    # expected = "Hello!!"
 
-    expect(actual).to eq(expected)
+    expect(greeting.chomp).to eq("Hello!!")
   end
 
-  xit 'test 10' do
+  it 'test 10' do
     greeting = "Hello!!\n\n"
     # In place of the line below, call a method to achieve the expected output.
-    actual = greeting._____
-    expected = "Hello!!\n"
+    # actual = greeting._____
+    # expected = "Hello!!\n"
 
-    expect(actual).to eq(expected)
+    expect(greeting.chomp).to eq("Hello!!\n")
+    expect(greeting.chomp.chomp).to eq("Hello!!")
   end
 
-  xit 'test 11' do
+  it 'test 11' do
     rhyme = "eeny, meeny, miny, moe"
     # In place of the line below, call a method to achieve the expected output.
-    actual = rhyme._____
-    expected = "ny, mny, miny, mo"
+    # actual = rhyme._____
+    # expected = "ny, mny, miny, mo"
 
-    expect(actual).to eq(expected)
+    expect(rhyme.delete("e")).to eq("ny, mny, miny, mo")
   end
 
-  xit 'test 12' do
+  it 'test 12' do
     rhyme = "eeny, meeny, miny, moe"
     # In place of the line below, call a method to achieve the expected output.
-    actual = rhyme._____
-    expected = "ny, mny, mny, m"
+    # actual = rhyme._____
+    # expected = "ny, mny, mny, m"
 
-    expect(actual).to eq(expected)
+    expect(rhyme.delete("eio")).to eq("ny, mny, mny, m")
+    expect(rhyme.delete("oei")).to eq("ny, mny, mny, m")
   end
 
-  xit 'test 13' do
+  it 'test 13' do
     greeting = "Hello World!"
     # In place of the line below, call a method to get the number of characters in the string
-    actual = greeting._____
-    expected = 12
+    # actual = greeting._____
+    # expected = 12
 
-    expect(actual).to eq(expected)
+    expect(greeting.length).to eq(12)
   end
 
-  xit 'test 14' do
+  it 'test 14' do
     greeting = "Hello World!\n"
     # In place of the line below, call a method to get the number of characters in the string
-    actual = greeting._____
-    expected = 13
+    # actual = greeting._____
+    # expected = 13
 
-    expect(actual).to eq(expected)
+    expect(greeting.length).to eq(13)
   end
 
-  xit 'test 15' do
+  it 'test 15' do
     greeting = "Hello       World!"
     # In place of the line below, call a method to get the number of characters in the string
-    actual = greeting._____
-    expected = 18
+    # actual = greeting._____
+    # expected = 18
 
-    expect(actual).to eq(expected)
+    expect(greeting.length).to eq(18)
   end
 
-  xit 'test 16' do
+  it 'test 16' do
     greeting = "Hello World!"
     # In place of the line below, call a method to get the number of 'o' in the string
-    actual = greeting._____
-    expected = 2
+    # actual = greeting._____
+    # expected = 2
 
-    expect(actual).to eq(expected)
+    expect(greeting.count("o")).to eq(2)
   end
 
-  xit 'test 17' do
+  it 'test 17' do
     greeting = "Hello World!"
     # In place of the line below, call a method to get the number of vowels in the string
-    actual = greeting._____
-    expected = 3
+    # actual = greeting._____
+    # expected = 3
 
-    expect(actual).to eq(expected)
+    expect(greeting.count("aeiou")).to eq(3)
   end
 
-  xit 'test 18' do
+  it 'test 18' do
     greeting = "Hello World!"
     # In place of the line below, call a method to check if the string includes 'llo'
-    actual = greeting._____
-    expected = true
+    # actual = greeting._____
+    # expected = true
 
-    expect(actual).to eq(expected)
+    expect(greeting.include?("llo")).to eq(true)
   end
 
-  xit 'test 19' do
+  it 'test 19' do
     greeting = "Hello World!"
     # In place of the line below, call a method to check if the string includes 'lol'
-    actual = greeting._____
-    expected = false
+    # actual = greeting._____
+    # expected = false
 
-    expect(actual).to eq(expected)
+    expect(greeting.include?("lol")).to eq(false)
   end
 
-  xit 'test 20' do
+  it 'test 20' do
     greeting = "Hello World, my name is"
     name = "Harry Potter"
     # In place of the line below, use string manipulation to combine the
     #greeting and name variables to acheive the expected outcome
-    actual = _________
-    expected = "Hello World, my name is Harry Potter"
+    # actual = _________
+    # expected = "Hello World, my name is Harry Potter"
 
-    expect(actual).to eq(expected)
+    expect("Hello World, my name is #{name}").to eq("Hello World, my name is Harry Potter")
   end
 
-  xit 'test 21' do
+  it 'test 21' do
     # See if you can use another method than the last test to achieve the same goal:
     greeting = "Hello World, my name is"
     name = "Harry Potter"
-    actual = ________
-    expected = "Hello World, my name is Harry Potter"
+    # actual = ________
+    # expected = "Hello World, my name is Harry Potter"
+    # .join(' ')
 
-    expect(actual).to eq(expected)
+    expect(greeting.concat(" ", name)).to eq("Hello World, my name is Harry Potter")
   end
 
-  xit 'test 22' do
+  it 'test 22' do
     greeting = "Hello World, my name is"
     name = "Harry Potter"
-    actual = ________
-    expected = "Hello World, my name is Harry Potter"
+    # actual = ________
+    # expected = "Hello World, my name is Harry Potter"
 
-    expect(actual).to eq(expected)
+    expect(greeting + " " + name).to eq("Hello World, my name is Harry Potter")
   end
 
-  xit 'test 23' do
+  it 'test 23' do
     phrase = "  \n\t to the moon\n\n\t    "
     # In place of the line below, call a method to acheive the expected outcome
-    actual = ________
-    expected = "to the moon"
+    # actual = ________
+    # expected = "to the moon"
 
-    expect(actual).to eq(expected)
+    expect(phrase.strip).to eq("to the moon")
   end
 end

From 353435aa9e426fb31b577f9eb2a56d46bd289df5 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Wed, 21 Dec 2022 16:35:12 -0700
Subject: [PATCH 09/45] Add data-types, integers

---
 .../spec/ints_and_floats_spec.rb              | 53 ++++++++++---------
 1 file changed, 27 insertions(+), 26 deletions(-)

diff --git a/data-types/ints_and_floats/spec/ints_and_floats_spec.rb b/data-types/ints_and_floats/spec/ints_and_floats_spec.rb
index b5ce319a..f28aac56 100644
--- a/data-types/ints_and_floats/spec/ints_and_floats_spec.rb
+++ b/data-types/ints_and_floats/spec/ints_and_floats_spec.rb
@@ -4,76 +4,77 @@
     unlucky = 13
     # Using the two variables defined above,
     # add the lucky number and the unlucky number
-    sum = ________
-    expect(sum).to eq(20)
+    # sum = ________
+    expect(lucky + unlucky).to eq(20)
   end
 
-  xit 'test 2' do
+  it 'test 2' do
     lucky = 7
     unlucky = 13
     # Using the two variables defined above,
     # subtract the unlucky from the lucky
-    difference = ________
-    expect(difference).to eq(-6)
+    # difference = ________
+    expect(lucky - unlucky).to eq(-6)
   end
 
-  xit 'test 3' do
+  it 'test 3' do
     lucky = 7
     unlucky = 13
     # Using the two variables defined above,
     # divide unlucky by lucky
     # NOTE: this is integer division
-    quotient = ________
-    expect(quotient).to eq(1)
+    # quotient = ________
+    expect(unlucky / lucky).to eq(1)
+    expect(unlucky.div(lucky)).to eq(1)
   end
 
-  xit 'test 4' do
+  it 'test 4' do
     lucky = 7
     unlucky = 13
     # Using the two variables defined above,
     # divide unlucky by lucky
-    quotient = ________
-    expect(quotient).to eq(1.8571428571428572)
+    # quotient = ________
+    expect(unlucky.fdiv(lucky)).to eq(1.8571428571428572)
   end
 
-  xit 'test 5' do
+  it 'test 5' do
     lucky = 7
     unlucky = 13
     # Using the two variables defined above,
     # find the remainder of the unlucky divided by the lucky
-    remainder = ____________
-    expect(remainder).to eq(6)
+    # remainder = ____________
+    expect(unlucky.remainder(lucky)).to eq(6)
   end
 
-  xit 'test 6' do
+  it 'test 6' do
     lucky = 7
     # Using the variable defined above,
     # find out if the lucky number is even
-    even = _________
-    expect(even).to eq(false)
+    # even = _________
+    expect(lucky.even?).to eq(false)
   end
 
-  xit 'test 7' do
+  it 'test 7' do
     pi = 3.14
     # Using the variable defined above,
     # round the number to the nearest whole number
-    rounded = _________
-    expect(rounded).to eq(3)
+    # rounded = _________
+    expect(pi.round).to eq(3)
   end
 
-  xit 'test 8' do
+  it 'test 8' do
     pi = 3.14
     # Using the variable defined above,
     # round the number to one decimal place
-    rounded = _________
-    expect(rounded).to eq(3.1)
+    # rounded = _________
+    expect(pi.round(1)).to eq(3.1)
   end
 
-  xit 'test 9' do
+  it 'test 9' do
     pi = 3.14
     # Using the variable defined above,
     # round the number to the next highest whole number
-    rounded = _________
-    expect(rounded).to eq(4)
+    # rounded = _________
+    expect(pi.ceil).to eq(4)
   end
 end

From 227c3a24a2514443ff762ad424dedfe8886c74e2 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Wed, 21 Dec 2022 18:19:16 -0700
Subject: [PATCH 10/45] Add half data-types, adv collections

---
 .../spec/advanced_nesting_spec.rb             | 139 +++++++++++++-----
 1 file changed, 106 insertions(+), 33 deletions(-)

diff --git a/data-types/collections/advanced_nested_collections/spec/advanced_nesting_spec.rb b/data-types/collections/advanced_nested_collections/spec/advanced_nesting_spec.rb
index 1c416475..e6fc890b 100644
--- a/data-types/collections/advanced_nested_collections/spec/advanced_nesting_spec.rb
+++ b/data-types/collections/advanced_nested_collections/spec/advanced_nesting_spec.rb
@@ -15,57 +15,69 @@
 RSpec.describe 'Advanced Nested Collections' do
   it 'test 1' do
     # EXAMPLE
-    employees = stores[:olive_garden][:employees]
+    # employees = stores[:olive_garden][:employees]
 
-    expected = ["Jeff", "Zach", "Samantha"]
-    expect(employees).to eq(expected)
+    # expected = ["Jeff", "Zach", "Samantha"]
+    expect(stores[:olive_garden][:employees]).to eq(["Jeff", "Zach", "Samantha"])
   end
 
-  xit 'test 2' do
+  it 'test 2' do
     # Find the ingredients for pancakes
-    pancake_ingredients = _____
+    # pancake_ingredients = _____
 
-    expected = ["Flour", "Eggs", "Milk", "Syrup"]
-    expect(pancake_ingredients).to eq(expected)
+    # expected = ["Flour", "Eggs", "Milk", "Syrup"]
+    expect(stores[:dennys][:dishes].first[:ingredients]).to eq(["Flour", "Eggs", "Milk", "Syrup"])
   end
 
-  xit 'test 3' do
+  it 'test 3' do
     # Find the price of risotto
-    risotto_price = ____
+    # risotto_price = ____
 
-    expect(risotto_price).to eq(12)
+    expect(stores[:olive_garden][:dishes].first[:price]).to eq(12)
   end
 
-  xit 'test 4' do
+  it 'test 4' do
     # Find the ingredients for a Big Mac
-    big_mac_ingredients = ____
+    # big_mac_ingredients = ____
 
-    expected = ['Bun','Hamburger','Ketchup','pickles']
-    expect(big_mac_ingredients).to eq(expected)
+    # expected = ['Bun','Hamburger','Ketchup','pickles']
+    expect(stores[:macdonalds][:dishes][0][:ingredients]).to eq(['Bun','Hamburger','Ketchup','pickles'])
   end
 
-  xit 'test 5' do
+  it 'test 5' do
     # Find a list of restaurants
-    store_names = ____
+    # store_names = ____
 
-    expected = [:olive_garden, :dennys, :macdonalds]
-    expect(store_names).to eq(expected)
+    # expected = [:olive_garden, :dennys, :macdonalds]
+    expect(stores.keys).to eq([:olive_garden, :dennys, :macdonalds])
   end
 
-  xit 'test 6' do
+  it 'test 6' do
     # Find dishes names for Olive Garden
-    dishes_names = ____
+    # dishes_names = ____
 
-    expect(dishes_names).to eq(['Risotto', 'Steak'])
+    list_of_dishes = stores[:olive_garden][:dishes].map do |dish_info|
+      dish_info[:name]
+    end
+
+    expect(list_of_dishes).to eq(['Risotto', 'Steak'])
   end
 
+  ######################## PICK UP FROM HERE ########################
   xit 'test 7' do
     # Return a list of employees across
     # all restaurants
-    employee_names = ____
+    # employee_names = ____
+    all_employees = []
+
+    stores.each do |restaurant|
+      all_employees << restaurant[:employees]
+    end
+
+    all_employees
 
-    expected = ["Jeff", "Zach", "Samantha", "Bob", "Sue", "James", "Alvin", "Simon", "Theodore"]
-    expect(employee_names).to eq(expected)
+    # expected = ["Jeff", "Zach", "Samantha", "Bob", "Sue", "James", "Alvin", "Simon", "Theodore"]
+    expect(all_employees).to eq(["Jeff", "Zach", "Samantha", "Bob", "Sue", "James", "Alvin", "Simon", "Theodore"])
   end
 
   xit 'test 8' do
@@ -73,7 +85,27 @@
     # across all restaurants
     ingredients = ____
 
-    expected = [
+    # expected = [
+    #   "Rice",
+    #   "Cheese",
+    #   "Butter",
+    #   "Beef",
+    #   "Garlic",
+    #   "Flour",
+    #   "Eggs",
+    #   "Milk",
+    #   "Syrup",
+    #   "Flour",
+    #   "Eggs",
+    #   "Syrup",
+    #   "Bun",
+    #   "Hamburger",
+    #   "Ketchup",
+    #   "pickles",
+    #   "Potatoes",
+    #   "Salt"
+    # ]
+    expect(ingredients).to eq([
       "Rice",
       "Cheese",
       "Butter",
@@ -92,8 +124,7 @@
       "pickles",
       "Potatoes",
       "Salt"
-    ]
-    expect(ingredients).to eq(expected)
+    ])
   end
 
   xit 'test 9' do
@@ -108,7 +139,19 @@
 
     olive_garden_menu = _____
     
-    expected = {
+    # expected = {
+    #   "Risotto" => {
+    #     :name => "Risotto",
+    #     :ingredients => ["Rice", "Cheese", "Butter"],
+    #     :price => 12
+    #   },
+    #   "Steak" => {
+    #     :name => "Steak",
+    #     :ingredients => ["Beef", "Garlic"],
+    #     :price => 15
+    #   }
+    # }
+    expect(olive_garden_menu).to eq({
       "Risotto" => {
         :name => "Risotto",
         :ingredients => ["Rice", "Cheese", "Butter"],
@@ -119,15 +162,46 @@
         :ingredients => ["Beef", "Garlic"],
         :price => 15
       }
-    }
-    expect(olive_garden_menu).to eq(expected)
+    })
   end
 
   xit 'test 11' do
     # Return a full menu across all restaurants
     full_menu = ____
 
-    expected = {
+    # expected = {
+    #   "Risotto" => {
+    #     :name => "Risotto",
+    #     :ingredients => ["Rice", "Cheese", "Butter"],
+    #     :price => 12
+    #   },
+    #   "Steak" => {
+    #     :name => "Steak",
+    #     :ingredients => ["Beef", "Garlic"],
+    #     :price => 15
+    #   },
+    #   "Pancakes" => {
+    #     :name => "Pancakes",
+    #     :ingredients => ["Flour", "Eggs", "Milk", "Syrup"],
+    #     :price => 10
+    #   },
+    #   "Waffles" => {
+    #     :name => "Waffles",
+    #     :ingredients => ["Flour", "Eggs", "Syrup"],
+    #     :price => 7
+    #   },
+    #   "Big Mac" => {
+    #     :name => "Big Mac",
+    #     :ingredients => ["Bun", "Hamburger", "Ketchup", "pickles"],
+    #     :price => 5
+    #   },
+    #   "Fries" => {
+    #     :name => "Fries",
+    #     :ingredients => ["Potatoes", "Salt"],
+    #     :price => 2
+    #   }
+    # }
+    expect(full_menu).to eq({
       "Risotto" => {
         :name => "Risotto",
         :ingredients => ["Rice", "Cheese", "Butter"],
@@ -158,7 +232,6 @@
         :ingredients => ["Potatoes", "Salt"],
         :price => 2
       }
-    }
-    expect(full_menu).to eq(expected)
+    })
   end
 end

From 94dbe9479f0319b4d8f4a37144bff246f842facf Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Thu, 22 Dec 2022 09:36:56 -0700
Subject: [PATCH 11/45] Add reduce_pattern test

---
 enumerables/exercises_1/spec/reduce_pattern_spec.rb | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/enumerables/exercises_1/spec/reduce_pattern_spec.rb b/enumerables/exercises_1/spec/reduce_pattern_spec.rb
index bb24bd1f..b0d6c573 100644
--- a/enumerables/exercises_1/spec/reduce_pattern_spec.rb
+++ b/enumerables/exercises_1/spec/reduce_pattern_spec.rb
@@ -27,7 +27,13 @@
   xit 'capitalizes key words in phrase' do
     keywords = ["fish", "blue"]
     phrase = 'one fish two fish red fish blue fish'
-    # Your code goes here
+
+    keywords.each do |keyword|
+      phrase = phrase.gsub(keyword, keyword.upcase) if keywords.include?(keyword)
+    end
+    # phrase.split.each do |keyword|
+    #   keyword.upcase if keywords.include?(keyword)
+    
     expect(phrase).to eq('one FISH two FISH red FISH BLUE FISH')
   end
 

From 5374ba3e01a9529f5bcaba0f3557f285c06fcd81 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Thu, 22 Dec 2022 10:15:45 -0700
Subject: [PATCH 12/45] Add iteration map_pattern

---
 iteration/exercises/spec/map_pattern_spec.rb | 86 ++++++++++++++++----
 1 file changed, 69 insertions(+), 17 deletions(-)

diff --git a/iteration/exercises/spec/map_pattern_spec.rb b/iteration/exercises/spec/map_pattern_spec.rb
index 22a17b77..dce699b7 100644
--- a/iteration/exercises/spec/map_pattern_spec.rb
+++ b/iteration/exercises/spec/map_pattern_spec.rb
@@ -9,34 +9,44 @@
     expect(capitalized_names).to eq(["Alice", "Bob", "Charlie"])
   end
 
-  xit 'test 2' do
+  it 'test 2' do
     family = {
       mother: "alice",
       father: "bob",
       brother: "charlie"
     }
+
     capitalized_family = {}
+
     family.each do |relationship, name|
       capitalized_family[relationship] = name.capitalize
     end
+
     expected = {
       mother: "Alice",
       father: "Bob",
       brother: "Charlie"
     }
+
     expect(capitalized_family).to eq(expected)
   end
 
-  xit 'test 3' do
+
+
+  it 'test 3' do
     numbers = [1, 2, 3, 4, 5]
     doubles = []
+
     numbers.each do |number|
-      # Your Code Here
+      doubles << number * 2
     end
+
     expect(doubles).to eq([2, 4, 6, 8, 10])
   end
 
-  xit 'test 4' do
+
+
+  it 'test 4' do
     numbers = {
       one: 1,
       two: 2,
@@ -45,9 +55,11 @@
       five: 5
     }
     doubles = {}
+
     numbers.each do |name, number|
-      # Your Code Here
+      doubles[name] = number * 2
     end
+
     expected = {
       one: 2,
       two: 4,
@@ -58,15 +70,21 @@
     expect(doubles).to eq(expected)
   end
 
-  xit 'test 5' do
+
+  it 'test 5' do
     numbers = [1, 2, 3, 4, 5]
     squares = []
-    # Your Code Here
+
+    numbers.each do |number|
+      squares << number ** 2
+    end
 
     expect(squares).to eq([1, 4, 9, 16, 25])
   end
 
-  xit 'test 6' do
+
+
+  it 'test 6' do
     numbers = {
       one: 1,
       two: 2,
@@ -75,7 +93,10 @@
       five: 5
     }
     squares = {}
-    # Your Code Here
+   
+    numbers.each do |word, number|
+      squares[word] = number ** 2
+    end
 
     expected = {
       one: 1,
@@ -87,14 +108,23 @@
     expect(squares).to eq(expected)
   end
 
-  xit 'test 7' do
+
+
+  it 'test 7' do
     names = ["alice", "bob", "charlie", "david", "eve"]
-    #Your Code Here
+    lengths = []
+
+    names.each do |name|
+      lengths << name.length
+    end 
 
     expect(lengths).to eq([5, 3, 7, 5, 3])
   end
 
-  xit 'test 8' do
+
+
+
+  it 'test 8' do
     family = {
       mother: "alice",
       father: "bob",
@@ -102,7 +132,12 @@
       uncle: "david",
       sister: "eve"
     }
-    #Your Code Here
+    
+    lengths = {}
+
+    family.each do |relationship, name|
+      lengths[relationship] = name.length
+    end
 
     expected = {
       mother: 5,
@@ -114,14 +149,25 @@
     expect(lengths).to eq(expected)
   end
 
-  xit 'test 9' do
+
+
+
+  it 'test 9' do
     names = ["alice", "bob", "charlie", "david", "eve"]
-    #Your Code Here
+    
+    backwards = []
+
+    names.each do |name|
+      backwards << name.reverse
+    end
 
     expect(backwards).to eq(["ecila", "bob", "eilrahc", "divad", "eve"])
   end
 
-  xit 'test 10' do
+
+
+
+  it 'test 10' do
     family = {
       mother: "alice",
       father: "bob",
@@ -129,7 +175,12 @@
       uncle: "david",
       sister: "eve"
     }
-    #Your Code Here
+
+    backwards = {}
+
+    family.each do |relationship, name|
+      backwards[relationship] = name.reverse
+    end
 
     expected = {
       mother: "ecila",
@@ -140,5 +191,6 @@
     }
     expect(backwards).to eq(expected)
   end
+
 end
 

From 3743f22b905dcd8ef09df9c00e0b9fa0cf73dd38 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Thu, 22 Dec 2022 12:19:28 -0700
Subject: [PATCH 13/45] Add iteration max-min file

---
 .../spec/max_and_min_by_pattern_spec.rb       | 165 ++++++++++++++++--
 1 file changed, 150 insertions(+), 15 deletions(-)

diff --git a/iteration/exercises/spec/max_and_min_by_pattern_spec.rb b/iteration/exercises/spec/max_and_min_by_pattern_spec.rb
index 6fbd4eb5..2b0f8088 100644
--- a/iteration/exercises/spec/max_and_min_by_pattern_spec.rb
+++ b/iteration/exercises/spec/max_and_min_by_pattern_spec.rb
@@ -1,15 +1,22 @@
 RSpec.describe 'max and min by pattern' do
+
   it 'test 1'  do
     numbers = [1, 100, 1000, 1000000]
     greatest = numbers[0]
+    # the original array <numbers> does NOT need to be sorted first 
+    # cuz the method below will always find the greatest number after it's full iteration
+    
     numbers.each do |number|
       if number > greatest
         greatest = number
       end
     end
-    expect(greatest).to eq(100000)
+
+    expect(greatest).to eq(1000000)
   end
 
+
+
   it 'test 2' do
     magnitudes = {
       ones: 1,
@@ -17,26 +24,38 @@
       thousands: 1000,
       millions: 1000000
     }
+
     greatest = magnitudes[magnitudes.keys[0]]
+    # The first element (index pos. 0) of the value(s) of the keys is being called on here
+
     magnitudes.each do |name, value|
       if value > greatest
         greatest = value
       end
     end
+
     expect(greatest).to eq(1000000)
   end
 
-  xit 'test 3' do
+
+
+  it 'test 3' do
     meals = ["banana", "nuts", "salad", "steak", "cake"]
     shortest_word = meals[0]
+    
     meals.each do |meal|
-      # Your Code Here
+      if meal.length < shortest_word.length
+        shortest_word = meal
+      end
     end
-
+ 
     expect(shortest_word).to eq("nuts")
   end
 
-  xit 'test 4' do
+
+
+
+  it 'test 4' do
     meals = {
       breakfast: "banana",
       snack: "nuts",
@@ -45,22 +64,84 @@
       dessert: "cake"
     }
     shortest_word = meals[meals.keys.first]
+
+    # meals[meals.keys.first] =(is equal to)= meals[:breakfast] => "banana"
+    # meals returns hash, keys returns array, first returns string/value
+    # shortest_word = meals[meals.keys[0]] # This is the same as the line above
+
     meals.each do |meal, dish|
-      # Your Code Here
+      if dish.length < shortest_word.length
+        shortest_word = dish
+      end
     end
 
     expect(shortest_word).to eq("nuts")
   end
 
-  xit 'test 5' do
+
+
+  it 'test 4.5' do
+    meals = {
+      breakfast: "banana",
+      snack: "nuts",
+      lunch: "salad",
+      dinner: "steak",
+      dessert: "cake"
+    }
+    
+    # longest_word = meals[meals.keys.last]
+    # meals.each do |meal, dish|
+    #   if dish.length > longest_word.length
+    #     longest_word = dish
+    #   end
+    # end
+    # expect(longest_word).to eq("banana")
+
+    
+    # words_length_array = meals.map do |meal, dish|
+    #   [dish.length, dish]
+    # end.sort.group_by do |dish|
+    #   dish.first
+    # end
+    #=> {4=>[[4, "cake"], [4, "nuts"]], 5=>[[5, "salad"], [5, "steak"]], 6=>[[6, "banana"]]}
+
+    # words_length.sort
+    # words_length.sort.group_by(&:first)
+    # &: is a shortcut for 
+
+
+    # .map returns a modified ARRAY / .each returns the original collection (hash/array)
+    words_length_array = meals.map do |meal, dish|
+      [dish.length, dish]
+    end.sort
+
+    expect(words_length_array.first.last).to eq("cake")
+    #=> words_length_array: {[4, "cake"], [4, "nuts"], [5, "salad"], [5, "steak"], [6, "banana"]}
+    #=> words_length_array.first: [4, "cake"]
+    #=> words_length_array.first.last: "cake"
+
+    expect(words_length_array.last.last).to eq("banana")
+  end
+
+
+
+
+  it 'test 5' do
     stats = [3001, 431, 1695, 0.27601, 0.340]
     most_digits = stats[0]
-    # Your Code Here
+
+    stats.each do |element|
+      if most_digits.to_s.delete(".").length < element.to_s.delete(".").length
+        most_digits = element
+      end
+    end
 
     expect(most_digits).to eq(0.27601)
   end
 
-  xit 'test 6' do
+
+
+  it 'test 6' do
     stats = {
       games_played: 3001,
       home_runs: 431,
@@ -68,19 +149,39 @@
       batting_average: 0.27601,
       on_base_percentage: 0.340
     }
+
     most_digits = stats[stats.keys.first]
-    # Your Code Here
+
+    stats.each do |title, number|
+      # if there was only one value in the || it would default to the ARRAY of the key-value PAIR
+      if most_digits.to_s.delete(".").length < number.to_s.delete(".").length
+        most_digits = number
+      end
+    end
+
 
     expect(most_digits).to eq(0.27601)
   end
 
-  xit 'test 7' do
+
+
+
+  it 'test 7' do
     ages = [39, 45, 29, 24, 50]
-    # Your Code Here
+    oldest = ages[0]
+
+    ages.each do |age|
+      if age > oldest
+        oldest = age
+      end
+    end
 
     expect(oldest).to eq(50)
   end
 
+
+
+
   xit 'test 8' do
     ages = {
       abdi: 39,
@@ -89,12 +190,43 @@
       margaret: 24,
       miguel: 50
     }
-    # Your Code Here
 
-    expected = {name: "miguel", age: 50}
-    expect(oldest).to eq(expected)
+    # oldest = {}
+    # # We must have this variable set to something so it can be redefined inside the code block
+    # oldest_age = ages[ages.keys.first]
+
+    # ages.each do |name, age|
+    #   if age > oldest_age
+    #     oldest_age = age
+    #     oldest = {name: name.to_s, age: age}
+    #     # Here we redefine that previously made empty hash
+    #   end
+    # end
+
+    # expected = {name: "miguel", age: 50}
+    # expect(oldest).to eq(expected)
+
+    ## ATTEMPT TO USE .MAP ##
+
+    oldest_age = ages[ages.keys.first]
+    oldest = ages.map do |name, age|
+      if age > oldest_age
+        oldest_age = age
+        {name: name.to_s, age: age}
+      end
+    end.compact
+    # we use .compact cuz .map returns nil for elements that's do NOT pass the if conditional!
+    expect(oldest.last).to eq(expected)
+    #if you don't put .last you will get an array returned cuz .map returns an array,
+    # AND the array will include multiple hashes (last line of our code block) that were created 
+    # so you only want the LAST one/oldest one!
   end
 
+
+
+  
+
+
   xit 'test 9' do
     programmers = [["katrina", "sandi", "jim", "aaron", "desi"], ["abby", "jon", "susan"]]
     # Your Code Here
@@ -102,6 +234,9 @@
     expect(fewest_programmers).to eq(["abby", "jon", "susan"])
   end
 
+
+
+
   xit 'test 10' do
     programmers = {ruby: ["katrina", "sandi", "jim", "aaron", "desi"], java: ["abby", "jon", "susan"]}
     # Your Code Here

From 0688b6d3b21b9c05c0642bb5fbbf045a9ab2b6ea Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Thu, 22 Dec 2022 13:47:43 -0700
Subject: [PATCH 14/45] Add medusa methods

---
 mythical-creatures/lib/medusa.rb       | 45 ++++++++++++++++++++++++++
 mythical-creatures/spec/medusa_spec.rb | 36 +++++++++++++++++++--
 2 files changed, 79 insertions(+), 2 deletions(-)

diff --git a/mythical-creatures/lib/medusa.rb b/mythical-creatures/lib/medusa.rb
index e69de29b..c3fd4ec7 100644
--- a/mythical-creatures/lib/medusa.rb
+++ b/mythical-creatures/lib/medusa.rb
@@ -0,0 +1,45 @@
+class Medusa
+	attr_reader :name,
+							:statues
+						
+	def initialize(name)
+		@name = name
+		@statues = []
+		@victims_full = false
+	end
+
+	def stare(victim)
+		@statues << victim
+		victim.stoned = true
+		revive
+	end
+
+	def revive
+		if @statues.count > 3 
+			@statues[0].stoned = false
+			@statues.shift
+		end
+	end
+
+	def victims_full?
+		if @statues.count >= 3
+			@victims_full = true
+		else
+			false
+		end
+	end 
+end
+
+class Person
+	attr_reader :name
+	attr_accessor :stoned
+						
+	def initialize(name)
+		@name = name
+		@stoned = false
+	end
+
+	def stoned?
+		@stoned
+	end
+end
\ No newline at end of file
diff --git a/mythical-creatures/spec/medusa_spec.rb b/mythical-creatures/spec/medusa_spec.rb
index 628c02ef..40659e53 100644
--- a/mythical-creatures/spec/medusa_spec.rb
+++ b/mythical-creatures/spec/medusa_spec.rb
@@ -32,10 +32,42 @@
   end
 
   it 'can only have three victims' do
-    # your code here
+    medusa = Medusa.new('Cassiopeia')
+    leon = Person.new('Leon')
+    mel = Person.new('Mel')
+    huy = Person.new('Huy')
+    cyclops = Person.new('Cyclops')
+
+    medusa.stare(leon)
+    medusa.stare(mel)
+    expect(medusa.victims_full?).to be false
+
+    medusa.stare(huy)
+    expect(medusa.victims_full?).to be true
   end
 
   it 'if a fourth victim is stoned the first is unstoned' do
-    # your code here
+    medusa = Medusa.new('Cassiopeia')
+    leon = Person.new('Leon')
+    mel = Person.new('Mel')
+    huy = Person.new('Huy')
+    cyclops = Person.new('Cyclops')
+
+    medusa.stare(leon)
+    medusa.stare(mel)
+    expect(medusa.victims_full?).to be false
+
+    medusa.stare(huy)
+    expect(medusa.victims_full?).to be true
+
+    medusa.stare(cyclops)
+
+    expect(leon.stoned?).to be false
+    expect(medusa.victims_full?).to be true
+    expect(medusa.statues.count).to eq(3)
+
+    expect(mel.stoned?).to be true
+    expect(huy.stoned?).to be true
+    expect(cyclops.stoned?).to be true
   end
 end

From 21147a5616f88ff7a5366d7045397eba6f658451 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Thu, 22 Dec 2022 14:39:23 -0700
Subject: [PATCH 15/45] Add werewolf.rb

---
 mythical-creatures/lib/werewolf.rb       | 56 ++++++++++++++++++++
 mythical-creatures/spec/werewolf_spec.rb | 66 +++++++++++++++++++-----
 2 files changed, 108 insertions(+), 14 deletions(-)

diff --git a/mythical-creatures/lib/werewolf.rb b/mythical-creatures/lib/werewolf.rb
index e69de29b..4fed2a23 100644
--- a/mythical-creatures/lib/werewolf.rb
+++ b/mythical-creatures/lib/werewolf.rb
@@ -0,0 +1,56 @@
+class Werewolf
+	attr_reader :name,
+							:location,
+							:victims
+						
+						
+	def initialize(name, location = "London")
+		@name = name
+		@location = location
+		@human = true
+		@hungry = false
+		@victims = []
+  end
+
+	def human?
+		@human
+	end
+
+	def wolf?
+		if human? 
+			false
+		else
+			true
+		end
+	end
+
+	def change!
+		if human?
+			@human = false
+			@hungry = true
+		else
+			@human = true
+			@hungry = false
+		end
+	end
+
+	def hungry?
+		@hungry
+	end
+
+	def consumes(victim)
+		if wolf?
+			@victims << victim
+			@hungry = false
+			victim.status = :dead_as_a_doorknob
+		end
+	end
+end
+
+class Victim
+	attr_accessor :status
+
+	def initialize
+		@status = :alive
+	end
+end
\ No newline at end of file
diff --git a/mythical-creatures/spec/werewolf_spec.rb b/mythical-creatures/spec/werewolf_spec.rb
index aab327ca..aa2588cd 100644
--- a/mythical-creatures/spec/werewolf_spec.rb
+++ b/mythical-creatures/spec/werewolf_spec.rb
@@ -14,12 +14,15 @@
 
   it 'is by default human' do
     werewolf = Werewolf.new('David', 'London')
-    expect(werewolf.human?).to be false
+
+    expect(werewolf.human?).to be true
   end
 
   it 'when starting as a human, changing makes it turn into a werewolf' do
     werewolf = Werewolf.new('David', 'London')
+
     werewolf.change!
+
     expect(werewolf.wolf?).to be true
     expect(werewolf.human?).to be false
   end
@@ -50,35 +53,70 @@
   end
 
   it 'is not hungry by default' do
-    # your code here
+    werewolf = Werewolf.new('David', 'London')
+
+    expect(werewolf.hungry?).to be false
   end
 
   it 'becomes hungry after changing to a werewolf' do
-    # your code here
+    werewolf = Werewolf.new('David', 'London')
+
+    expect(werewolf.hungry?).to be false
+    werewolf.change!
+    expect(werewolf.hungry?).to be true
   end
 
-  class Victim
-    attr_accessor :status
+  # class Victim
+  #   attr_accessor :status
 
-    def initialize
-      @status = :alive
-    end
-  end
+  #   def initialize
+  #     @status = :alive
+  #   end
+  # end
 
   it 'consumes a victim' do
-    # your code here
+    werewolf = Werewolf.new('David', 'London')
+    victim = Victim.new
+
+    werewolf.change!
+
+    expect(werewolf.victims).to eq([])
+
+    werewolf.consumes(victim)
+
+    expect(werewolf.victims).to eq([victim])
   end
 
-  it 'cannot consume a victim if it is in human form' do
-    # your code here
+  it 'cannot consume a victim if (the werewolf) is in human form' do
+    werewolf = Werewolf.new('David', 'London')
+    victim = Victim.new
+
+    werewolf.consumes(victim)
+
+    expect(werewolf.victims).to eq([])
   end
 
   it 'a werewolf that has consumed a human being is no longer hungry' do
-    # your code here
+    werewolf = Werewolf.new('David', 'London')
+    victim = Victim.new
+
+    werewolf.change!
+
+    expect(werewolf.hungry?).to be true
+
+    werewolf.consumes(victim)
+    
+    expect(werewolf.hungry?).to be false
   end
 
   it 'a werewolf who has consumed a victim makes the victim dead' do
-    # your code here
+    werewolf = Werewolf.new('David', 'London')
+    victim = Victim.new
+
+    werewolf.change!
+    werewolf.consumes(victim)
+
+    expect(victim.status).to eq(:dead_as_a_doorknob)
   end
 
 end

From d78be935f1daa3fd5eb4f4430bf681d19452298a Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Thu, 22 Dec 2022 16:20:07 -0700
Subject: [PATCH 16/45] Add data-types, collections, adv nested methods finish

---
 .../spec/advanced_nesting_spec.rb             | 138 +++++++-----------
 1 file changed, 49 insertions(+), 89 deletions(-)

diff --git a/data-types/collections/advanced_nested_collections/spec/advanced_nesting_spec.rb b/data-types/collections/advanced_nested_collections/spec/advanced_nesting_spec.rb
index e6fc890b..3d5ae8dc 100644
--- a/data-types/collections/advanced_nested_collections/spec/advanced_nesting_spec.rb
+++ b/data-types/collections/advanced_nested_collections/spec/advanced_nesting_spec.rb
@@ -63,49 +63,32 @@
     expect(list_of_dishes).to eq(['Risotto', 'Steak'])
   end
 
-  ######################## PICK UP FROM HERE ########################
-  xit 'test 7' do
+  it 'test 7' do
     # Return a list of employees across
     # all restaurants
     # employee_names = ____
-    all_employees = []
 
-    stores.each do |restaurant|
-      all_employees << restaurant[:employees]
+    all_employees = stores.flat_map do |restaurant, info|
+      info[:employees]
     end
 
-    all_employees
-
     # expected = ["Jeff", "Zach", "Samantha", "Bob", "Sue", "James", "Alvin", "Simon", "Theodore"]
     expect(all_employees).to eq(["Jeff", "Zach", "Samantha", "Bob", "Sue", "James", "Alvin", "Simon", "Theodore"])
   end
 
-  xit 'test 8' do
-    # Return a list of all ingredients
-    # across all restaurants
-    ingredients = ____
-
-    # expected = [
-    #   "Rice",
-    #   "Cheese",
-    #   "Butter",
-    #   "Beef",
-    #   "Garlic",
-    #   "Flour",
-    #   "Eggs",
-    #   "Milk",
-    #   "Syrup",
-    #   "Flour",
-    #   "Eggs",
-    #   "Syrup",
-    #   "Bun",
-    #   "Hamburger",
-    #   "Ketchup",
-    #   "pickles",
-    #   "Potatoes",
-    #   "Salt"
-    # ]
-    expect(ingredients).to eq([
+
+  it 'test 8' do
+    # Return a list of all ingredients across all restaurants
+    # ingredients = ____
+
+    ingredients = stores.flat_map do |restaurant, info|
+    info[:dishes].flat_map do |dish|
+      dish[:ingredients]
+    end
+  end
+
+
+    expected = [
       "Rice",
       "Cheese",
       "Butter",
@@ -124,34 +107,31 @@
       "pickles",
       "Potatoes",
       "Salt"
-    ])
+    ]
+    expect(ingredients).to eq(expected)
   end
 
-  xit 'test 9' do
+  it 'test 9' do
     # Return the full menu price for Olive Garden
-    full_menu_price = ____
+    # full_menu_price = ____
+
+    full_menu_price = stores[:olive_garden][:dishes].map do |dish|
+      dish[:price]
+    end.sum
 
     expect(full_menu_price).to eq(27)
   end
 
-  xit 'test 10' do
+  it 'test 10' do
     # Return the full menu for Olive Garden
+    # olive_garden_menu = _____
+    olive_garden_menu = {}
 
-    olive_garden_menu = _____
+    stores[:olive_garden][:dishes].select do |dish|
+      olive_garden_menu[dish[:name]] = {:name => dish[:name], :ingredients => dish[:ingredients], :price => dish[:price]}
+    end
     
-    # expected = {
-    #   "Risotto" => {
-    #     :name => "Risotto",
-    #     :ingredients => ["Rice", "Cheese", "Butter"],
-    #     :price => 12
-    #   },
-    #   "Steak" => {
-    #     :name => "Steak",
-    #     :ingredients => ["Beef", "Garlic"],
-    #     :price => 15
-    #   }
-    # }
-    expect(olive_garden_menu).to eq({
+    expected = {
       "Risotto" => {
         :name => "Risotto",
         :ingredients => ["Rice", "Cheese", "Butter"],
@@ -162,46 +142,24 @@
         :ingredients => ["Beef", "Garlic"],
         :price => 15
       }
-    })
+    }
+    expect(olive_garden_menu).to eq(expected)
   end
 
-  xit 'test 11' do
+  it 'test 11' do
     # Return a full menu across all restaurants
-    full_menu = ____
-
-    # expected = {
-    #   "Risotto" => {
-    #     :name => "Risotto",
-    #     :ingredients => ["Rice", "Cheese", "Butter"],
-    #     :price => 12
-    #   },
-    #   "Steak" => {
-    #     :name => "Steak",
-    #     :ingredients => ["Beef", "Garlic"],
-    #     :price => 15
-    #   },
-    #   "Pancakes" => {
-    #     :name => "Pancakes",
-    #     :ingredients => ["Flour", "Eggs", "Milk", "Syrup"],
-    #     :price => 10
-    #   },
-    #   "Waffles" => {
-    #     :name => "Waffles",
-    #     :ingredients => ["Flour", "Eggs", "Syrup"],
-    #     :price => 7
-    #   },
-    #   "Big Mac" => {
-    #     :name => "Big Mac",
-    #     :ingredients => ["Bun", "Hamburger", "Ketchup", "pickles"],
-    #     :price => 5
-    #   },
-    #   "Fries" => {
-    #     :name => "Fries",
-    #     :ingredients => ["Potatoes", "Salt"],
-    #     :price => 2
-    #   }
-    # }
-    expect(full_menu).to eq({
+    # full_menu = ____
+
+    full_menu = {}
+
+    stores.each do |restaurant, info|
+      info[:dishes].select do |dish|
+        full_menu[dish[:name]] = {:name => dish[:name], :ingredients => dish[:ingredients], :price => dish[:price]}
+      end
+    end
+    
+
+    expected = {
       "Risotto" => {
         :name => "Risotto",
         :ingredients => ["Rice", "Cheese", "Butter"],
@@ -232,6 +190,8 @@
         :ingredients => ["Potatoes", "Salt"],
         :price => 2
       }
-    })
+    }
+
+    expect(full_menu).to eq(expected)
   end
 end

From 7e886c71a62b626f643b8fcfa226d47316db536d Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Thu, 22 Dec 2022 16:39:17 -0700
Subject: [PATCH 17/45] Fix small {} to [] error in comments

---
 iteration/exercises/spec/max_and_min_by_pattern_spec.rb | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/iteration/exercises/spec/max_and_min_by_pattern_spec.rb b/iteration/exercises/spec/max_and_min_by_pattern_spec.rb
index 2b0f8088..a147c75c 100644
--- a/iteration/exercises/spec/max_and_min_by_pattern_spec.rb
+++ b/iteration/exercises/spec/max_and_min_by_pattern_spec.rb
@@ -114,9 +114,10 @@
     words_length_array = meals.map do |meal, dish|
       [dish.length, dish]
     end.sort
+    require 'pry'; binding.pry
 
     expect(words_length_array.first.last).to eq("cake")
-    #=> words_length_array: {[4, "cake"], [4, "nuts"], [5, "salad"], [5, "steak"], [6, "banana"]}
+    #=> words_length_array: [[4, "cake"], [4, "nuts"], [5, "salad"], [5, "steak"], [6, "banana"]]
     #=> words_length_array.first: [4, "cake"]
     #=> words_length_array.first.last: "cake"
 

From 310dac6a7fa047c989821e82d85609d20e562d07 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Thu, 22 Dec 2022 17:41:16 -0700
Subject: [PATCH 18/45] Add enumerables map

---
 .../exercises_1/spec/map_pattern_spec.rb      | 61 ++++++++++++++-----
 enumerables/exercises_1/spec/map_spec.rb      | 43 ++++++++-----
 2 files changed, 76 insertions(+), 28 deletions(-)

diff --git a/enumerables/exercises_1/spec/map_pattern_spec.rb b/enumerables/exercises_1/spec/map_pattern_spec.rb
index e15e4059..e4f1e7bd 100644
--- a/enumerables/exercises_1/spec/map_pattern_spec.rb
+++ b/enumerables/exercises_1/spec/map_pattern_spec.rb
@@ -3,55 +3,88 @@
   it 'capitalizes' do
     names = ["alice", "bob", "charlie"]
     capitalized_names = []
+    
     names.each do |name|
       capitalized_names << name.capitalize
     end
+
     expect(capitalized_names).to eq(["Alice", "Bob", "Charlie"])
   end
 
-  xit 'doubles' do
+  it 'doubles' do
     numbers = [1, 2, 3, 4, 5]
     doubles = []
+
     numbers.each do |number|
-      # Your code goes here
+      doubles << number * 2
     end
+
     expect(doubles).to eq([2, 4, 6, 8, 10])
   end
 
-  xit 'squares' do
+  it 'squares' do
     numbers = [1, 2, 3, 4, 5]
     squares = []
-    # Your code goes here
+
+    numbers.each do |num|
+      squares << num * num
+    end
+
     expect(squares).to eq([1, 4, 9, 16, 25])
   end
 
-  xit 'lengths' do
+  it 'lengths' do
     names = ["alice", "bob", "charlie", "david", "eve"]
-    # Your code goes here
+    lengths = []
+
+    names.each do |name|
+      lengths << name.length
+    end
+
     expect(lengths).to eq([5, 3, 7, 5, 3])
   end
 
-  xit 'normalize zip codes' do
+  it 'normalize zip codes' do
     numbers = [234, 10, 9119, 38881]
-    # Your code goes here
+    zip_code = []
+
+    numbers.each do |num|
+      zip_code << num.to_s.rjust(5, "0")
+    end
+
     expect(zip_code).to eq(["00234", "00010", "09119", "38881"])
   end
 
-  xit 'backwards' do
+  it 'backwards' do
     names = ["alice", "bob", "charlie", "david", "eve"]
-    # Your code goes here
+    backwards = []
+
+    names.each do |name|
+      backwards << name.reverse
+    end
+
     expect(backwards).to eq(["ecila", "bob", "eilrahc", "divad", "eve"])
   end
 
-  xit 'words with no vowels' do
+  it 'words with no vowels' do
     words = ["green", "sheep", "travel", "least", "boat"]
-    # Your code goes here
+    without_vowels = []
+
+    words.each do |word|
+      without_vowels.push(word.delete("aeiou"))
+    end
+
     expect(without_vowels).to  eq(["grn", "shp", "trvl", "lst", "bt"])
   end
 
-  xit 'trims last letter' do
+  it 'trims last letter' do
     animals = ["dog", "cat", "mouse", "frog", "platypus"]
-    # Your code goes here
+    trimmed = []
+
+    animals.each do |animal|
+      trimmed << animal.chop
+    end
+
     expect(trimmed).to eq(["do", "ca", "mous", "fro", "platypu"])
   end
 end
diff --git a/enumerables/exercises_1/spec/map_spec.rb b/enumerables/exercises_1/spec/map_spec.rb
index de324004..35ebed5d 100644
--- a/enumerables/exercises_1/spec/map_spec.rb
+++ b/enumerables/exercises_1/spec/map_spec.rb
@@ -2,53 +2,68 @@
 
   it 'capitalizes' do
     names = ["alice", "bob", "charlie"]
+    
     capitalized_names = names.map do |name|
       name.capitalize
     end
+    # <.map> doesn't need an accumulator cuz you can define a variable that will become the modified array
+    # <.each> needs one because it returns the original array!
     expect(capitalized_names).to eq(["Alice", "Bob", "Charlie"])
   end
 
-  xit 'doubles' do
+  it 'doubles' do
     numbers = [1, 2, 3, 4, 5]
     doubles = numbers.map do |number|
-      # Your code goes here
+      number * 2
     end
     expect(doubles).to eq([2, 4, 6, 8, 10])
   end
 
-  xit 'squares' do
+  it 'squares' do
     numbers = [1, 2, 3, 4, 5]
-    # Your code goes here
+    squares = numbers.map do |num|
+      num * num
+    end
     expect(squares).to eq([1, 4, 9, 16, 25])
   end
 
-  xit 'lengths' do
+  it 'lengths' do
     names = ["alice", "bob", "charlie", "david", "eve"]
-    # Your code goes here
+    lengths = names.map do |name|
+      name.length
+    end
     expect(lengths).to eq([5, 3, 7, 5, 3])
   end
 
-  xit 'normalize zip codes' do
+  it 'normalize zip codes' do
     numbers = [234, 10, 9119, 38881]
-    # Your code goes here
+    zip_codes = numbers.map do |num|
+      num.to_s.rjust(5, "0")
+    end
     expect(zip_codes).to eq(["00234", "00010", "09119", "38881"])
   end
 
-  xit 'backwards' do
+  it 'backwards' do
     names = ["alice", "bob", "charlie", "david", "eve"]
-    # Your code goes here
+    backwards = names.map do |name|
+      name.reverse
+    end
     expect(backwards).to eq(["ecila", "bob", "eilrahc", "divad", "eve"])
   end
 
-  xit 'words with no vowels' do
+  it 'words with no vowels' do
     words = ["green", "sheep", "travel", "least", "boat"]
-    # Your code goes here
+    without_vowels = words.map do |word|
+      word.delete("aeiou")
+    end
     expect(without_vowels).to eq(["grn", "shp", "trvl", "lst", "bt"])
   end
 
-  xit 'trims last letter' do
+  it 'trims last letter' do
     animals = ["dog", "cat", "mouse", "frog", "platypus"]
-    # Your code goes here
+    trimmed = animals.map do |animal|
+      animal.chop
+    end
     expect(trimmed).to eq(["do", "ca", "mous", "fro", "platypu"])
   end
 end

From ff1cefee63e20474acdb4dac33c65030c1092492 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Thu, 22 Dec 2022 18:12:59 -0700
Subject: [PATCH 19/45] Add enumerables select

---
 .../exercises_1/spec/select_pattern_spec.rb   | 88 ++++++++++++++-----
 enumerables/exercises_1/spec/select_spec.rb   | 64 +++++++++-----
 2 files changed, 112 insertions(+), 40 deletions(-)

diff --git a/enumerables/exercises_1/spec/select_pattern_spec.rb b/enumerables/exercises_1/spec/select_pattern_spec.rb
index ace429eb..e2ae1966 100644
--- a/enumerables/exercises_1/spec/select_pattern_spec.rb
+++ b/enumerables/exercises_1/spec/select_pattern_spec.rb
@@ -3,73 +3,121 @@
   it 'picks even numbers' do
     numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     evens = []
+
     numbers.each do |number|
       evens << number if number.even?
     end
+
     expect(evens).to eq([2, 4, 6, 8, 10])
   end
 
-  xit 'picks odd numbers' do
+  it 'picks odd numbers' do
     numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     odds = []
+
     numbers.each do |number|
-      # Your code goes here
+      odds << number if number.odd?
     end
+
     expect(odds).to eq([1, 3, 5, 7, 9])
   end
 
-  xit 'words with three letters' do
+  it 'words with three letters' do
     words = ["pill", "bad", "finger", "cat", "blue", "dog", "table", "red"]
     selected = []
-    # Your code goes here
+    
+    words.each do |word|
+      selected << word if word.length == 3
+    end
+
     expect(selected).to eq(["bad", "cat", "dog", "red"])
   end
 
-  xit 'words with more than three letters' do
+  it 'words with more than three letters' do
     words = ["pill", "bad", "finger", "cat", "blue", "dog", "table", "red"]
-    # Your code goes here
+    selected = []
+
+    words.each do |word|
+      selected << word if word.length > 3
+    end
+
     expect(selected).to eq(["pill", "finger", "blue", "table"])
   end
 
-  xit 'words ending in e' do
+  it 'words ending in e' do
     words = ["are", "you", "strike", "thinking", "belt", "piece", "warble", "sing", "pipe"]
-    # Your code goes here
+    selected = []
+
+    words.each do |word|
+      selected << word if word.end_with?("e")
+    end
+
     expect(selected).to eq(["are", "strike", "piece", "warble", "pipe"])
   end
 
-  xit 'words ending in ing' do
+  it 'words ending in ing' do
     words = ["bring", "finger", "drought", "singing", "bingo", "purposeful"]
-    # Your code goes here
+    selected = []
+
+    words.each do |word|
+      selected << word if word.end_with?("ing")
+    end
+
     expect(selected).to eq(["bring", "singing"])
   end
 
-  xit 'words containing e' do
+  it 'words containing e' do
     words = ["four", "red", "five", "blue", "pizza", "purple"]
-    # Your code goes here
+    selected = []
+
+    words.each do |word|
+      selected << word if word.include?("e")
+    end
+
     expect(selected).to eq(["red", "five", "blue", "purple"])
   end
 
-  xit 'dinosaurs' do
+  it 'dinosaurs' do
     animals = ["tyrannosaurus", "narwhal", "eel", "achillesaurus", "qingxiusaurus"]
-    # Your code goes here
+    dinosaurs = []
+
+    animals.each do |animal|
+      dinosaurs << animal if animal.end_with?("saurus")
+    end
+
     expect(dinosaurs).to eq(["tyrannosaurus", "achillesaurus", "qingxiusaurus"])
   end
 
-  xit 'floats' do
+  it 'floats' do
     numbers = [3, 1.4, 3.5, 2, 4.9, 9.1, 8.0]
-    # Your code goes here
+    floats = []
+
+    numbers.each do |num|
+      floats << num if num.is_a?(Float)
+    end 
+
     expect(floats).to eq([1.4, 3.5, 4.9, 9.1, 8.0])
   end
 
-  xit 'arrays' do
+  it 'arrays' do
     elements = ["CAT", ["dog"], 23, [56, 3, 8], "AIMLESS", 43, "butter"]
-    # Your code goes here
+    arrays = []
+
+    elements.each do |element|
+      arrays << element if element.is_a?(Array)
+    end
+
     expect(arrays).to eq([["dog"], [56, 3, 8]])
   end
 
-  xit 'hashes' do
+  it 'hashes' do
     elements = ["cat", {:dog=>"fido"}, 23, {:stuff=>"things"}, "aimless", 43]
-    # Your code goes here
+    hashes = []
+
+    elements.each do |element|
+      hashes << element if element.is_a?(Hash)
+    end
+
     expect(hashes).to eq([{:dog=>"fido"}, {:stuff=>"things"}])
   end
 end
diff --git a/enumerables/exercises_1/spec/select_spec.rb b/enumerables/exercises_1/spec/select_spec.rb
index 34e686eb..797d5e8d 100644
--- a/enumerables/exercises_1/spec/select_spec.rb
+++ b/enumerables/exercises_1/spec/select_spec.rb
@@ -2,71 +2,95 @@
 
   it 'even numbers' do
     numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
     evens = numbers.select do |number|
       number.even?
     end
+
     expect(evens).to eq([2, 4, 6, 8, 10])
   end
 
-  xit 'odd numbers' do
+  it 'odd numbers' do
     numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    
     odds = numbers.select do |number|
-      # Your code goes here
+      number.odd?
     end
+    # <.select> will only move the number IF it meets the criteria in the codeblock
+    # this enumb. adds a level of functionality behind the scenes!
+    # think of it like: ".select this item IF...."
     expect(odds).to eq([1, 3, 5, 7, 9])
   end
 
-  xit 'words with three letters' do
+  it 'words with three letters' do
     words = ["pill", "bad", "finger", "cat", "blue", "dog", "table", "red"]
-    # Your code goes here
+    selected = words.select do |word|
+      word.length == 3
+    end
     expect(selected).to eq(["bad", "cat", "dog", "red"])
   end
 
-  xit 'words with more than three letters' do
+  it 'words with more than three letters' do
     words = ["pill", "bad", "finger", "cat", "blue", "dog", "table", "red"]
-    # Your code goes here
+    selected = words.select do |word|
+      word.length > 3
+    end
     expect(selected).to eq(["pill", "finger", "blue", "table"])
   end
 
-  xit 'wordss ending in e' do
+  it 'wordss ending in e' do
     words = ["are", "you", "strike", "thinking", "belt", "piece", "warble", "sing", "pipe"]
-    # Your code goes here
+    selected = words.select do |word|
+      word.end_with?("e")
+    end
     expect(selected).to eq(["are", "strike", "piece", "warble", "pipe"])
   end
 
-  xit 'words ending in ing' do
+  it 'words ending in ing' do
     words = ["bring", "finger", "drought", "singing", "bingo", "purposeful"]
-    # Your code goes here
+    selected = words.select do |word|
+      word.end_with?("ing")
+    end
     expect(selected).to eq(["bring", "singing"])
   end
 
-  xit 'words containing e' do
+  it 'words containing e' do
     words = ["four", "red", "five", "blue", "pizza", "purple"]
-    # Your code goes here
+    selected = words.select do |word|
+      word.include?("e")
+    end
     expect(selected).to eq(["red", "five", "blue", "purple"])
   end
 
-  xit 'dinosaurs' do
+  it 'dinosaurs' do
     animals = ["tyrannosaurus", "narwhal", "eel", "achillesaurus", "qingxiusaurus"]
-    # Your code goes here
+    dinosaurs = animals.select do |animal|
+      animal.end_with?("saurus")
+    end
     expect(dinosaurs).to eq(["tyrannosaurus", "achillesaurus", "qingxiusaurus"])
   end
 
-  xit 'floats' do
+  it 'floats' do
     numbers = [3, 1.4, 3.5, 2, 4.9, 9.1, 8.0]
-    # Your code goes here
+    floats = numbers.select do |num|
+      num.is_a?(Float)
+    end
     expect(floats).to eq([1.4, 3.5, 4.9, 9.1, 8.0])
   end
 
-  xit 'arrays' do
+  it 'arrays' do
     elements = ["CAT", ["dog"], 23, [56, 3, 8], "AIMLESS", 43, "butter"]
-    # Your code goes here
+    arrays = elements.select do |element|
+      element.is_a?(Array)
+    end
     expect(arrays).to eq([["dog"], [56, 3, 8]])
   end
 
-  xit 'hashes' do
+  it 'hashes' do
     elements = ["cat", {:dog=>"fido"}, 23, {:stuff=>"things"}, "aimless", 43]
-    # Your code goes here
+    hashes = elements.select do |element|
+      element.is_a?(Hash)
+    end
     expect(hashes).to eq([{:dog=>"fido"}, {:stuff=>"things"}])
   end
 end

From ff704732df9f78925a7bac23650ac2981a9bdcd1 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Thu, 22 Dec 2022 19:39:02 -0700
Subject: [PATCH 20/45] Add enumerables half group_by

---
 .../exercises_1/spec/group_by_pattern_spec.rb | 27 ++++++++++++++-----
 enumerables/exercises_1/spec/group_by_spec.rb | 24 ++++++++++++-----
 2 files changed, 38 insertions(+), 13 deletions(-)

diff --git a/enumerables/exercises_1/spec/group_by_pattern_spec.rb b/enumerables/exercises_1/spec/group_by_pattern_spec.rb
index 07d39a89..4c60dad7 100644
--- a/enumerables/exercises_1/spec/group_by_pattern_spec.rb
+++ b/enumerables/exercises_1/spec/group_by_pattern_spec.rb
@@ -3,28 +3,41 @@
   it 'group words by length' do
     words = ["sue", "alice", "steve", "sally", "adam", "fort", "tops", "dog", "cat"]
     grouped = Hash.new {|hash, key| hash[key] = []}
+   
     words.each do |word|
       grouped[word.length] << word
     end
+
     expected = {3=>["sue", "dog", "cat"], 4=>["adam", "fort", "tops"], 5=>["alice", "steve", "sally"]}
     expect(grouped).to eq(expected)
   end
 
-  xit 'groups by odds and evens' do
+  it 'groups by odds and evens' do
     numbers = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
-    odd_and_even = Hash.new {|hash, key| hash[key] = []}
+    odd_and_even = Hash.new {|key, value| key[value] = []}
+    # everytime you assign a new key the value will be an array
+    
     numbers.each do |number|
-      # Your code goes here
+      if number.odd? 
+        odd_and_even[1] << number 
+      else
+        odd_and_even[0] << number
+      end
     end
+
     expected = {1=>[1, 1, 3, 5, 13, 21, 55], 0=>[2, 8, 34]}
     expect(odd_and_even).to eq(expected)
   end
 
-  xit 'groups by first letter' do
-    words = ["ant", "axis", "albatross", "bolt", "badge", "butter", "car", "cdr", "column"]
+  it 'groups by first letter' do
+    words = ["ant", "axis", "albatross", "bolt", "badge", "butter", "car", "cdr", "column", "1zebra"]
     words_by_first_letter = Hash.new {|hash, key| hash[key] = []}
-    # Your code goes here
-    expected = {"a"=>["ant", "axis", "albatross"], "b"=>["bolt", "badge", "butter"], "c"=>["car", "cdr", "column"]}
+
+    words.each do |word|
+      words_by_first_letter[word.chr] << word
+    end
+
+    expected = {"a"=>["ant", "axis", "albatross"], "b"=>["bolt", "badge", "butter"], "c"=>["car", "cdr", "column"], "1"=>["1zebra"]}
     expect(words_by_first_letter).to eq(expected)
   end
 
diff --git a/enumerables/exercises_1/spec/group_by_spec.rb b/enumerables/exercises_1/spec/group_by_spec.rb
index 841917df..8de837b0 100644
--- a/enumerables/exercises_1/spec/group_by_spec.rb
+++ b/enumerables/exercises_1/spec/group_by_spec.rb
@@ -1,25 +1,37 @@
 RSpec.describe 'group by' do
   it 'groups words by length' do
     words = ["sue", "alice", "steve", "sally", "adam", "fort", "tops", "dog", "cat"]
+   
     grouped = words.group_by do |word|
       word.length
     end
+    
     expected = {3=>["sue", "dog", "cat"], 4=>["adam", "fort", "tops"], 5=>["alice", "steve", "sally"]}
     expect(grouped).to eq(expected)
   end
 
-  xit 'group by odd and even' do
+  it 'group by odd and even' do
     numbers = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
-    odd_and_even = numbers.group_by do |number|
-      # Your code goes here
-    end
+      
+      odd_and_even = numbers.group_by do |num|
+        if num.odd?
+          1
+        else
+          0
+        end
+      end
+      
     expected = {1=>[1, 1, 3, 5, 13, 21, 55], 0=>[2, 8, 34]}
     expect(odd_and_even).to eq(expected)
   end
 
-  xit 'group by first letter' do
+  it 'group by first letter' do
     words = ["ant", "axis", "albatross", "bolt", "badge", "butter", "car", "cdr", "column"]
-    # Your code goes here
+    
+    words_by_first_letter = words.group_by do |word|
+      word.chr
+    end
+
     expected = {"a"=>["ant", "axis", "albatross"], "b"=>["bolt", "badge", "butter"], "c"=>["car", "cdr", "column"]}
     expect(words_by_first_letter).to eq(expected)
   end

From f58d55d39e2fac2e2783ebf263d643fb9151c1a7 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Fri, 23 Dec 2022 10:02:24 -0700
Subject: [PATCH 21/45] Add mythical creatures centaur

---
 mythical-creatures/lib/centaur.rb       | 83 +++++++++++++++++++++++++
 mythical-creatures/lib/medusa.rb        |  2 +-
 mythical-creatures/lib/ogre.rb          |  8 +++
 mythical-creatures/spec/centaur_spec.rb | 38 +++++++++--
 4 files changed, 126 insertions(+), 5 deletions(-)

diff --git a/mythical-creatures/lib/centaur.rb b/mythical-creatures/lib/centaur.rb
index e69de29b..516c4abb 100644
--- a/mythical-creatures/lib/centaur.rb
+++ b/mythical-creatures/lib/centaur.rb
@@ -0,0 +1,83 @@
+class Centaur
+	attr_reader :name,
+							:breed
+
+  def initialize(name, breed)
+		@name = name
+		@breed = breed
+		@cranky = false
+		@standing = true
+		@runs = 0 
+		@shots = 0
+		@sick = 0
+  end
+
+	def shoot
+		if @shots < 3 && @standing
+			@shots += 1
+			'Twang!!!'
+		else
+			'NO!'
+		end
+	end
+
+	def run
+		if @standing
+			@runs +=1
+			'Clop clop clop clop!'
+		else
+			'NO!'
+		end
+	end
+
+	def cranky?
+		check_if_cranky
+		@cranky 
+	end
+
+	def check_if_cranky
+		if @runs + @shots >= 3
+			@cranky = true
+		else
+			@cranky = false
+		end
+	end
+
+	def standing?
+		@standing
+	end
+
+	def sleep
+		if @standing 
+			'NO!'
+		else
+			@shots = 0
+			@runs = 0
+		end
+	end
+
+	def lay_down
+		@standing = false
+	end
+
+	def laying?
+		!@standing 
+	end
+
+	def stand_up
+		@standing = true
+	end
+
+	def drink_potion
+		if @standing && @cranky == false
+			@sick = true
+		elsif @standing && @cranky == true
+			@shots = 0
+			@runs = 0
+		end
+	end
+
+	def sick?
+		@sick
+	end
+end
\ No newline at end of file
diff --git a/mythical-creatures/lib/medusa.rb b/mythical-creatures/lib/medusa.rb
index c3fd4ec7..72b6a45c 100644
--- a/mythical-creatures/lib/medusa.rb
+++ b/mythical-creatures/lib/medusa.rb
@@ -1,6 +1,6 @@
 class Medusa
 	attr_reader :name,
-							:statues
+				:statues
 						
 	def initialize(name)
 		@name = name
diff --git a/mythical-creatures/lib/ogre.rb b/mythical-creatures/lib/ogre.rb
index e69de29b..8321e1bd 100644
--- a/mythical-creatures/lib/ogre.rb
+++ b/mythical-creatures/lib/ogre.rb
@@ -0,0 +1,8 @@
+class Ogre
+	attr_reader :name
+
+  def initialize(name)
+		@name = name
+  end
+
+end
\ No newline at end of file
diff --git a/mythical-creatures/spec/centaur_spec.rb b/mythical-creatures/spec/centaur_spec.rb
index 9dfcd0d1..a3e68237 100644
--- a/mythical-creatures/spec/centaur_spec.rb
+++ b/mythical-creatures/spec/centaur_spec.rb
@@ -113,14 +113,44 @@
   end
 
   it 'becomes rested after drinking a potion' do
-    # your code here
+    centaur = Centaur.new('George', 'Palomino')
+
+    centaur.shoot
+    centaur.run
+    centaur.shoot
+    expect(centaur.cranky?).to be true
+
+    centaur.drink_potion
+    expect(centaur.cranky?).to be false
+
+    centaur.run
+    centaur.shoot
+    expect(centaur.cranky?).to be false
+
+    centaur.shoot
+    expect(centaur.cranky?).to be true
   end
 
   it 'can only drink a potion whilst standing' do
-    # your code here
+    centaur = Centaur.new('George', 'Palomino')
+
+    centaur.shoot
+    centaur.run
+    centaur.shoot
+    expect(centaur.cranky?).to be true
+
+    centaur.lay_down
+    centaur.drink_potion
+
+    expect(centaur.cranky?).to be true
   end
 
-  it 'gets stick if a potion is drunk while rested' do
-    # your code here
+  it 'gets sick if a potion is drunk while rested' do
+    centaur = Centaur.new('George', 'Palomino')
+    expect(centaur.cranky?).to be false
+
+    centaur.drink_potion
+
+    expect(centaur.sick?).to be true
   end
 end

From e3b74761e163419682fa6a9672e7134fa8ffe5e9 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Fri, 23 Dec 2022 10:10:50 -0700
Subject: [PATCH 22/45] Add mythical creatures ogre setup

---
 mythical-creatures/spec/ogre_spec.rb | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/mythical-creatures/spec/ogre_spec.rb b/mythical-creatures/spec/ogre_spec.rb
index 1e8f1cf3..dd838062 100644
--- a/mythical-creatures/spec/ogre_spec.rb
+++ b/mythical-creatures/spec/ogre_spec.rb
@@ -7,18 +7,18 @@
     expect(ogre.name).to eq('Brak')
   end
 
-  it 'lives somewhere by default' do
+  xit 'lives somewhere by default' do
     ogre = Ogre.new('Brak')
     expect(ogre.home).to eq('Swamp')
   end
 
-  it 'doesnt have to live in a swamp' do
+  xit 'doesnt have to live in a swamp' do
     ogre = Ogre.new('Brak', 'Castle')
 
     expect(ogre.home).to eq('Castle')
   end
 
-  it 'can meets humans' do
+  xit 'can meets humans' do
     ogre = Ogre.new('Brak')
     human = Human.new
     expect(human.name).to eq('Jane')
@@ -28,7 +28,7 @@
     expect(human.encounter_counter).to eq(1)
   end
 
-  it 'is noticed by humans every third encounter' do
+  xit 'is noticed by humans every third encounter' do
     ogre = Ogre.new('Brak')
     human = Human.new
 
@@ -41,7 +41,7 @@
     expect(human.notices_ogre?).to be true
   end
 
-  it 'is noticed by humans the sixth time' do
+  xit 'is noticed by humans the sixth time' do
     ogre = Ogre.new('Brak')
     human = Human.new
 
@@ -50,7 +50,7 @@
     expect(human.notices_ogre?).to be true
   end
 
-  it 'can swing a club' do
+  xit 'can swing a club' do
     ogre = Ogre.new('Brak')
     human = Human.new
 
@@ -59,7 +59,7 @@
     expect(ogre.swings).to eq(1)
   end
 
-  it 'swings its club when noticed by a human' do
+  xit 'swings its club when noticed by a human' do
     ogre = Ogre.new('Brak')
     human = Human.new
     ogre.encounter(human)
@@ -73,7 +73,7 @@
     expect(human.notices_ogre?).to be true
   end
 
-  it 'hits the human every second time it swings' do
+  xit 'hits the human every second time xit swings' do
     ogre = Ogre.new('Brak')
     human = Human.new
 
@@ -84,7 +84,7 @@
     expect(human.knocked_out?).to be true
   end
 
-  it 'apologizes and the human wakes up' do
+  xit 'apologizes and the human wakes up' do
     ogre = Ogre.new('Brak')
     human = Human.new
 

From 910e20b96a2cb461dca2319eb6f9df95c5b903f6 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Fri, 23 Dec 2022 14:46:16 -0700
Subject: [PATCH 23/45] Add mythical creatures ogre

---
 mythical-creatures/lib/ogre.rb       | 54 ++++++++++++++++++++++++++--
 mythical-creatures/spec/ogre_spec.rb | 20 ++++++-----
 2 files changed, 63 insertions(+), 11 deletions(-)

diff --git a/mythical-creatures/lib/ogre.rb b/mythical-creatures/lib/ogre.rb
index 8321e1bd..c8151e2d 100644
--- a/mythical-creatures/lib/ogre.rb
+++ b/mythical-creatures/lib/ogre.rb
@@ -1,8 +1,58 @@
 class Ogre
-	attr_reader :name
+	attr_reader :name, 
+							:home, 
+							:swings,
+							:encounter_counter
 
-  def initialize(name)
+  def initialize(name, home = "Swamp")
 		@name = name
+		@home = home
+		@swings = 0
+		@encounter_counter = 0
   end
 
+	def encounter(human)
+		human.encounter_counter += 1 
+		@encounter_counter += 1
+		if human.encounter_counter >= 3
+			human.notices_ogre = true
+			swing_at(human)
+			human.encounter_counter = 0
+		end
+	end
+
+	def swing_at(human)
+		@swings += 1
+		if @swings.even?
+			human.knocked_out = true
+		end
+	end
+
+	def apologize(human)
+		human.knocked_out = false
+	end
+
+end
+
+class Human
+	attr_reader :name
+	attr_accessor :encounter_counter,
+								:notices_ogre,
+								:knocked_out
+
+  def initialize
+		@name = "Jane"
+		@encounter_counter = 0
+		@notices_ogre = false
+		@knocked_out = false
+  end
+
+	def notices_ogre?
+		@notices_ogre
+	end
+
+	def knocked_out?
+		@knocked_out
+	end
+
 end
\ No newline at end of file
diff --git a/mythical-creatures/spec/ogre_spec.rb b/mythical-creatures/spec/ogre_spec.rb
index dd838062..dd04448f 100644
--- a/mythical-creatures/spec/ogre_spec.rb
+++ b/mythical-creatures/spec/ogre_spec.rb
@@ -7,18 +7,18 @@
     expect(ogre.name).to eq('Brak')
   end
 
-  xit 'lives somewhere by default' do
+  it 'lives somewhere by default' do
     ogre = Ogre.new('Brak')
     expect(ogre.home).to eq('Swamp')
   end
 
-  xit 'doesnt have to live in a swamp' do
+  it 'doesnt have to live in a swamp' do
     ogre = Ogre.new('Brak', 'Castle')
 
     expect(ogre.home).to eq('Castle')
   end
 
-  xit 'can meets humans' do
+  it 'can meets humans' do
     ogre = Ogre.new('Brak')
     human = Human.new
     expect(human.name).to eq('Jane')
@@ -28,7 +28,7 @@
     expect(human.encounter_counter).to eq(1)
   end
 
-  xit 'is noticed by humans every third encounter' do
+  it 'is noticed by humans every third encounter' do
     ogre = Ogre.new('Brak')
     human = Human.new
 
@@ -41,7 +41,7 @@
     expect(human.notices_ogre?).to be true
   end
 
-  xit 'is noticed by humans the sixth time' do
+  it 'is noticed by humans the sixth time' do
     ogre = Ogre.new('Brak')
     human = Human.new
 
@@ -50,7 +50,7 @@
     expect(human.notices_ogre?).to be true
   end
 
-  xit 'can swing a club' do
+  it 'can swing a club' do
     ogre = Ogre.new('Brak')
     human = Human.new
 
@@ -59,7 +59,7 @@
     expect(ogre.swings).to eq(1)
   end
 
-  xit 'swings its club when noticed by a human' do
+  it 'swings its club when noticed by a human' do
     ogre = Ogre.new('Brak')
     human = Human.new
     ogre.encounter(human)
@@ -73,18 +73,20 @@
     expect(human.notices_ogre?).to be true
   end
 
-  xit 'hits the human every second time xit swings' do
+  it 'hits the human every second time it swings' do
     ogre = Ogre.new('Brak')
     human = Human.new
 
     6.times { ogre.encounter(human) }
 
     expect(ogre.encounter_counter).to eq(6)
+
     expect(ogre.swings).to eq(2)
+
     expect(human.knocked_out?).to be true
   end
 
-  xit 'apologizes and the human wakes up' do
+  it 'apologizes and the human wakes up' do
     ogre = Ogre.new('Brak')
     human = Human.new
 

From db4c1b1661286a8b7d020eb7685f38e9ec118017 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Fri, 23 Dec 2022 14:58:05 -0700
Subject: [PATCH 24/45] Add mythical creatures Lovisa

---
 mythical-creatures/lib/lovisa.rb       | 21 +++++++++++++++++++++
 mythical-creatures/lib/the_journey.rb  |  0
 mythical-creatures/spec/lovisa_spec.rb |  7 ++++---
 3 files changed, 25 insertions(+), 3 deletions(-)
 create mode 100644 mythical-creatures/lib/lovisa.rb
 delete mode 100644 mythical-creatures/lib/the_journey.rb

diff --git a/mythical-creatures/lib/lovisa.rb b/mythical-creatures/lib/lovisa.rb
new file mode 100644
index 00000000..f3328003
--- /dev/null
+++ b/mythical-creatures/lib/lovisa.rb
@@ -0,0 +1,21 @@
+class Lovisa
+  attr_reader :title,
+              :characteristics
+
+  def initialize(title, characteristics = ["brilliant"])
+    @title = title
+    @characteristics = characteristics
+  end
+
+  def brilliant?
+	  characteristics.include?("brilliant")
+  end
+
+	def kind?
+	  characteristics.include?("kind")
+  end
+
+	def say(words)
+		"**;* #{words} **;*"
+	end
+end
\ No newline at end of file
diff --git a/mythical-creatures/lib/the_journey.rb b/mythical-creatures/lib/the_journey.rb
deleted file mode 100644
index e69de29b..00000000
diff --git a/mythical-creatures/spec/lovisa_spec.rb b/mythical-creatures/spec/lovisa_spec.rb
index 50cbd6f4..722e7bf4 100644
--- a/mythical-creatures/spec/lovisa_spec.rb
+++ b/mythical-creatures/spec/lovisa_spec.rb
@@ -4,27 +4,28 @@
 RSpec.describe Lovisa do
   it 'she has a title' do
     lovisa = Lovisa.new('Lovisa the Swedish Goddess')
+    
     expect(lovisa.title).to eq('Lovisa the Swedish Goddess')
   end
 
   it 'she is brilliant by default' do
     lovisa = Lovisa.new('Lovisa the Mentor')
+
     expect(lovisa.characteristics).to eq(['brilliant'])
-    expect(lovisa.brilliant?).to eq(true)
     expect(lovisa.brilliant?).to be true
   end
 
   it "she is more than brilliant" do
     loivsa = Lovisa.new('Lovisa the friend', ['brilliant', 'kind'])
+
     expect(loivsa.characteristics).to eq(['brilliant', 'kind'])
-    expect(loivsa.brilliant?).to eq(true)
     expect(loivsa.brilliant?).to be true
-    expect(loivsa.kind?).to eq(true)
     expect(loivsa.kind?).to be true
   end
 
   it 'she says sparkly stuff' do
     loivsa = Lovisa.new('Lovisa the Loved')
+
     expect(loivsa.say('Wonderful!')).to eq('**;* Wonderful! **;*')
     expect(loivsa.say('You are doing great!')).to eq('**;* You are doing great! **;*')
   end

From 4c9731a299b867b7e2088cbf90406b2b3af9e73e Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Fri, 23 Dec 2022 15:32:18 -0700
Subject: [PATCH 25/45] Add part direwolf

---
 mythical-creatures/README.md             |  1 +
 mythical-creatures/lib/direwolf.rb       | 41 ++++++++++++++++++++++++
 mythical-creatures/spec/direwolf_spec.rb | 17 ++++++----
 3 files changed, 52 insertions(+), 7 deletions(-)

diff --git a/mythical-creatures/README.md b/mythical-creatures/README.md
index df22a247..af3a30d2 100644
--- a/mythical-creatures/README.md
+++ b/mythical-creatures/README.md
@@ -36,6 +36,7 @@ Continue to follow the errors that your test provides until the test passes. The
 * `werewolf_spec.rb`
 * `centaur_spec.rb`
 * `ogre_spec.rb`
+* `lovisa_spec.rb`
 * `direwolf_spec.rb`
 * `the_journey_spec.rb` (see below)
 
diff --git a/mythical-creatures/lib/direwolf.rb b/mythical-creatures/lib/direwolf.rb
index e69de29b..0b3d33b3 100644
--- a/mythical-creatures/lib/direwolf.rb
+++ b/mythical-creatures/lib/direwolf.rb
@@ -0,0 +1,41 @@
+class Direwolf
+    attr_reader :name,
+								:home,
+								:size,
+								:starks_to_protect,
+								:location
+
+    def initialize(name, home = 'Beyond the Wall', size = 'Massive')
+        @name = name
+				@home = home
+				@size = size
+				@starks_to_protect = []
+				@location = home
+    end
+
+		def protects(a_stark)
+			if a_stark.location == @location && @starks_to_protect.length < 2
+					@starks_to_protect << a_stark 
+			end
+		end
+
+end
+
+class Stark
+	attr_reader :name, 
+							:home,
+							:location
+
+	def initialize(name, location = 'Winterfell')
+		@name = name
+		@home = "Winderfell"
+		@location = location 
+		@safe = false
+		@house_words = house_wo
+	end
+
+	def safe?
+		@safe
+	end
+
+end
\ No newline at end of file
diff --git a/mythical-creatures/spec/direwolf_spec.rb b/mythical-creatures/spec/direwolf_spec.rb
index 345cc5a2..8693f644 100644
--- a/mythical-creatures/spec/direwolf_spec.rb
+++ b/mythical-creatures/spec/direwolf_spec.rb
@@ -66,20 +66,23 @@
   it 'can only protect two Starks at a time' do
     summer_wolf = Direwolf.new('Summer', "Winterfell")
     lady_wolf = Direwolf.new('Lady', "Winterfell")
+
     sansa_stark = Stark.new('Sansa')
-    john_stark = Stark.new('Jon')
+    jon_stark = Stark.new('Jon')
     rob_stark = Stark.new('Rob')
     bran_stark = Stark.new('Bran')
     arya_stark = Stark.new('Arya')
 
     summer_wolf.protects(sansa_stark)
-    summer_wolf.protects(john_stark)
+    summer_wolf.protects(jon_stark)
+
     lady_wolf.protects(rob_stark)
     lady_wolf.protects(bran_stark)
     lady_wolf.protects(arya_stark)
 
     expect(summer_wolf.starks_to_protect).to include(sansa_stark)
     expect(summer_wolf.starks_to_protect).to include(jon_stark)
+
     expect(lady_wolf.starks_to_protect).to include(rob_stark)
     expect(lady_wolf.starks_to_protect).to include(bran_stark)
     expect(lady_wolf.starks_to_protect).to_not include(arya_stark)
@@ -92,7 +95,7 @@
     expect(stark.house_words).to eq('Winter is Coming')
   end
 
-  it 'protects the Starks' do
+  xit 'protects the Starks' do
     wolf = Direwolf.new('Nymeria', "Winterfell")
     arya_stark = Stark.new('Arya')
     sansa_stark = Stark.new('Sansa')
@@ -103,13 +106,13 @@
     expect(sansa_stark.safe?).to be false
   end
 
-  it 'hunts white walkers' do
+  xit 'hunts white walkers' do
     wolf = Direwolf.new('Nymeria', 'Winterfell')
 
     expect(wolf.hunts_white_walkers?).to be true
   end
 
-  it 'will not hunt white walkers when protecting Starks' do
+  xit 'will not hunt white walkers when protecting Starks' do
     wolf = Direwolf.new('Nymeria', "Winterfell")
     arya_stark = Stark.new('Arya')
 
@@ -118,7 +121,7 @@
     expect(wolf.hunts_white_walkers?).to be false
   end
 
-  it 'can leave and stop protecting Starks' do
+  xit 'can leave and stop protecting Starks' do
     summer_wolf = Direwolf.new('Summer', "Winterfell")
     lady_wolf = Direwolf.new('Lady', "Winterfell")
     sansa_stark = Stark.new('Sansa')
@@ -133,7 +136,7 @@
     expect(arya_stark.safe?).to be false
   end
 
-  it 'returns the Stark object when it leaves' do
+  xit 'returns the Stark object when it leaves' do
     summer_wolf = Direwolf.new('Summer', "Winterfell")
     lady_wolf = Direwolf.new('Lady', "Winterfell")
     sansa_stark = Stark.new('Sansa')

From f548f52873eec7be41d63a12295801239ed9322b Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Fri, 23 Dec 2022 15:57:24 -0700
Subject: [PATCH 26/45] Add mythical creatures direwolf

---
 mythical-creatures/lib/direwolf.rb       | 20 ++++++++++++++++++--
 mythical-creatures/spec/direwolf_spec.rb | 16 ++++++++++------
 2 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/mythical-creatures/lib/direwolf.rb b/mythical-creatures/lib/direwolf.rb
index 0b3d33b3..fe6e11ae 100644
--- a/mythical-creatures/lib/direwolf.rb
+++ b/mythical-creatures/lib/direwolf.rb
@@ -11,27 +11,43 @@ def initialize(name, home = 'Beyond the Wall', size = 'Massive')
 				@size = size
 				@starks_to_protect = []
 				@location = home
+				@hunts_white_walkers = true
     end
 
 		def protects(a_stark)
 			if a_stark.location == @location && @starks_to_protect.length < 2
 					@starks_to_protect << a_stark 
+					a_stark.safe = true
+					@hunts_white_walkers = false
 			end
 		end
 
+		def hunts_white_walkers?
+			@hunts_white_walkers
+		end
+
+		def leaves(a_stark)
+			a_stark.safe = false
+			@starks_to_protect.delete(a_stark)
+			a_stark
+		end
+
 end
 
 class Stark
 	attr_reader :name, 
 							:home,
-							:location
+							:location,
+							:house_words
+
+	attr_accessor :safe
 
 	def initialize(name, location = 'Winterfell')
 		@name = name
 		@home = "Winderfell"
 		@location = location 
 		@safe = false
-		@house_words = house_wo
+		@house_words = 'Winter is Coming'
 	end
 
 	def safe?
diff --git a/mythical-creatures/spec/direwolf_spec.rb b/mythical-creatures/spec/direwolf_spec.rb
index 8693f644..7e2ebb5c 100644
--- a/mythical-creatures/spec/direwolf_spec.rb
+++ b/mythical-creatures/spec/direwolf_spec.rb
@@ -95,7 +95,7 @@
     expect(stark.house_words).to eq('Winter is Coming')
   end
 
-  xit 'protects the Starks' do
+  it 'protects the Starks' do
     wolf = Direwolf.new('Nymeria', "Winterfell")
     arya_stark = Stark.new('Arya')
     sansa_stark = Stark.new('Sansa')
@@ -106,13 +106,13 @@
     expect(sansa_stark.safe?).to be false
   end
 
-  xit 'hunts white walkers' do
+  it 'hunts white walkers' do
     wolf = Direwolf.new('Nymeria', 'Winterfell')
 
     expect(wolf.hunts_white_walkers?).to be true
   end
 
-  xit 'will not hunt white walkers when protecting Starks' do
+  it 'will not hunt white walkers when protecting Starks' do
     wolf = Direwolf.new('Nymeria', "Winterfell")
     arya_stark = Stark.new('Arya')
 
@@ -121,30 +121,34 @@
     expect(wolf.hunts_white_walkers?).to be false
   end
 
-  xit 'can leave and stop protecting Starks' do
+  it 'can leave and stop protecting Starks' do
     summer_wolf = Direwolf.new('Summer', "Winterfell")
     lady_wolf = Direwolf.new('Lady', "Winterfell")
+
     sansa_stark = Stark.new('Sansa')
     arya_stark = Stark.new('Arya')
 
     summer_wolf.protects(arya_stark)
     lady_wolf.protects(sansa_stark)
+
     summer_wolf.leaves(arya_stark)
 
     expect(summer_wolf.starks_to_protect).to be_empty
-    expect(lady_wolf.starks_to_protect.first.name).to be('Sansa')
+    expect(lady_wolf.starks_to_protect.first.name).to eq('Sansa')
     expect(arya_stark.safe?).to be false
   end
 
-  xit 'returns the Stark object when it leaves' do
+  it 'returns the Stark object when it leaves' do
     summer_wolf = Direwolf.new('Summer', "Winterfell")
     lady_wolf = Direwolf.new('Lady', "Winterfell")
+    
     sansa_stark = Stark.new('Sansa')
     arya_stark = Stark.new('Arya')
     rickon_stark = Stark.new('Rickon')
 
     summer_wolf.protects(arya_stark)
     lady_wolf.protects(sansa_stark)
+    
     summer_wolf.leaves(arya_stark)
 
     expected = lady_wolf.leaves(rickon_stark)

From dbf9e5c27e99467919749253ee763e99649f9bc7 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Fri, 23 Dec 2022 17:52:05 -0700
Subject: [PATCH 27/45] Create phoenix mythical creature

---
 mythical-creatures/lib/phoenix.rb       | 40 ++++++++++++++
 mythical-creatures/spec/phoenix_spec.rb | 69 +++++++++++++++++++++++++
 2 files changed, 109 insertions(+)
 create mode 100644 mythical-creatures/lib/phoenix.rb
 create mode 100644 mythical-creatures/spec/phoenix_spec.rb

diff --git a/mythical-creatures/lib/phoenix.rb b/mythical-creatures/lib/phoenix.rb
new file mode 100644
index 00000000..542448b7
--- /dev/null
+++ b/mythical-creatures/lib/phoenix.rb
@@ -0,0 +1,40 @@
+class Phoenix
+		attr_reader :name,
+								:color,
+								:mood,
+								:emotional_tracker
+
+	def initialize(name, color = "golden", mood = "stoic")
+		@name = name
+		@color = color
+		@mood = mood
+		@emotional_tracker = {}
+		@releases_tear = false
+	end
+
+	def feels_emotion(emotion)
+		@color = "sarlet"
+		@mood = "heated"
+
+		if @emotional_tracker.has_key?(emotion)
+			@emotional_tracker[emotion] += 1
+		
+			if @emotional_tracker[emotion] == 3
+				@releases_tear = true
+				@color = "golden"
+				@mood = "stoic"
+			elsif @emotional_tracker[emotion] > 3
+				@releases_tear = false
+				@emotional_tracker[emotion] = 1
+			end
+			
+		else
+			@emotional_tracker[emotion] = 1
+		end
+	end
+
+	def releases_tear?
+		@releases_tear
+	end
+
+end
\ No newline at end of file
diff --git a/mythical-creatures/spec/phoenix_spec.rb b/mythical-creatures/spec/phoenix_spec.rb
new file mode 100644
index 00000000..0823ba72
--- /dev/null
+++ b/mythical-creatures/spec/phoenix_spec.rb
@@ -0,0 +1,69 @@
+require 'rspec'
+require './lib/phoenix'
+
+RSpec.describe Phoenix do
+
+	it "exists" do
+		phoenix = Phoenix.new("Bennu")
+
+		expect(phoenix.name).to eq("Bennu")
+	end
+
+	it "is born a golden color and in a stoic mood" do
+		phoenix = Phoenix.new("Bennu")
+
+		expect(phoenix.color).to eq("golden")
+		expect(phoenix.mood).to eq("stoic")
+	end
+
+
+	it "can change color & mood when feeling an emotion" do
+		phoenix = Phoenix.new("Bennu")
+
+		phoenix.feels_emotion(:joyful)
+
+		expect(phoenix.color).to eq("sarlet")
+		expect(phoenix.mood).to eq("heated")
+	end
+
+	it "can track how many times it has the same emotion" do
+		phoenix = Phoenix.new("Bennu")
+
+		phoenix.feels_emotion(:joyful)
+		phoenix.feels_emotion(:joyful)
+		phoenix.feels_emotion(:joyful)
+
+		expect(phoenix.emotional_tracker[:joyful]).to eq(3)
+	end
+
+	it "releases a single tear after feeling the same emotion 3 times" do
+		phoenix = Phoenix.new("Bennu")
+
+		phoenix.feels_emotion(:joyful)
+		phoenix.feels_emotion(:joyful)
+		phoenix.feels_emotion(:joyful)
+
+		expect(phoenix.emotional_tracker[:joyful]).to eq(3)
+		expect(phoenix.releases_tear?).to be true
+	end
+
+	it "it forgets that emotion after feeling it 3 times" do
+		phoenix = Phoenix.new("Bennu")
+
+		phoenix.feels_emotion(:joyful)
+		expect(phoenix.emotional_tracker[:joyful]).to eq(1)
+
+		phoenix.feels_emotion(:joyful)
+		expect(phoenix.emotional_tracker[:joyful]).to eq(2)
+
+		phoenix.feels_emotion(:joyful)
+		expect(phoenix.emotional_tracker[:joyful]).to eq(3)
+		expect(phoenix.releases_tear?).to be true
+
+		phoenix.feels_emotion(:joyful)
+		expect(phoenix.emotional_tracker[:joyful]).to eq(1)
+		expect(phoenix.releases_tear?).to be false
+	end
+
+
+end
\ No newline at end of file

From fe7368202433fc70feae5af36b4fefecd7ce8a68 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Fri, 23 Dec 2022 18:04:07 -0700
Subject: [PATCH 28/45] Add more phoenix test ideas

---
 mythical-creatures/spec/phoenix_spec.rb | 30 ++++++++++++++++++-------
 1 file changed, 22 insertions(+), 8 deletions(-)

diff --git a/mythical-creatures/spec/phoenix_spec.rb b/mythical-creatures/spec/phoenix_spec.rb
index 0823ba72..5963da02 100644
--- a/mythical-creatures/spec/phoenix_spec.rb
+++ b/mythical-creatures/spec/phoenix_spec.rb
@@ -16,6 +16,14 @@
 		expect(phoenix.mood).to eq("stoic")
 	end
 
+	xit "can age" do
+	end
+
+	xit "can will burst into flames every 500 years" do
+	end
+
+	xit "is reborn after bursting into flames" do
+	end
 
 	it "can change color & mood when feeling an emotion" do
 		phoenix = Phoenix.new("Bennu")
@@ -36,7 +44,7 @@
 		expect(phoenix.emotional_tracker[:joyful]).to eq(3)
 	end
 
-	it "releases a single tear after feeling the same emotion 3 times" do
+	it "releases a tear after feeling the same emotion 3 times & returns to default mood & color" do
 		phoenix = Phoenix.new("Bennu")
 
 		phoenix.feels_emotion(:joyful)
@@ -45,25 +53,31 @@
 
 		expect(phoenix.emotional_tracker[:joyful]).to eq(3)
 		expect(phoenix.releases_tear?).to be true
+		expect(phoenix.mood).to eq("stoic")
+		expect(phoenix.color).to eq("golden")
 	end
 
-	it "it forgets that emotion after feeling it 3 times" do
+	it "it forgets an emotion after releasing a tear/feeling the same emotion 3 times" do
 		phoenix = Phoenix.new("Bennu")
 
 		phoenix.feels_emotion(:joyful)
-		expect(phoenix.emotional_tracker[:joyful]).to eq(1)
-
-		phoenix.feels_emotion(:joyful)
-		expect(phoenix.emotional_tracker[:joyful]).to eq(2)
-
 		phoenix.feels_emotion(:joyful)
+		phoenix.feels_emotion(:joyful)	
 		expect(phoenix.emotional_tracker[:joyful]).to eq(3)
-		expect(phoenix.releases_tear?).to be true
 
 		phoenix.feels_emotion(:joyful)
 		expect(phoenix.emotional_tracker[:joyful]).to eq(1)
 		expect(phoenix.releases_tear?).to be false
 	end
 
+	xit "feels joyful when being near a human" do
+	end
+
+
+	xit "when that human is sick it's tear can heal the human" do
+	end
+
+	xit "spends time with humans" do
+	end
 
 end
\ No newline at end of file

From e304ba0d0c4bcfb4698778b7280482a3f1e69990 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Sat, 24 Dec 2022 11:44:19 -0700
Subject: [PATCH 29/45] Add phoenix test/methods but stuck now

---
 mythical-creatures/lib/phoenix.rb       |  87 ++++++++++++---
 mythical-creatures/spec/phoenix_spec.rb | 141 +++++++++++++++++-------
 2 files changed, 173 insertions(+), 55 deletions(-)

diff --git a/mythical-creatures/lib/phoenix.rb b/mythical-creatures/lib/phoenix.rb
index 542448b7..adb36ad2 100644
--- a/mythical-creatures/lib/phoenix.rb
+++ b/mythical-creatures/lib/phoenix.rb
@@ -1,40 +1,91 @@
 class Phoenix
-		attr_reader :name,
-								:color,
-								:mood,
-								:emotional_tracker
+	attr_reader :name,
+							:color,
+							:mood,
+							:emotional_awareness
+
+	attr_accessor :feels_emotion(emotion)
 
 	def initialize(name, color = "golden", mood = "stoic")
 		@name = name
 		@color = color
 		@mood = mood
-		@emotional_tracker = {}
+		@emotional_awareness = {}
 		@releases_tear = false
 	end
 
-	def feels_emotion(emotion)
-		@color = "sarlet"
-		@mood = "heated"
+	def burst_into_flame
+			@color = "golden"
+			@mood = "stoic"
+			@emotional_awareness = {}
+	end
 
-		if @emotional_tracker.has_key?(emotion)
-			@emotional_tracker[emotion] += 1
+	def feels_emotion(emotion)
+		if @emotional_awareness.has_key?(emotion)
+			@emotional_awareness[emotion] += 1
 		
-			if @emotional_tracker[emotion] == 3
+			if @emotional_awareness[emotion] == 2
+				@color = "scarlet"
+				@mood = "fiery"
+			elsif @emotional_awareness[emotion] == 3
 				@releases_tear = true
-				@color = "golden"
-				@mood = "stoic"
-			elsif @emotional_tracker[emotion] > 3
+				@color = "crimson"
+				@mood = "ablaze"
+			elsif @emotional_awareness[emotion] == 4
 				@releases_tear = false
-				@emotional_tracker[emotion] = 1
+				@color = "deep violet"
+				@mood = "incandescent"
+			elsif @emotional_awareness[emotion] >= 5
+				burst_into_flame
 			end
-			
+
 		else
-			@emotional_tracker[emotion] = 1
+			@emotional_awareness[emotion] = 1
+			@color = "amber"
+			@mood = "heated"
 		end
 	end
 
 	def releases_tear?
 		@releases_tear
 	end
+end
+
+
+class Pharaoh
+	attr_reader :name,
+				:reputation,
+				:dynastic_period
+
+	def initialize(name, reputation, dynastic_period)
+		@name = name
+		@reputation = reputation
+		@dynastic_period = dynastic_period
+		@health = true
+		@alive = true
+	end
+
+	def healthy?
+		@health
+	end
+
+	def age(number)
+		if number >= 30
+			@health = false
+		end
+	end
+
+	def takes_action(emotion)
+		phoenix.feels_emotion(emotion)
+	end
+
+	def alive?
+		@alive
+	end
+
+	def dies
+		@alive == false
+		5.times { phoenix.feels_emotion(:sorrow) }
+	end
 
-end
\ No newline at end of file
+end
diff --git a/mythical-creatures/spec/phoenix_spec.rb b/mythical-creatures/spec/phoenix_spec.rb
index 5963da02..2917ca23 100644
--- a/mythical-creatures/spec/phoenix_spec.rb
+++ b/mythical-creatures/spec/phoenix_spec.rb
@@ -5,79 +5,146 @@
 
 	it "exists" do
 		phoenix = Phoenix.new("Bennu")
-
 		expect(phoenix.name).to eq("Bennu")
 	end
 
 	it "is born a golden color and in a stoic mood" do
 		phoenix = Phoenix.new("Bennu")
-
 		expect(phoenix.color).to eq("golden")
 		expect(phoenix.mood).to eq("stoic")
 	end
 
-	xit "can age" do
-	end
-
-	xit "can will burst into flames every 500 years" do
-	end
-
-	xit "is reborn after bursting into flames" do
-	end
-
-	it "can change color & mood when feeling an emotion" do
+	it "changes color & mood when feeling an emotion" do
 		phoenix = Phoenix.new("Bennu")
-
 		phoenix.feels_emotion(:joyful)
-
-		expect(phoenix.color).to eq("sarlet")
+		expect(phoenix.color).to eq("amber")
 		expect(phoenix.mood).to eq("heated")
 	end
 
-	it "can track how many times it has the same emotion" do
+	it "has emotional awareness about how many times it has the same emotion" do
 		phoenix = Phoenix.new("Bennu")
-
-		phoenix.feels_emotion(:joyful)
 		phoenix.feels_emotion(:joyful)
+		expect(phoenix.emotional_awareness[:joyful]).to eq(1)
 		phoenix.feels_emotion(:joyful)
+		expect(phoenix.emotional_awareness[:joyful]).to eq(2)
+	end 
 
-		expect(phoenix.emotional_tracker[:joyful]).to eq(3)
-	end
-
-	it "releases a tear after feeling the same emotion 3 times & returns to default mood & color" do
+	it "changes color & mood when feeling an emotion 2, 3, and 4 times" do
 		phoenix = Phoenix.new("Bennu")
 
+		2.times { phoenix.feels_emotion(:joyful) }
+		expect(phoenix.color).to eq("scarlet")
+		expect(phoenix.mood).to eq("fiery")
+
 		phoenix.feels_emotion(:joyful)
+		expect(phoenix.color).to eq("crimson")
+		expect(phoenix.mood).to eq("ablaze")
+
 		phoenix.feels_emotion(:joyful)
-		phoenix.feels_emotion(:joyful)
+		expect(phoenix.color).to eq("deep violet")
+		expect(phoenix.mood).to eq("incandescent")
+	end
 
-		expect(phoenix.emotional_tracker[:joyful]).to eq(3)
+	it "only releases a tear after feeling the same emotion 3 times" do
+		phoenix = Phoenix.new("Bennu")
+		3.times { phoenix.feels_emotion(:joyful) }
 		expect(phoenix.releases_tear?).to be true
-		expect(phoenix.mood).to eq("stoic")
-		expect(phoenix.color).to eq("golden")
+		phoenix.feels_emotion(:joyful)
+		expect(phoenix.releases_tear?).to be false
 	end
 
-	it "it forgets an emotion after releasing a tear/feeling the same emotion 3 times" do
+	it "bursts into flames and is born again after feeling the same emotion 5 times" do
 		phoenix = Phoenix.new("Bennu")
+		5.times { phoenix.feels_emotion(:joyful) }
+		expect(phoenix.emotional_awareness).to eq({})
+		expect(phoenix.color).to eq("golden")
+		expect(phoenix.mood).to eq("stoic")
+	end
 
-		phoenix.feels_emotion(:joyful)
-		phoenix.feels_emotion(:joyful)
-		phoenix.feels_emotion(:joyful)	
-		expect(phoenix.emotional_tracker[:joyful]).to eq(3)
+	it "pharaohs have names, reputations, and a dynastic period" do
+		narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE")
+		khufu = Pharaoh.new("Khufu", "The Builder", "3150 BCE")
+		tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE")
+
+		expect(narmer.name).to eq("Narmer")
+		expect(narmer.reputation).to eq("The Unifer")
+		expect(narmer.dynastic_period).to eq("3100 BCE")
+
+		expect(khufu.name).to eq("Khufu")
+		expect(khufu.reputation).to eq("The Builder")
+		expect(khufu.dynastic_period).to eq("3150 BCE")
+
+		expect(tutankhamun.name).to eq("Tutankhamun")
+		expect(tutankhamun.reputation).to eq("The Child")
+		expect(tutankhamun.dynastic_period).to eq("1500 BCE")
+	end
+
+	it "pharaohs can check if they are health" do
+		narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE")
+		khufu = Pharaoh.new("Khufu", "The Builder", "3150 BCE")
+		tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE")
+
+		expect(narmer.healthy?).to eq(true)
+		expect(khufu.healthy?).to eq(true)
+		expect(tutankhamun.healthy?).to eq(true)
+	end
+
+	it "pharaohs age and become unhealth by the age of 18" do
+		narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE")
+		
+		narmer.age(10)
+		expect(narmer.healthy?).to eq(true)
+		
+		narmer.age(18)
+		expect(narmer.healthy?).to eq(false)
+
+		narmer.age(30)
+		expect(narmer.healthy?).to eq(false)
 
-		phoenix.feels_emotion(:joyful)
-		expect(phoenix.emotional_tracker[:joyful]).to eq(1)
-		expect(phoenix.releases_tear?).to be false
 	end
 
-	xit "feels joyful when being near a human" do
+	it "feels an emotion when observing the action of a pharaoh" do
+		phoenix = Phoenix.new("Bennu")
+		khufu = Pharaoh.new("Khufu", "The Builder", "3150 BCE")
+
+		khufu.takes_action(:fascination)
+		expect(phoenix.emotional_awareness[:fascination]).to eq(1)
 	end
 
+	it "feels an emotion when a pharaoh takes an action" do
+		phoenix = Phoenix.new("Bennu")
+		khufu = Pharaoh.new("Khufu", "The Builder", "3150 BCE")
 
-	xit "when that human is sick it's tear can heal the human" do
+		3.times { khufu.takes_action(:fascination) }
+		expect(phoenix.releases_tear?).to eq(true)
 	end
 
-	xit "spends time with humans" do
+	it "the unhealthy pharaoh become healthy after receiving a phoenix tear" do
+		phoenix = Phoenix.new("Bennu")
+		tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE")
+		
+		expect(tutankhamun.healthy?).to eq(true)
+		
+		tutankhamun.age(18)
+		expect(tutankhamun.healthy?).to eq(false)
+
+		3.times { tutankhamun.takes_action(:astonishment) }
+		expect(phoenix.releases_tear?).to eq(true)
+		expect(tutankhamun.healthy?).to eq(true)
 	end
 
+	it "when a pharaoh dies the phoenix feels sorrow 5 times, bursts into flames, and is reborn" do
+		phoenix = Phoenix.new("Bennu")
+		tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE")
+		
+		tutankhamun.age(19)
+		expect(tutankhamun.alive?).to eq(true)
+
+		tutankhamun.dies
+		expect(tutankhamun.alive?).to eq(false)
+
+		expect(phoenix.emotional_awareness).to eq({})
+		expect(phoenix.color).to eq("golden")
+		expect(phoenix.mood).to eq("stoic")
+	end
 end
\ No newline at end of file

From 823524353b12b6770b1c838aa1752c3f873453e8 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Sat, 24 Dec 2022 13:04:26 -0700
Subject: [PATCH 30/45] Fix methods & tests with peer help - must add a few
 more tests

---
 mythical-creatures/lib/phoenix.rb       | 39 ++++++++++-----
 mythical-creatures/spec/phoenix_spec.rb | 63 +++++++++++++++++--------
 2 files changed, 71 insertions(+), 31 deletions(-)

diff --git a/mythical-creatures/lib/phoenix.rb b/mythical-creatures/lib/phoenix.rb
index adb36ad2..b377d3e2 100644
--- a/mythical-creatures/lib/phoenix.rb
+++ b/mythical-creatures/lib/phoenix.rb
@@ -2,9 +2,8 @@ class Phoenix
 	attr_reader :name,
 							:color,
 							:mood,
-							:emotional_awareness
-
-	attr_accessor :feels_emotion(emotion)
+							:emotional_awareness,
+							:pharaoh
 
 	def initialize(name, color = "golden", mood = "stoic")
 		@name = name
@@ -12,12 +11,19 @@ def initialize(name, color = "golden", mood = "stoic")
 		@mood = mood
 		@emotional_awareness = {}
 		@releases_tear = false
+		@pharaoh = nil
+	end
+
+	def follows_pharaoh(pharaoh)
+		@pharaoh = pharaoh
 	end
 
 	def burst_into_flame
 			@color = "golden"
 			@mood = "stoic"
 			@emotional_awareness = {}
+			@releases_tear = false
+			@pharaoh = nil
 	end
 
 	def feels_emotion(emotion)
@@ -28,7 +34,7 @@ def feels_emotion(emotion)
 				@color = "scarlet"
 				@mood = "fiery"
 			elsif @emotional_awareness[emotion] == 3
-				@releases_tear = true
+				releases_tear
 				@color = "crimson"
 				@mood = "ablaze"
 			elsif @emotional_awareness[emotion] == 4
@@ -49,18 +55,29 @@ def feels_emotion(emotion)
 	def releases_tear?
 		@releases_tear
 	end
+
+	def releases_tear
+		@releases_tear = true
+		if @pharaoh != nil
+		@pharaoh.health = true 
+		end
+	end 
 end
 
 
 class Pharaoh
 	attr_reader :name,
 				:reputation,
-				:dynastic_period
+				:dynastic_period,
+				:phoenix
+
+	attr_accessor :health
 
-	def initialize(name, reputation, dynastic_period)
+	def initialize(name, reputation, dynastic_period, phoenix)
 		@name = name
 		@reputation = reputation
 		@dynastic_period = dynastic_period
+		@phoenix = phoenix
 		@health = true
 		@alive = true
 	end
@@ -70,13 +87,14 @@ def healthy?
 	end
 
 	def age(number)
-		if number >= 30
+		if number >= 18
 			@health = false
 		end
+		@health
 	end
 
 	def takes_action(emotion)
-		phoenix.feels_emotion(emotion)
+		@phoenix.feels_emotion(emotion)
 	end
 
 	def alive?
@@ -84,8 +102,7 @@ def alive?
 	end
 
 	def dies
-		@alive == false
-		5.times { phoenix.feels_emotion(:sorrow) }
+		5.times { @phoenix.feels_emotion(:sorrow) }
+		@alive = false
 	end
-
 end
diff --git a/mythical-creatures/spec/phoenix_spec.rb b/mythical-creatures/spec/phoenix_spec.rb
index 2917ca23..075f8729 100644
--- a/mythical-creatures/spec/phoenix_spec.rb
+++ b/mythical-creatures/spec/phoenix_spec.rb
@@ -48,6 +48,7 @@
 	it "only releases a tear after feeling the same emotion 3 times" do
 		phoenix = Phoenix.new("Bennu")
 		3.times { phoenix.feels_emotion(:joyful) }
+
 		expect(phoenix.releases_tear?).to be true
 		phoenix.feels_emotion(:joyful)
 		expect(phoenix.releases_tear?).to be false
@@ -61,10 +62,14 @@
 		expect(phoenix.mood).to eq("stoic")
 	end
 
-	it "pharaohs have names, reputations, and a dynastic period" do
-		narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE")
-		khufu = Pharaoh.new("Khufu", "The Builder", "3150 BCE")
-		tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE")
+	########################
+
+	it "pharaohs have names, reputations, a dynastic period, and the phoenix" do
+		phoenix = Phoenix.new("Bennu")
+		
+		narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE", phoenix)
+		khufu = Pharaoh.new("Khufu", "The Builder", "2600 BCE", phoenix)
+		tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE", phoenix)
 
 		expect(narmer.name).to eq("Narmer")
 		expect(narmer.reputation).to eq("The Unifer")
@@ -72,7 +77,7 @@
 
 		expect(khufu.name).to eq("Khufu")
 		expect(khufu.reputation).to eq("The Builder")
-		expect(khufu.dynastic_period).to eq("3150 BCE")
+		expect(khufu.dynastic_period).to eq("2600 BCE")
 
 		expect(tutankhamun.name).to eq("Tutankhamun")
 		expect(tutankhamun.reputation).to eq("The Child")
@@ -80,18 +85,24 @@
 	end
 
 	it "pharaohs can check if they are health" do
-		narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE")
-		khufu = Pharaoh.new("Khufu", "The Builder", "3150 BCE")
-		tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE")
+		phoenix = Phoenix.new("Bennu")
+		
+		narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE", phoenix)
+		khufu = Pharaoh.new("Khufu", "The Builder", "2600 BCE", phoenix)
+		tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE", phoenix)
 
 		expect(narmer.healthy?).to eq(true)
 		expect(khufu.healthy?).to eq(true)
 		expect(tutankhamun.healthy?).to eq(true)
 	end
 
-	it "pharaohs age and become unhealth by the age of 18" do
-		narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE")
-		
+	# add test to allow phoenix to follow pharaoh 
+
+	it "pharaohs become unhealth at the age of 18" do
+		phoenix = Phoenix.new("Bennu")
+		narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE", phoenix)
+		phoenix.follows_pharaoh(narmer)
+
 		narmer.age(10)
 		expect(narmer.healthy?).to eq(true)
 		
@@ -103,9 +114,10 @@
 
 	end
 
-	it "feels an emotion when observing the action of a pharaoh" do
+	it "the phoenix feels an emotion when a pharaoh takes an action" do
 		phoenix = Phoenix.new("Bennu")
-		khufu = Pharaoh.new("Khufu", "The Builder", "3150 BCE")
+		khufu = Pharaoh.new("Khufu", "The Builder", "3150 BCE", phoenix)
+		phoenix.follows_pharaoh(khufu)
 
 		khufu.takes_action(:fascination)
 		expect(phoenix.emotional_awareness[:fascination]).to eq(1)
@@ -113,7 +125,8 @@
 
 	it "feels an emotion when a pharaoh takes an action" do
 		phoenix = Phoenix.new("Bennu")
-		khufu = Pharaoh.new("Khufu", "The Builder", "3150 BCE")
+		khufu = Pharaoh.new("Khufu", "The Builder", "3150 BCE", phoenix)
+		phoenix.follows_pharaoh(khufu)
 
 		3.times { khufu.takes_action(:fascination) }
 		expect(phoenix.releases_tear?).to eq(true)
@@ -121,30 +134,40 @@
 
 	it "the unhealthy pharaoh become healthy after receiving a phoenix tear" do
 		phoenix = Phoenix.new("Bennu")
-		tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE")
-		
+		tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE", phoenix)
+		phoenix.follows_pharaoh(tutankhamun)
+
 		expect(tutankhamun.healthy?).to eq(true)
 		
 		tutankhamun.age(18)
 		expect(tutankhamun.healthy?).to eq(false)
 
-		3.times { tutankhamun.takes_action(:astonishment) }
+		3.times { tutankhamun.takes_action(:compassion) }
 		expect(phoenix.releases_tear?).to eq(true)
 		expect(tutankhamun.healthy?).to eq(true)
 	end
 
 	it "when a pharaoh dies the phoenix feels sorrow 5 times, bursts into flames, and is reborn" do
 		phoenix = Phoenix.new("Bennu")
-		tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE")
-		
+		tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE", phoenix)
+		phoenix.follows_pharaoh(tutankhamun)
+
 		tutankhamun.age(19)
 		expect(tutankhamun.alive?).to eq(true)
+		
+		4.times { tutankhamun.takes_action(:curiosity) }
+		expect(phoenix.emotional_awareness[:curiosity]).to eq(4)
+		expect(phoenix.color).to eq("deep violet")
+		expect(phoenix.mood).to eq("incandescent")
 
 		tutankhamun.dies
 		expect(tutankhamun.alive?).to eq(false)
 
-		expect(phoenix.emotional_awareness).to eq({})
 		expect(phoenix.color).to eq("golden")
 		expect(phoenix.mood).to eq("stoic")
+		expect(phoenix.emotional_awareness).to eq({})
+		expect(phoenix.releases_tear?).to eq(false)
+		expect(phoenix.pharaoh).to eq(nil)
+
 	end
 end
\ No newline at end of file

From b518ddc76f767ccd53f5dcd13cba273462efdcc1 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Sat, 24 Dec 2022 14:06:20 -0700
Subject: [PATCH 31/45] Finish Phoenix Mythical Creature

---
 mythical-creatures/lib/phoenix.rb       |  14 +-
 mythical-creatures/spec/phoenix_spec.rb | 316 +++++++++++++-----------
 2 files changed, 185 insertions(+), 145 deletions(-)

diff --git a/mythical-creatures/lib/phoenix.rb b/mythical-creatures/lib/phoenix.rb
index b377d3e2..546cf951 100644
--- a/mythical-creatures/lib/phoenix.rb
+++ b/mythical-creatures/lib/phoenix.rb
@@ -14,11 +14,7 @@ def initialize(name, color = "golden", mood = "stoic")
 		@pharaoh = nil
 	end
 
-	def follows_pharaoh(pharaoh)
-		@pharaoh = pharaoh
-	end
-
-	def burst_into_flame
+	def bursts_into_flames
 			@color = "golden"
 			@mood = "stoic"
 			@emotional_awareness = {}
@@ -42,7 +38,7 @@ def feels_emotion(emotion)
 				@color = "deep violet"
 				@mood = "incandescent"
 			elsif @emotional_awareness[emotion] >= 5
-				burst_into_flame
+				bursts_into_flames
 			end
 
 		else
@@ -55,13 +51,17 @@ def feels_emotion(emotion)
 	def releases_tear?
 		@releases_tear
 	end
-
+	
 	def releases_tear
 		@releases_tear = true
 		if @pharaoh != nil
 		@pharaoh.health = true 
 		end
 	end 
+
+	def follows_pharaoh(pharaoh)
+		@pharaoh = pharaoh
+	end
 end
 
 
diff --git a/mythical-creatures/spec/phoenix_spec.rb b/mythical-creatures/spec/phoenix_spec.rb
index 075f8729..7a14d4e5 100644
--- a/mythical-creatures/spec/phoenix_spec.rb
+++ b/mythical-creatures/spec/phoenix_spec.rb
@@ -3,171 +3,211 @@
 
 RSpec.describe Phoenix do
 
-	it "exists" do
-		phoenix = Phoenix.new("Bennu")
-		expect(phoenix.name).to eq("Bennu")
-	end
-
-	it "is born a golden color and in a stoic mood" do
-		phoenix = Phoenix.new("Bennu")
-		expect(phoenix.color).to eq("golden")
-		expect(phoenix.mood).to eq("stoic")
-	end
+	describe "The Phoenix was Self-created at the Beginning of Time" do
+		it "exists" do
+			phoenix = Phoenix.new("Bennu")
 
-	it "changes color & mood when feeling an emotion" do
-		phoenix = Phoenix.new("Bennu")
-		phoenix.feels_emotion(:joyful)
-		expect(phoenix.color).to eq("amber")
-		expect(phoenix.mood).to eq("heated")
-	end
-
-	it "has emotional awareness about how many times it has the same emotion" do
-		phoenix = Phoenix.new("Bennu")
-		phoenix.feels_emotion(:joyful)
-		expect(phoenix.emotional_awareness[:joyful]).to eq(1)
-		phoenix.feels_emotion(:joyful)
-		expect(phoenix.emotional_awareness[:joyful]).to eq(2)
-	end 
+			expect(phoenix.name).to eq("Bennu")
+		end
 
-	it "changes color & mood when feeling an emotion 2, 3, and 4 times" do
-		phoenix = Phoenix.new("Bennu")
+		it "is born golden and stoic" do
+			phoenix = Phoenix.new("Bennu")
 
-		2.times { phoenix.feels_emotion(:joyful) }
-		expect(phoenix.color).to eq("scarlet")
-		expect(phoenix.mood).to eq("fiery")
+			expect(phoenix.color).to eq("golden")
+			expect(phoenix.mood).to eq("stoic")
+		end
 
-		phoenix.feels_emotion(:joyful)
-		expect(phoenix.color).to eq("crimson")
-		expect(phoenix.mood).to eq("ablaze")
+		it "changes color & mood when feeling an emotion" do
+			phoenix = Phoenix.new("Bennu")
 
-		phoenix.feels_emotion(:joyful)
-		expect(phoenix.color).to eq("deep violet")
-		expect(phoenix.mood).to eq("incandescent")
-	end
+			phoenix.feels_emotion(:cognizance)
 
-	it "only releases a tear after feeling the same emotion 3 times" do
-		phoenix = Phoenix.new("Bennu")
-		3.times { phoenix.feels_emotion(:joyful) }
+			expect(phoenix.color).to eq("amber")
+			expect(phoenix.mood).to eq("heated")
+		end
 
-		expect(phoenix.releases_tear?).to be true
-		phoenix.feels_emotion(:joyful)
-		expect(phoenix.releases_tear?).to be false
-	end
+		it "has emotional awareness about how many times it has the same emotion" do
+			phoenix = Phoenix.new("Bennu")
 
-	it "bursts into flames and is born again after feeling the same emotion 5 times" do
-		phoenix = Phoenix.new("Bennu")
-		5.times { phoenix.feels_emotion(:joyful) }
-		expect(phoenix.emotional_awareness).to eq({})
-		expect(phoenix.color).to eq("golden")
-		expect(phoenix.mood).to eq("stoic")
-	end
+			phoenix.feels_emotion(:curiosity)
+			expect(phoenix.emotional_awareness[:curiosity]).to eq(1)
 
-	########################
+			phoenix.feels_emotion(:curiosity)
+			expect(phoenix.emotional_awareness[:curiosity]).to eq(2)
+		end 
 
-	it "pharaohs have names, reputations, a dynastic period, and the phoenix" do
-		phoenix = Phoenix.new("Bennu")
+		it "has emotional awareness about how many times it has had different emotions" do
+			phoenix = Phoenix.new("Bennu")
 		
-		narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE", phoenix)
-		khufu = Pharaoh.new("Khufu", "The Builder", "2600 BCE", phoenix)
-		tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE", phoenix)
+			phoenix.feels_emotion(:exuberance)
+			phoenix.feels_emotion(:exuberance)
+			phoenix.feels_emotion(:exuberance)
 
-		expect(narmer.name).to eq("Narmer")
-		expect(narmer.reputation).to eq("The Unifer")
-		expect(narmer.dynastic_period).to eq("3100 BCE")
+			phoenix.feels_emotion(:wisdom)
+			phoenix.feels_emotion(:wisdom)
 
-		expect(khufu.name).to eq("Khufu")
-		expect(khufu.reputation).to eq("The Builder")
-		expect(khufu.dynastic_period).to eq("2600 BCE")
+			phoenix.feels_emotion(:autonomy)
 
-		expect(tutankhamun.name).to eq("Tutankhamun")
-		expect(tutankhamun.reputation).to eq("The Child")
-		expect(tutankhamun.dynastic_period).to eq("1500 BCE")
-	end
+			expect(phoenix.emotional_awareness).to eq({:exuberance => 3, :wisdom => 2, :autonomy => 1})
+			expect(phoenix.emotional_awareness.include?(:sorrow)).to eq(false)
+		end
 
-	it "pharaohs can check if they are health" do
-		phoenix = Phoenix.new("Bennu")
-		
-		narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE", phoenix)
-		khufu = Pharaoh.new("Khufu", "The Builder", "2600 BCE", phoenix)
-		tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE", phoenix)
+		it "changes color & mood when feeling an emotion 2, 3, and 4 times" do
+			phoenix = Phoenix.new("Bennu")
 
-		expect(narmer.healthy?).to eq(true)
-		expect(khufu.healthy?).to eq(true)
-		expect(tutankhamun.healthy?).to eq(true)
-	end
+			2.times { phoenix.feels_emotion(:curiosity) }
+			expect(phoenix.color).to eq("scarlet")
+			expect(phoenix.mood).to eq("fiery")
 
-	# add test to allow phoenix to follow pharaoh 
+			phoenix.feels_emotion(:curiosity)
+			expect(phoenix.color).to eq("crimson")
+			expect(phoenix.mood).to eq("ablaze")
 
-	it "pharaohs become unhealth at the age of 18" do
-		phoenix = Phoenix.new("Bennu")
-		narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE", phoenix)
-		phoenix.follows_pharaoh(narmer)
+			phoenix.feels_emotion(:curiosity)
+			expect(phoenix.color).to eq("deep violet")
+			expect(phoenix.mood).to eq("incandescent")
+		end
 
-		narmer.age(10)
-		expect(narmer.healthy?).to eq(true)
-		
-		narmer.age(18)
-		expect(narmer.healthy?).to eq(false)
+		it "only releases a tear after feeling the same emotion 3 times" do
+			phoenix = Phoenix.new("Bennu")
+			
+			2.times { phoenix.feels_emotion(:confusion) }
+			expect(phoenix.releases_tear?).to be false
 
-		narmer.age(30)
-		expect(narmer.healthy?).to eq(false)
+			phoenix.feels_emotion(:confusion)
+			expect(phoenix.releases_tear?).to be true
 
-	end
-
-	it "the phoenix feels an emotion when a pharaoh takes an action" do
-		phoenix = Phoenix.new("Bennu")
-		khufu = Pharaoh.new("Khufu", "The Builder", "3150 BCE", phoenix)
-		phoenix.follows_pharaoh(khufu)
+			phoenix.feels_emotion(:confusion)
+			expect(phoenix.releases_tear?).to be false
+		end
 
-		khufu.takes_action(:fascination)
-		expect(phoenix.emotional_awareness[:fascination]).to eq(1)
-	end
+		it "bursts into flames and is reborn after feeling the same emotion 5 times" do
+			phoenix = Phoenix.new("Bennu")
 
-	it "feels an emotion when a pharaoh takes an action" do
-		phoenix = Phoenix.new("Bennu")
-		khufu = Pharaoh.new("Khufu", "The Builder", "3150 BCE", phoenix)
-		phoenix.follows_pharaoh(khufu)
+			5.times { phoenix.feels_emotion(:gratitude) }
 
-		3.times { khufu.takes_action(:fascination) }
-		expect(phoenix.releases_tear?).to eq(true)
+			expect(phoenix.color).to eq("golden")
+			expect(phoenix.mood).to eq("stoic")
+			expect(phoenix.emotional_awareness).to eq({})
+			expect(phoenix.releases_tear?).to eq(false)
+			expect(phoenix.pharaoh).to eq(nil)
+		end
 	end
 
-	it "the unhealthy pharaoh become healthy after receiving a phoenix tear" do
-		phoenix = Phoenix.new("Bennu")
-		tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE", phoenix)
-		phoenix.follows_pharaoh(tutankhamun)
-
-		expect(tutankhamun.healthy?).to eq(true)
-		
-		tutankhamun.age(18)
-		expect(tutankhamun.healthy?).to eq(false)
-
-		3.times { tutankhamun.takes_action(:compassion) }
-		expect(phoenix.releases_tear?).to eq(true)
-		expect(tutankhamun.healthy?).to eq(true)
+	describe "Pharaohs can Exist" do
+		it "pharaohs have names, reputations, a dynastic period, and the phoenix" do
+			phoenix = Phoenix.new("Bennu")
+			
+			narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE", phoenix)
+			khufu = Pharaoh.new("Khufu", "The Builder", "2600 BCE", phoenix)
+			tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE", phoenix)
+
+			expect(narmer.name).to eq("Narmer")
+			expect(narmer.reputation).to eq("The Unifer")
+			expect(narmer.dynastic_period).to eq("3100 BCE")
+
+			expect(khufu.name).to eq("Khufu")
+			expect(khufu.reputation).to eq("The Builder")
+			expect(khufu.dynastic_period).to eq("2600 BCE")
+
+			expect(tutankhamun.name).to eq("Tutankhamun")
+			expect(tutankhamun.reputation).to eq("The Child")
+			expect(tutankhamun.dynastic_period).to eq("1500 BCE")
+		end
+
+		it "pharaohs can check if they are healthy" do
+			phoenix = Phoenix.new("Bennu")
+			
+			narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE", phoenix)
+			khufu = Pharaoh.new("Khufu", "The Builder", "2600 BCE", phoenix)
+			tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE", phoenix)
+
+			expect(narmer.healthy?).to eq(true)
+			expect(khufu.healthy?).to eq(true)
+			expect(tutankhamun.healthy?).to eq(true)
+		end
 	end
 
-	it "when a pharaoh dies the phoenix feels sorrow 5 times, bursts into flames, and is reborn" do
-		phoenix = Phoenix.new("Bennu")
-		tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE", phoenix)
-		phoenix.follows_pharaoh(tutankhamun)
-
-		tutankhamun.age(19)
-		expect(tutankhamun.alive?).to eq(true)
-		
-		4.times { tutankhamun.takes_action(:curiosity) }
-		expect(phoenix.emotional_awareness[:curiosity]).to eq(4)
-		expect(phoenix.color).to eq("deep violet")
-		expect(phoenix.mood).to eq("incandescent")
-
-		tutankhamun.dies
-		expect(tutankhamun.alive?).to eq(false)
-
-		expect(phoenix.color).to eq("golden")
-		expect(phoenix.mood).to eq("stoic")
-		expect(phoenix.emotional_awareness).to eq({})
-		expect(phoenix.releases_tear?).to eq(false)
-		expect(phoenix.pharaoh).to eq(nil)
-
+	describe "The Phoenix throughout Ancient Egypt" do
+		it "the phoenix chooses to follow the pharaoh" do
+			phoenix = Phoenix.new("Bennu")
+			narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE", phoenix)
+			
+			phoenix.follows_pharaoh(narmer)
+
+			expect(phoenix.pharaoh).to eq(narmer)
+		end
+
+		it "the pharaoh becomes unhealth at the age of 18" do
+			phoenix = Phoenix.new("Bennu")
+			narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE", phoenix)
+			phoenix.follows_pharaoh(narmer)
+
+			narmer.age(10)
+			expect(narmer.healthy?).to eq(true)
+			
+			narmer.age(18)
+			expect(narmer.healthy?).to eq(false)
+
+			narmer.age(30)
+			expect(narmer.healthy?).to eq(false)
+		end
+
+		it "the phoenix feels an emotion when the pharaoh takes an action" do
+			phoenix = Phoenix.new("Bennu")
+			khufu = Pharaoh.new("Khufu", "The Builder", "3150 BCE", phoenix)
+			phoenix.follows_pharaoh(khufu)
+
+			khufu.takes_action(:perseverance)
+			expect(phoenix.emotional_awareness[:perseverance]).to eq(1)
+		end
+
+		it "the phoenix releases a tear after the pharaoh takes the same 3 actions" do
+			phoenix = Phoenix.new("Bennu")
+			khufu = Pharaoh.new("Khufu", "The Builder", "3150 BCE", phoenix)
+			phoenix.follows_pharaoh(khufu)
+
+			3.times { khufu.takes_action(:perseverance) }
+			expect(phoenix.releases_tear?).to eq(true)
+		end
+
+		it "the unhealthy pharaoh becomes healthy after the phoenix releases a tear" do
+			phoenix = Phoenix.new("Bennu")
+			tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE", phoenix)
+			phoenix.follows_pharaoh(tutankhamun)
+
+			expect(tutankhamun.healthy?).to eq(true)
+			
+			tutankhamun.age(18)
+			expect(tutankhamun.healthy?).to eq(false)
+
+			3.times { tutankhamun.takes_action(:compassion) }
+			expect(phoenix.releases_tear?).to eq(true)
+			
+			expect(tutankhamun.healthy?).to eq(true)
+		end
+
+		it "when the pharaoh dies the phoenix feels sorrow 5 times, bursts into flames, and is reborn" do
+			phoenix = Phoenix.new("Bennu")
+			tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE", phoenix)
+			phoenix.follows_pharaoh(tutankhamun)
+
+			tutankhamun.age(19)
+			expect(tutankhamun.alive?).to eq(true)
+
+			4.times { tutankhamun.takes_action(:trepidation) }
+			expect(phoenix.emotional_awareness[:trepidation]).to eq(4)
+			expect(phoenix.color).to eq("deep violet")
+			expect(phoenix.mood).to eq("incandescent")
+
+			tutankhamun.dies
+			expect(tutankhamun.alive?).to eq(false)
+
+			expect(phoenix.color).to eq("golden")
+			expect(phoenix.mood).to eq("stoic")
+			expect(phoenix.emotional_awareness).to eq({})
+			expect(phoenix.releases_tear?).to eq(false)
+			expect(phoenix.pharaoh).to eq(nil)
+		end
 	end
 end
\ No newline at end of file

From afb73b6446de94c2d21c389945d59cb2b0b82fc5 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Sun, 25 Dec 2022 07:57:16 -0700
Subject: [PATCH 32/45] fix: Modify duplicate words Phoenix

---
 .../spec/advanced_nesting_spec.rb                         | 1 +
 images/enumerables-setup-map.jpg                          | 0
 mythical-creatures/spec/phoenix_spec.rb                   | 8 ++++----
 3 files changed, 5 insertions(+), 4 deletions(-)
 create mode 100644 images/enumerables-setup-map.jpg

diff --git a/data-types/collections/advanced_nested_collections/spec/advanced_nesting_spec.rb b/data-types/collections/advanced_nested_collections/spec/advanced_nesting_spec.rb
index 3d5ae8dc..c312962b 100644
--- a/data-types/collections/advanced_nested_collections/spec/advanced_nesting_spec.rb
+++ b/data-types/collections/advanced_nested_collections/spec/advanced_nesting_spec.rb
@@ -157,6 +157,7 @@
         full_menu[dish[:name]] = {:name => dish[:name], :ingredients => dish[:ingredients], :price => dish[:price]}
       end
     end
+    # Huy used <.map> twice to make the code "cleaner"
     
 
     expected = {
diff --git a/images/enumerables-setup-map.jpg b/images/enumerables-setup-map.jpg
new file mode 100644
index 00000000..e69de29b
diff --git a/mythical-creatures/spec/phoenix_spec.rb b/mythical-creatures/spec/phoenix_spec.rb
index 7a14d4e5..24024c68 100644
--- a/mythical-creatures/spec/phoenix_spec.rb
+++ b/mythical-creatures/spec/phoenix_spec.rb
@@ -55,15 +55,15 @@
 		it "changes color & mood when feeling an emotion 2, 3, and 4 times" do
 			phoenix = Phoenix.new("Bennu")
 
-			2.times { phoenix.feels_emotion(:curiosity) }
+			2.times { phoenix.feels_emotion(:gratitude) }
 			expect(phoenix.color).to eq("scarlet")
 			expect(phoenix.mood).to eq("fiery")
 
-			phoenix.feels_emotion(:curiosity)
+			phoenix.feels_emotion(:gratitude)
 			expect(phoenix.color).to eq("crimson")
 			expect(phoenix.mood).to eq("ablaze")
 
-			phoenix.feels_emotion(:curiosity)
+			phoenix.feels_emotion(:gratitude)
 			expect(phoenix.color).to eq("deep violet")
 			expect(phoenix.mood).to eq("incandescent")
 		end
@@ -84,7 +84,7 @@
 		it "bursts into flames and is reborn after feeling the same emotion 5 times" do
 			phoenix = Phoenix.new("Bennu")
 
-			5.times { phoenix.feels_emotion(:gratitude) }
+			5.times { phoenix.feels_emotion(:revelation) }
 
 			expect(phoenix.color).to eq("golden")
 			expect(phoenix.mood).to eq("stoic")

From 9e6b05cb71e9d54a1ee08230b2485f51589bb240 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Sun, 25 Dec 2022 08:06:27 -0700
Subject: [PATCH 33/45] Update emotions last time Phoenix

---
 mythical-creatures/spec/phoenix_spec.rb | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/mythical-creatures/spec/phoenix_spec.rb b/mythical-creatures/spec/phoenix_spec.rb
index 24024c68..ce29e9bc 100644
--- a/mythical-creatures/spec/phoenix_spec.rb
+++ b/mythical-creatures/spec/phoenix_spec.rb
@@ -43,27 +43,27 @@
 			phoenix.feels_emotion(:exuberance)
 			phoenix.feels_emotion(:exuberance)
 
-			phoenix.feels_emotion(:wisdom)
-			phoenix.feels_emotion(:wisdom)
+			phoenix.feels_emotion(:gratitude)
+			phoenix.feels_emotion(:gratitude)
 
 			phoenix.feels_emotion(:autonomy)
 
-			expect(phoenix.emotional_awareness).to eq({:exuberance => 3, :wisdom => 2, :autonomy => 1})
+			expect(phoenix.emotional_awareness).to eq({:exuberance => 3, :gratitude => 2, :autonomy => 1})
 			expect(phoenix.emotional_awareness.include?(:sorrow)).to eq(false)
 		end
 
 		it "changes color & mood when feeling an emotion 2, 3, and 4 times" do
 			phoenix = Phoenix.new("Bennu")
 
-			2.times { phoenix.feels_emotion(:gratitude) }
+			2.times { phoenix.feels_emotion(:wisdom) }
 			expect(phoenix.color).to eq("scarlet")
 			expect(phoenix.mood).to eq("fiery")
 
-			phoenix.feels_emotion(:gratitude)
+			phoenix.feels_emotion(:wisdom)
 			expect(phoenix.color).to eq("crimson")
 			expect(phoenix.mood).to eq("ablaze")
 
-			phoenix.feels_emotion(:gratitude)
+			phoenix.feels_emotion(:wisdom)
 			expect(phoenix.color).to eq("deep violet")
 			expect(phoenix.mood).to eq("incandescent")
 		end

From 83ab2a6c05860149b1646c6680cc8fda0ee808a8 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Sun, 25 Dec 2022 13:48:18 -0700
Subject: [PATCH 34/45] modify age Phoenix

---
 mythical-creatures/spec/phoenix_spec.rb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/mythical-creatures/spec/phoenix_spec.rb b/mythical-creatures/spec/phoenix_spec.rb
index ce29e9bc..2739a6fa 100644
--- a/mythical-creatures/spec/phoenix_spec.rb
+++ b/mythical-creatures/spec/phoenix_spec.rb
@@ -143,13 +143,13 @@
 			narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE", phoenix)
 			phoenix.follows_pharaoh(narmer)
 
-			narmer.age(10)
+			narmer.age(17)
 			expect(narmer.healthy?).to eq(true)
 			
 			narmer.age(18)
 			expect(narmer.healthy?).to eq(false)
 
-			narmer.age(30)
+			narmer.age(19)
 			expect(narmer.healthy?).to eq(false)
 		end
 

From 8ec9abc527700bebf4b3d1a6c649dcd41494c7d1 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Mon, 26 Dec 2022 11:01:06 -0700
Subject: [PATCH 35/45] Add enumberable find

---
 .../exercises_1/spec/find_pattern_spec.rb     | 96 +++++++++++++++----
 enumerables/exercises_1/spec/find_spec.rb     | 72 ++++++++++----
 2 files changed, 132 insertions(+), 36 deletions(-)

diff --git a/enumerables/exercises_1/spec/find_pattern_spec.rb b/enumerables/exercises_1/spec/find_pattern_spec.rb
index 513ea7c7..72661f42 100644
--- a/enumerables/exercises_1/spec/find_pattern_spec.rb
+++ b/enumerables/exercises_1/spec/find_pattern_spec.rb
@@ -12,61 +12,121 @@
     expect(found).to eq("unicorn")
   end
 
-  xit 'no waldo' do
+ it 'no waldo' do
     words = ["scarf", "sandcastle", "flag", "pretzel", "crow", "key"]
     found = nil
     words.each do |word|
-      # Your code goes here
+      if word == "waldo"
+        found = word
+      end
     end
     expect(found).to eq(nil)
   end
 
-  xit 'found waldo' do
+  it 'found waldo' do
     words = ["noise", "dog", "fair", "house", "waldo", "bucket", "fish"]
     found = nil
-    # Your code goes here
+    words.each do |word|
+      if word == "waldo"
+        found = word
+      end
+    end
     expect(found).to eq("waldo")
   end
 
-  xit 'no three letter words' do
+  it 'no three letter words' do
     words = ["piglet", "porridge", "bear", "blueberry"]
-    # Your code goes here
+    found = nil
+
+    words.each do |word|
+      if word.length == 3
+        found = word
+      end
+    end
+
     expect(found).to eq(nil)
   end
 
-  xit 'finds 13' do
+  it 'finds 13' do
     numbers = [2, 13, 19, 8, 3, 27]
-    # Your code goes here
+    found = nil
+
+    numbers.each do |num|
+      if num == 13
+        found = num
+      end
+    end
+
     expect(found).to eq(13)
   end
 
-  xit 'first even number' do
+  it 'first even number' do
     numbers = [3, 7, 13, 11, 10, 2, 17]
-    # Your code goes here
+    found = nil
+
+    numbers.each do |num|
+      if num.even? == true
+        found = num
+        break
+      end
+    end
+
     expect(found).to eq(10)
   end
 
-  xit 'first multiple of 3' do
+  it 'first multiple of 3' do
     numbers = [2, 8, 9, 27, 24, 5]
-    # Your code goes here
+    found = nil
+
+    numbers.each do |num|
+      if num % 3 == 0
+        found = num
+        break
+      end
+    end
+
     expect(found).to eq(9)
   end
 
-  xit 'first word starting with q' do
+  it 'first word starting with q' do
     words = ["weirdo", "quill", "fast", "quaint", "quitter", "koala"]
-    # Your code goes here
+    found = nil
+
+    words.each do |word|
+      if word.start_with?("q")
+        found = word
+        break
+      end
+    end
+
     expect(found).to eq("quill")
   end
 
-  xit 'first word ending with er' do
+  it 'first word ending with er' do
     words = ["biggest", "pour", "blight", "finger", "pie", "border"]
-    # Your code goes here
+    found = nil
+
+    words.each do |word|
+      if word.end_with?("er")
+        found = word
+        break
+      end
+    end
+
     expect(found).to eq("finger")
   end
 
-  xit 'first number greater than 20' do
+  it 'first number greater than 20' do
     numbers = [1, 8, 19, 21, 29, 31, 34]
-    # Your code goes here
+    found = nil
+
+    numbers.each do |num|
+      if num > 20
+        found = num
+        break
+      end
+    end
+    
     expect(found).to eq(21)
   end
 end
diff --git a/enumerables/exercises_1/spec/find_spec.rb b/enumerables/exercises_1/spec/find_spec.rb
index 8745de8c..b97841b5 100644
--- a/enumerables/exercises_1/spec/find_spec.rb
+++ b/enumerables/exercises_1/spec/find_spec.rb
@@ -2,65 +2,101 @@
 
   it 'first seven letter word' do
     words = ["capricious", "berry", "unicorn", "bag", "apple", "festering", "pretzel", "pencil"]
+    
     found = words.find do |word|
       word.length == 7
     end
+
     expect(found).to eq("unicorn")
   end
 
-  xit 'no waldo' do
+  it 'no waldo' do
     words = ["scarf", "sandcastle", "flag", "pretzel", "crow", "key"]
+    
     found = words.find do |word|
-      # Your code goes here
+      word == "waldo"
     end
+
     expect(found).to eq(nil)
   end
 
-  xit 'found waldo' do
+  it 'found waldo' do
     words = ["noise", "dog", "fair", "house", "waldo", "bucket", "fish"]
-    # Your code goes here
+    
+    found = words.find do |word|
+      word == "waldo"
+    end
+
     expect(found).to eq("waldo")
   end
 
-  xit 'no three letter words' do
+  it 'no three letter words' do
     words = ["piglet", "porridge", "bear", "blueberry"]
-    # Your code goes here
+   
+    found = words.find do |word|
+      word.length == 3
+    end
+
     expect(found).to eq(nil)
   end
 
-  xit 'find 13' do
+  it 'find 13' do
     numbers = [2, 13, 19, 8, 3, 27]
-    # Your code goes here
+    
+    found = numbers.find do |num|
+      num == 13
+    end 
+
     expect(found).to eq(13)
   end
 
-  xit 'find first even number' do
+  it 'find first even number' do
     numbers = [3, 7, 13, 11, 10, 2, 17]
-    # Your code goes here
+    
+    found = numbers.find do |num|
+      num.even?
+    end
+
     expect(found).to eq(10)
   end
 
-  xit 'first multiple of 3' do
+  it 'first multiple of 3' do
     numbers = [2, 8, 9, 27, 24, 5]
-    # Your code goes here
+
+    found = numbers.find do |num|
+      num % 3 == 0
+    end
+    
     expect(found).to eq(9)
   end
 
-  xit 'first word starting with q' do
+  it 'first word starting with q' do
     words = ["weirdo", "quill", "fast", "quaint", "quitter", "koala"]
-    # Your code goes here
+    
+    found = words.find do |word|
+      word.start_with?("q")
+    end
+
     expect(found).to eq("quill")
   end
 
-  xit 'first word ending with er' do
+  it 'first word ending with er' do
     words = ["biggest", "pour", "blight", "finger", "pie", "border"]
-    # Your code goes here
+  
+    found = words.find do |word|
+      word.end_with?("er")
+    end
+
     expect(found).to eq("finger")
   end
 
-  xit 'first number greater than 20' do
+  it 'first number greater than 20' do
     numbers = [1, 8, 19, 21, 29, 31, 34]
-    # Your code goes here
+    
+    found = numbers.find do |num|
+      num > 20
+    end
+
     expect(found).to eq(21)
   end
 end

From 0aed563dabf715ea42776b78a4c5a5967db855b8 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Mon, 26 Dec 2022 11:51:23 -0700
Subject: [PATCH 36/45] fix: mythical creatures direwolf leaves method

---
 mythical-creatures/lib/direwolf.rb       | 1 -
 mythical-creatures/spec/direwolf_spec.rb | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/mythical-creatures/lib/direwolf.rb b/mythical-creatures/lib/direwolf.rb
index fe6e11ae..2a1644f2 100644
--- a/mythical-creatures/lib/direwolf.rb
+++ b/mythical-creatures/lib/direwolf.rb
@@ -29,7 +29,6 @@ def hunts_white_walkers?
 		def leaves(a_stark)
 			a_stark.safe = false
 			@starks_to_protect.delete(a_stark)
-			a_stark
 		end
 
 end
diff --git a/mythical-creatures/spec/direwolf_spec.rb b/mythical-creatures/spec/direwolf_spec.rb
index 7e2ebb5c..e5785e9c 100644
--- a/mythical-creatures/spec/direwolf_spec.rb
+++ b/mythical-creatures/spec/direwolf_spec.rb
@@ -147,7 +147,7 @@
     rickon_stark = Stark.new('Rickon')
 
     summer_wolf.protects(arya_stark)
-    lady_wolf.protects(sansa_stark)
+    lady_wolf.protects(rickon_stark)
     
     summer_wolf.leaves(arya_stark)
 

From c53a6fccacfee09f50aac69d8b3b3e4d164d8852 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Mon, 26 Dec 2022 15:02:17 -0700
Subject: [PATCH 37/45] Add notes to make changes Phoenix

---
 mythical-creatures/lib/phoenix.rb       | 38 ++++++++++----------
 mythical-creatures/spec/phoenix_spec.rb | 48 ++++++++-----------------
 2 files changed, 35 insertions(+), 51 deletions(-)

diff --git a/mythical-creatures/lib/phoenix.rb b/mythical-creatures/lib/phoenix.rb
index 546cf951..9b61223a 100644
--- a/mythical-creatures/lib/phoenix.rb
+++ b/mythical-creatures/lib/phoenix.rb
@@ -20,19 +20,26 @@ def bursts_into_flames
 			@emotional_awareness = {}
 			@releases_tear = false
 			@pharaoh = nil
+			# not have to se to nil
+			# could call follows pharaoh again
 	end
 
 	def feels_emotion(emotion)
 		if @emotional_awareness.has_key?(emotion)
 			@emotional_awareness[emotion] += 1
 		
+			#pharaoh dies!
 			if @emotional_awareness[emotion] == 2
 				@color = "scarlet"
 				@mood = "fiery"
 			elsif @emotional_awareness[emotion] == 3
-				releases_tear
 				@color = "crimson"
 				@mood = "ablaze"
+				@releases_tear = true
+				@pharaoh.healthy = true if @pharaoh != nil
+					# if @pharaoh != nil
+					# 	pharaoh.healthy = true 
+					# end
 			elsif @emotional_awareness[emotion] == 4
 				@releases_tear = false
 				@color = "deep violet"
@@ -51,13 +58,6 @@ def feels_emotion(emotion)
 	def releases_tear?
 		@releases_tear
 	end
-	
-	def releases_tear
-		@releases_tear = true
-		if @pharaoh != nil
-		@pharaoh.health = true 
-		end
-	end 
 
 	def follows_pharaoh(pharaoh)
 		@pharaoh = pharaoh
@@ -71,26 +71,27 @@ class Pharaoh
 				:dynastic_period,
 				:phoenix
 
-	attr_accessor :health
+	attr_accessor :age, :healthy
 
 	def initialize(name, reputation, dynastic_period, phoenix)
 		@name = name
 		@reputation = reputation
 		@dynastic_period = dynastic_period
 		@phoenix = phoenix
-		@health = true
-		@alive = true
+		@healthy = true
+		@dead = false
+		@age = 0
 	end
 
 	def healthy?
-		@health
+		@healthy
 	end
 
-	def age(number)
-		if number >= 18
-			@health = false
+	def ages
+		@age += 1
+		if @age >= 18
+			@healthy = false
 		end
-		@health
 	end
 
 	def takes_action(emotion)
@@ -98,11 +99,12 @@ def takes_action(emotion)
 	end
 
 	def alive?
-		@alive
+		!@dead
 	end
 
 	def dies
+		#DOES this make sense here? NO = it should be in the Phoneix class
 		5.times { @phoenix.feels_emotion(:sorrow) }
-		@alive = false
+		@dead = true
 	end
 end
diff --git a/mythical-creatures/spec/phoenix_spec.rb b/mythical-creatures/spec/phoenix_spec.rb
index 2739a6fa..3aac33c2 100644
--- a/mythical-creatures/spec/phoenix_spec.rb
+++ b/mythical-creatures/spec/phoenix_spec.rb
@@ -17,7 +17,8 @@
 			expect(phoenix.mood).to eq("stoic")
 		end
 
-		it "changes color & mood when feeling an emotion" do
+		#this test might NOT be needed?? Just skip to next one
+		it "changes color & mood when feeling any single emotion" do
 			phoenix = Phoenix.new("Bennu")
 
 			phoenix.feels_emotion(:cognizance)
@@ -68,7 +69,7 @@
 			expect(phoenix.mood).to eq("incandescent")
 		end
 
-		it "only releases a tear after feeling the same emotion 3 times" do
+		it "releases a tear only after feeling the same emotion on the 3rd time" do
 			phoenix = Phoenix.new("Bennu")
 			
 			2.times { phoenix.feels_emotion(:confusion) }
@@ -97,59 +98,40 @@
 	describe "Pharaohs can Exist" do
 		it "pharaohs have names, reputations, a dynastic period, and the phoenix" do
 			phoenix = Phoenix.new("Bennu")
-			
-			narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE", phoenix)
-			khufu = Pharaoh.new("Khufu", "The Builder", "2600 BCE", phoenix)
-			tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE", phoenix)
+			narmer = Pharaoh.new("Narmer", "The Unifier", "3100 BCE", phoenix)
 
 			expect(narmer.name).to eq("Narmer")
-			expect(narmer.reputation).to eq("The Unifer")
+			expect(narmer.reputation).to eq("The Unifier")
 			expect(narmer.dynastic_period).to eq("3100 BCE")
-
-			expect(khufu.name).to eq("Khufu")
-			expect(khufu.reputation).to eq("The Builder")
-			expect(khufu.dynastic_period).to eq("2600 BCE")
-
-			expect(tutankhamun.name).to eq("Tutankhamun")
-			expect(tutankhamun.reputation).to eq("The Child")
-			expect(tutankhamun.dynastic_period).to eq("1500 BCE")
 		end
 
 		it "pharaohs can check if they are healthy" do
 			phoenix = Phoenix.new("Bennu")
+			narmer = Pharaoh.new("Narmer", "The Unifier", "3100 BCE", phoenix)
 			
-			narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE", phoenix)
-			khufu = Pharaoh.new("Khufu", "The Builder", "2600 BCE", phoenix)
-			tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE", phoenix)
-
 			expect(narmer.healthy?).to eq(true)
-			expect(khufu.healthy?).to eq(true)
-			expect(tutankhamun.healthy?).to eq(true)
 		end
 	end
 
 	describe "The Phoenix throughout Ancient Egypt" do
 		it "the phoenix chooses to follow the pharaoh" do
 			phoenix = Phoenix.new("Bennu")
-			narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE", phoenix)
+			narmer = Pharaoh.new("Narmer", "The Unifier", "3100 BCE", phoenix)
 			
 			phoenix.follows_pharaoh(narmer)
 
 			expect(phoenix.pharaoh).to eq(narmer)
 		end
 
-		it "the pharaoh becomes unhealth at the age of 18" do
+		it "the pharaoh is unhealthy at the age of 18 or older" do
 			phoenix = Phoenix.new("Bennu")
-			narmer = Pharaoh.new("Narmer", "The Unifer", "3100 BCE", phoenix)
+			narmer = Pharaoh.new("Narmer", "The Unifier", "3100 BCE", phoenix)
 			phoenix.follows_pharaoh(narmer)
 
-			narmer.age(17)
+			narmer.age = 17
 			expect(narmer.healthy?).to eq(true)
 			
-			narmer.age(18)
-			expect(narmer.healthy?).to eq(false)
-
-			narmer.age(19)
+			narmer.ages
 			expect(narmer.healthy?).to eq(false)
 		end
 
@@ -162,6 +144,7 @@
 			expect(phoenix.emotional_awareness[:perseverance]).to eq(1)
 		end
 
+		# This test is NOT necessary!
 		it "the phoenix releases a tear after the pharaoh takes the same 3 actions" do
 			phoenix = Phoenix.new("Bennu")
 			khufu = Pharaoh.new("Khufu", "The Builder", "3150 BCE", phoenix)
@@ -175,10 +158,8 @@
 			phoenix = Phoenix.new("Bennu")
 			tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE", phoenix)
 			phoenix.follows_pharaoh(tutankhamun)
-
-			expect(tutankhamun.healthy?).to eq(true)
 			
-			tutankhamun.age(18)
+			18.times { tutankhamun.ages }
 			expect(tutankhamun.healthy?).to eq(false)
 
 			3.times { tutankhamun.takes_action(:compassion) }
@@ -192,8 +173,9 @@
 			tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE", phoenix)
 			phoenix.follows_pharaoh(tutankhamun)
 
-			tutankhamun.age(19)
+			tutankhamun.age = 19
 			expect(tutankhamun.alive?).to eq(true)
+			# This should be it's own method, below a new method
 
 			4.times { tutankhamun.takes_action(:trepidation) }
 			expect(phoenix.emotional_awareness[:trepidation]).to eq(4)

From a1378e8601b594bb7ec7e8078baf022b9ae38e50 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Tue, 27 Dec 2022 17:44:12 -0700
Subject: [PATCH 38/45] Add enumerables count, reject, sort_by

---
 .../exercises_1/spec/count_pattern_spec.rb    |  56 +++++++---
 enumerables/exercises_1/spec/count_spec.rb    |  42 +++++---
 .../exercises_1/spec/reject_pattern_spec.rb   | 102 ++++++++++++------
 enumerables/exercises_1/spec/reject_spec.rb   |  78 +++++++++-----
 .../exercises_1/spec/sort_by_pattern_spec.rb  |  69 ++++++++++--
 enumerables/exercises_1/spec/sort_by_spec.rb  |  30 ++++--
 6 files changed, 270 insertions(+), 107 deletions(-)

diff --git a/enumerables/exercises_1/spec/count_pattern_spec.rb b/enumerables/exercises_1/spec/count_pattern_spec.rb
index 9bfb006b..f387b9f1 100644
--- a/enumerables/exercises_1/spec/count_pattern_spec.rb
+++ b/enumerables/exercises_1/spec/count_pattern_spec.rb
@@ -9,49 +9,77 @@
     expect(tally).to eq(3)
   end
 
-  xit 'counts numbers greater than 17' do
+  it 'counts numbers greater than 17' do
     numbers = [9, 18, 12, 17, 1, 3, 99]
     tally = 0
     numbers.each do |number|
-      # Your code goes here
+      tally += 1 if number > 17
     end
     expect(tally).to eq(2)
   end
 
-  xit 'words that are uppercase' do
+  it 'words that are uppercase' do
     words = ["trousers", "SOCKS", "sweater", "Cap", "SHOE", "TIE"]
     tally = 0
-    # Your code goes here
+    cap_letters = ["A".."Z"]
+    
+    words.each do |word|
+      tally += 1 if word.upcase == word
+    end
+
     expect(tally).to eq(3)
   end
 
-  xit 'words ending in ing' do
+  it 'words ending in ing' do
     words = ["thought", "brake", "shin", "juice", "trash"]
-    # Your code goes here
+    tally = 0
+
+    words.each do |word|
+      tally +=1 if word.include?("ing")
+    end
+
     expect(tally).to eq(0)
   end
 
-  xit 'even numbers' do
+  it 'even numbers' do
     numbers = [9, 2, 1, 3, 18, 39, 71, 4, 6]
-    # Your code goes here
+    tally = 0 
+    numbers.each do |num|
+      tally += 1 if num.even?
+    end
     expect(tally).to eq(4)
   end
 
-  xit 'multiples of 5' do
+  it 'multiples of 5' do
     numbers = [2, 5, 19, 25, 35, 67]
-    # Your code goes here
+    tally = 0 
+
+    numbers.each do |num|
+      tally += 1 if num % 5 == 0
+    end
+
     expect(tally).to eq(3)
   end
 
-  xit 'round prices' do
+  it 'round prices' do
     prices = [1.0, 3.9, 5.99, 18.5, 20.0]
-    # Your code goes here
+    tally = 0 
+
+    prices.each do |price|
+      tally += 1 if price.round == price
+    end
+
     expect(tally).to eq(2)
   end
 
-  xit 'four letter words' do
+  it 'four letter words' do
     words = ["bake", "bark", "corn", "apple", "wart", "bird", "umbrella", "fart"]
-    # Your code goes here
+    tally = 0 
+
+    words.each do |word|
+      tally += 1 if word.length == 4
+    end
+
     expect(tally).to eq(6)
   end
 
diff --git a/enumerables/exercises_1/spec/count_spec.rb b/enumerables/exercises_1/spec/count_spec.rb
index be22cf8c..d3f3b64b 100644
--- a/enumerables/exercises_1/spec/count_spec.rb
+++ b/enumerables/exercises_1/spec/count_spec.rb
@@ -8,47 +8,61 @@
     expect(tally).to eq(3)
   end
 
-  xit 'numbers greater than 17' do
+  it 'numbers greater than 17' do
     numbers = [9, 18, 12, 17, 1, 3, 99]
     tally = numbers.count do |number|
-      # Your code goes here
+      number > 17
     end
     expect(tally).to eq(2)
   end
 
-  xit 'words that are uppercase' do
+  it 'words that are uppercase' do
     words = ["trousers", "SOCKS", "sweater", "Cap", "SHOE", "TIE"]
-    # Your code goes here
+    
+    tally = words.count do |word|
+      word.upcase == word
+    end
+
     expect(tally).to eq(3)
   end
 
-  xit 'words ending in ing' do
+  it 'words ending in ing' do
     words = ["thought", "brake", "shin", "juice", "trash"]
-    # Your code goes here
+    tally = words.count do |word|
+      word.include?("ing")
+    end
     expect(tally).to eq(0)
   end
 
-  xit 'even numbers' do
+  it 'even numbers' do
     numbers = [9, 2, 1, 3, 18, 39, 71, 4, 6]
-    # Your code goes here
+    tally = numbers.count do |num|
+      num.even?
+    end
     expect(tally).to eq(4)
   end
 
-  xit 'multiples of 5' do
+  it 'multiples of 5' do
     numbers = [2, 5, 19, 25, 35, 67]
-    # Your code goes here
+    tally = numbers.count do |num|
+      num % 5 == 0
+    end
     expect(tally).to eq(3)
   end
 
-  xit 'round prices' do
+  it 'round prices' do
     prices = [1.0, 3.9, 5.99, 18.5, 20.0]
-    # Your code goes here
+    tally = prices.count do |price|
+      price.round == price
+    end
     expect(tally).to eq(2)
   end
 
-  xit 'four letter words' do
+  it 'four letter words' do
     words = ["bake", "bark", "corn", "apple", "wart", "bird", "umbrella", "fart"]
-    # Your code goes here
+    tally = words.count do |word|
+      word.length == 4
+    end
     expect(tally).to eq(6)
   end
 end
diff --git a/enumerables/exercises_1/spec/reject_pattern_spec.rb b/enumerables/exercises_1/spec/reject_pattern_spec.rb
index dd5c2717..290c276f 100644
--- a/enumerables/exercises_1/spec/reject_pattern_spec.rb
+++ b/enumerables/exercises_1/spec/reject_pattern_spec.rb
@@ -3,92 +3,130 @@
   it 'removes zeroes' do
     numbers = [2, 93, 7, 0, 0, 1, 0, 31, 0, 368]
     filtered = []
+
     numbers.each do |number|
       filtered << number unless number.zero?
     end
+
     expect(filtered).to eq([2, 93, 7, 1, 31, 368])
   end
 
-  xit 'removes vowels' do
+  it 'removes vowels' do
     letters = ["a", "l", "l", " ", "y", "o", "u", "r", " ", "b", "a", "s", "e", " ", "a", "r", "e", " ", "b", "e", "l", "o", "n", "g", " ", "t", "o", " ", "u", "s"]
     remaining = []
+
     letters.each do |letter|
-      # Your code goes here
+      remaining << letter unless ["a", "e", "o", "u", "i", "y"].include?(letter)
     end
+
     expect(remaining).to eq(["l", "l", " ", "r", " ", "b", "s", " ", "r", " ", "b", "l", "n", "g", " ", "t", " ", "s"])
   end
 
-  xit 'removes numbers divisible by 3' do
+  it 'removes numbers divisible by 3' do
     numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
     remaining = []
-    # Your code goes here
+    numbers.each do |num|
+      remaining << num unless num % 3 == 0
+    end
     expect(remaining).to eq([1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20])
   end
 
-  xit 'removes words longer than 3 letters' do
-    skip
+  it 'removes words longer than 3 letters' do
     words = ["pill", "bad", "finger", "cat", "blue", "dog", "table", "red"]
-    # Your code goes here
-    expected(selected).to eq(["bad", "cat", "dog", "red"])
+    selected = []
+    words.each do |word|
+      selected << word unless word.length > 3
+    end
+    expect(selected).to eq(["bad", "cat", "dog", "red"])
   end
 
-  xit 'removes words ending in e' do
+  it 'removes words ending in e' do
     words = ["are", "you", "strike", "thinking", "belt", "piece", "warble", "sing", "pipe"]
-    # Your code goes here
-    expected(selected).to eq(["you", "thinking", "belt", "sing"])
+    selected = []
+    words.each do |word|
+      selected << word unless word.end_with?("e")
+    end
+    expect(selected).to eq(["you", "thinking", "belt", "sing"])
   end
 
-  xit 'removes words ending in ing' do
+  it 'removes words ending in ing' do
     words = ["bring", "finger", "drought", "singing", "bingo", "purposeful"]
-    # Your code goes here
+    selected = []
+    words.each do |word|
+      selected << word unless word.end_with?("ing")
+    end
     expect(selected).to eq(["finger", "drought", "bingo", "purposeful"])
   end
 
-  xit 'removes words containing e' do
+  it 'removes words containing e' do
     words = ["four", "red", "five", "blue", "pizza", "purple"]
-    # Your code goes here
+    selected = []
+    words.each do |word|
+      selected << word unless word.include?("e")
+    end
     expect(selected).to eq(["four", "pizza"])
   end
 
-  xit 'removes dinosaurs' do
+  it 'removes dinosaurs' do
     animals = ["tyrannosaurus", "narwhal", "eel", "achillesaurus", "qingxiusaurus"]
-    # Your code goes here
-    expect(notasaurus).to eq(["narwhal", "eel"])
+    not_a_saurus = []
+    animals.each do |animal|
+      not_a_saurus << animal unless animal.include?("saurus")
+    end
+    expect(not_a_saurus).to eq(["narwhal", "eel"])
   end
 
-  xit 'removes numbers' do
+  it 'removes numbers' do
     elements = ["cat", "dog", 23, 81.1, 56, "aimless", 43]
-    # Your code goes here
-    expected(not_numbers).to eq(["cat", "dog", "aimless"])
+    not_numbers = []
+    elements.each do |element|
+      not_numbers << element unless element.is_a?(Float) || element.is_a?(Integer)
+    end
+    expect(not_numbers).to eq(["cat", "dog", "aimless"])
   end
 
-  xit 'removes floats' do
+  it 'removes floats' do
     elements = ["cat", "dog", 32.333, 23, 56, "aimless", 43.2]
-    # Your code goes here
+    not_numbers = []
+    elements.each do |element|
+      not_numbers << element unless element.is_a?(Float)
+    end
     expect(not_numbers).to eq(["cat", "dog", 23, 56, "aimless"])
   end
 
-  xit 'removes animals starting with vowels' do
+  it 'removes animals starting with vowels' do
     animals = ["aardvark", "bonobo", "cat", "dog", "elephant"]
-    # Your code goes here
+    remaining = []
+    animals.each do |animal|
+      remaining << animal unless "aeoui".include?(animal.chr)
+    end
     expect(remaining).to eq(["bonobo", "cat", "dog"])
   end
 
-  xit 'removes upcased words' do
+  it 'removes upcased words' do
     words = ["CAT", "dog", "AIMLESS", "Trevor", "butter"]
-    # Your code goes here
+    remaining = []
+    words.each do |word|
+      remaining << word unless word.upcase == word
+    end
     expect(remaining).to eq(["dog", "Trevor", "butter"])
   end
 
-  xit 'removes arrays' do
+  it 'removes arrays' do
     elements = ["CAT", ["dog"], 23, [56, 3, 8], "AIMLESS", 43, "butter"]
-    # Your code goes here
-    expected(remaining).to eq(["CAT", 23, "AIMLESS", 43, "butter"])
+    remaining = []
+    elements.each do |element|
+      remaining << element unless element.is_a?(Array)
+    end
+    expect(remaining).to eq(["CAT", 23, "AIMLESS", 43, "butter"])
   end
 
-  xit 'removes hashes' do
+  it 'removes hashes' do
     elements = ["cat", {:dog=>"fido"}, 23, {:stuff=>"things"}, "aimless", 43]
-    # Your code goes here
+    remaining = []
+    elements.each do |element|
+      remaining << element unless element.is_a?(Hash)
+    end
     expect(remaining).to eq(["cat", 23, "aimless", 43])
   end
 end
diff --git a/enumerables/exercises_1/spec/reject_spec.rb b/enumerables/exercises_1/spec/reject_spec.rb
index 59101f4a..015cb974 100644
--- a/enumerables/exercises_1/spec/reject_spec.rb
+++ b/enumerables/exercises_1/spec/reject_spec.rb
@@ -8,83 +8,107 @@
     expect(filtered).to eq([2, 93, 7, 1, 31, 368])
   end
 
-  xit 'removes vowels' do
+  it 'removes vowels' do
     letters = ["a", "l", "l", " ", "y", "o", "u", "r", " ", "b", "a", "s", "e", " ", "a", "r", "e", " ", "b", "e", "l", "o", "n", "g", " ", "t", "o", " ", "u", "s"]
     remaining = letters.reject do |letter|
-      # Your code goes here
+      "aeouiy".include?(letter)
     end
     expect(remaining).to eq(["l", "l", " ", "r", " ", "b", "s", " ", "r", " ", "b", "l", "n", "g", " ", "t", " ", "s"])
   end
 
-  xit 'remove numbers divisible by 3' do
+  it 'remove numbers divisible by 3' do
     numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
-    # Your code goes here
+    remaining = numbers.reject do |num|
+      num % 3 == 0
+    end
     expect(remaining).to eq([1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20])
   end
 
-  xit 'remove words longer tghan three letters' do
+  it 'remove words longer than three letters' do
     words = ["pill", "bad", "finger", "cat", "blue", "dog", "table", "red"]
-    # Your code goes here
+    selected = words.reject do |word|
+      word.length > 3
+    end
     expect(selected).to eq(["bad", "cat", "dog", "red"])
   end
 
-  xit 'remove words ending in e' do
+  it 'remove words ending in e' do
     words = ["are", "you", "strike", "thinking", "belt", "piece", "warble", "sing", "pipe"]
-    # Your code goes here
+    selected = words.reject do |word|
+      word.end_with?("e")
+    end
     expect(selected).to eq(["you", "thinking", "belt", "sing"])
   end
 
-  xit 'remove words ending in ing' do
+  it 'remove words ending in ing' do
     words = ["bring", "finger", "drought", "singing", "bingo", "purposeful"]
-    # Your code goes here
+    selected = words.reject do |word|
+      word.end_with?("ing")
+    end
     expect(selected).to eq(["finger", "drought", "bingo", "purposeful"])
   end
 
-  xit 'remove words containing e' do
+  it 'remove words containing e' do
     words = ["four", "red", "five", "blue", "pizza", "purple"]
-    # Your code goes here
+    selected = words.reject do |word|
+      word.include?("e")
+    end
     expect(selected).to eq(["four", "pizza"])
   end
 
-  xit 'remove dinosaurs' do
+  it 'remove dinosaurs' do
     animals = ["tyrannosaurus", "narwhal", "eel", "achillesaurus", "qingxiusaurus"]
-    # Your code goes here
-    expect(notasaurus).to eq(["narwhal", "eel"])
+    not_a_saurus = animals.reject do |animal|
+      animal.include?("saurus")
+    end
+    expect(not_a_saurus).to eq(["narwhal", "eel"])
   end
 
-  xit 'remove numbers' do
+  it 'remove numbers' do
     elements = ["cat", "dog", 23, 81.1, 56, "aimless", 43]
-    # Your code goes here
+    not_numbers = elements.reject do |element|
+      element.is_a?(Float) || element.is_a?(Integer)
+    end
     expect(not_numbers).to eq(["cat", "dog", "aimless"])
   end
 
-  xit 'remove floats' do
+  it 'remove floats' do
     elements = ["cat", "dog", 32.333, 23, 56, "aimless", 43.2]
-    # Your code goes here
+    not_numbers = elements.reject do |element|
+      element.is_a?(Float)
+    end
     expect(not_numbers).to eq(["cat", "dog", 23, 56, "aimless"])
   end
 
-  xit 'remove animals starting with a vowel' do
+  it 'remove animals starting with a vowel' do
     animals = ["aardvark", "bonobo", "cat", "dog", "elephant"]
-    # Your code goes here
+    remaining = animals.reject do |animal|
+      "aeoui".include?(animal.chr)
+    end
     expect(remaining).to eq(["bonobo", "cat", "dog"])
   end
 
-  xit 'remove upcased words' do
+  it 'remove upcased words' do
     words = ["CAT", "dog", "AIMLESS", "Trevor", "butter"]
-    # Your code goes here
+    remaining = words.reject do |word|
+      word.upcase == word
+    end
     expect(remaining).to eq(["dog", "Trevor", "butter"])
   end
 
-  xit 'remove arrays' do
+  it 'remove arrays' do
     elements = ["CAT", ["dog"], 23, [56, 3, 8], "AIMLESS", 43, "butter"]
-    # Your code goes here
+    remaining = elements.reject do |element|
+      element.is_a?(Array)
+    end
     expect(remaining).to eq(["CAT", 23, "AIMLESS", 43, "butter"])
   end
 
-  xit 'remove hashes' do
+  it 'remove hashes' do
     elements = ["cat", {:dog=>"fido"}, 23, {:stuff=>"things"}, "aimless", 43]
-    # Your code goes here
+      remaining = elements.reject do |element|
+        element.is_a?(Hash)
+      end
     expect(remaining).to eq(["cat", 23, "aimless", 43])
   end
 end
diff --git a/enumerables/exercises_1/spec/sort_by_pattern_spec.rb b/enumerables/exercises_1/spec/sort_by_pattern_spec.rb
index 0970204a..c625bb5a 100644
--- a/enumerables/exercises_1/spec/sort_by_pattern_spec.rb
+++ b/enumerables/exercises_1/spec/sort_by_pattern_spec.rb
@@ -3,58 +3,107 @@
   it 'sorts alphabetically' do
     words = ["broccoli", "Carrots", "FISH", "Bacon", "candy"]
     transformed = []
+    
     words.each do |word|
       transformed << [word.downcase, word]
     end
+
     transformed = transformed.sort
     sorted = []
+
     transformed.each do |sort_key, word|
       sorted << word
     end
+
     expect(sorted).to eq(["Bacon", "broccoli", "candy", "Carrots", "FISH"])
   end
 
-  xit 'alphabetically by last letter' do
+  it 'alphabetically by last letter' do
     things = ["pill", "box", "glass", "water", "sponge"]
     transformed = []
+
     things.each do |thing|
-      # Your code goes here
+      transformed << [thing.reverse, thing]
     end
+
     transformed = transformed.sort
     sorted = []
+
     transformed.each do |sort_key, thing|
       sorted << thing
     end
     expect(sorted).to eq(["sponge", "pill", "water", "glass", "box"])
   end
 
-  xit 'sort by distance' do
+  it 'sort by distance' do
     distances = ["1cm", "9cm", "30cm", "4cm", "2cm"]
     transformed = []
-    # Your code goes here
+
+    distances.each do |distance|
+      transformed << [distance.to_i, distance]
+    end
+
     transformed = transformed.sort
     sorted = []
+
     transformed.each do |sort_key, distance|
       sorted << distance
     end
+
     expect(sorted).to eq(["1cm", "2cm", "4cm", "9cm", "30cm"])
   end
 
-  xit 'by length' do
+  it 'by length' do
     words = ["heteromorph", "ancyloceratina", "bioengineering", "mathematical", "bug"]
-    # Your code goes here
+    transformed = []
+
+    words.each do |word|
+      transformed << [word.length, word]
+    end
+
+    transformed = transformed.sort
+    sorted = []
+
+    transformed.each do |sort_key, word|
+      sorted << word
+    end
+
     expect(sorted).to eq(["bug", "heteromorph", "mathematical", "ancyloceratina", "bioengineering"])
   end
 
-  xit 'by proximity to ten' do
+  it 'by proximity to ten' do
     prices = [3.02, 9.91, 17.9, 10.01, 11.0]
-    # Your code goes here
+    transformed = []
+
+    prices.each do |price|
+      transformed << [(price - 10).abs, price]
+    end
+
+    transformed = transformed.sort
+    sorted = []
+
+    transformed.each do |sort_key, price|
+      sorted << price
+    end
+
     expect(sorted).to eq([10.01, 9.91, 11.0, 3.02, 17.9])
   end
 
-  xit 'by number of cents' do
+  it 'by number of cents' do
     prices = [3.02, 9.91, 7.9, 10.01, 11.0]
-    # Your code goes here
+    transformed = []
+
+    prices.each do |price|
+      transformed << [(price.to_i - price).abs, price]
+    end
+
+    transformed = transformed.sort
+    sorted = []
+
+    transformed.each do |sort_key, price|
+      sorted << price
+    end
+
     expect(sorted).to eq([11.0, 10.01, 3.02, 7.9, 9.91])
   end
 end
diff --git a/enumerables/exercises_1/spec/sort_by_spec.rb b/enumerables/exercises_1/spec/sort_by_spec.rb
index fa317429..472b827b 100644
--- a/enumerables/exercises_1/spec/sort_by_spec.rb
+++ b/enumerables/exercises_1/spec/sort_by_spec.rb
@@ -8,35 +8,45 @@
     expect(sorted).to eq(["Bacon", "broccoli", "candy", "Carrots", "FISH"])
   end
 
-  xit 'alphabetically by last letter' do
+  it 'alphabetically by last letter' do
     things = ["pill", "box", "glass", "water", "sponge"]
     sorted = things.sort_by do |thing|
-      # Your code goes here
+     thing[-1]
     end
     expect(sorted).to eq(["sponge", "pill", "water", "glass", "box"])
   end
 
-  xit 'distance' do
+  it 'distance' do
     distances = ["1cm", "9cm", "30cm", "4cm", "2cm"]
-    # Your code goes here
+    sorted = distances.sort_by do |distance|
+      distance.to_i
+    end
     expect(sorted).to eq(["1cm", "2cm", "4cm", "9cm", "30cm"])
   end
 
-  xit 'length' do
+  it 'length' do
     words = ["heteromorph", "ancyloceratina", "bioengineering", "mathematical", "bug"]
-    # Your code goes here
+    sorted = words.sort_by do |word|
+      word.length
+    end
     expect(sorted).to eq(["bug", "heteromorph", "mathematical", "ancyloceratina", "bioengineering"])
   end
 
-  xit 'proximity to ten' do
+  it 'proximity to ten' do
     prices = [3.02, 9.91, 17.9, 10.01, 11.0]
-    # Your code goes here
+    
+    sorted = prices.sort_by do |price|
+      (price - 10).abs
+    end
+
     expect(sorted).to eq([10.01, 9.91, 11.0, 3.02, 17.9])
   end
 
-  xit 'number of cents' do
+  it 'number of cents' do
     prices = [3.02, 9.91, 7.9, 10.01, 11.0]
-    # Your code goes here
+    sorted = prices.sort_by do |price|
+      (price.to_i - price).abs
+    end
     expect(sorted).to eq([11.0, 10.01, 3.02, 7.9, 9.91])
   end
 end

From e1428492c0988a45fa9ed7959fbb0bd5141ac675 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Tue, 27 Dec 2022 19:38:35 -0700
Subject: [PATCH 39/45] Add more enumerables

---
 .../exercises_1/spec/reduce_pattern_spec.rb   | 20 +++++-----
 enumerables/exercises_1/spec/reduce_spec.rb   | 38 +++++++++++++------
 2 files changed, 37 insertions(+), 21 deletions(-)

diff --git a/enumerables/exercises_1/spec/reduce_pattern_spec.rb b/enumerables/exercises_1/spec/reduce_pattern_spec.rb
index b0d6c573..2a44b415 100644
--- a/enumerables/exercises_1/spec/reduce_pattern_spec.rb
+++ b/enumerables/exercises_1/spec/reduce_pattern_spec.rb
@@ -2,38 +2,40 @@
   it 'sums a list of numbers' do
     numbers = [32, 1, 21, 5, 81, 333]
     sum = 0
+    
     numbers.each do |number|
       sum = sum + number
     end
+
     expect(sum).to eq(473)
   end
 
-  xit 'subtracts a list of numbers' do
+  it 'subtracts a list of numbers' do
     numbers = [28, 12, 38, 1, 91]
     difference = 0
     numbers.each do |number|
-      # Your code goes here
+      difference = difference - number
     end
     expect(difference).to eq(-170)
   end
 
-  xit 'multiplies a list of numbers' do
+  it 'multiplies a list of numbers' do
     numbers = [2, 3, 5, 7]
     product = 1
-    # Your code goes here
+    numbers.each do |number|
+      product = product * number
+    end
     expect(product).to eq(210)
   end
 
-  xit 'capitalizes key words in phrase' do
+  it 'capitalizes key words in phrase' do
     keywords = ["fish", "blue"]
     phrase = 'one fish two fish red fish blue fish'
 
     keywords.each do |keyword|
-      phrase = phrase.gsub(keyword, keyword.upcase) if keywords.include?(keyword)
+      phrase = phrase.gsub(keyword, keyword.upcase) 
     end
-    # phrase.split.each do |keyword|
-    #   keyword.upcase if keywords.include?(keyword)
-    
+
     expect(phrase).to eq('one FISH two FISH red FISH BLUE FISH')
   end
 
diff --git a/enumerables/exercises_1/spec/reduce_spec.rb b/enumerables/exercises_1/spec/reduce_spec.rb
index 9ed0ada9..4c985fbd 100644
--- a/enumerables/exercises_1/spec/reduce_spec.rb
+++ b/enumerables/exercises_1/spec/reduce_spec.rb
@@ -2,52 +2,66 @@
 
   it 'sums a list of numbers' do
     numbers = [32, 1, 21, 5, 81, 333]
+    
     result = numbers.reduce(0) do |sum, number|
       sum + number
     end
+    
     expect(result).to eq(473)
   end
 
-  xit 'subtracts a list of numbers' do
+  it 'subtracts a list of numbers' do
     numbers = [28, 12, 38, 1, 91]
     result = numbers.reduce(0) do |difference, number|
-      # Your code goes here
+      difference - number
     end
     expect(result).to eq(-170)
   end
 
-  xit 'multiplies a list of numbers' do
+  it 'multiplies a list of numbers' do
     numbers = [2, 3, 5, 7]
     # initial value is 1
-    # Your code goes here
+
+    result = numbers.reduce(1) do |one, number|
+      one * number
+    end
+
     expect(result).to eq(210)
   end
 
-  xit 'capitalize key words in phrase' do
+  it 'capitalize key words in phrase' do
     keywords = ["fish", "blue"]
     # initial value is 'one fish two fish red fish blue fish'
-    # Your code goes here
+    result = keywords.reduce("one fish two fish red fish blue fish") do |phrase, keyword|
+      phrase.gsub(keyword, keyword.upcase) 
+    end 
     expect(result).to eq('one FISH two FISH red FISH BLUE FISH')
   end
 
-  xit 'divides 560 by a bunch of numbers' do
+  it 'divides 560 by a bunch of numbers' do
     numbers = [2, 2, 2, 5, 7]
     # initial value is 560
-    # Your code goes here
+    result = numbers.reduce(560) do |big_numero, number|
+      big_numero / number
+    end
     expect(result).to eq(2)
   end
 
-  xit 'subtract smallest values from 100' do
+  it 'subtract smallest values from 100' do
     elements = [[8, 5, 3], [1, 9, 11], [4, 7, 2], [19, 34, 6]]
     # initial value is 100
-    # Your code goes here
+    result = elements.reduce(100) do |start_num, smallest_num|
+      start_num - smallest_num.min
+    end
     expect(result).to eq(88)
   end
 
-  xit 'adds all second values together' do
+  it 'adds all second values together' do
     elements = [["a", 1], ["b", 9], ["c", 21]]
     # initial value is 0
-    # Your code goes here
+    result = elements.reduce(0) do |zero, second_element|
+      zero + second_element[1]
+    end
     expect(result).to eq(31)
   end
 end

From 5f7eb325eb8ba233edf103e61630c0d6140473bd Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Wed, 28 Dec 2022 14:32:11 -0700
Subject: [PATCH 40/45] Fix: Update Phoenix - final version

---
 mythical-creatures/lib/phoenix.rb       |   9 +-
 mythical-creatures/spec/phoenix_spec.rb | 124 +++++++++++-------------
 2 files changed, 62 insertions(+), 71 deletions(-)

diff --git a/mythical-creatures/lib/phoenix.rb b/mythical-creatures/lib/phoenix.rb
index 9b61223a..68d0c485 100644
--- a/mythical-creatures/lib/phoenix.rb
+++ b/mythical-creatures/lib/phoenix.rb
@@ -17,11 +17,9 @@ def initialize(name, color = "golden", mood = "stoic")
 	def bursts_into_flames
 			@color = "golden"
 			@mood = "stoic"
+			@pharaoh = nil
 			@emotional_awareness = {}
 			@releases_tear = false
-			@pharaoh = nil
-			# not have to se to nil
-			# could call follows pharaoh again
 	end
 
 	def feels_emotion(emotion)
@@ -98,13 +96,14 @@ def takes_action(emotion)
 		@phoenix.feels_emotion(emotion)
 	end
 
-	def alive?
-		!@dead
+	def dead?
+		@dead
 	end
 
 	def dies
 		#DOES this make sense here? NO = it should be in the Phoneix class
 		5.times { @phoenix.feels_emotion(:sorrow) }
 		@dead = true
+		@healthy = false
 	end
 end
diff --git a/mythical-creatures/spec/phoenix_spec.rb b/mythical-creatures/spec/phoenix_spec.rb
index 3aac33c2..0e1b5c87 100644
--- a/mythical-creatures/spec/phoenix_spec.rb
+++ b/mythical-creatures/spec/phoenix_spec.rb
@@ -10,66 +10,51 @@
 			expect(phoenix.name).to eq("Bennu")
 		end
 
-		it "is born golden and stoic" do
+		it "is born golden, stoic, and without a pharaoh" do
 			phoenix = Phoenix.new("Bennu")
 
 			expect(phoenix.color).to eq("golden")
 			expect(phoenix.mood).to eq("stoic")
+			expect(phoenix.pharaoh).to eq(nil)
 		end
 
-		#this test might NOT be needed?? Just skip to next one
-		it "changes color & mood when feeling any single emotion" do
+		it "changes color & mood when feeling an emotion 1, 2, 3, and 4 times" do
 			phoenix = Phoenix.new("Bennu")
 
-			phoenix.feels_emotion(:cognizance)
-
+			phoenix.feels_emotion(:cognizance) 
 			expect(phoenix.color).to eq("amber")
 			expect(phoenix.mood).to eq("heated")
+		
+			phoenix.feels_emotion(:cognizance) 
+			expect(phoenix.color).to eq("scarlet")
+			expect(phoenix.mood).to eq("fiery")
+
+			phoenix.feels_emotion(:cognizance)
+			expect(phoenix.color).to eq("crimson")
+			expect(phoenix.mood).to eq("ablaze")
+
+			phoenix.feels_emotion(:cognizance)
+			expect(phoenix.color).to eq("deep violet")
+			expect(phoenix.mood).to eq("incandescent")
 		end
 
 		it "has emotional awareness about how many times it has the same emotion" do
 			phoenix = Phoenix.new("Bennu")
 
-			phoenix.feels_emotion(:curiosity)
-			expect(phoenix.emotional_awareness[:curiosity]).to eq(1)
+			phoenix.feels_emotion(:exuberance)
 
 			phoenix.feels_emotion(:curiosity)
-			expect(phoenix.emotional_awareness[:curiosity]).to eq(2)
-		end 
-
-		it "has emotional awareness about how many times it has had different emotions" do
-			phoenix = Phoenix.new("Bennu")
-		
-			phoenix.feels_emotion(:exuberance)
-			phoenix.feels_emotion(:exuberance)
-			phoenix.feels_emotion(:exuberance)
+			phoenix.feels_emotion(:curiosity)
+			phoenix.feels_emotion(:curiosity)
 
 			phoenix.feels_emotion(:gratitude)
 			phoenix.feels_emotion(:gratitude)
 
-			phoenix.feels_emotion(:autonomy)
-
-			expect(phoenix.emotional_awareness).to eq({:exuberance => 3, :gratitude => 2, :autonomy => 1})
+			expect(phoenix.emotional_awareness).to eq({:exuberance => 1, :curiosity => 3, :gratitude => 2})
 			expect(phoenix.emotional_awareness.include?(:sorrow)).to eq(false)
-		end
-
-		it "changes color & mood when feeling an emotion 2, 3, and 4 times" do
-			phoenix = Phoenix.new("Bennu")
-
-			2.times { phoenix.feels_emotion(:wisdom) }
-			expect(phoenix.color).to eq("scarlet")
-			expect(phoenix.mood).to eq("fiery")
-
-			phoenix.feels_emotion(:wisdom)
-			expect(phoenix.color).to eq("crimson")
-			expect(phoenix.mood).to eq("ablaze")
-
-			phoenix.feels_emotion(:wisdom)
-			expect(phoenix.color).to eq("deep violet")
-			expect(phoenix.mood).to eq("incandescent")
-		end
+		end 
 
-		it "releases a tear only after feeling the same emotion on the 3rd time" do
+		it "releases a tear after feeling the same emotion on the 3rd time ONLY" do
 			phoenix = Phoenix.new("Bennu")
 			
 			2.times { phoenix.feels_emotion(:confusion) }
@@ -89,50 +74,56 @@
 
 			expect(phoenix.color).to eq("golden")
 			expect(phoenix.mood).to eq("stoic")
-			expect(phoenix.emotional_awareness).to eq({})
-			expect(phoenix.releases_tear?).to eq(false)
 			expect(phoenix.pharaoh).to eq(nil)
+			expect(phoenix.emotional_awareness).to eq({})
 		end
 	end
 
-	describe "Pharaohs can Exist" do
-		it "pharaohs have names, reputations, a dynastic period, and the phoenix" do
+	describe "The Phoenix throughout Ancient Egypt" do
+		it "a pharaoh has a name, reputation, dynastic period, and the phoenix" do
 			phoenix = Phoenix.new("Bennu")
 			narmer = Pharaoh.new("Narmer", "The Unifier", "3100 BCE", phoenix)
 
 			expect(narmer.name).to eq("Narmer")
 			expect(narmer.reputation).to eq("The Unifier")
 			expect(narmer.dynastic_period).to eq("3100 BCE")
+			expect(narmer.phoenix).to eq(phoenix)
 		end
 
-		it "pharaohs can check if they are healthy" do
+		it "a pharaoh can check if they are healthy" do
 			phoenix = Phoenix.new("Bennu")
 			narmer = Pharaoh.new("Narmer", "The Unifier", "3100 BCE", phoenix)
 			
 			expect(narmer.healthy?).to eq(true)
 		end
-	end
-
-	describe "The Phoenix throughout Ancient Egypt" do
-		it "the phoenix chooses to follow the pharaoh" do
+	
+		it "a pharaoh can age" do
 			phoenix = Phoenix.new("Bennu")
 			narmer = Pharaoh.new("Narmer", "The Unifier", "3100 BCE", phoenix)
 			
-			phoenix.follows_pharaoh(narmer)
+			24.times { narmer.ages }
 
-			expect(phoenix.pharaoh).to eq(narmer)
+			expect(narmer.age).to eq(24)
 		end
 
-		it "the pharaoh is unhealthy at the age of 18 or older" do
+		it "a pharaoh can die" do
 			phoenix = Phoenix.new("Bennu")
 			narmer = Pharaoh.new("Narmer", "The Unifier", "3100 BCE", phoenix)
-			phoenix.follows_pharaoh(narmer)
 
-			narmer.age = 17
-			expect(narmer.healthy?).to eq(true)
+			narmer.age = 60
+			expect(narmer.dead?).to eq(false)
 			
-			narmer.ages
-			expect(narmer.healthy?).to eq(false)
+			narmer.dies
+			expect(narmer.dead?).to eq(true)
+		end
+
+		it "the phoenix chooses to follow the pharaoh" do
+			phoenix = Phoenix.new("Bennu")
+			khufu = Pharaoh.new("Khufu", "The Builder", "3150 BCE", phoenix)
+
+			phoenix.follows_pharaoh(khufu)
+
+			expect(phoenix.pharaoh).to eq(khufu)
 		end
 
 		it "the phoenix feels an emotion when the pharaoh takes an action" do
@@ -141,17 +132,23 @@
 			phoenix.follows_pharaoh(khufu)
 
 			khufu.takes_action(:perseverance)
+			
 			expect(phoenix.emotional_awareness[:perseverance]).to eq(1)
 		end
 
-		# This test is NOT necessary!
-		it "the phoenix releases a tear after the pharaoh takes the same 3 actions" do
+		it "the pharaoh is unhealthy at the age of 18 or older" do
 			phoenix = Phoenix.new("Bennu")
 			khufu = Pharaoh.new("Khufu", "The Builder", "3150 BCE", phoenix)
 			phoenix.follows_pharaoh(khufu)
 
-			3.times { khufu.takes_action(:perseverance) }
-			expect(phoenix.releases_tear?).to eq(true)
+			khufu.age = 17
+			expect(khufu.healthy?).to eq(true)
+			
+			khufu.ages
+			expect(khufu.healthy?).to eq(false)
+
+			khufu.ages
+			expect(khufu.healthy?).to eq(false)
 		end
 
 		it "the unhealthy pharaoh becomes healthy after the phoenix releases a tear" do
@@ -173,23 +170,18 @@
 			tutankhamun = Pharaoh.new("Tutankhamun", "The Child", "1500 BCE", phoenix)
 			phoenix.follows_pharaoh(tutankhamun)
 
-			tutankhamun.age = 19
-			expect(tutankhamun.alive?).to eq(true)
-			# This should be it's own method, below a new method
-
 			4.times { tutankhamun.takes_action(:trepidation) }
 			expect(phoenix.emotional_awareness[:trepidation]).to eq(4)
 			expect(phoenix.color).to eq("deep violet")
 			expect(phoenix.mood).to eq("incandescent")
 
-			tutankhamun.dies
-			expect(tutankhamun.alive?).to eq(false)
+			tutankhamun.dies 			
+			expect(tutankhamun.dead?).to eq(true)
 
 			expect(phoenix.color).to eq("golden")
 			expect(phoenix.mood).to eq("stoic")
-			expect(phoenix.emotional_awareness).to eq({})
-			expect(phoenix.releases_tear?).to eq(false)
 			expect(phoenix.pharaoh).to eq(nil)
+			expect(phoenix.emotional_awareness).to eq({})
 		end
 	end
 end
\ No newline at end of file

From a738ee12998963670eed187c2f34b24df35c2725 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Wed, 28 Dec 2022 14:54:18 -0700
Subject: [PATCH 41/45] Add enumerables reduce_pattern

---
 .../exercises_1/spec/reduce_pattern_spec.rb   | 20 +++++++++++++------
 enumerables/exercises_1/spec/reduce_spec.rb   |  4 ++--
 2 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/enumerables/exercises_1/spec/reduce_pattern_spec.rb b/enumerables/exercises_1/spec/reduce_pattern_spec.rb
index 2a44b415..e1eaea0a 100644
--- a/enumerables/exercises_1/spec/reduce_pattern_spec.rb
+++ b/enumerables/exercises_1/spec/reduce_pattern_spec.rb
@@ -39,24 +39,32 @@
     expect(phrase).to eq('one FISH two FISH red FISH BLUE FISH')
   end
 
-  xit 'divide 560 by a bunch of numbers' do
+  it 'divide 560 by a bunch of numbers' do
     numbers = [2, 2, 2, 5, 7]
     quotient = 560
-    # Your code goes here
+    
+    numbers.each do |num|
+      quotient = quotient / num
+    end
+
     expect(quotient).to eq(2)
   end
 
-  xit 'subtracts smallest numbers from 100' do
+  it 'subtracts smallest numbers from 100' do
     elements = [[8, 5, 3], [1, 9, 11], [4, 7, 2], [19, 34, 6]]
     difference = 100
-    # Your code goes here
+    elements.each do |element|
+      difference = difference - element.min
+    end
     expect(difference).to eq(88)
   end
 
-  xit 'adds all second values together' do
+  it 'adds all second values together' do
     elements = [["a", 1], ["b", 9], ["c", 21]]
     sum = 0
-    # Your code goes here
+    elements.each do |element|
+      sum = sum + element[1]
+    end
     expect(sum).to eq(31)
   end
 
diff --git a/enumerables/exercises_1/spec/reduce_spec.rb b/enumerables/exercises_1/spec/reduce_spec.rb
index 4c985fbd..bae9f848 100644
--- a/enumerables/exercises_1/spec/reduce_spec.rb
+++ b/enumerables/exercises_1/spec/reduce_spec.rb
@@ -41,8 +41,8 @@
   it 'divides 560 by a bunch of numbers' do
     numbers = [2, 2, 2, 5, 7]
     # initial value is 560
-    result = numbers.reduce(560) do |big_numero, number|
-      big_numero / number
+    result = numbers.reduce(560) do |quotient, number|
+      quotient / number
     end
     expect(result).to eq(2)
   end

From 1e1c29d2dcb746eeedb32d217c3007ec3af4a558 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Wed, 28 Dec 2022 15:25:49 -0700
Subject: [PATCH 42/45] Add enumerables any?

---
 .../exercises_1/spec/any_pattern_spec.rb      | 38 +++++++++++++------
 enumerables/exercises_1/spec/any_spec.rb      | 34 +++++++++++------
 2 files changed, 48 insertions(+), 24 deletions(-)

diff --git a/enumerables/exercises_1/spec/any_pattern_spec.rb b/enumerables/exercises_1/spec/any_pattern_spec.rb
index 3201a8c8..f9327720 100644
--- a/enumerables/exercises_1/spec/any_pattern_spec.rb
+++ b/enumerables/exercises_1/spec/any_pattern_spec.rb
@@ -9,43 +9,57 @@
     expect(has_zero).to eq(true)
   end
 
-  xit 'does not have any zeros' do
+  it 'does not have any zeros' do
     numbers = [3, 1, 3, 2, 4, 9, 8]
     has_zero = false
     numbers.each do |number|
-      # Your code goes here
+      has_zero = true if number.zero?
     end
     expect(has_zero).to eq(false)
   end
 
-  xit 'has at least one alice' do
+  it 'has at least one alice' do
     names = ["Bill", "Bob", "Burton", "Alice", "Brandon"]
     has_alice = false
-    # Your code goes here
+    names.each do |name|
+      has_alice = true if names.include?("Alice")
+    end
     expect(has_alice).to eq(true)
   end
 
-  xit 'no alices' do
+  it 'no alices' do
     names = ["Chuck", "Charlene", "Cory", "Chris", "Carl"]
-    # Your code goes here
+    has_alice = false
+    names.each do |name|
+      has_alice = true if names.include?("Alice")
+    end
     expect(has_alice).to eq(false)
   end
 
-  xit 'has a multi word phrase' do
+  it 'has a multi word phrase' do
     phrases = ["Sure!", "OK.", "I have no idea.", "Really?Whatever."]
-    # Your code goes here
+    has_multi_word_phrase = false
+    phrases.each do |phrase|
+      has_multi_word_phrase = true if phrase.include?(" ")
+    end
     expect(has_multi_word_phrase).to eq(true)
   end
 
-  xit 'has no monkeys' do
+  it 'has no monkeys' do
     animals = ["elephant", "hippo", "jaguar", "python"]
-    # Your code goes here
+    has_monkeys = false
+    animals.each do |animal|
+      has_monkeys = true if animal.include?("monkeys")
+    end
     expect(has_monkeys).to eq(false)
   end
 
-  xit 'has no multiples of five' do
+  it 'has no multiples of five' do
     numbers = [3, 1, 3, 2, 4, 9, 8]
-    # Your code goes here
+    multiples_of_5 = false
+    numbers.each do |num|
+      multiples_of_5 = true if num % 5 == 0
+    end
     expect(multiples_of_5).to eq(false)
   end
 end
diff --git a/enumerables/exercises_1/spec/any_spec.rb b/enumerables/exercises_1/spec/any_spec.rb
index a57f0243..5240bd88 100644
--- a/enumerables/exercises_1/spec/any_spec.rb
+++ b/enumerables/exercises_1/spec/any_spec.rb
@@ -7,41 +7,51 @@
     expect(has_zero).to eq(true)
   end
 
-  xit 'does not have zeroes' do
+  it 'does not have zeroes' do
     numbers = [3, 1, 3, 2, 4, 9, 8]
     has_zero = numbers.any? do |number|
-      # Your code goes here
+      number.zero?
     end
     expect(has_zero).to eq(false)
   end
 
-  xit 'has at least one alice' do
+  it 'has at least one alice' do
     names = ["Bill", "Bob", "Burton", "Alice", "Brandon"]
-    # Your code goes here
+    has_alice = names.any? do |name|
+      name.include?("Alice")
+    end
     expect(has_alice).to eq(true)
   end
 
-  xit 'no alices' do
+  it 'no alices' do
     names = ["Chuck", "Charlene", "Cory", "Chris", "Carl"]
-    # Your code goes here
+    has_alice = names.any? do |name|
+      names.include?("Alice")
+    end
     expect(has_alice).to eq(false)
   end
 
-  xit 'has a multi word phrase' do
+  it 'has a multi word phrase' do
     phrases = ["Sure!", "OK.", "I have no idea.", "Really?Whatever."]
-    # Your code goes here
+    multi_word_phrase = phrases.any? do |phrase|
+      phrase.include?(" ") 
+    end
     expect(multi_word_phrase).to eq(true)
   end
 
-  xit 'no monkeys' do
+  it 'has no monkeys' do
     animals = ["elephant", "hippo", "jaguar", "python"]
-    # Your code goes here
+    has_monkeys = animals.any? do |animal|
+      animal.include?("monkeys")
+    end
     expect(has_monkeys).to eq(false)
   end
 
-  xit 'no multiples of five' do
+  it 'has no multiples of five' do
     numbers = [3, 1, 3, 2, 4, 9, 8]
-    # Your code goes here
+    multiples_of_5 = numbers.any? do |num|
+      num % 5 == 0
+    end
     expect(multiples_of_5).to eq(false)
   end
 end

From f7990f29868d1dfda4e51c9b40ee10c61db7fb11 Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Wed, 28 Dec 2022 16:42:30 -0700
Subject: [PATCH 43/45] Add enumerables all? method

---
 .../exercises_1/spec/all_pattern_spec.rb      | 70 +++++++++++++------
 enumerables/exercises_1/spec/all_spec.rb      | 60 ++++++++++------
 2 files changed, 88 insertions(+), 42 deletions(-)

diff --git a/enumerables/exercises_1/spec/all_pattern_spec.rb b/enumerables/exercises_1/spec/all_pattern_spec.rb
index 8fd2c072..48099ffa 100644
--- a/enumerables/exercises_1/spec/all_pattern_spec.rb
+++ b/enumerables/exercises_1/spec/all_pattern_spec.rb
@@ -2,73 +2,101 @@
   it 'all zeros' do
     numbers = [0, 0, 0, 0, 0, 0, 0]
     all_zeros = true
+
     numbers.each do |number|
       all_zeros = false unless number.zero?
     end
+
     expect(all_zeros).to eq(true)
   end
 
-  xit 'not all zeros' do
+  it 'not all zeros' do
     numbers = [0, 0, 0, 0, 1, 0, 0, 0]
     all_zeros = true
     numbers.each do |number|
-      # Your code goes here
+      all_zeros = false unless number.zero?
     end
     expect(all_zeros).to eq(false)
   end
 
-  xit 'all gone' do
+  it 'all gone' do
     words = ["gone", "gone", "gone", "gone", "gone", "gone", "gone"]
     all_gone = true
-    # Your code goes here
+    words.each do |word|
+      all_gone = false unless word.include?("gone")
+    end
     expect(all_gone).to eq(true)
   end
 
-  xit 'not all gone' do
+  it 'not all gone' do
     words = ["gone", "gone", "gone", "gone", "gone", "there", "gone", "gone"]
-    # Your code goes here
+    all_gone = true
+    words.each do |word|
+      all_gone = false unless word.include?("gone")
+    end
     expect(all_gone).to eq(false)
   end
 
-  xit 'all empty' do
+  it 'all empty' do
     strings = ["", "", "", "", "", "", ""]
-    # Your code goes here
+    all_empty = true
+    strings.each do |string|
+      all_empty = false unless string.empty?
+    end
     expect(all_empty).to eq(true)
   end
 
-  xit 'not all empty' do
+  it 'not all empty' do
     strings = ["", "", "", "full", "", "", ""]
-    # Your code goes here
+    all_empty = true
+    strings.each do |string|
+      all_empty = false unless string.empty?
+    end
     expect(all_empty).to eq(false)
   end
 
-  xit 'not all uppercase' do
-    words = ["DOUGHNUT", "CASH", "MAIN", "bOWl", "SMACK", "SAND"]
-    # Your code goes here
+  it 'not all uppercase' do
+    words = ["DOUGHNUT", "CAsH", "MAIN", "bOWl", "SMACK", "SAND"]
+    all_caps = true
+    words.each do |word|
+      all_caps = false unless word.upcase == true
+    end
     expect(all_caps).to eq(false)
   end
 
-  xit 'all lies' do
+  it 'all lies' do
     lies = [false, false, false, false]
-    # Your code goes here
+    all_lies = true
+    lies.each do |lie|
+      all_lies = false unless lie == false
+    end
     expect(all_lies).to eq(true)
   end
 
-  xit 'all multiples of seven' do
+  it 'all multiples of seven' do
     numbers = [42, 14, 35, 49, 28, 56, 21, 7]
-    # Your code goes here
+    all_multiples_of_7 = true
+    numbers.each do |num|
+      all_multiples_of_7 = false unless num % 7 == 0
+    end
     expect(all_multiples_of_7).to eq(true)
   end
 
-  xit 'not all 3 digits long' do
+  it 'not all 3 digits long' do
     numbers = [981, 831, 509, 332, 892, 8999, 110]
-    # Your code goes here
+    all_3_digits = true
+    numbers.each do |num|
+      all_3_digits = false unless num.size == 3
+    end
     expect(all_3_digits).to eq(false)
   end
 
-  xit 'all four letter words' do
+  it 'all four letter words' do
     words = ["love", "hate", "fire", "bird", "call"]
-    # Your code goes here
+    all_4_letters = true
+    words.each do |word|
+      all_4_letters = false unless word.length == 4
+    end
     expect(all_4_letters).to eq(true)
   end
 end
diff --git a/enumerables/exercises_1/spec/all_spec.rb b/enumerables/exercises_1/spec/all_spec.rb
index 9a47e13c..c595634e 100644
--- a/enumerables/exercises_1/spec/all_spec.rb
+++ b/enumerables/exercises_1/spec/all_spec.rb
@@ -7,65 +7,83 @@
     expect(all_zeros).to eq(true)
   end
 
-  xit 'not all zeroes' do
+  it 'not all zeroes' do
     numbers = [0, 0, 0, 0, 1, 0, 0, 0]
     all_zeros = numbers.all? do |number|
-      # Your code goes here
+     number.zero?
     end
     expect(all_zeros).to eq(false)
   end
 
-  xit 'all gone' do
+  it 'all gone' do
     words = ["gone", "gone", "gone", "gone", "gone", "gone", "gone"]
-    # Your code goes here
+    all_gone = words.all? do |word|
+      word.include?("gone")
+    end
     expect(all_gone).to eq(true)
   end
 
-  xit 'not all gone' do
+  it 'not all gone' do
     words = ["gone", "gone", "gone", "gone", "gone", "there", "gone", "gone"]
-    # Your code goes here
+    all_gone = words.all? do |word|
+      word.include?("gone")
+    end
     expect(all_gone).to eq(false)
   end
 
-  xit 'all empty' do
+  it 'all empty' do
     strings = ["", "", "", "", "", "", ""]
-    # Your code goes here
+    all_empty = strings.all? do |string|
+      string.empty?
+    end
     expect(all_empty).to eq(true)
   end
 
-  xit 'not all empty' do
+  it 'not all empty' do
     strings = ["", "", "", "full", "", "", ""]
-    # Your code goes here
+    all_empty = strings.all? do |string|
+      string.empty?
+    end
     expect(all_empty).to eq(false)
   end
 
-  xit 'not all uppercase' do
-    words = ["DOUGHNUT", "CASH", "MAIN", "bOWl", "SMACK", "SAND"]
-    # Your code goes here
+  it 'not all uppercase' do
+    words = ["DOUGHNUT", "CAsH", "MAIN", "bOWl", "SMACK", "SAND"]
+    all_uppercase = words.all? do |word|
+      word.upcase == true
+    end
     expect(all_uppercase).to eq(false)
   end
 
-  xit 'all lies' do
+  it 'all lies' do
     lies = [false, false, false, false]
-    # Your code goes here
+    all_lies = lies.all? do |lie|
+      lie == false
+    end
     expect(all_lies).to eq(true)
   end
 
-  xit 'multiples of 7' do
+  it 'multiples of 7' do
     numbers = [42, 14, 35, 49, 28, 56, 21, 7]
-    # Your code goes here
+    all_multiples_of_7 = numbers.all? do |num|
+      num % 7 == 0
+    end
     expect(all_multiples_of_7).to eq(true)
   end
 
-  xit 'not all three digits long' do
+  it 'not all three digits long' do
     numbers = [981, 831, 509, 332, 892, 8999, 110]
-    # Your code goes here
+    all_3_digits = numbers.all? do |num|
+      num.size == 3
+    end
     expect(all_3_digits).to eq(false)
   end
 
-  xit 'all four letter words' do
+  it 'all four letter words' do
     words = ["love", "hate", "fire", "bird", "call"]
-    # Your code goes here
+    all_4_letters = words.all? do |word|
+      word.size == 4
+    end
     expect(all_4_letters).to eq(true)
   end
 end

From f0cafaee219716e180ecddcf9675d9e04cbd61db Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Sun, 29 Jan 2023 11:14:38 -0700
Subject: [PATCH 44/45] Add changes

---
 enumerables/exercises_1/spec/reduce_spec.rb   |  2 ++
 .../spec/max_and_min_by_pattern_spec.rb       | 26 +++++++++++--------
 mythical-creatures/spec/phoenix_spec.rb       |  6 +++--
 3 files changed, 21 insertions(+), 13 deletions(-)

diff --git a/enumerables/exercises_1/spec/reduce_spec.rb b/enumerables/exercises_1/spec/reduce_spec.rb
index bae9f848..44f847a4 100644
--- a/enumerables/exercises_1/spec/reduce_spec.rb
+++ b/enumerables/exercises_1/spec/reduce_spec.rb
@@ -29,6 +29,7 @@
     expect(result).to eq(210)
   end
 
+  
   it 'capitalize key words in phrase' do
     keywords = ["fish", "blue"]
     # initial value is 'one fish two fish red fish blue fish'
@@ -38,6 +39,7 @@
     expect(result).to eq('one FISH two FISH red FISH BLUE FISH')
   end
 
+
   it 'divides 560 by a bunch of numbers' do
     numbers = [2, 2, 2, 5, 7]
     # initial value is 560
diff --git a/iteration/exercises/spec/max_and_min_by_pattern_spec.rb b/iteration/exercises/spec/max_and_min_by_pattern_spec.rb
index a147c75c..c0b7d356 100644
--- a/iteration/exercises/spec/max_and_min_by_pattern_spec.rb
+++ b/iteration/exercises/spec/max_and_min_by_pattern_spec.rb
@@ -192,20 +192,23 @@
       miguel: 50
     }
 
-    # oldest = {}
+    oldest = {}
     # # We must have this variable set to something so it can be redefined inside the code block
-    # oldest_age = ages[ages.keys.first]
+    oldest_age = ages[ages.keys.first]
+    # oldest_age = ages.values.first #=> only this still passes the test
 
-    # ages.each do |name, age|
-    #   if age > oldest_age
-    #     oldest_age = age
-    #     oldest = {name: name.to_s, age: age}
-    #     # Here we redefine that previously made empty hash
-    #   end
-    # end
+# ages[ages.keys.first] =true= ages.values.first 
+
+    ages.each do |name, age|
+      if age > oldest_age
+        oldest_age = age
+        oldest = {name: name.to_s, age: age}
+        # Here we redefine that previously made empty hash
+      end
+    end
 
-    # expected = {name: "miguel", age: 50}
-    # expect(oldest).to eq(expected)
+    expected = {name: "miguel", age: 50}
+    expect(oldest).to eq(expected)
 
     ## ATTEMPT TO USE .MAP ##
 
@@ -216,6 +219,7 @@
         {name: name.to_s, age: age}
       end
     end.compact
+    expected = {name: "miguel", age: 50}
     # we use .compact cuz .map returns nil for elements that's do NOT pass the if conditional!
     expect(oldest.last).to eq(expected)
     #if you don't put .last you will get an array returned cuz .map returns an array,
diff --git a/mythical-creatures/spec/phoenix_spec.rb b/mythical-creatures/spec/phoenix_spec.rb
index 0e1b5c87..941f9001 100644
--- a/mythical-creatures/spec/phoenix_spec.rb
+++ b/mythical-creatures/spec/phoenix_spec.rb
@@ -133,7 +133,7 @@
 
 			khufu.takes_action(:perseverance)
 			
-			expect(phoenix.emotional_awareness[:perseverance]).to eq(1)
+			expect(phoenix.emotional_awareness).to eq({:perseverance => 1})
 		end
 
 		it "the pharaoh is unhealthy at the age of 18 or older" do
@@ -171,9 +171,11 @@
 			phoenix.follows_pharaoh(tutankhamun)
 
 			4.times { tutankhamun.takes_action(:trepidation) }
-			expect(phoenix.emotional_awareness[:trepidation]).to eq(4)
+
 			expect(phoenix.color).to eq("deep violet")
 			expect(phoenix.mood).to eq("incandescent")
+			expect(phoenix.pharaoh).to eq(tutankhamun)
+			expect(phoenix.emotional_awareness).to eq({:trepidation => 4})
 
 			tutankhamun.dies 			
 			expect(tutankhamun.dead?).to eq(true)

From 9b5ddd93f1ff4fedd93a31c3ef67eb569358604d Mon Sep 17 00:00:00 2001
From: Melony Franchini <meltravelz@gmail.com>
Date: Fri, 17 Feb 2023 11:40:00 -0700
Subject: [PATCH 45/45] Upate

---
 mythical-creatures/lib/unicorn.rb       |  9 ++++++++-
 mythical-creatures/lib/wizard.rb        |  2 --
 mythical-creatures/spec/unicorn_spec.rb | 16 +++++++++++-----
 3 files changed, 19 insertions(+), 8 deletions(-)

diff --git a/mythical-creatures/lib/unicorn.rb b/mythical-creatures/lib/unicorn.rb
index 480d2676..e9add4d1 100644
--- a/mythical-creatures/lib/unicorn.rb
+++ b/mythical-creatures/lib/unicorn.rb
@@ -1,12 +1,19 @@
 class Unicorn
   attr_reader :name, 
-              :color
+              :color,
+              :pockets
+            
 
   def initialize(name, color = "silver")
     @name = name
     @color = color
+    @pockets = []
   end
 
+  # def pockets
+  #   pockets = []
+  # end
+
 	def silver? 
 		@color == "silver"
 	end
diff --git a/mythical-creatures/lib/wizard.rb b/mythical-creatures/lib/wizard.rb
index c8f32524..14de543e 100644
--- a/mythical-creatures/lib/wizard.rb
+++ b/mythical-creatures/lib/wizard.rb
@@ -42,6 +42,4 @@ def cast
 		# "MAGIC MISSILE!"
 		# this last line is the return so it MUST go at the end
 	end
-
-
 end
\ No newline at end of file
diff --git a/mythical-creatures/spec/unicorn_spec.rb b/mythical-creatures/spec/unicorn_spec.rb
index 5d98343c..0319bf3f 100644
--- a/mythical-creatures/spec/unicorn_spec.rb
+++ b/mythical-creatures/spec/unicorn_spec.rb
@@ -3,26 +3,32 @@
 
 RSpec.describe Unicorn do
   it 'has a name' do
-    unicorn = Unicorn.new('Robert')
-    expect(unicorn.name).to eq('Robert')
+    robert_unicorn = Unicorn.new('Robert')
+
+    expect(robert_unicorn.name).to eq('Robert')
+    expect(robert_unicorn.silver?).to eq(true)
+    expect(robert_unicorn.pockets).to eq([])
   end
 
-  it 'is silver by default' do
+  xit 'is silver by default' do
     unicorn = Unicorn.new('Margaret')
+
     expect(unicorn.color).to eq('silver')
     expect(unicorn.silver?).to eq(true)
     # expect(unicorn.silver?).to be true
   end
 
-  it 'doesnt have to be silver' do
+  xit 'doesnt have to be silver' do
     unicorn = Unicorn.new('Barbara', 'purple')
+
     expect(unicorn.color).to eq('purple')
     expect(unicorn.silver?).to eq(false)
     # expect(unicorn.silver?).to be false
   end
 
-  it 'says sparkly stuff' do
+  xit 'says sparkly stuff' do
     unicorn = Unicorn.new('Johnny')
+
     expect(unicorn.say('Wonderful!')).to eq('**;* Wonderful! **;*')
     expect(unicorn.say('I dont like you very much.')).to eq('**;* I dont like you very much. **;*')
   end