Skip to content

Commit 3aeba10

Browse files
ardallieardallie
authored
Merge pull request ardallie#2 from ardallie/easy
Easy challenges - part 2
2 parents 63a3246 + 9b775de commit 3aeba10

23 files changed

+1058
-0
lines changed

‎README.md

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,9 @@
1+
## Coderbyte challenges in Java.
2+
3+
This repository contains a collection of code challenges from Coderbyte.com.
4+
5+
Solutions are grouped into three difficulty levels:
6+
7+
- easy
8+
- medium
9+
- hard

‎src/easy/LetterCapitalize.java

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
package easy;
2+
3+
/**
4+
* Have the function LetterCapitalize(str) take the str parameter
5+
* being passed and capitalize the first letter of each word.
6+
* Words will be separated by only one space.
7+
*/
8+
public class LetterCapitalize {
9+
10+
/**
11+
* Letter Capitalize function.
12+
*
13+
* @param str input string
14+
* @return string with the letters capitalised
15+
*/
16+
private static String letterCapitalize(String str) {
17+
String[] splitWords = str.split(" ");
18+
for (int i = 0; i < splitWords.length; i++) {
19+
String word = splitWords[i];
20+
splitWords[i] = word.substring(0, 1).toUpperCase() + word.substring(1);
21+
}
22+
return String.join(" ", splitWords);
23+
}
24+
25+
/**
26+
* Entry point.
27+
*
28+
* @param args command line arguments
29+
*/
30+
public static void main(String[] args) {
31+
var result1 = letterCapitalize("The soul becomes dyed with the color of its thoughts.");
32+
System.out.println(result1);
33+
var result2 = letterCapitalize("The universe is change; our life is what our thoughts make it.");
34+
System.out.println(result2);
35+
}
36+
37+
}

‎src/easy/LetterChanges.java

Lines changed: 54 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,54 @@
1+
package easy;
2+
3+
/**
4+
* Have the function LetterChanges(str) take the str parameter
5+
* being passed and modify it using the following algorithm.
6+
* Replace every letter in the string with the letter
7+
* following it in the alphabet (i.e. c becomes d, z becomes a).
8+
* Then capitalize every vowel in this new string (a-e-i-o-u)
9+
* and finally return this modified string.
10+
*/
11+
public class LetterChanges {
12+
13+
14+
/**
15+
* Letter Changes function.
16+
*
17+
* @param str input string
18+
* @return modified string
19+
*/
20+
private static String letterChanges(String str) {
21+
22+
char[] alphabet = {'b', 'c', 'd', 'E', 'f', 'g', 'h', 'I', 'j', 'k', 'l',
23+
'm', 'n', 'O', 'p', 'q', 'r', 's', 't', 'U', 'v', 'w', 'x', 'y', 'z', 'A'};
24+
char[] charArray = str.toLowerCase().toCharArray();
25+
StringBuilder output = new StringBuilder();
26+
27+
for (int i = 0; i < str.length(); i++) {
28+
char letter = str.charAt(i);
29+
boolean isLetter = letter >= 'a' && letter <= 'z';
30+
if (isLetter) {
31+
output.append(alphabet[charArray[i] - 97]);
32+
} else {
33+
output.append(letter);
34+
}
35+
}
36+
37+
return output.toString();
38+
}
39+
40+
/**
41+
* Entry point.
42+
*
43+
* @param args command line arguments
44+
*/
45+
public static void main(String[] args) {
46+
var result1 = letterChanges("anthology");
47+
System.out.println(result1);
48+
var result2 = letterChanges("equilibrium");
49+
System.out.println(result2);
50+
var result3 = letterChanges("oxford");
51+
System.out.println(result3);
52+
}
53+
54+
}

‎src/easy/MeanMode.java

Lines changed: 65 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,65 @@
1+
package easy;
2+
3+
import java.util.HashMap;
4+
import java.util.Map;
5+
6+
/**
7+
* Have the function MeanMode(arr) take the array of numbers stored in arr
8+
* and return 1 if the mode equals the mean, 0 if they don't equal each other
9+
* (i.e. [5, 3, 3, 3, 1] should return 1 because the mode (3) equals the mean (3)).
10+
* The array will not be empty, will only contain positive integers,
11+
* and will not contain more than one mode.
12+
*/
13+
public class MeanMode {
14+
15+
/**
16+
* Mean Mode function.
17+
*
18+
* @param arr input array.
19+
* @return 1 if the mode equals the mean, 0 if they don't equal each other
20+
*/
21+
private static String meanMode(int[] arr) {
22+
int sum = 0;
23+
int modeKey = 0;
24+
int modeVal = 0;
25+
26+
Map<Integer, Integer> modeMap = new HashMap<>();
27+
for (int item : arr) {
28+
modeMap.put(item, 0);
29+
}
30+
31+
for (int value : arr) {
32+
sum += value;
33+
int val = modeMap.get(value);
34+
if (val > 0) {
35+
modeMap.put(value, val + 1);
36+
} else {
37+
modeMap.put(value, 1);
38+
}
39+
}
40+
41+
for (Map.Entry<Integer, Integer> item : modeMap.entrySet()) {
42+
int itemKey = item.getKey();
43+
int itemVal = item.getValue();
44+
if (itemVal > modeVal) {
45+
modeVal = itemVal;
46+
modeKey = itemKey;
47+
}
48+
}
49+
50+
return modeKey == (sum / arr.length) ? "1" : "0";
51+
}
52+
53+
/**
54+
* Entry point.
55+
*
56+
* @param args command line arguments
57+
*/
58+
public static void main(String[] args) {
59+
var result1 = meanMode(new int[]{5, 3, 3, 3, 1});
60+
System.out.println(result1);
61+
var result2 = meanMode(new int[]{64, 64, 64, 64, 64, 64, 64, 64, 1024});
62+
System.out.println(result2);
63+
}
64+
65+
}

‎src/easy/MultiplicativePersistence.java

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
1+
package easy;
2+
3+
/**
4+
* Have the function MultiplicativePersistence(num) take the num parameter being passed
5+
* which will always be a positive integer
6+
* and return its multiplicative persistence which is
7+
* the number of times you must multiply the digits in num until you reach a single digit.
8+
* ---
9+
* For example: if num is 39 then your program
10+
* should return 3 because 3 * 9 = 27 then 2 * 7 = 14
11+
* and finally 1 * 4 = 4 then you stop at 4.
12+
*/
13+
public class MultiplicativePersistence {
14+
15+
/**
16+
* Multiplicative Persistence function.
17+
*
18+
* @param num input number
19+
* @return the number of times you must multiply
20+
*/
21+
private static int multiplicativePersistence(int num) {
22+
int times = 0;
23+
int multiplied = num;
24+
while (multiplied > 9) {
25+
int product = 1;
26+
String[] intArr = Integer.toString(multiplied).split("");
27+
for (String i : intArr) {
28+
product *= Integer.parseInt(i);
29+
}
30+
multiplied = product;
31+
times++;
32+
}
33+
return times;
34+
}
35+
36+
/**
37+
* Entry point.
38+
*
39+
* @param args command line arguments
40+
*/
41+
public static void main(String[] args) {
42+
var result1 = multiplicativePersistence(2677889);
43+
System.out.println(result1);
44+
var result2 = multiplicativePersistence(8192);
45+
System.out.println(result2);
46+
}
47+
48+
}

‎src/easy/NonrepeatingCharacter.java

Lines changed: 54 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,54 @@
1+
package easy;
2+
3+
import java.util.HashMap;
4+
5+
/**
6+
* Have the function NonrepeatingCharacter(str)
7+
* take the str parameter being passed,
8+
* which will contain only alphabetic characters and spaces,
9+
* and return the first non-repeating character.
10+
* ---
11+
* For example: if str is "agettkgaeee" then your program should return k.
12+
* The string will always contain at least one character and there will
13+
* always be at least one non-repeating character.
14+
*/
15+
public class NonrepeatingCharacter {
16+
17+
/**
18+
* Non-repeating Character function.
19+
*
20+
* @param str input string
21+
* @return the first non-repeating character
22+
*/
23+
private static String nonrepeatingCharacter(String str) {
24+
25+
char[] charArr = str.toLowerCase().toCharArray();
26+
HashMap<Integer, Integer> freq = new HashMap<>();
27+
28+
for (int c : charArr) {
29+
Integer count = freq.get(c);
30+
freq.put(c, count == null ? 1 : ++count);
31+
}
32+
33+
for (int c : charArr) {
34+
Integer count = freq.get(c);
35+
if (count == 1) {
36+
return String.valueOf((char) c);
37+
}
38+
}
39+
return "false";
40+
}
41+
42+
/**
43+
* Entry point.
44+
*
45+
* @param args command line arguments
46+
*/
47+
public static void main(String[] args) {
48+
var res1 = nonrepeatingCharacter("Beauty in things exists in the mind which contemplates them");
49+
System.out.println(res1);
50+
var res2 = nonrepeatingCharacter("A wise man apportions his beliefs to the evidence");
51+
System.out.println(res2);
52+
}
53+
54+
}

‎src/easy/NumberAddition.java

Lines changed: 46 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,46 @@
1+
package easy;
2+
3+
/**
4+
* Have the function NumberSearch(str) take the str parameter,
5+
* search for all the numbers in the string, add them together,
6+
* then return that final number.
7+
* ---
8+
* For example: if str is "88Hello 3World!" the output should be 91.
9+
* You will have to differentiate between single digit numbers
10+
* and multiple digit numbers like in the example above.
11+
* So "55Hello" and "5Hello 5" should return two different answers.
12+
* Each string will contain at least one letter or symbol.
13+
*/
14+
public class NumberAddition {
15+
16+
/**
17+
* Number Addition function.
18+
*
19+
* @param str input string
20+
* @return the final number
21+
*/
22+
private static int numberAddition(String str) {
23+
String cleaned = str.replaceAll("[^0-9]", " ");
24+
String[] splitNum = cleaned.split(" +");
25+
int sum = 0;
26+
for (String c : splitNum) {
27+
if (!c.equals("")) {
28+
sum += Integer.parseInt(c);
29+
}
30+
}
31+
return sum;
32+
}
33+
34+
/**
35+
* Entry point.
36+
*
37+
* @param args command line arguments
38+
*/
39+
public static void main(String[] args) {
40+
var result1 = numberAddition("Chillhouse Mix 2 (2001)");
41+
System.out.println(result1);
42+
var result2 = numberAddition("Cafe del Mar 5 (1998)");
43+
System.out.println(result2);
44+
}
45+
46+
}

‎src/easy/Palindrome.java

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
package easy;
2+
3+
/**
4+
* Have the function Palindrome(str) take the str parameter
5+
* being passed and return the string true
6+
* if the parameter is a palindrome,
7+
* (the string is the same forward as it is backward)
8+
* otherwise return the string false.
9+
* For example: "racecar" is also "racecar" backwards.
10+
* Punctuation and numbers will not be part of the string.
11+
*/
12+
public class Palindrome {
13+
14+
/**
15+
* Palindrome function.
16+
*
17+
* @param str input string
18+
* @return "true" is the string is a palindrome
19+
*/
20+
private static String palindrome(String str) {
21+
StringBuilder reversed = new StringBuilder();
22+
String cleaned = str.replaceAll(" ", "");
23+
reversed.append(cleaned).reverse();
24+
return cleaned.equals(reversed.toString()) && str.length() > 0 ? "true" : "false";
25+
}
26+
27+
/**
28+
* An improved function checking if a given string is a palindrome.
29+
* It compares two halves of a string, checking if a letter
30+
* from the first half matches the other half in the reverse order.
31+
*
32+
* @param str input string
33+
* @return true if the string is a palindrome
34+
*/
35+
private static boolean isPalindrome(String str) {
36+
char[] strArr = str.toCharArray();
37+
int len = strArr.length;
38+
for (int i = 0; i < len / 2; i++) {
39+
if (strArr[i] != strArr[len - i - 1]) {
40+
return false;
41+
}
42+
}
43+
return true;
44+
}
45+
46+
/**
47+
* Entry point.
48+
*
49+
* @param args command line arguments
50+
*/
51+
public static void main(String[] args) {
52+
var result1 = palindrome("dont nod");
53+
System.out.println(result1);
54+
var result2 = isPalindrome("dont nod");
55+
System.out.println(result2);
56+
var result3 = palindrome("rats live on no evil star");
57+
System.out.println(result3);
58+
var result4 = isPalindrome("rats live on no evil star");
59+
System.out.println(result4);
60+
}
61+
62+
}

0 commit comments

Comments
 (0)