Hello! Are you ready for an exciting journey into the world of strings and frequency analysis? Today, we’ll assist Alice, an aspiring cryptographer, with a fascinating task involving string transformations and calculations. Alice has developed a unique encoding scheme that shifts letters in the alphabet and analyzes their occurrences.

This should be a fun and insightful challenge that hones your problem-solving and coding skills. Let’s dive in!

Alice's encoding scheme involves two steps. First, she takes a word and shifts each character to the next one alphabetically. For example:

• 'a' becomes 'b'
• 'z' becomes 'a'

Next, Alice analyzes the frequency of each character in the transformed string. For each unique character, she calculates a product of its ASCII value and its frequency. Finally, she sorts these products in descending order.

Your task is to implement a Ruby method, character_frequency_encoding(word), that performs Alice’s encoding and returns the sorted list of products.

For example:

Ruby
Copy to clipboard
1word = "banana"

The method should return:

Ruby
Copy to clipboard
1[294, 222, 99]

Here’s how the process works:

1. Transform "banana" into "cbobob".
2. Calculate the products:
   • 'c': ASCII value 99, frequency 1, product 99 × 1 = 99.
   • 'b': ASCII value 98, frequency 3, product 98 × 3 = 294.
   • 'o': ASCII value 111, frequency 2, product 111 × 2 = 222.
3. Sort the products in descending order: [294, 222, 99].

To implement Alice’s encoding scheme, we start by shifting each character to the next in the alphabet. Using Ruby’s each_char method, we iterate over the string and transform each character.

Ruby
Copy to clipboard
1def character_frequency_encoding(word)
2  # Shift each character to the next in the alphabet
3  shifted_chars = word.each_char.map do |letter|
4    if letter == 'z'
5      'a' # Wrap around for 'z'
6    else
7      (letter.ord + 1).chr # Shift to the next character
8    end
9  end

At this stage, shifted_chars for "banana" will be ["c", "b", "o", "b", "o", "b"]. This array represents the transformed characters.

Next, we calculate the frequency of each character in the transformed array. By initializing a hash with a default value of 0, we can easily count occurrences as we iterate through the array of shifted characters.

Ruby
Copy to clipboard
1  # Initialize a frequency hash
2  frequency_hash = Hash.new(0)
3
4  # Count the frequency of each character
5  shifted_chars.each do |letter|
6    frequency_hash[letter] += 1
7  end

The frequency_hash now holds the counts of each character. For "banana", it will be:

Ruby
Copy to clipboard
1{"c" => 1, "b" => 3, "o" => 2}

Once the frequencies are ready, we calculate the product of each character’s ASCII value and its frequency. These products are stored in an array.

Ruby
Copy to clipboard
1  # Calculate the products of ASCII values and frequencies
2  combined_values = frequency_hash.map do |letter, freq|
3    letter.ord * freq
4  end

For the example "banana", the array combined_values will contain:

Ruby
Copy to clipboard
1[99, 294, 222]

Finally, we sort the calculated products in descending order to complete Alice’s encoding scheme.

Ruby
Copy to clipboard
1  # Sort the products in descending order
2  combined_values.sort.reverse
3end

This ensures the output is properly organized. For "banana", the sorted array will be:

Ruby
Copy to clipboard
1[294, 222, 99]

Here is the full implementation of Alice’s encoding scheme, combining all the steps:

Ruby
Copy to clipboard
1def character_frequency_encoding(word)
2  # Shift each character to the next in the alphabet
3  shifted_chars = word.each_char.map do |letter|
4    if letter == 'z'
5      'a' # Wrap around for 'z'
6    else
7      (letter.ord + 1).chr # Shift to the next character
8    end
9  end
10
11  # Initialize a frequency hash
12  frequency_hash = Hash.new(0)
13
14  # Count the frequency of each character
15  shifted_chars.each do |letter|
16    frequency_hash[letter] += 1
17  end
18
19  # Calculate the products of ASCII values and frequencies
20  combined_values = frequency_hash.map do |letter, freq|
21    letter.ord * freq
22  end
23
24  # Sort the products in descending order
25  combined_values.sort.reverse
26end

Great job! You’ve successfully implemented Alice’s unique encoding scheme. Along the way, you explored string transformations, hash frequency analysis, and sorting techniques. This exercise demonstrates how breaking a problem into smaller, manageable steps leads to clear and effective solutions.

Keep practicing, and see how far you can take these skills in future challenges!