diff --git a/14-arrays/questions/array-basics.md b/14-arrays/questions/1-array-basics.md
similarity index 99%
rename from 14-arrays/questions/array-basics.md
rename to 14-arrays/questions/1-array-basics.md
index 8b7f70d..1f6651a 100644
--- a/14-arrays/questions/array-basics.md
+++ b/14-arrays/questions/1-array-basics.md
@@ -1,4 +1,4 @@
-# Arrays
+# Array Basics Quiz
 
 ## What's an array?
 1. Accelerated charged particle array gun from Star Wars
diff --git a/14-arrays/questions/2-arrays.md b/14-arrays/questions/2-arrays.md
new file mode 100644
index 0000000..9cd046d
--- /dev/null
+++ b/14-arrays/questions/2-arrays.md
@@ -0,0 +1,168 @@
+# Arrays Quiz
+
+## What's the length of this array literal?
+```go
+gadgets := [...]string{"Mighty Mouse", "Amazing Keyboard", "Shiny Monitor"}
+```
+1. 0
+2. 1
+3. 2
+4. 3 *CORRECT*
+
+> **4:** Yes! There are 3 elements in the element list. So, Go sets the length of the array to 3.
+>
+
+
+## What's the type and length of this array literal?
+```go
+gadgets := [...]string{}
+```
+1. [0]string and 0 *CORRECT*
+2. [0]string{} and 0
+3. [1]string and 1 
+4. [1]string{} and 1 
+
+> **1:** Yes! There are no elements in the element list. So, Go sets the length of the array to 0.
+>
+
+## What does this program print?
+```go
+package main
+import "fmt"
+
+func main() {
+	gadgets := [3]string{"Confused Drone"}
+	fmt.Printf("%q\n", gadgets)
+}
+```
+1. [3]string{"Confused Drone", "", ""}
+2. [1]string{"Confused Drone"}
+3. ["Confused Drone" "" ""] *CORRECT*
+4. ["Confused Drone"]
+
+> **1:** %q verb doesn't print the type of an array.
+>
+> **2, 4:** Array's length cannot change depending on the elements.
+>
+> **3:** Yes! Go sets the uninitialized elements to their zero values.
+>
+
+
+## Are these arrays comparable?
+```go
+gadgets := [3]string{"Confused Drone"}
+gears   := [...]string{"Confused Drone"}
+
+fmt.Println(gadgets == gears)
+```
+1. Yes, because they have identical types and elements
+2. No, because their types are different *CORRECT*
+3. No, because their elements are different
+
+> **2:** Yes! gadget's type is [3]string whereas gears's type is [1]string.
+>
+
+
+## What does this program print?
+```go
+gadgets := [3]string{"Confused Drone", "Broken Phone"}
+gears   := gadgets
+
+gears[2] = "Shiny Mouse"
+
+fmt.Printf("%q\n", gadgets)
+```
+1. ["Confused Drone" "Broken Phone" "Shiny Mouse"]
+2. ["Confused Drone" "Broken Phone" ""] *CORRECT*
+3. ["" "" "Shiny Mouse"]
+4. ["" "" ""]
+
+> **2:** Yes! When you assign an array, Go creates a copy of the original array. So, gadgets and gears arrays are not connected. Changing one of them won't effect the other one.
+>
+
+
+## What's the type of the digits array?
+```go
+digits := [...][5]string{
+	{
+		"## ",
+		" # ",
+		" # ",
+		" # ",
+		"###",
+	},
+	[5]string{
+		"###",
+		"  #",
+		"###",
+		"  #",
+		"###",
+	},
+}
+```
+1. [...][5]string
+2. [2][2]string
+3. [2][5]string *CORRECT*
+4. [5][5]string
+
+> **3:** Awesome! There are two inner arrays, so the outer array's length becomes 2. Also note that, `[5]string` in front of the second element is unnecessary.
+>
+
+
+## What does this program print?
+```go
+rates := [...]float64{
+    5: 1.5,
+    2.5,
+    0: 0.5,
+}
+
+fmt.Printf("%#v\n", rates)
+```
+1. [7]float64{0.5, 0, 0, 0, 0, 1.5, 2.5} *CORRECT*
+2. [7]float64{1.5, 2.5, 0.5, 0, 0, 0, 0}
+3. [3]float64{1.5, 2.5, 0.5}
+4. [3]float64{0.5, 2.5, 1.5}
+
+> **1:** That's right! For the explanation check out the example in the course repository here: https://github.com/inancgumus/learngo/tree/master/14-arrays/11-keyed-elements/06-keyed-and-unkeyed
+>
+
+
+
+## Are these arrays equal?
+```go
+type three [3]int
+
+nums  := [3]int{1, 2, 3}
+nums2 := three{1, 2, 3}
+
+fmt.Println(nums == nums2)
+```
+**Note:** _To solve this question you need to watch the comparison and unnamed types lectures._
+1. Yes, because they have identical underlying types and elements *CORRECT*
+2. No, because their types are different
+3. No, because their length is different
+
+> **1:** Yes! They both have the same underlying types: [3]int
+>
+
+
+## Are these array variables equal?
+```go
+type (
+    threeA [3]int
+    threeB [3]int
+)
+
+nums  := threeA{1, 2, 3}
+nums2 := threeA(threeB{1, 2, 3})
+
+fmt.Println(nums == nums2)
+```
+**Note:** _To solve this question you need to the watch comparison and unnamed types lectures._
+1. Yes, because they have identical underlying types and elements *CORRECT*
+2. No, because their types are different
+3. No, because their length is different
+
+> **1:** Yes! Actually, arrays have different types, so normally they're not comparable. However, when you convert `threeB{1, 2, 3}` array to `threeA` type, they become comparable.
+>
\ No newline at end of file
diff --git a/14-arrays/questions/README.md b/14-arrays/questions/README.md
index 485d3fe..305618f 100644
--- a/14-arrays/questions/README.md
+++ b/14-arrays/questions/README.md
@@ -1,3 +1,4 @@
 # Array Quizzes
 
-* [Array Basics](array-basics.md)
\ No newline at end of file
+* [Array Basics](1-array-basics.md)
+* [Arrays](2-arrays.md)
\ No newline at end of file