├── .gitignore
├── README.md
└── src
├── Java101Exercises.java
└── Java101ExerciseTest.java
/.gitignore:
--------------------------------------------------------------------------------
1 | .idea
2 | out
3 | *.iml
4 | *.class
5 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # java-101-exercises
2 | This file has a set of Java exercises to use for improve your skill level in Java and preparing you for coding interview questions. There are five levels of problems. As you improve you can move up levels.
3 |
4 |
5 | LEVELS:
6 | BASIC Exercise 001 - 010
7 | EASY Exercise 011 - 040
8 | INTERMEDIATE Exercise 041 - 070
9 | DIFFICULT Exercise 071 - 090
10 | ADVANCED Exercise 091 - 101
11 |
12 |
--------------------------------------------------------------------------------
/src/Java101Exercises.java:
--------------------------------------------------------------------------------
1 | import java.util.ArrayList;
2 | import java.util.List;
3 |
4 | /**
5 | * This file has a set of Java exercises to use for improve your skill level in Java and preparing you for coding
6 | * interview questions. There are five levels of problems. As you improve you can move up levels.
7 | *
8 | * LEVELS:
9 | * BASIC Exercise 001 - 010
10 | * EASY Exercise 011 - 040
11 | * INTERMEDIATE Exercise 041 - 070
12 | * DIFFICULT Exercise 071 - 090
13 | * ADVANCED Exercise 091 - 101
14 | *
15 | */
16 |
17 | public class Java101Exercises {
18 |
19 | /**
20 | * Exercise 001 - Add Ints
21 | * Write a method to add to integers (int) and return the sum.
22 | *
23 | * LEVEL: BASIC
24 | *
25 | * @param a First number to add
26 | * @param b Second number to add
27 | * @return The sum
28 | */
29 | public static int addInts001(int a, int b) {
30 | // TODO: Write code here
31 | return 0;
32 | }
33 |
34 | /**
35 | * Exercise 002 - Say Hello
36 | *
37 | * Given an input String, name; return a String with "Hello " appended in-front of name and "!" appended after name.
38 | *
39 | * LEVEL: BASIC
40 | *
41 | * @param name A name
42 | * @return A greeting.
43 | */
44 | public static String sayHello002(String name) {
45 | // TODO: Write code here
46 | return null;
47 | }
48 |
49 | /**
50 | * Exercise 003 - Say Codeup
51 | *
52 | * Write a method to return an array of nine strings with the message below using asterisk.
53 | *
54 | *
55 | * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
56 | * * * * * * * * * * * *
57 | * * * * * * * * * * * *
58 | * * * * * * * * * * *
59 | * * * * * * * * * * * * * * * * * * * * *
60 | * * * * * * * * * *
61 | * * * * * * * * * * *
62 | * * * * * * * * * * *
63 | * * * * * * * * * * * * * * * * * * * * * * * * * * *
64 | *
65 | *
66 | *
67 | * LEVEL: BASIC
68 | *
69 | * @return A String array with an asterisks drawing of CODEUP
70 | */
71 | public static String[] sayCodeup003() {
72 | // TODO: Write code here
73 | return null;
74 | }
75 |
76 | /**
77 | * Exercise 004 - Add doubles
78 | * Write a method to add to real numbers (double) and return the sum as a double.
79 | *
80 | * LEVEL: BASIC
81 | *
82 | * @param a First number to add
83 | * @param b Second number to add
84 | * @return The sum
85 | */
86 | public static double addDouble004(double a, double b) {
87 | // TODO: Write code here
88 | return 0.0;
89 | }
90 |
91 | /**
92 | * Exercise 005 - Concatenate strings
93 | * Write a method to join to Strings together with a space between the two Strings.
94 | *
95 | * LEVEL: BASIC
96 | *
97 | * @param a First String
98 | * @param b Second String
99 | * @return The joined strings
100 | */
101 | public static String concatenateStrings005(String a, String b) {
102 | // TODO: Write code here
103 | return null;
104 | }
105 |
106 | /**
107 | * Exercise 006 - is Equal
108 | * Write a method that accepts two integers and returns the boolean value true if they are equal and returns the
109 | * boolean value false if the are not equal.
110 | *
111 | * LEVEL: BASIC
112 | *
113 | * @param a First integer
114 | * @param b Second integer
115 | * @return Boolean flag reflecting equality
116 | */
117 | public static boolean isEqual006(int a, int b) {
118 | // TODO: Write code here
119 | return false;
120 | }
121 |
122 | /**
123 | * Exercise 007 - is Greater Than
124 | * Write a method that accepts two doubles and returns the boolean value true if a is greater than b and returns
125 | * the boolean value false if a is not greater than b.
126 | *
127 | * LEVEL: BASIC
128 | *
129 | * @param a First double
130 | * @param b Second double
131 | * @return Boolean flag reflecting the relationship
132 | */
133 | public static boolean isGreaterThan007(double a, double b) {
134 | // TODO: Write code here
135 | return false;
136 | }
137 |
138 | /**
139 | * Exercise 008 - Cubed
140 | * Write a method that accepts a double and returns the number cubed ( times itself three times).
141 | * LEVEL: BASIC
142 | *
143 | * @param a The number
144 | * @return The cubed value of the number.
145 | */
146 | public static double cube008(double a) {
147 | return 0.0;
148 | }
149 |
150 | /**
151 | * Exercise 009 - Positive Difference
152 | * Write a method that accepts two integers and returns the positive difference between the two numbers.
153 | *
154 | * LEVEL: BASIC
155 | *
156 | * @param a First integer
157 | * @param b Second integer
158 | * @return The positive difference between the two numbers
159 | */
160 | public static int calcPositiveDifference009(int a, int b) {
161 | // TODO: Write code here
162 | return 0;
163 | }
164 |
165 | /**
166 | * Exercise 010 - Remainder
167 | * Write a method that accepts two integers and returns the remainder from the division .
168 | *
169 | * LEVEL: BASIC
170 | *
171 | * @param a Number to be divided
172 | * @param b Number to divide by
173 | * @return remainder from the division
174 | */
175 | public static int calcRemainder010(int a, int b) {
176 | // TODO: Write code here
177 | return 0;
178 | }
179 |
180 | /**
181 | * Exercise 011 - Preform Indicate Operation
182 | * Write a method with 3 parameters; a String and 2 doubles. The string will be an operation that the operation
183 | * needs to process on the two operands. Return the result if the operation. Return 0.0 if the operation is not
184 | * one of the four specified. The operation should be case sensitive.
185 | *
186 | * LEVEL: EASY
187 | *
188 | * @param operation ADD, SUB, MUL, DIV
189 | * @param op1 First operand
190 | * @param op2 Second operand
191 | * @return Result
192 | */
193 | public static double preformIndicatedOperation011(String operation, double op1, double op2) {
194 | // TODO: Write code here
195 | return 0;
196 | }
197 |
198 | /**
199 | * Exercise 012 - Find Factors
200 | * Find all of the factors for a given positive integer (int). The result needs to be sorted in ascending order.
201 | *
202 | * LEVEL: EASY
203 | *
204 | * @param num The number to be factored
205 | * @return An Integer ArrayList of factors of num.
206 | */
207 | public static ArrayList findFactors012(int num) {
208 | // TODO: Write code here
209 | return null;
210 | }
211 |
212 | /**
213 | * Exercise 013 - Get Nearest Integer to Real Sum
214 | * Given a two double parameters, return the nearest integer sum. If a number is half-way between to integers,
215 | * round up for positive sums and down for negative sums.
216 | *
217 | * LEVEL: EASY
218 | *
219 | * @param firstRealAddend First real number
220 | * @param secondRealAddend Second real number
221 | * @return Integer sum
222 | */
223 | public static int getNearestIntegerToRealSum013(double firstRealAddend, double secondRealAddend ) {
224 | // TODO: Write code here
225 | return 0;
226 | }
227 |
228 | /**
229 | * Exercise 014 - Is it a number
230 | * Given a string s, write a method (function) that will return true if its a valid single integer or floating
231 | * point number or false if its not.
232 | *
233 | * LEVEL: EASY
234 | *
235 | * Valid examples, should return true:
236 | * isDigit("3")
237 | * isDigit(" 3 ")
238 | * isDigit("-3.23")
239 | *
240 | * should return false:
241 | * isDigit("3-4")
242 | * isDigit(" 3 5")
243 | * isDigit("3 5")
244 | * isDigit("zero")
245 | *
246 | * @param stringToTest
247 | * @return True if number, false if not.
248 | */
249 | public static boolean isNumber014(String stringToTest) {
250 | return false;
251 | }
252 |
253 | /**
254 | * Exercise 015 - Find Two Addends
255 | * Given a primitive array of integers and a number n, return whether any two numbers from the array add up to
256 | * equal n.
257 | *
258 | * For example, given [7, 15, 3, 6, 8] and n equal to 13, return true since 7 + 6 is 13.
259 | *
260 | * LEVEL: EASY
261 | *
262 | * @param nums
263 | * @param n
264 | * @return
265 | */
266 | public static boolean findTwoAddends015(int[] nums, int n) {
267 | // TODO: Write code here
268 | return false;
269 | }
270 |
271 | /**
272 | * Exercise 016 - Count Inversions
273 | * This problem was asked by Google.
274 | *
275 | * We can determine how "out of order" an array A is by counting the number of inversions it has. Two elements
276 | * A[i] and A[j] form an inversion if A[i] > A[j] but i < j. That is, a smaller element appears after a larger
277 | * element.
278 | *
279 | * Given an array, count the number of inversions it has. Do this faster than O(N^2) time.
280 | *
281 | * You may assume each element in the array is distinct.
282 | *
283 | * For example, a sorted list has zero inversions. The array [2, 4, 1, 3, 5] has three inversions: (2, 1), (4, 1),
284 | * and (4, 3). The array [5, 4, 3, 2, 1] has ten inversions: every distinct pair forms an inversion.
285 | *
286 | * LEVEL: EASY
287 | *
288 | * @param nums An array of integers
289 | * @return The number of inversions in the array.
290 | */
291 | public static int countInversionsInArray016(int[] nums) {
292 | // TODO: Write code here
293 | return 0;
294 | }
295 |
296 | /**
297 | * Exercise 041 - Multiply Elements of a List
298 | * Given an array of integers, return a new array such that each element at index i of the new array is the product
299 | * of all the numbers in the original array except the one at i.
300 | *
301 | * For example, if our input was [1, 2, 3, 4, 5], the expected output would be [120, 60, 40, 30, 24]. If our input
302 | * was [3, 2, 1], the expected output would be [2, 3, 6].
303 | *
304 | * LEVEL: INTERMEDIATE
305 | *
306 | * @param iList An array of integers
307 | * @return An array of products of integers
308 | * @throws Exception Invalid input should throw an exception
309 | */
310 | public static List multiplyElementsOfList041(List iList) throws Exception {
311 | // TODO: Write code here
312 | return null;
313 | }
314 |
315 | /**
316 | * Exercise 071 - Find Factors Efficiently
317 | * Find all of the factors for a given integer (int). The integer could be negative. The result needs to be sorted
318 | * in ascending order.
319 | *
320 | * The solution must be able to find the factors for 2080046 in less than 200000 nano-seconds. (ms/1000000).
321 | *
322 | * LEVEL: DIFFICULT
323 | *
324 | * @param num The number to be factored
325 | * @return An Integer ArrayList of factors of num.
326 | */
327 | public static ArrayList findFactorsEfficiently071(int num) {
328 | // TODO: Write code here
329 | return null;
330 | }
331 |
332 | /**
333 | * Exercise 072 - Roman numeral conversion
334 | * Given a roman numeral in a string, convert it to an integer (int). Do not worry about any roman digits past
335 | * M (1000).
336 | *
337 | * I = 1
338 | * V = 5
339 | * X = 10
340 | * L = 50
341 | * C = 100
342 | * D = 500
343 | * M = 1000
344 | *
345 | * LEVEL: DIFFICULT
346 | *
347 | * @param romanNumeral The roman numeral to convert
348 | * @return The equivalent integer
349 | */
350 | public static int convertRomanNumeral072(String romanNumeral) {
351 | return 0;
352 | }
353 | }
354 |
--------------------------------------------------------------------------------
/src/Java101ExerciseTest.java:
--------------------------------------------------------------------------------
1 | import org.junit.Test;
2 |
3 | import java.util.ArrayList;
4 | import java.util.List;
5 |
6 | import static org.junit.Assert.*;
7 | import static org.junit.Assert.assertEquals;
8 |
9 | public class Java101ExerciseTest {
10 | private ArrayList testList;
11 |
12 | @Test
13 | public void exercise001Test() {
14 | assertEquals("Java101Exercises.addInts001(3, 4) failed", 7, Java101Exercises.addInts001(3, 4));
15 | assertEquals("Java101Exercises.addInts001(-8, 3) failed", -5, Java101Exercises.addInts001(-8, 3));
16 | }
17 |
18 | @Test
19 | public void exercise002Test() {
20 | assertEquals("Java101Exercises.sayHello002(\"James\") failed", "Hello James!", Java101Exercises.sayHello002("James"));
21 | assertEquals("Java101Exercises.sayHello002(\"Miguel\") failed", "Hello Miguel!", Java101Exercises.sayHello002("Miguel"));
22 | assertEquals("Java101Exercises.sayHello002(\"\") failed", "Hello !", Java101Exercises.sayHello002(""));
23 | assertEquals("Java101Exercises.sayHello002(null) failed", "Hello null!", Java101Exercises.sayHello002(null));
24 | }
25 |
26 | @Test
27 | public void exercise003Test() {
28 | String[] codeup = Java101Exercises.sayCodeup003();
29 | assertEquals("Java101Exercises.sayCodeup003() failed on test 01",
30 | "* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *",
31 | codeup[0].trim());
32 | assertEquals("Java101Exercises.sayCodeup003() failed on test 02",
33 | "* * * * * * * * * * *",
34 | codeup[1].trim());
35 | assertEquals("Java101Exercises.sayCodeup003() failed on test 03",
36 | "* * * * * * * * * * *",
37 | codeup[2].trim());
38 | assertEquals("Java101Exercises.sayCodeup003() failed on test 04",
39 | "* * * * * * * * * *",
40 | codeup[3].trim());
41 | assertEquals("Java101Exercises.sayCodeup003() failed on test 05",
42 | "* * * * * * * * * * * * * * * * * * * *",
43 | codeup[4].trim());
44 | assertEquals("Java101Exercises.sayCodeup003() failed on test 06",
45 | "* * * * * * * * *",
46 | codeup[5].trim());
47 | assertEquals("Java101Exercises.sayCodeup003() failed on test 07",
48 | "* * * * * * * * * *",
49 | codeup[6].trim());
50 | assertEquals("Java101Exercises.sayCodeup003() failed on test 08",
51 | "* * * * * * * * * *",
52 | codeup[7].trim());
53 | assertEquals("Java101Exercises.sayCodeup003() failed on test 09",
54 | "* * * * * * * * * * * * * * * * * * * * * * * * * *",
55 | codeup[8].trim());
56 | }
57 |
58 | @Test
59 | public void exercise004Test() {
60 | assertEquals("Java101Exercises.addDouble004(3.5, 4.7) failed",
61 | 8.2, Java101Exercises.addDouble004(3.5, 4.7), 0.000001);
62 | assertEquals("Java101Exercises.addDouble004(-8.2, 3.7) failed",
63 | -4.6, Java101Exercises.addDouble004(-8.3, 3.7), 0.000001);
64 | }
65 |
66 | @Test
67 | public void exercise005Test() {
68 | assertTrue("Java101Exercises.concatenateStrings005(\"Marilyn\", \"Monre\") failed",
69 | "Marilyn Monre".equals(Java101Exercises.concatenateStrings005("Marilyn", "Monre")));
70 | assertTrue("Java101Exercises.concatenateStrings005(\"Henry\", \"Ford\") failed",
71 | "Henry Ford".equals(Java101Exercises.concatenateStrings005("Henry", "Ford")));
72 | }
73 |
74 | @Test
75 | public void exercise006Test() {
76 | assertFalse("Java101Exercises.isEqual006(9, 7) failed",
77 | Java101Exercises.isEqual006(9, 7));
78 | assertTrue("Java101Exercises.isEqual006(7, 7) failed",
79 | Java101Exercises.isEqual006(7, 7));
80 | }
81 |
82 | @Test
83 | public void exercise007Test() {
84 | assertTrue("Java101Exercises.isGreaterThan007(9.3, 7.4) failed",
85 | Java101Exercises.isGreaterThan007(9.3, 7.4));
86 | assertFalse("Java101Exercises.isGreaterThan007(3.14, 3.14) failed",
87 | Java101Exercises.isGreaterThan007(3.14, 3.14));
88 | assertFalse("Java101Exercises.isGreaterThan007(3.14, 9.14) failed",
89 | Java101Exercises.isGreaterThan007(3.14, 9.14));
90 | }
91 |
92 | @Test
93 | public void exercise008Test() {
94 | assertEquals("Java101Exercises.cube008(9.3) failed", 64.0,
95 | Java101Exercises.cube008(4), 0.000001);
96 | assertEquals("Java101Exercises.cube008(2) failed", 8.0,
97 | Java101Exercises.cube008(2), 0.000001);
98 | assertEquals("Java101Exercises.cube008(-5) failed", -125.0,
99 | Java101Exercises.cube008(-5), 0.000001);
100 | }
101 |
102 | @Test
103 | public void exercise009Test() {
104 | assertEquals("Java101Exercises.calcPositiveDifference009(4, 10) failed", 6,
105 | Java101Exercises.calcPositiveDifference009(4, 10));
106 | assertEquals("Java101Exercises.calcPositiveDifference009(-2, 17) failed", 19,
107 | Java101Exercises.calcPositiveDifference009(-2, 17));
108 | assertEquals("Java101Exercises.calcPositiveDifference009(-5, -28) failed", 23,
109 | Java101Exercises.calcPositiveDifference009(-5, -28));
110 | }
111 |
112 | @Test
113 | public void exercise010Test() {
114 | assertEquals("Java101Exercises.calcRemainder010(10, 4) failed", 2,
115 | Java101Exercises.calcRemainder010(10, 4));
116 | assertEquals("Java101Exercises.calcRemainder010(64, -8) failed", 0,
117 | Java101Exercises.calcRemainder010(64, -8));
118 | assertEquals("Java101Exercises.calcRemainder010(-5, -28) failed", 5,
119 | Java101Exercises.calcRemainder010(5, 28));
120 | }
121 |
122 | @Test
123 | public void exercise011Test() {
124 | assertEquals("exercise011Test failed test 01.",7.0, Java101Exercises.preformIndicatedOperation011("ADD",3, 4), 0.00001);
125 | assertEquals("exercise011Test failed test 02.",-1.0, Java101Exercises.preformIndicatedOperation011("SUB",3, 4), 0.00001);
126 | assertEquals("exercise011Test failed test 03.",12.0, Java101Exercises.preformIndicatedOperation011("MUL",3, 4), 0.00001);
127 | assertEquals("exercise011Test failed test 04.",0.75, Java101Exercises.preformIndicatedOperation011("DIV",3, 4), 0.00001);
128 |
129 | assertEquals("exercise011Test failed test 05.",-5.0, Java101Exercises.preformIndicatedOperation011("ADD",-8, 3), 0.00001);
130 | assertEquals("exercise011Test failed test 06.",-11.0, Java101Exercises.preformIndicatedOperation011("SUB",-8, 3), 0.00001);
131 | assertEquals("exercise011Test failed test 07.",-24.0, Java101Exercises.preformIndicatedOperation011("MUL",-8, 3), 0.00001);
132 | assertEquals("exercise011Test failed test 08.",-2.666666, Java101Exercises.preformIndicatedOperation011("DIV",-8, 3), 0.00001);
133 |
134 | assertEquals("exercise011Test failed test 09.",0.0, Java101Exercises.preformIndicatedOperation011("MIN",-8, 3), 0.00001);
135 | }
136 |
137 | @Test
138 | public void exercise012Test() {
139 |
140 | // test 1
141 | testList = Java101Exercises.findFactors012(1);
142 | assert(testList != null);
143 | assertEquals(1, (long)testList.size());
144 | assertEquals(1, (long)testList.get(0));
145 |
146 | // test 2
147 | testList = Java101Exercises.findFactors012(2);
148 | assert(testList != null);
149 | assertEquals(2, (long)testList.size());
150 | assertEquals(1, (long)testList.get(0));
151 | assertEquals(2, (long)testList.get(1));
152 |
153 | // test 3
154 | testList = Java101Exercises.findFactors012(3);
155 | assert(testList != null);
156 | assertEquals(2, (long)testList.size());
157 | assertEquals(1, (long)testList.get(0));
158 | assertEquals(3, (long)testList.get(1));
159 |
160 | // test 9
161 | testList = Java101Exercises.findFactors012(9);
162 | assert(testList != null);
163 | assertEquals(3, (long)testList.size(), 3);
164 | assertEquals(1, (long)testList.get(0), 1);
165 | assertEquals(3, (long)testList.get(1), 3);
166 | assertEquals(9, (long)testList.get(2), 9);
167 |
168 | // test 8
169 | testList = Java101Exercises.findFactors012(8);
170 | assert(testList != null);
171 | assertEquals(4, (long)testList.size());
172 | assertEquals(1, (long)testList.get(0));
173 | assertEquals(2, (long)testList.get(1));
174 | assertEquals(4, (long)testList.get(2));
175 | assertEquals(8, (long)testList.get(3));
176 |
177 | // test 125
178 | testList = Java101Exercises.findFactors012(125);
179 | assert(testList != null);
180 | assertEquals(4, (long)testList.size());
181 | assertEquals(1, (long)testList.get(0));
182 | assertEquals(5, (long)testList.get(1));
183 | assertEquals(25, (long)testList.get(2));
184 | assertEquals(125, (long)testList.get(3));
185 |
186 | // test 2080046
187 | testList = Java101Exercises.findFactors012(2080046);
188 | assert(testList != null);
189 | // [1, 2, 359, 718, 2897, 5794, 1040023, 2080046]
190 | assertEquals(8, (long)testList.size());
191 | assertEquals(1, (long)testList.get(0));
192 | assertEquals(359, (long)testList.get(2));
193 | assertEquals(5794, (long)testList.get(5));
194 | assertEquals(2080046, (long)testList.get(7));
195 | }
196 |
197 | @Test
198 | public void exercise013Test() {
199 | double p1 = 0.4;
200 | double p2 = 0.3;
201 | assertEquals("exercise003 Test failed test 01.", 1, Java101Exercises.getNearestIntegerToRealSum013(p1, p2));
202 | assertEquals("exercise003 Test failed test 02.", 0, Java101Exercises.getNearestIntegerToRealSum013(p1, -p2));
203 | assertEquals("exercise003 Test failed test 03.", -1, Java101Exercises.getNearestIntegerToRealSum013(-p1, -p2));
204 |
205 | p1 = -3.2;
206 | p2 = -2.3;
207 | assertEquals("exercise003 Test failed test 04.", -6, Java101Exercises.getNearestIntegerToRealSum013(p1, p2));
208 | assertEquals("exercise003 Test failed test 05.", -1, Java101Exercises.getNearestIntegerToRealSum013(p1, -p2));
209 | assertEquals("exercise003 Test failed test 06.", 6, Java101Exercises.getNearestIntegerToRealSum013(-p1, -p2));
210 |
211 | p1 = 13.8;
212 | p2 = -17.3;
213 | assertEquals("exercise003 Test failed test 07.", -4, Java101Exercises.getNearestIntegerToRealSum013(p1, p2));
214 | assertEquals("exercise003 Test failed test 08.", 31, Java101Exercises.getNearestIntegerToRealSum013(p1, -p2));
215 | assertEquals("exercise003 Test failed test 09.", 4, Java101Exercises.getNearestIntegerToRealSum013(-p1, -p2));
216 | }
217 |
218 | @Test
219 | public void exercise014Test() {
220 | // int test
221 | assertEquals("Java101Exercises.isNumber014(\"3\") Failed", true,
222 | Java101Exercises.isNumber014("3"));
223 | assertEquals("Java101Exercises.isNumber014(\" +3 \") Failed", true,
224 | Java101Exercises.isNumber014(" +3 "));
225 | assertEquals("Java101Exercises.isNumber014(\" -3\") Failed", true,
226 | Java101Exercises.isNumber014(" -3"));
227 | assertEquals("Java101Exercises.isNumber014(\"0\") Failed", true,
228 | Java101Exercises.isNumber014("0"));
229 |
230 | // real test
231 | assertEquals("Java101Exercises.isNumber014(\"3.14159\") Failed", true,
232 | Java101Exercises.isNumber014("3.14159"));
233 | assertEquals("Java101Exercises.isNumber014(\" -3.14159 \") Failed", true,
234 | Java101Exercises.isNumber014(" -3.14159 "));
235 | assertEquals("Java101Exercises.isNumber014(\" +3.14159 \") Failed", true,
236 | Java101Exercises.isNumber014(" +3.14159 "));
237 | assertEquals("Java101Exercises.isNumber014(\"0.0\") Failed", true,
238 | Java101Exercises.isNumber014("0.0"));
239 |
240 | // random test
241 | for (int i = 1; i < 10; i++) {
242 | double x = (Math.random() * 201) - 100;
243 | long l = (long) x;
244 | String ds = Double.toString(x);
245 | String ls = Long.toString(l);
246 | assertEquals("Java101Exercises.isNumber014(\"" + ds + "\") Failed", true,
247 | Java101Exercises.isNumber014(ds));
248 | assertEquals("Java101Exercises.isNumber014(\"" + ls + "\") Failed", true,
249 | Java101Exercises.isNumber014(ls));
250 | }
251 |
252 | // non-numeric test
253 | assertEquals("Java101Exercises.isNumber014(\"is not a number\") Failed", false,
254 | Java101Exercises.isNumber014("is not a number"));
255 | assertEquals("Java101Exercises.isNumber014(\"3 .14159\") Failed", false,
256 | Java101Exercises.isNumber014("3 .14159"));
257 | assertEquals("Java101Exercises.isNumber014(\"+ 3.14159\") Failed", false,
258 | Java101Exercises.isNumber014("+ 3.14159"));
259 | assertEquals("Java101Exercises.isNumber014(\"3.141.59\") Failed", false,
260 | Java101Exercises.isNumber014("3.141.59"));
261 | assertEquals("Java101Exercises.isNumber014(\"\") Failed", false,
262 | Java101Exercises.isNumber014(""));
263 | assertEquals("Java101Exercises.isNumber014(\"zero\") Failed", false,
264 | Java101Exercises.isNumber014("zero"));
265 | }
266 |
267 | @Test
268 | public void exercise015Test() {
269 | int[] nums = {7, 15, 3, 6, 8};
270 | assertEquals("findTwoAddends015 failed test 01.", true, Java101Exercises.findTwoAddends015(nums, 13));
271 | assertEquals("findTwoAddends015 failed test 02.", false, Java101Exercises.findTwoAddends015(nums, 25));
272 |
273 | nums = new int[]{-3, 14, -7, 5, 19};
274 | assertEquals("findTwoAddends015 failed test 03.", true, Java101Exercises.findTwoAddends015(nums, -2));
275 | assertEquals("findTwoAddends015 failed test 04.", false, Java101Exercises.findTwoAddends015(nums, 13));
276 |
277 | nums = new int[]{2, 4, 6, 8, -10};
278 | assertEquals("findTwoAddends015 failed test 05.", true, Java101Exercises.findTwoAddends015(nums, 10));
279 | assertEquals("findTwoAddends015 failed test 06.", false, Java101Exercises.findTwoAddends015(nums, 11));
280 |
281 | nums = null;
282 | assertEquals("findTwoAddends015 failed test 07.", false, Java101Exercises.findTwoAddends015(nums, 25));
283 |
284 | nums = new int[1];
285 | assertEquals("findTwoAddends015 failed test 08.", false, Java101Exercises.findTwoAddends015(nums, 25));
286 | }
287 |
288 | @Test
289 | public void exercise016Test() {
290 | int[] nums = {7, 15, 3, 6, 8};
291 | assertEquals("countInversionsInArray016 failed test 01.", 5, Java101Exercises.countInversionsInArray016(nums));
292 |
293 | nums = new int[]{-3, 14, -7, 5, 19};
294 | assertEquals("countInversionsInArray016 failed test 02.", 3, Java101Exercises.countInversionsInArray016(nums));
295 |
296 | nums = new int[]{2, 4, 6, 8, -10};
297 | assertEquals("countInversionsInArray016 failed test 03.", 4, Java101Exercises.countInversionsInArray016(nums));
298 |
299 | nums = new int[]{2, 4, 6, 8, 10};
300 | assertEquals("countInversionsInArray016 failed test 04.", 0, Java101Exercises.countInversionsInArray016(nums));
301 |
302 | nums = new int[]{10, 8, 6, 4, 2};
303 | assertEquals("countInversionsInArray016 failed test 05.", 10, Java101Exercises.countInversionsInArray016(nums));
304 |
305 | nums = null;
306 | assertEquals("countInversionsInArray016 failed test 06.", 0, Java101Exercises.countInversionsInArray016(nums));
307 |
308 | nums = new int[1];
309 | assertEquals("countInversionsInArray016 failed test 07.", 0, Java101Exercises.countInversionsInArray016(nums));
310 | }
311 |
312 | @Test
313 | public void exercise041Test() {
314 | ArrayList input = new ArrayList();
315 | input.add(1);
316 | input.add(2);
317 | input.add(3);
318 | input.add(4);
319 | input.add(5);
320 |
321 | ArrayList expected = new ArrayList();
322 | expected.add(120);
323 | expected.add(60);
324 | expected.add(40);
325 | expected.add(30);
326 | expected.add(24);
327 |
328 | List results;
329 | try {
330 | results = Java101Exercises.multiplyElementsOfList041(input);
331 | assertTrue("exercise041Test failed test 01.", expected.equals(results));
332 | } catch (Exception e) {
333 | fail("exercise041Test threw an unexpected exception on test 01");
334 | }
335 |
336 | input.clear();
337 | input.add(7);
338 | input.add(-4);
339 | input.add(6);
340 | input.add(-3);
341 | input.add(5);
342 |
343 | expected.clear();
344 | expected.add(360);
345 | expected.add(-630);
346 | expected.add(420);
347 | expected.add(-840);
348 | expected.add(504);
349 |
350 | try {
351 | results = Java101Exercises.multiplyElementsOfList041(input);
352 | assertTrue("exercise041Test failed test 02.", expected.equals(results));
353 | } catch (Exception e) {
354 | fail("exercise041Test threw an unexpected exception on test 02");
355 | }
356 |
357 | try {
358 | input.clear();
359 | results = Java101Exercises.multiplyElementsOfList041(input);
360 | fail("exercise041Test did not throw an expected exception on test 03");
361 | } catch (Exception e) {
362 | // Past test, no action required
363 | }
364 |
365 | try {
366 | results = Java101Exercises.multiplyElementsOfList041(null);
367 | fail("exercise041Test did not throw an expected exception on test 04");
368 | } catch (Exception e) {
369 | // Past test, no action required
370 | }
371 | }
372 |
373 | @Test
374 | public void exercise071Test() {
375 |
376 | // test 1
377 | testList = Java101Exercises.findFactorsEfficiently071(1);
378 | assert(testList != null);
379 | assertEquals(1, (long)testList.size());
380 | assertEquals(1, (long)testList.get(0));
381 |
382 | // test 2
383 | testList = Java101Exercises.findFactorsEfficiently071(2);
384 | assert(testList != null);
385 | assertEquals(2, (long)testList.size());
386 | assertEquals(1, (long)testList.get(0));
387 | assertEquals(2, (long)testList.get(1));
388 |
389 | // test 3
390 | testList = Java101Exercises.findFactorsEfficiently071(3);
391 | assert(testList != null);
392 | assertEquals(2, (long)testList.size());
393 | assertEquals(1, (long)testList.get(0));
394 | assertEquals(3, (long)testList.get(1));
395 |
396 | // test -3
397 | testList = Java101Exercises.findFactorsEfficiently071(-3);
398 | assert(testList != null);
399 | assertEquals(4, (long)testList.size());
400 | assertEquals(-3, (long)testList.get(0));
401 | assertEquals(-1, (long)testList.get(1));
402 | assertEquals(1, (long)testList.get(2));
403 | assertEquals(3, (long)testList.get(3));
404 |
405 | // test 9
406 | testList = Java101Exercises.findFactorsEfficiently071(9);
407 | assert(testList != null);
408 | assertEquals(3, (long)testList.size(), 3);
409 | assertEquals(1, (long)testList.get(0), 1);
410 | assertEquals(3, (long)testList.get(1), 3);
411 | assertEquals(9, (long)testList.get(2), 9);
412 |
413 | // test 8
414 | testList = Java101Exercises.findFactorsEfficiently071(8);
415 | assert(testList != null);
416 | assertEquals(4, (long)testList.size());
417 | assertEquals(1, (long)testList.get(0));
418 | assertEquals(2, (long)testList.get(1));
419 | assertEquals(4, (long)testList.get(2));
420 | assertEquals(8, (long)testList.get(3));
421 |
422 | // test 125
423 | testList = Java101Exercises.findFactorsEfficiently071(125);
424 | assert(testList != null);
425 | assertEquals(4, (long)testList.size());
426 | assertEquals(1, (long)testList.get(0));
427 | assertEquals(5, (long)testList.get(1));
428 | assertEquals(25, (long)testList.get(2));
429 | assertEquals(125, (long)testList.get(3));
430 |
431 | // test -125
432 | testList = Java101Exercises.findFactorsEfficiently071(-125);
433 | assert(testList != null);
434 | assertEquals(8, (long)testList.size());
435 | assertEquals(-125, (long)testList.get(0));
436 | assertEquals(-5, (long)testList.get(2));
437 | assertEquals(5, (long)testList.get(5));
438 | assertEquals(125, (long)testList.get(7));
439 |
440 | // test 2080046
441 | // also test time
442 | long startTime = System.nanoTime();
443 | testList = Java101Exercises.findFactorsEfficiently071(2080046);
444 | assert(testList != null);
445 | long endTime = System.nanoTime();
446 | long duration = (endTime - startTime);
447 | assertTrue("The algorithm takes too long to complete", duration < 200000);
448 |
449 | // [1, 2, 359, 718, 2897, 5794, 1040023, 2080046]
450 | assertEquals(8, (long)testList.size());
451 | assertEquals(1, (long)testList.get(0));
452 | assertEquals(359, (long)testList.get(2));
453 | assertEquals(5794, (long)testList.get(5));
454 | assertEquals(2080046, (long)testList.get(7));
455 | }
456 |
457 | @Test
458 | public void convertRomanNumeral072Test() {
459 | assertEquals("Java101Exercises.convertRomanNumeral072(\"I\") Failed", 1, Java101Exercises.convertRomanNumeral072("I"));
460 | assertEquals("Java101Exercises.convertRomanNumeral072(\"MCMXXLIV\") Failed", 1976, Java101Exercises.convertRomanNumeral072("MCMLXXVI"));
461 | assertEquals("Java101Exercises.convertRomanNumeral072(\"MDCCXII\") Failed", 1492, Java101Exercises.convertRomanNumeral072("MCDXCII"));
462 | assertEquals("Java101Exercises.convertRomanNumeral072(\"CC\") Failed", 200, Java101Exercises.convertRomanNumeral072("CC"));
463 | assertEquals("Java101Exercises.convertRomanNumeral072(\"MCCCDXXXIV\") Failed", 1836, Java101Exercises.convertRomanNumeral072("MDCCCXXXVI"));
464 | assertEquals("Java101Exercises.convertRomanNumeral072(\"MMCCXXII\") Failed", 2222, Java101Exercises.convertRomanNumeral072("MMCCXXII"));
465 | assertEquals("Java101Exercises.convertRomanNumeral072(\"MMI\") Failed", 2001, Java101Exercises.convertRomanNumeral072("MMI"));
466 | assertEquals("Java101Exercises.convertRomanNumeral072(\"MCM\") Failed", 1900, Java101Exercises.convertRomanNumeral072("MCM"));
467 | assertEquals("Java101Exercises.convertRomanNumeral072(\"CD\") Failed", 400, Java101Exercises.convertRomanNumeral072("CD"));
468 | assertEquals("Java101Exercises.convertRomanNumeral072(\"DC\") Failed", 600, Java101Exercises.convertRomanNumeral072("DC"));
469 | assertEquals("Java101Exercises.convertRomanNumeral072(\"CXC\") Failed", 190, Java101Exercises.convertRomanNumeral072("CXC"));
470 | assertEquals("Java101Exercises.convertRomanNumeral072(\"XL\") Failed", 40, Java101Exercises.convertRomanNumeral072("XL"));
471 | assertEquals("Java101Exercises.convertRomanNumeral072(\"LX\") Failed", 60, Java101Exercises.convertRomanNumeral072("LX"));
472 | assertEquals("Java101Exercises.convertRomanNumeral072(\"IX\") Failed", 9, Java101Exercises.convertRomanNumeral072("IX"));
473 | assertEquals("Java101Exercises.convertRomanNumeral072(\"XI\") Failed", 11, Java101Exercises.convertRomanNumeral072("XI"));
474 | assertEquals("Java101Exercises.convertRomanNumeral072(\"IV\") Failed", 4, Java101Exercises.convertRomanNumeral072("IV"));
475 | assertEquals("Java101Exercises.convertRomanNumeral072(\"VI\") Failed", 6, Java101Exercises.convertRomanNumeral072("VI"));
476 | }
477 | }
478 |
--------------------------------------------------------------------------------