May 4, 2016 23:11
Blogger
April 29, 2016 13:48
Blogger
Stack Class in C#
Since I was bored at work, I started thinking that we never created a stack for one of the class assignments. So I decided to create my own, which wasn't that hard since its essentially just a wrapper around an array.
I started to work on it yesterday for a couple hours and finished it this morning.
Here is my code:
Thanks for reading!
April 27, 2016 02:48
Blogger
CS 2420 - Assignment 9 - Max Heap
While the assignment its self wasn't too hard, it took me a while to do all the conditional logic behind the Sink() function.
Here is my code:
using System; using System.Collections; using System.Collections.Generic; namespace Assignment9 { class MaxHeap<T> : IEnumerable<T> where T : IComparable { private T[] UnderlyingArray; private int ElementCount = 0; private int OldCount = 0; private bool IsHeap = true; public MaxHeap(int starting_size) { UnderlyingArray = new T[starting_size]; } public MaxHeap() { UnderlyingArray = new T[5]; } public int Count { get { return ElementCount; } } public void Clear() { UnderlyingArray = new T[UnderlyingArray.Length]; } public T this[int index] { get { return UnderlyingArray[index]; } } public void Add(T new_value) { if (!IsHeap) BuildHeap(); if (ElementCount == UnderlyingArray.Length) Resize(); UnderlyingArray[ElementCount] = new_value; Swim(); ElementCount++; } public T PopTop() { if (!IsHeap) BuildHeap(); T max = UnderlyingArray[0]; Swap(0, ElementCount - 1); UnderlyingArray[ElementCount - 1] = default(T); ElementCount--; Sink(); return max; } public void Sort() { if (!IsHeap) BuildHeap(); OldCount = ElementCount; for (int i = 0; i < OldCount; i++) { Swap(0, ElementCount - 1); ElementCount--; Sink(); } IsHeap = false; ElementCount = OldCount; } public void BuildHeap() { if (IsHeap) return; int last_item = OldCount - 1; for (int index = 0; index < OldCount / 2; index++) { Swap(index, last_item); last_item--; } ElementCount = OldCount; IsHeap = true; } private void Swim() { int current_index = ElementCount; while (current_index != 0) { int parent_index = FindParent(current_index); if (UnderlyingArray[current_index].CompareTo(UnderlyingArray[parent_index]) == 0) break; else if (UnderlyingArray[current_index].CompareTo(UnderlyingArray[parent_index]) > 0) Swap(current_index, parent_index); current_index = parent_index; } } private void Swap(int first, int second) { T temp = UnderlyingArray[first]; UnderlyingArray[first] = UnderlyingArray[second]; UnderlyingArray[second] = temp; } private void Sink() { int current_index = 0; while (current_index < ElementCount) { int max_child_index = current_index; int left_child_index = FindLeft(current_index); int right_child_index = FindRight(current_index); if (left_child_index >= ElementCount) break; if (right_child_index >= ElementCount) max_child_index = left_child_index; if (right_child_index < ElementCount && UnderlyingArray[left_child_index].CompareTo(UnderlyingArray[right_child_index]) == 0) max_child_index = left_child_index; if (right_child_index < ElementCount && UnderlyingArray[left_child_index].CompareTo(UnderlyingArray[right_child_index]) > 0) max_child_index = left_child_index; if (right_child_index < ElementCount && UnderlyingArray[left_child_index].CompareTo(UnderlyingArray[right_child_index]) < 0) max_child_index = right_child_index; if (UnderlyingArray[max_child_index].CompareTo(UnderlyingArray[current_index]) == 0) break; if (UnderlyingArray[max_child_index].CompareTo(UnderlyingArray[current_index]) > 0) Swap(current_index, max_child_index); current_index = max_child_index; } } private int FindParent(int current_index) { return (current_index - 1) / 2; } private int FindLeft(int current_index) { return (current_index * 2) + 1; } private int FindRight(int current_index) { return (current_index * 2) + 2; } private void Resize() { T[] new_array = new T[UnderlyingArray.Length * 2]; for (int index = 0; index < UnderlyingArray.Length; index++) new_array[index] = UnderlyingArray[index]; UnderlyingArray = new_array; } public IEnumerator<T> GetEnumerator() { for (int index = 0; index < ElementCount; index++) { T temp = UnderlyingArray[index]; //Console.WriteLine("Current Value: {0}", temp); yield return temp; } } IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } } }
That's all for now, thanks for reading!
April 20, 2016 15:56
Blogger
CS 2420 - Assignment 8 - Components
The point of this week's assignment to learn how to use components to build a game, instead of hard coding everything like we usually do. We also had a chance to review inheritance and understand how it works.
This time around there is too much code involved for me to put it here like I usually do, but if you are interested in looking at the code you can look here:
https://github.com/fushinoryuu/EAE2420/tree/master/DataStructuresAndSorts/Assignment8
I created these main class files: Component, Entity, Grid, Point, and Power Up.
The Grid was essentially a 2D array and everything ran through this file, it represented the map the player was going to play on. It also updated itself on the position of each enemy and the player and then displayed itself on the console.
The player and the enemies in the game all inherited from the Entity class and used a bunch of components to make each unique. For example, enemies had a component that allowed them to wrap around the Grid but the player was bound and couldn't go past the edges of the grid. To do this there was two components and I just had to make sure to give one to the player and the other to the enemies.
Power Ups are a type of component, but they don't inherit from the component class. I made it so they would modify the player's action. For example I had a Teleport Power Up. When they stepped on it, they would get randomly taken to an empty spot in the map.
I had a lot of fun with this assignment, but it took a little longer than I anticipated.
Anyways, that's all for now. Thanks for reading!
April 12, 2016 10:47
Blogger
CS 2420 - Assignment 7 - Hash Table
Here is my code:
That's all for now, thanks for reading!
April 6, 2016 02:40
Blogger
CS 2420 - Assignment 6 - A Star
G: -12, -8 H: 12, -9 I: -18, -11 J: -4, -11 K: -12, -14 L: 2, -18
M: 18, -13 N: 4, -9 O: 22, 11 P: 18, 3
That's all for now, thanks for reading!
March 30, 2016 22:05
Blogger
Breadth First Search - Matrix
We didn't have to code it in class, we just had to know how one would write the algorithm. Last night I decided that I would try to code it and here is my work:
In my grid I make the starting cell marked with an X and the destination is marked with a D. The final path would be calculated by simply following the cell values in descending order to the final destination.
That's all for now, thanks for reading!
March 24, 2016 02:37
Blogger
CS 2420 - Assignment 5 - Part 5
using System; using System.Collections.Generic; namespace Assignment5 { public TreeNode<string> root; public ExpressionTree(string input) { root = null; ExpressionParser parser = new ExpressionParser(this, input); } private class ExpressionParser { private Stack<TreeNode<string>> numberStack, operatorStack; public ExpressionParser(ExpressionTree tree, string input) { numberStack = new Stack<TreeNode<string>>(); operatorStack = new Stack<TreeNode<string>>(); string[] expressionArray = new string[input.Length]; expressionArray = input.Split(); BuildNodes(tree, expressionArray); } private void BuildNodes(ExpressionTree tree, string[] expressionArray) { foreach (string item in expressionArray) { double tempNumber; if (double.TryParse(item, out tempNumber)) { TreeNode<string> number_node = new TreeNode<string>
{ Data = tempNumber.ToString() }; numberStack.Push(number_node); } else { TreeNode<string> operator_node = new TreeNode<string>
{ Data = item }; operatorStack.Push(operator_node); } } BuildTree(tree); } private void BuildTree(ExpressionTree tree) { while (operatorStack.Count != 0) { TreeNode<string> tempRoot = operatorStack.Pop(); tempRoot.Right = numberStack.Pop(); tempRoot.Left = numberStack.Pop(); if((tempRoot.Data == "*" || tempRoot.Data == "/") && (tempRoot.Right.Data == "+" || tempRoot.Right.Data == "-")) { tempRoot = tree.RotateLeft(tempRoot); } numberStack.Push(tempRoot); } TreeNode<string> subTree = numberStack.Pop(); tree.root = tree.RotateLeft(subTree); } } private TreeNode<string> RotateLeft(TreeNode<string> currentNode) { TreeNode<string> tempNode = currentNode; currentNode = currentNode.Right; tempNode.Right = currentNode.Left; currentNode.Left = tempNode; return currentNode; } public void Evaluate(TreeNode<string> node) { if (node.Left != null) Evaluate(node.Left); if (node.Right != null) Evaluate(node.Right); switch (node.Data) { case "+": double addResult = double.Parse(node.Left.Data) +
double.Parse(node.Right.Data); node.Data = addResult.ToString(); node.Left = null; node.Right = null; break; case "-": double subResult = double.Parse(node.Left.Data) -
double.Parse(node.Right.Data); node.Data = subResult.ToString(); node.Left = null; node.Right = null; break; case "*": double multResult = double.Parse(node.Left.Data) *
double.Parse(node.Right.Data); node.Data = multResult.ToString(); node.Left = null; node.Right = null; break; case "/": double divResult = double.Parse(node.Left.Data) /
double.Parse(node.Right.Data); node.Data = divResult.ToString(); node.Left = null; node.Right = null; break; case "^": double expResult = Math.Pow(double.Parse(node.Left.Data),
double.Parse(node.Right.Data)); node.Data = expResult.ToString(); node.Left = null; node.Right = null; break; } } public string TraversePre(MyList<string> list, TreeNode<string> node) { list.Add(node.Data); if (node.Left != null) TraversePre(list, node.Left); if (node.Right != null) TraversePre(list, node.Right); return string.Join(", ", list); } public string TraverseIn(MyList<string> list, TreeNode<string> node) { if (node.Left != null) TraverseIn(list, node.Left); list.Add(node.Data); if (node.Right != null) TraverseIn(list, node.Right); return string.Join(", ", list); } public string TraversePost(MyList<string> list, TreeNode<string> node) { if (node.Left != null) TraversePost(list, node.Left); if (node.Right != null) TraversePost(list, node.Right); list.Add(node.Data); return string.Join(", ", list);} } }
I was not able to make my Binary Search Tree self balancing. I know what I need to do, but I never had time to actually implement the code. I will try to finish writing the code and post it here when I'm done with my AVL tree.
Anyways, that's all for now. Thanks for reading!
March 16, 2016 23:19
Blogger
CS 2420 - Assignment 5 - Part 4
At first I had created each class in separate class files, but it was kind of weird how I was parsing the input and how I was building the tree. So I decided to move my Expression Parser class to be nested within my Expression Tree class. This would allow me to do all the parsing and building of the tree within one class file instead of two where it can get messy and confusing.
Here is my new code, thanks for reading:
using System; using System.Collections.Generic; namespace Assignment5 { class ExpressionTree { public TreeNode<string> root; private int node_count; public ExpressionTree(string input) { root = null; ExpressionParser parser = new ExpressionParser(this, input); } private class ExpressionParser { private Stack<TreeNode<string>> numberStack, operatorStack; public ExpressionParser(ExpressionTree tree, string input) { numberStack = new Stack<TreeNode<string>>(); operatorStack = new Stack<TreeNode<string>>(); Console.WriteLine(input.Length); string[] expressionArray = new string[input.Length]; expressionArray = input.Split(); BuildNodes(tree, expressionArray); } private void BuildNodes(ExpressionTree tree, string[] expressionArray) { foreach (string item in expressionArray) { int tempInt; if (Int32.TryParse(item, out tempInt)) { TreeNode<string> number_node = new TreeNode<string> { Data = tempInt.ToString() }; numberStack.Push(number_node); } else
{ TreeNode<string> operator_node = new TreeNode<string> { Data = item }; operatorStack.Push(operator_node); } } BuildTree(tree); } private void BuildTree(ExpressionTree tree) { tree.node_count = numberStack.Count + operatorStack.Count; while (operatorStack.Count != 0) { TreeNode<string> tempRoot = operatorStack.Pop(); tempRoot.Right = numberStack.Pop(); tempRoot.Left = numberStack.Pop(); numberStack.Push(tempRoot); } tree.root = numberStack.Pop(); } } public int NodeCount { get { return node_count; } } // TODO Finish Evaluate public void Evaluate(MyList<string> list, TreeNode<string> node) { if (node.Left != null) Evaluate(list, node.Left); if (node.Right != null) Evaluate(list, node.Right); throw new NotImplementedException(); } public string TraversePre(MyList<string> list, TreeNode<string> node) { list.Add(node.Data); if (node.Left != null) TraversePre(list, node.Left); if (node.Right != null) TraversePre(list, node.Right); return string.Join(", ", list); } public string TraverseIn(MyList<string> list, TreeNode<string> node) { if (node.Left != null) TraverseIn(list, node.Left); list.Add(node.Data); if (node.Right != null) TraverseIn(list, node.Right); return string.Join(", ", list); } public string TraversePost(MyList<string> list, TreeNode<string> node) { if (node.Left != null) TraversePost(list, node.Left); if (node.Right != null) TraversePost(list, node.Right); list.Add(node.Data); return string.Join(", ", list); } } }
March 9, 2016 10:37
Blogger
CS 2420 - Assignment 5 - Part 3
Yesterday after class, I figured out how to finish my Expression Tree and the Parser that takes the user's input.
Expression Tree:
using System; namespace Assignment5 { class ExpressionTree { public TreeNode<string> root; public int node_count; public ExpressionTree() { root = null; } // TODO Finish Evaluate public void Evaluate() { } public string TraversePre(MyList<string> list, TreeNode<string> node) { list.Add(node.data); if (node.left != null) TraversePre(list, node.left); if (node.right != null) TraversePre(list, node.right); return string.Join(", ", list); } public string TraverseIn(MyList<string> list, TreeNode<string> node) { if (node.left != null) TraverseIn(list, node.left); list.Add(node.data); if (node.right != null) TraverseIn(list, node.right); return string.Join(", ", list); } public string TraversePost(MyList<string> list, TreeNode<string> node) { if (node.left != null) TraversePost(list, node.left); if (node.right != null) TraversePost(list, node.right); list.Add(node.data); return string.Join(", ", list); } } }
Parser:
using System; using System.Collections; using System.Collections.Generic; namespace Assignment5 { class ExpressionParser { private Stack<TreeNode<string>> numberStack, operatorStack; public ExpressionParser(ExpressionTree ETree, string input) { numberStack = new Stack<TreeNode<string>>(); operatorStack = new Stack<TreeNode<string>>(); ToArray(ETree, input); } public void ToArray(ExpressionTree ETree, string input) { string[] expressions = new string[input.Length]; expressions = input.Split(); BuildNodes(expressions, ETree); } private void BuildNodes(string[] expressions, ExpressionTree ETree) { foreach (string item in expressions) { int tempInt; if (Int32.TryParse(item, out tempInt)) { TreeNode<string> number_node = new TreeNode<string> { data = tempInt.ToString() }; numberStack.Push(number_node); } else { TreeNode<string> operator_node = new TreeNode<string> { data = item }; operatorStack.Push(operator_node); } } BuildTree(ETree); } private void BuildTree(ExpressionTree ETree) { ETree.node_count = numberStack.Count + operatorStack.Count; while (operatorStack.Count != 0) { TreeNode<string> tempRoot = operatorStack.Pop(); tempRoot.right = numberStack.Pop(); tempRoot.left = numberStack.Pop(); numberStack.Push(tempRoot); } ETree.root = numberStack.Pop(); } } }
I will continue to work on this assignment. Thanks for reading!
March 7, 2016 00:29
Blogger
CS 2420 - Assignment 5 - Part 2
Here is what I have now:
using System; class BinarySearchTree { public TreeNoderoot; private int node_count; public BinarySearchTree() { root = null; node_count = 0; } public void Add(int item) { TreeNode new_node = new TreeNode (item); if (root == null) root = new_node; else { TreeNode crawler = root; while (crawler != null) { new_node.parent = crawler; if (item >= crawler.data) crawler = crawler.right; else crawler = crawler.left; } if (item >= new_node.parent.data) new_node.parent.right = new_node; else new_node.parent.left = new_node; } node_count++; CalculateHeight(root); Console.WriteLine(""); } public TreeNode Contains(int item) { TreeNode crawler = root; while (crawler != null) { if (item == crawler.data) return crawler; else if (item >= crawler.data) crawler = crawler.right; else crawler = crawler.left; } return null; } // TODO Finish Remove function public void Remove(TreeNode node) { if (node == null) Console.WriteLine("\nCould not remove the node you were looking for!\n"); else { //Work needed } } public void Clear() { root = null; node_count = 0; } public int NodeCount { get { return node_count; } } private void CalculateHeight(TreeNode node) { if (node.left != null) CalculateHeight(node.left); if (node.right != null) CalculateHeight(node.right); if (node.left != null && node.right != null) node.height = Math.Max(node.left.height, node.right.height) + 1; else if (node.left != null && node.right == null) node.height = node.left.height + 1; else if (node.left == null && node.right != null) node.height = node.right.height + 1; else if (node.left == null && node.right == null) node.height = 1; Console.WriteLine("Node value: {0} Node Height: {1}", node.data, node.height); CheckBalance(node); } private void CheckBalance(TreeNode node) { if (node.left == null && node.right == null) return; else if (node.left != null && node.right == null) if (node.left.height > 1) Rotate(node); else if (node.left == null && node.right != null) if (node.right.height > 1) Rotate(node); else if (node.left != null && node.right != null) { if (node.left.height > node.right.height + 1) Rotate(node.left); else if (node.right.height > node.left.height + 1) Rotate(node.right); } } // TODO Finish Rotate function private void Rotate(TreeNode node) { //Work needed } public string TraversePre(MyList list, TreeNode node) { list.Add(node.data); if (node.left != null) TraversePre(list, node.left); if (node.right != null) TraversePre(list, node.right); return string.Join(", ", list); } public string TraverseIn(MyList list, TreeNode node) { if (node.left != null) TraverseIn(list, node.left); list.Add(node.data); if (node.right != null) TraverseIn(list, node.right); return string.Join(", ", list); } public string TraversePost(MyList list, TreeNode node) { if (node.left != null) TraversePost(list, node.left); if (node.right != null) TraversePost(list, node.right); list.Add(node.data); return string.Join(", ", list); } }
There has been a few changes to the rest of the code as well. I have been trying to figure out how to make my tree self balancing. And while I have been able to calculate the depth/height of each node, I am running into issues on how I should rotate the nodes. I am also working on removing nodes, but I haven't made much progress in that department either.
Anyways, that's all for now. Thanks for reading!
March 3, 2016 19:24
Blogger
CS 2420 - Assignment 5 - Part 1
The assignment will have us built two trees: a Binary Search Tree and a Binary Expression Tree.
I have started working on both, but I have been mainly focusing on the BS Tree since to me its the easiest of the two. I am actually almost done with the BS Tree, here is what I have:
class BinarySearchTree { public TreeNoderoot; private int node_count; public BinarySearchTree() { root = null; node_count = 0; } public void Add(int item) { TreeNode new_node = new TreeNode (item); if (root == null) root = new_node; else { TreeNode crawler = root; while (crawler != null) { new_node.parent = crawler; if (item >= crawler.data) crawler = crawler.right; else crawler = crawler.left; } if (item >= new_node.parent.data) new_node.parent.right = new_node; else new_node.parent.left = new_node; } node_count++; } public bool Contains(int item) { TreeNode crawler = root; while (crawler != null) { if (item == crawler.data) return true; else if (item >= crawler.data) crawler = crawler.right; else crawler = crawler.left; } return false; } public void Clear() { root = null; node_count = 0; } public int NodeCount { get { return node_count; } } public void TraversePre(MyList list, TreeNode node) { list.Add(node.data); if (node.left != null) TraversePre(list, node.left); if (node.right != null) TraversePre(list, node.right); } public void TraverseIn(MyList list, TreeNode node) { if (node.left != null) TraverseIn(list, node.left); list.Add(node.data); if (node.right != null) TraverseIn(list, node.right); } public void TraversePost(MyList list, TreeNode node) { if (node.left != null) TraversePost(list, node.left); if (node.right != null) TraversePost(list, node.right); list.Add(node.data); } }
My Binary Search Tree takes advantage of the List class I wrote for assignment 4 and of a Node class that has only three properties: Left, Right, & Parent. That's all for now, thanks for reading!
March 1, 2016 17:25
Blogger
Linked List class in C#
I also decided to make my own enumerator for the linked list. Here is what I wrote:
February 26, 2016 22:27
Blogger
CS 2420 - Assignment 4 - Part 5
After thinking about it for a while, I decided that I would create a new class that would just be called from the Main function and it would sort lists of different sizes and it would output the time in milliseconds to a text file. This would make it easier to actually make a graph for each sort. In a graph, X would be the number of elements in the list and Y would be the time it took to sort the list.
Here is what I have for this new class:
using System; using System.Diagnostics; using System.IO; class RunningTimes { public static void SortPlot(ISorter sorter, int elements, string name) { Random randint = new Random(); Stopwatch watch = new Stopwatch(); StreamWriter file = new StreamWriter(@"ChristianMunoz_RunningTimes.txt", true); long time = watch.ElapsedMilliseconds; int[] list; while(elements > 0) { list = new int[elements]; for (int i = 0; i < list.Length; i++) list[i] = randint.Next(1, 200); watch.Reset(); watch.Start(); sorter.sort(list, 0, list.Length); watch.Stop(); time = watch.ElapsedMilliseconds; Console.WriteLine(time); file.WriteLine("Sort: {0} Element count: {1} Time in Milliseconds: {2}", name, elements, time); elements = elements - 10000; } file.WriteLine(" "); file.Close(); } }
In the part that says: @"ChristianMunoz_RunningTimes.txt" that is the location and name of the text file I'm creating. You can change the name to anything you want, and you can find the file in your pc by first going to the folder where you have your C# work: Documents\CSharp\DataStructuresAndSorts\Assignment4\bin\Debug. Or you can also replace the name and tell Visual Studio a specific location by pasting in a path that you want.
This is how I call the function from my main:
RunningTimes.SortPlot(qSorter, 70000, "Quick Sort");
Since this new class isn't doing anything special, I don't have to create a new instance of the class and I can just call it from my other file. In the above example: I pass in a Quick Sort object, I tell it how big I want my list to be (in this case it will be 70000 integers), and just for kicks I pass in a string to make it easier to read the txt file of the sort that I am on. The output of the file will look like this:
Quick Sort Element count: 70000 Time in Milliseconds: 93 Quick Sort Element count: 60000 Time in Milliseconds: 72 Quick Sort Element count: 50000 Time in Milliseconds: 48 Quick Sort Element count: 40000 Time in Milliseconds: 37 Quick Sort Element count: 30000 Time in Milliseconds: 20 Quick Sort Element count: 20000 Time in Milliseconds: S Quick Sort Element count: 10000 Time in Milliseconds: 2
That's all for now, thanks for reading!
February 25, 2016 19:03
Blogger
CS 2420 - Assignment 4 - Part 4
Here is the finished Enumerator class:
private class myEnumerator : IEnumerator{ private MyList myList; private int index; public myEnumerator(MyList myList) { this.myList = myList; index = -1; } public bool MoveNext() { index++; return (index < myList.Count); } public T Current { get { return myList[index]; } } object IEnumerator.Current { get { return Current; } } // Not Needed public void Dispose() { //Not Needed } public void Reset() { index = -1; } }
This new class is embedded in the List class, and it just spits out the next item in the list. The cool thing about this new Enumerator is that it will stop as soon as it reached the Count of the items in the list instead of the length of the array. This way if there are any empty slots in the array, they won't get printed in the list.
That's all for now, thanks for reading!
Archive
- September 2016
- August 2016
- June 2016
- May 2016
- April 2016
- March 2016
- February 2016
- January 2016
- December 2015
- November 2015
- October 2015
- September 2015
- August 2015
- July 2015
- June 2015
- May 2015
- April 2015
- March 2015
- February 2015
- January 2015
- November 2014
- October 2014
- September 2014
- August 2014
- June 2014
- May 2014
- April 2014
- March 2014
- February 2014
- January 2014
- December 2013
- November 2013
- October 2013
- September 2013
- August 2013
- July 2013
- June 2013
- May 2013
- April 2013
- March 2013
- February 2013
- January 2013
- December 2012
- November 2012
- October 2012
- September 2012
- August 2012
- April 2012
- March 2012
- February 2012
- January 2012
- December 2011
- November 2011
- October 2011
- September 2011
- August 2011
- March 2011
- February 2011
- January 2011
- December 2010
- November 2010
- October 2010
While I was working, I found that 99% of the code was going to be the same, and I didn't want to just create a copy and tweak a few lines. So instead I decided to create a abstract Heap class that I could inherit from.
So I created the base class and moved most of the code to that file. Then I made the Max and Min Heap classes and made the changes required in each class to make it work. While this also wasn't that hard, I think that it was a good exerciser. I did something similar in the Components assignment, but I think this was a much better example of how to use inheritance.
Here is my code:
That's all for now, thanks for reading!