Ruby 字母加密

我对此非常迷茫，因此任何帮助都将不胜感激

我尝试将句子作为输入，并返回一个输出，所有字母在给定值后3位。所以“A”会变成“D”，“B”会变成“E”等等

我认为应该从以下价值观开始：

Alphabet = ('a'..'z').split('')
function Cyphering
   precypheredLeters = inputSentence.split('')
   precypheredLeters.each do |x|
       if 

在这段代码之后，我想给“x”一个索引值（比如如果“x”等于字母“C”，那么索引值应该是3，那么我可以再加上3，把它变成“F”

另外，如果我的输入语句是“Ruby Red！@#$”，如果我希望空格和符号保持不变，如何返回它们的值

如果一个字母输入是“Z”，我希望它从Z=>26变成C=>3，“Y”变成“B”

---

谢谢！

从Sagar的评论中剽窃，但这应该适用于您的示例字符串：

def lame_cipher(str)
  str.tr('a-zA-Z', 'd-za-cD-ZA-C')
end

lame_cipher 'Ruby Red !@#$'
#=> "Uxeb Uhg !@\#$"

或

---

从Sagar的评论中窃取，但这应该适用于您的示例字符串：

def lame_cipher(str)
  str.tr('a-zA-Z', 'd-za-cD-ZA-C')
end

lame_cipher 'Ruby Red !@#$'
#=> "Uxeb Uhg !@\#$"

或

我最喜欢

字符串#tr

解决方案，但这里有另一种方法：

class Rot
  UPPER = ('A'.ord .. 'Z'.ord).freeze
  LOWER = ('a'.ord .. 'z'.ord).freeze

  attr_reader :n

  def initialize(n=13)
    @n = n
  end

  def cipher(str)
    str.unpack('U*').map do |o|
      if UPPER.cover?(o)
        UPPER.begin + (o - UPPER.begin + n) % UPPER.size
      elsif LOWER.cover?(o)
        LOWER.begin + (o - LOWER.begin + n) % LOWER.size
      else
        o
      end
    end.pack('U*')
  end
end

rot = Rot.new(3)
rot.cipher("Hello, world!") # => Khoor, zruog!

它的工作原理是分解和调整由定义为类常量的两个范围选择的代码点

---

这里是@lacostenycoder的

String#tr

解决方案的重构版本：

class Lame
  UPPER = ('A' .. 'Z').to_a.freeze
  LOWER = ('a' .. 'z').to_a.freeze

  attr_reader :to

  def initialize(n=13)
    @to = [LOWER, UPPER].map { |a| a.rotate(n) }.join
  end

  def cipher(str)
    str.tr('a-zA-Z', to)
  end
end

require 'benchmark/ips'

lame = Lame.new
rot = Rot.new
str = 'sphinx of black quartz, judge my vow'.freeze

Benchmark.ips do |x|
  x.report('tr') { lame.cipher(str) }
  x.report('unpack') { rot.cipher(str) }
end

和基准结果：

                  tr    475.305k (± 4.5%) i/s -      2.410M in   5.081979s
              unpack     64.604k (± 3.5%) i/s -    323.493k in   5.013385s

我最喜欢

字符串#tr

解决方案，但这里有另一种方法：

class Rot
  UPPER = ('A'.ord .. 'Z'.ord).freeze
  LOWER = ('a'.ord .. 'z'.ord).freeze

  attr_reader :n

  def initialize(n=13)
    @n = n
  end

  def cipher(str)
    str.unpack('U*').map do |o|
      if UPPER.cover?(o)
        UPPER.begin + (o - UPPER.begin + n) % UPPER.size
      elsif LOWER.cover?(o)
        LOWER.begin + (o - LOWER.begin + n) % LOWER.size
      else
        o
      end
    end.pack('U*')
  end
end

rot = Rot.new(3)
rot.cipher("Hello, world!") # => Khoor, zruog!

它的工作原理是分解和调整由定义为类常量的两个范围选择的代码点

---

这里是@lacostenycoder的

String#tr

解决方案的重构版本：

class Lame
  UPPER = ('A' .. 'Z').to_a.freeze
  LOWER = ('a' .. 'z').to_a.freeze

  attr_reader :to

  def initialize(n=13)
    @to = [LOWER, UPPER].map { |a| a.rotate(n) }.join
  end

  def cipher(str)
    str.tr('a-zA-Z', to)
  end
end

require 'benchmark/ips'

lame = Lame.new
rot = Rot.new
str = 'sphinx of black quartz, judge my vow'.freeze

Benchmark.ips do |x|
  x.report('tr') { lame.cipher(str) }
  x.report('unpack') { rot.cipher(str) }
end

和基准结果：

                  tr    475.305k (± 4.5%) i/s -      2.410M in   5.081979s
              unpack     64.604k (± 3.5%) i/s -    323.493k in   5.013385s

---

'abc xyz'.tr（'a-z'，'d-z'+'a-c'）#=>“def abc”

或一种不太硬的编码方式可以写成：

'abc xyz'.tr（'a-z'，（'a'..'z'）。to_a.旋转（3）.连接）#=>“def abc”

函数加密

-那是什么编程语言？@Stefan也

（'a'..'z'）。拆分（'

给出了

名称（a.“z”：范围的未定义方法“split”可以写成：
'abc xyz'.tr（'a-z'，'d-z'+'a-c'））#=>“def abc”
或一种不太硬的编码方式：
'abc xyz'.tr（'a-z'，（'a'..'z'）。to_a.旋转（3.连接）#=>“def abc”
函数加密

-那是什么编程语言？@Stefan也是

'a（'split z'））

给出了

命名错误（未定义的方法“拆分”表示“a”。“z”：范围）

。也许你可以改进Sagar Pandya的代码–一个

tr

调用应该足以替换大写和小写字符。而且

+

并不是真的需要。我想也许在你的第二个版本中，你可以有第二个参数来确定旋转。@Stefan我不知道如何将它转换为wo带上你的建议，可以吗？@lacostenycoder试试这个：

str.tr（'a-zA-Z'，'d-zA-cD-zA-C'））

也许你可以改进Sagar Pandya的代码–一个

tr

调用就足以替换大写和小写字符。而且

+

并不是真的需要。我想也许在你的第二个版本中，你可以有第二个参数来确定旋转。@Stefan我不知道如何让它工作k有你的建议，可以吗？@lacostenycoder试试这个：

str.tr（'a-zA-Z'，'d-zA-cD-zA-C'）

@lacostenycoder不，你的

String#tr

解决方案更快。我怀疑你的基准包括“启动时间”在每次迭代中，我对你的解决方案进行了一点重构，比我的解决方案快了7.5倍。@lacostenycoder不，你的

String#tr

解决方案更快。我怀疑你的基准测试包括了“启动时间”我对你的解决方案进行了一点重构，它比我的快7.5倍。