computation_pasteurizer/index.html at master · JacobCWard/computation_pasteurizer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
<html>
<head>
<title>Jacob Ward's CSIS 2420 Homework</title>
<style type="text/css">
html,body {
	background: rgb(255, 255, 255);
	font-family: Arial;
	font-size: 14px;
	margin-left: 5%;
	margin-right: 5%;
	padding: 0;
}
</style>
</head>

<body>

	<h1>CSIS 2420 Homework</h1>
	<h2>
		Jacob Ward<br />
		jacobward@suumail.net<br />
	</h2>
	<br />

	<h2>Week 1</h2>
	<h3>
		<p>
			<a href="./week01/week01-ex1.html">Ex. 1: List four pre-computer
				data structures not covered in class</a>
		</p>
		<p>
			<a href="./week01/week01-ex2.html">Ex. 2: Writing a static method
				that takes positive integer n as input and outputs an array of n
				random integers in the range 0 -> 1,000,000</a>
		</p>
		</br>
	</h3>

	<h2>Week 2</h2>
	<h3>
		<p>
			<a href="./week02/week02-ex1.html">Ex. 1: Using the Node class,
				create 4 different nodes and place in them: Last name, First name,
				Major, Class.</a>
		</p>
		<p>
			<a href="./week02/week02-ex2.html">Ex. 2: Add a Big Integer and a
				Character to the front of your list, and print the entire contents
				of your list.</a>
		</p>
		<p>
			<a href="./week02/week02-ex3.html">Ex. 3: Write a test driver for
				your new List class.</a>
		</p>
		<p>
			<a href="./week02/week02-ex4.html">Ex. 4: Add insertAtBack() and
				removeFromBack() methods to the List class</a>
		</p>
		<p>
			<a href="./week02/week02-ex5.html">Ex. 5: Create a list and fill
				it with the squares from 1 to 100, then print out the contents.</a>
		</p>
		<p>
			<a href="./week02/week02-ex6.html">Ex. 6: Have the last node of
				the List in ex. 3 point to the first node.</a>
		</p>
		</br>
	</h3>

	<h2>Week 3</h2>
	<h3>
		<p>
			<a href="./week03/week03-ex1.html">Ex. 1: Add and test a method
				for the List class which returns the size of the list.</a>
		</p>
		<p>
			<a href="./week03/week03-ex2.html">Ex. 2: Add and test a method
				for the List class which returns a copy of the list.</a>
		</p>
		<p>
			<a href="./week03/week03-ex3.html">Ex. 3: Add and test static a
				method to the List class which appends one list to another and
				returns the result.</a>
		</p>
		<p>
			<a href="./week03/week03-ex4.html">Ex. 4: Write code that pushes
				10 strings onto the stack (version 2), printing while it goes, then
				pops them off, printing while it removes.</a>
		</p>
		<p>
			<a href="./week03/week03-ex5.html">Ex. 5: Rewrite the Stack2
				class using composition, and write an appropriate test driver.</a>
		</p>
		<p>
			<a href="./week03/week03-ex6.html">Ex. 6: Rewrite the Queue class
				using composition, and write an appropriate test driver.</a>
		</p>
		<p>
			<a href="./week03/week03-ex7.html">Ex. 7: Use your code from week
				1 to generate 15 random ints in the range 0 to 1000 and print them.
				Draw by hand the resulting BST you would get given this data.</a>
		</p>
		<p>
			<a href="./week03/week03-ex8.html">Ex. 8: Finish our test driver
				for the TreeNode. Print all contents using only reference to the
				root.</a>
		</p>
		<p>
			<a href="./week03/week03-ex9.html">Ex. 9: Generate 10 random ints
				in the range 0 to 100, print them in the order they are generated
				and insert them into a tree constructed using just the TreeNode
				class. Print out the keys in such a way that it proves that the data
				was inserted in the way you expect.</a>
		</p>
		</br>
	</h3>

	<h2>Week 5</h2>
	<h3>
		<p>
			<a href="./week05/week05-ex1.html">Ex. 1: Generate 1000 random
				ints in the range 0 to 1 million, print them in the order they are
				generated and insert them into the tree. Then do an inOrderTraversal
				which prints out the keys. What can you say about the values printed
				out? How fast is this algorithm on 1 million keys where the keys
				range from 0 to 1 billion?</a>
		</p>
		<p>
			<a href="./week05/week05-ex2.html">Ex. 2: Add and test min() and
				max() methods to the Tree class.</a>
		</p>
		<p>
			<a href="./week05/week05-ex3.html">Ex. 3: Add a find(key) method
				to the Tree class which returns true if the key is in the Tree and
				false if key is not in the tree.</a>
		</p>
		<p>
			<a href="./week05/week05-ex4.html">Ex. 4: Reimplement TreeNode
				and TreeNodeTest to store strings. Use it to store the first 20
				words in the "About SUU" web page. Then print the contents of the
				tree.</a>
		</p>
		</br>
	</h3>

	<h2>Week 6</h2>
	<h3>
		<p>
			<a href="./week06/week06-ex1.html">Ex. 1: Generate 15 random ints
				in the range 0 to 100. Demonstrate by hand the insertion of these
				numbers into a hash array of size 31. Use the mod 31 hash. Resolve
				the collisions by chaining.</a>
		</p>
		<p>
			<a href="./week06/week06-ex2.html">Ex. 2: Using the hash table
				code given in class as a starting point, generate 100 random ints in
				the range 0 to 1 million and insert these into an appropriately
				sized hash table. Then walk through the table printing all values
				inserted at each index.</a>
		</p>
		<p>
			<a href="./week06/week06-ex3.html">Ex. 3: Show by hand every step
				in the process of constructing a heap from the following initial
				values: v = [9, 12, 17, 30, 50, 20, 60, 65, 4, 19].</a>
		</p>
		<p>
			<a href="./week06/week06-ex4.html">Ex. 4: Generate 10 random ints
				in the range 0 to 1000. Create a heap with these values. Pictorially
				show the history of HeapSort at each step. Show a picture after the
				initial swap, then after reheapifying for every step. (The
				complexity of this assignment is 21 steps).</a>
		</p>
		<p>
			<a href="./week06/week06-ex5.html">Ex. 5: Suppose we have a heap
				stored in any array H with values: H = [65,
				50,60,30,19,20,17,12,4,9]. Show every step illustrating how the
				array changes during the HeapSort algorithm using the same approach
				as in ex. 3.</a>
		</p>
		</br>
	</h3>

	<h2>Week 7</h2>
	<h3>
		<p>
			<a href="./week07/week07-ex1.html">Ex. 1: Using the graph given
				in class, determine by brute force the shortest path from A to H.
				Show by hand at least 10 different paths with their total weights.
				(There are 8 vertices in this graph).</a>
		</p>
		<p>
			<a href="./week07/week07-ex2.html">Ex. 2: Using the graph we used
				for ex. #1, write out the adjacency matrix and adjacency list
				representations. For the adjacency matrix, show the weights.</a>
		</p>
		<p>
			<a href="./week07/week07-ex3.html">Ex. 3: Give the adjacency
				matrix and the adjacency list for the heap you created in week 6 ex.
				3.</a>
		</p>
		<p>
			<a href="./week07/week07-ex4.html">Ex. 4: Complete the event
				charts for Depth First and Breadth First search on the graph given
				in class.</a>
		</p>
		<p>
			<a href="./week07/week07-ex5.html">Ex. 5: Illustrate breadth
				first traversal for the graph given in ex. 1, starting from vertex
				A. Use the list of events and queue contents as illustrated in
				class.</a>
		</p>
		<p>
			<a href="./week07/week07-ex6.html">Ex. 6: Illustrate depth first
				traversal for the graph given in ex. 1, starting from vertex A. Use
				the list of events and stack contents as illustrated in class.</a>
		</p>
		</br>
	</h3>

	<h2>Week 9</h2>
	<h3>
		<p>
			<a href="./week09/week09-ex1.html">Ex. 1: Using the SUU privacy policy, clean up the text and parse it following the example we did in class.  Make sure to clean out all non-word symbols.  How many (real) words in this file?  (Hint: see the Pattern class)</a>
		</p>
		<p>
			<a href="./week09/week09-ex2.html">Ex. 2: Demo the following ArrayList methods:  contains, remove, clear and isEmpty using our data set.</a>
		</p>
		<p>
			<a href="./week09/week09-ex3.html">Ex. 3: Demo the PriorityQueue methods: add, clear, contains, peak, remove, size using our data set.</a>
		</p>
		<p>
			<a href="./week09/week09-ex5.html">Ex. 5: Write a filter that selects the words starting with ÔaÕ or ÔbÕ.  How big is it?  (Hint: use compareTo())</a>
		</p>
		</br>
	</h3>

	<h2>Week 11</h2>
	<h3>
		<p>
			<a href="./week11/week11-ex1.html">Ex. 1: Write a filter that allows you to find the set A of words starting with a, b, c or d.  How many elements in the set?</a>
		</p>
		<p>
			<a href="./week11/week11-ex2.html">Ex. 2: Write a filter that allows you to find the set B of words starting with c, d, e or f.  How many elements in the set?</a>
		</p>
		<p>
			<a href="./week11/week11-ex3.html">Ex. 3: Form the union of sets A and B.  How many elements in the set?</a>
		</p>
		<p>
			<a href="./week11/week11-ex4.html">Ex. 4: When you print out the data from a HashSet, does it follow the same order you would expect from the order in the text?  Why?</a>
		</p>
		<p>
			<a href="./week11/week11-ex5.html">Ex. 5: Improve our countwords program so that it does not distinguish between upper and lower case.</a>
		</p>
		<p>
			<a href="./week11/week11-ex7.html">Ex. 7: Using the set operators given in class, find the union, intersection and difference of the sets A and B above.  How big are each of these new sets?  Make sure to use proper implementations of the set operators.</a>
		</p>
		<p>
			<a href="./week11/week11-ex8.html">Ex. 8: Create filters that select the following:</br>
  -- All words that are used more than 100 times.</br>
  --All words that are used more than 50 times.</br>
  --All words used more than 10 times.</br>
  Print out the sets and give their size for each category.</a>
		</p>
		</br>
	</h3>

	<h2>Week 12</h2>
	<h3>
		<p>
			<a href="./week12/week12-ex1.html">Ex. 1: Change our definition of the compareTo method so the data shows the most frequent words at the top.</a>
		</p>
		<p>
			<a href="./week12/week12-ex2.html">Ex. 2: Improve the code so it changes all words to lowercase before comparing.</a>
		</p>
		<p>
			<a href="./week12/week12-ex3.html">Ex. 3: Do what you need to do to improve the output.</a>
		</p>
		<p>
			<a href="./week12/week12-ex4.html">Ex. 4: Create a small table showing the complexity of the operations of search, insert and delete for the special purpose data structures: stack, queue priority queue (heap implementation).</a>
		</p>
		</br>
	</h3>

	<h2><a href="https://github.com/jacobward1898/2420Project">Final Project GitHub Repository</a></h2>

</body>
</html>