How to properly use the map and map! methods - ruby

Question

I am working on a caesar cipher which is a real simple cipher which shifts each letter in a message to the right in accordance with a given key. For example, with a key of 3, the message "hello" would become encrypted as "ifmmp"
I have written this program as a series of loops which are... I forgot the term, but its where you have a loop inside of a loop. The term escapes me at the moment.
Anyway, the way I am doing this is by first converting the message, which might consist of several statements, into an array of words.
Then, I am converting each of those words into an array of letters, so that I can shift them individually.
Finally, I am merging the array of letters into a single words, and I am merging the array of words back into a single message.
The problem I am running into is that whenever I am trying to use the map and map! methods, I cannot get the shifted letters to retain their value. I come from a C/C++ background, and in those languages I wouldn't have a problem with doing this because I understand how pointers and references work, but I don't know how this works in Ruby.
My question is: How can I get the values of an array to be changed inside of a loop, and not reset back to their original values once I exit the loop? The commented code is as follows:
def caesar_cipher(message,key)
#Convert message to array
message = message.split(' ')
#Map each word in the array to the cipher method
message.map! do |word|
puts "message is: #{message} and the current word is: #{word}"
#Split each word into an array of characters
word = word.split('')
puts "after splitting word is: #{word.inspect}"
#Map each letter to cipher function
word.map do |letter|
puts "trying to shift the letter: #{letter.inspect}"
#Based on the value of the key, each letter will be shifted to the right key times
key.times do
#Cases when the letter is at the end of the alphabet
case letter
when "z"
letter = "a"
when "Z"
letter = "A"
#By default, each letter will be shifted to the next letter in the alphabet per each iteration of the loop
else
letter = letter.next!
end
puts "the letter is now: #{letter.inspect}"
end
#Join the array of letters back into a single word
word = word.join('')
puts "after joining word is: #{word.inspect}"
end
end
#Join the array of words back into the shifted message
message.join(' ')
end

Answer 1

Your code was mostly fine. I made just two tiny fixes
def caesar_cipher(message,key)
message = message.split(' ')
message.map! do |word|
word = word.split('')
word.map! do |letter| # or word = word.map
key.times do
case letter
when "z"
letter = "a"
when "Z"
letter = "A"
else
letter = letter.next!
end
end
letter # return the next letter from the block
end
word.join('')
end
message.join(' ')
end
puts caesar_cipher('hello', 2)
# >> jgnnq
What you were doing wrong
The values were not retaining changes because you didn't save them (map doesn't change the original array, it returns a changed copy)
Sometimes, return value of word.map was letter.next! (because it was the last expression evaluated in the block), which is a number, not a letter. You need to always return the letter.

Answer 2

Not a direct answer to the question, but you might find a more functional approach useful.
I try to reduce nested loops and conditional branch logic where possible, as they can be quite painful to follow.
def caesar_cipher(message, key)
key.times do
message = message
.split("")
.map(&:ord) # convert each character to ascii number
.map(&:next) # increment ascii number by 1
.map(&:chr) # convert ascii number back to character
.join
.gsub("{", "a") # fix characters out of range
.gsub("[", "A")
end
message
end