Lesson 3

Welcome to new session, where we are embarking on a journey into the mystical territory of combined **string** and **array** operations. Have you ever thought about how to update a string and an array in parallel while a specific condition holds true? That's precisely what we'll explore today, all in the context of a real-world scenario related to a mystery novel book club. Get ready to dive in!

Our mission today is to generate a unique encoded message for a book club. Here's the fun part: to create a cryptic message, we will process a string and an array of numbers simultaneously and stop once a given condition is satisfied.

For the string, our task is to replace each letter with the next alphabetical letter and then reverse the entire updated string. For the array of numbers, our task is to divide each number by 2, round the result, and accumulate the rounded numbers until their total exceeds `20`

.

When the accumulated total exceeds `20`

, we immediately stop the process and return the updated string and the as-yet-unprocessed numbers in their original order.

**Example**

Consider the input string `"books"`

and array `{10, 20, 30, 50, 100}`

.

We start our process with an empty string and a sum of `0`

.

- For the first character
`'b'`

in`'books'`

, we replace it with the next alphabet`'c'`

. For the corresponding number`10`

in the array, we divide it by`2`

and round it. The result is`5`

. The sum after the first operation is`5`

, which is less than`20`

, so we continue to the next character. - For the next character
`'o'`

, we replace it with`'p'`

. For the corresponding number`20`

in the array, half and rounded is`10`

. The sum after the second operation is`15`

(`5 + 10`

). The sum still doesn't exceed`20`

, so we move to the third character. - For the next character
`'o'`

, we replace it with`'p'`

. For the corresponding number`30`

in the array, half and rounded is`15`

. When we add this`15`

to the previously calculated sum of`15`

, it totals`30`

, which is more than`20`

. So, we stop the process here. - We have processed
`'b'`

,`'o'`

, and`'o'`

from the word`'books'`

and replaced them with`'c'`

,`'p'`

, and`'p'`

respectively to get`"cpp"`

. After reversing, we get`"ppc"`

. - For the array, we exclude any numbers that we have processed. Hence, we exclude the first three numbers, and the array becomes
`{50, 100}`

.

So the output should be `"ppc 50, 100"`

.

Let's begin our journey by setting up two crucial components: our resultant string and a variable to keep track of the cumulative sum.

Java`1import java.util.ArrayList; 2import java.util.Collections; 3import java.util.List; 4 5public class MysteryNovel { 6 public static String solution(String inputString, List<Integer> numbers) { 7 String result = ""; 8 int sum_so_far = 0;`

With the setup complete, it's time to roll up our sleeves and process the `inputString`

and array. We need to iterate over the `inputString`

and update each character to its next alphabetical character. Simultaneously, we'll keep tabs on our array condition — if the sum of half of the numbers crosses our threshold of `20`

, we should stop the process.

Java`1import java.math.Math; 2import java.util.ArrayList; 3import java.util.List; 4 5public class MysteryNovel { 6 public static String solution(String inputString, List<Integer> numbers) { 7 StringBuilder result = new StringBuilder(); 8 int sum_so_far = 0; 9 int i = 0; 10 while (i < inputString.length() && sum_so_far <= 20) { 11 result.append(inputString.charAt(i) == 'z' ? 'a' : (char) (inputString.charAt(i) + 1)); 12 int half_number = (int) Math.round(numbers.get(i) / 2.0); 13 sum_so_far += half_number; 14 i++; 15 }`

With the updates complete, we're one step away from solving this mystery. We must reverse our string to generate the final encoded message! At the end, we return the processed string and the remaining array as a single concatenated string separated by a space.

Java`1import java.util.ArrayList; 2import java.util.List; 3import java.util.Collections; 4 5public class MysteryNovel { 6 public static String solution(String inputString, List<Integer> numbers) { 7 StringBuilder result = new StringBuilder(); 8 int sum_so_far = 0; 9 int i = 0; 10 while (i < inputString.length() && sum_so_far <= 20) { 11 result.append(inputString.charAt(i) == 'z' ? 'a' : (char) (inputString.charAt(i) + 1)); 12 int half_number = (int) Math.round(numbers.get(i) / 2.0); 13 sum_so_far += half_number; 14 i++; 15 } 16 result.reverse(); 17 List<Integer> remainingNumbers = numbers.subList(i, numbers.size()); 18 String remainingNumbersString = remainingNumbers.toString(); 19 return result.toString() + " " + remainingNumbersString.substring(1, remainingNumbersString.length() - 1); 20 } 21 22 public static void main(String[] args) { 23 List<Integer> numbers = new ArrayList<>(); 24 numbers.add(10); 25 numbers.add(20); 26 numbers.add(30); 27 numbers.add(50); 28 numbers.add(100); 29 30 String result = solution("books", numbers); 31 System.out.println(result); 32 33 // Output: 34 // ppc 50, 100 35 } 36}`

Congratulations! You have successfully navigated and implemented a complex process that involved string manipulation, array processing, and cumulative conditions. This computational challenge has given you the perspective on how to apply these programming elements in real-world scenarios.

Up next, I encourage you to solve more problems that require you to iterate and update arrays based on certain conditions. We will meet again soon to crack another problem and delve deeper into the world of coding. Keep practicing and happy coding!