Takes user input string and convert it to secret code from hash - ruby

Question

I was given a code challenge of taking a user input and converting that input using the following cipher information:
replace = {
"A" => "Z",
"B" => "Y",
"C" => "X",
"D" => "W",
"E" => "V",
"F" => "U",
"G" => "T",
"H" => "S",
"I" => "R",
"J" => "Q",
"K" => "P",
"L" => "O",
"M" => "N",
"N" => "M",
"O" => "L",
"P" => "K",
"Q" => "K",
"R" => "I",
"S" => "H",
"T" => "G",
"U" => "F",
"V" => "E",
"W" => "D",
"X" => "C",
"Y" => "B",
"Z" => "A"
}
This is my code:
puts "Time to decipher some code: "
input = gets.chomp.upcase
replace.each do |k, v|
input.gsub!(k,v)
end
puts input
In my each block, my cipher doesn't seem to properly convert. Can anyone explain why this might be?

Answer 1

You're iterating through the hash replace rather than the input string. So, if your input = "HELLO"...
Input: HELLO
Input: HVLLO
Input: SVLLO
Input: SVOOO
Input: SVLLL #changing back O to L
Input: HVLLL #changing back S to H
Input: HELLL #changing back V to E
Since you're iterating through replace you will end up switching letters more than once.
My solution to this problem would have been to iterate through each of the letters in input and then replace them according to replace. In order to iterate through input I would have to split it and then eventually join it later into a string.

Answer 2

Your problem is not Ruby-specific. It is a very very very elementary (school) level algorithm mistake. You got your result because the replaced characters can later match to be replaced with something else.
It is reminiscent of a mistake when one has variables a = "foo" and b = "bar" and is trying to switch their values, doing:
b = a
a = b
A typical way to do it correctly is:
input.gsub!(/./, Hash.new{|_, k| k}.merge(replace))

Answer 3

input = gets.chomp.upcase
p input.gsub(/[A-Z]/, replace)
The mysterious /[A-Z]/ part is a regular expression, which searches a string for any uppercase character. gsub then replaces it with what's in the replace hash.

Answer 4

Try something like this:
replace = {
"A" => "Z",
"B" => "Y",
"C" => "X",
"D" => "W",
"E" => "V",
"F" => "U",
"G" => "T",
"H" => "S",
"I" => "R",
"J" => "Q",
"K" => "P",
"L" => "O",
"M" => "N",
"N" => "M",
"O" => "L",
"P" => "K",
"Q" => "K",
"R" => "I",
"S" => "H",
"T" => "G",
"U" => "F",
"V" => "E",
"W" => "D",
"X" => "C",
"Y" => "B",
"Z" => "A"
}
puts "Time to decipher some code: "
input = gets.chomp.upcase
output = ""
input.each_char do |c|
output << replace[c]
end
puts output

Answer 5

Thanks everyone for all of the help! I was able to solve it using many of your posts, but Raman's seemed to be the simplest.
replace = {
"A" => "Z",
"B" => "Y",
"C" => "X",
"D" => "W",
"E" => "V",
"F" => "U",
"G" => "T",
"H" => "S",
"I" => "R",
"J" => "Q",
"K" => "P",
"L" => "O",
"M" => "N",
"N" => "M",
"O" => "L",
"P" => "K",
"Q" => "K",
"R" => "I",
"S" => "H",
"T" => "G",
"U" => "F",
"V" => "E",
"W" => "D",
"X" => "C",
"Y" => "B",
"Z" => "A"
}
puts "Time to decipher some code: "
input = gets.chomp.upcase
output = ""
input.each_char do |c|
output << replace[c]
end
puts output