Caesar cipher using Ruby

caesar.rb

ALPHABET_SIZE = 26

def caesar_cipher(string)
  shiftyArray = []
  charLine = string.chars.map(&:ord)

  shift = 1
  ALPHABET_SIZE.times do |shift|
    shiftyArray << charLine.map do |c|
      ((c + shift) < 123 ? (c + shift) : (c + shift) - 26).chr
    end.join
  end

  shiftyArray
end

puts caesar_cipher("testing")

caesar_2.rb

def caesar_cipher(string, shift = 1)
  alphabet   = Array('a'..'z')
  encrypter  = Hash[alphabet.zip(alphabet.rotate(shift))]
  string.chars.map { |c| encrypter.fetch(c, " ") }
end

p caesar_cipher("testing").join

caesar_3.rb

def caesar_cipher(string, shift = 1)
  alphabet  = Array('a'..'z')
  non_caps  = Hash[alphabet.zip(alphabet.rotate(shift))]
  
  alphabet = Array('A'..'Z')
  caps     = Hash[alphabet.zip(alphabet.rotate(shift))]
  
  encrypter = non_caps.merge(caps)
  
  string.chars.map { |c| encrypter.fetch(c, c) }
end

p caesar_cipher("testingzZ1Z").join

Thank you for this. I see two things I believe should be updated:

example 1:
((c + shift) < 123 ? (c + shift) : (c + shift) - 26).chr
to
((c + shift) < 123 ? (c + shift).chr : (c + shift) - 26).chr

example 2 (to handle characters outside of a..z ):
string.chars.map { |c| encrypter.fetch(c, " ") }
to
string.chars.map { |c| encrypter.fetch(c, c) }

Good congrats!! but I got this way of doing also
def cipher(string,key)
namem=[]
string.downcase.bytes.map do|c|
namem.push(c+key<123?(c+key):(c+key-26))
end
namem.pack('c*')
end
puts cipher('What a string!',5)

@che30 Very very slick. Essentially:

string.chars.map(&:ord) can be replaced with string.bytes

Array.pack can be used to boil down a lot of the enumerable code seen in the original example, but be warned--You MUST speficially pass 'c*' as the argument, otherwise badness happens.

I am however curious, why did you feel the need to call downcase on the string input? Does it change anything?

Awesome @matugm Thanks for sharing!