Hello and welcome to today's Scala lesson! We are going to dive into an engaging challenge that will test our abilities in string manipulation, leveraging the power of nested loops. Prepare yourself for an interesting journey as we explore how to extract odd-indexed characters from each word in a sentence, but only if the word has an even number of characters. Sounds exciting, doesn't it? Let's get started!

Here's a detailed look at our task: We will work with a string that represents a sentence in which words are separated by spaces. Your task is to create a Scala function that identifies the odd-indexed characters of words that have an even number of characters. Then, you will combine these characters into a single string, maintaining the order in which they appear in the sentence.

Let's consider an example to foster a deep understanding: "Scala is a functional programming language." Here, the word Scala has 5 characters (an odd number), so it will be skipped. However, the word language has 8 characters (an even number), and we will select the odd-indexed characters from this word: specifically, 'a', 'g', and 'e'. Similarly, we select 's' from is, and 'u', 'c', 'i', 'n', and 'l' from functional. The word a will be skipped as it has an odd number of characters.

Thus, if our function is working correctly, it should return "aglscinl". This task highlights the versatility of loops and conditionals in solving various string challenges with Scala!

We initiate our solution-building process by splitting the sentence into words. Scala provides us with the split method, which makes this task easy. The function separates the sentence into words at each space, giving us an array containing all the words in the sentence.

Scala
Copy to clipboard
1def solution(sentence: String): String = {
2  val words = sentence.split(" ")
3  // we will proceed progressively
4}

Now, let's delve into nested loops: an outer loop that iterates over every word and an inner operation that checks every character within each word. Firstly, we'll use an if condition that verifies whether a word has an even length. How do we do this? By using the modulus operator on the length of the word with 2. If this modulus is zero, our word has an even length!

Scala
Copy to clipboard
1def solution(sentence: String): String = {
2  val words = sentence.split(" ")
3  for (word <- words) {
4    if (word.length % 2 == 0) {  // confirms whether the length of the word is even
5      // we are building up our solution progressively
6    }
7  }
8}

With our outer loop set, it's time to complete our inner functionality. We intend to extract only the odd-indexed characters in each word of even length. To accomplish this, we utilize Scala's filter in combination with zipWithIndex to select the desired characters at odd positions. These characters are then appended to our result string, which will be returned as our final output.

Scala
Copy to clipboard
1def solution(sentence: String): String = {
2  val words = sentence.split(" ")
3  val result = new StringBuilder
4  for (word <- words) {
5    if (word.length % 2 == 0) {  // check if the length of the word is even
6      result.append(word.zipWithIndex.collect { case (char, index) if index % 2 != 0 => char })
7    }
8  }
9  result.mkString
10}

Bravo! You've just successfully navigated through the maze of nested loops to extract specific information from words within a sentence using Scala. You've learned how to analyze a sentence by breaking it down into its constituent words and then processing each word from a new perspective.

Now, use this knowledge as a foundation in your exploration of nested loops. Practicing more is key, as the more you apply what you've learned, the more you will reinforce this knowledge. Are you ready to dive deeper into the world of nested loops and string manipulations in Scala? Let's dive right in!