ruby - 将所有偶数索引整数乘以 2

Question

想要取一个固定的整数并将所有偶数（索引）整数乘以 2。我认为最好的方法是首先将 fixnum 转换为数组。所以让我们说以下16位数：a = 4408041234567901

我知道我可以：

a.to_s.split('')

这会将“a”返回到“字符串”数字数组。但后来我无法跟进：

a.map!.with_index {|i,n| i.even? n*2}

猜猜我有点坚持如何创建一种方法来做到这一点。所以我的问题甚至可能是如何将这组数字变成一个固定数字/整数数组而不是字符串。

Answer 1

我宁愿从循环中完全删除条件，方法是创建一个Enumerator包含要乘以的系数（偶数索引为 2，奇数索引为 1。）

coef = [2, 1].cycle

这实质上创建了一个Enumerator交替返回2和1何时next调用它的函数。然后，您可以使用它来简化您map的：

a.to_s.each_char.map { |v| v.to_i * coef.next }

Answer 2

要将其更改为数组，您可以这样做

a = 4408041234567901
arr = a.to_s.chars.map(&:to_i)
# => [4, 4, 0, 8, 0, 4, 1, 2, 3, 4, 5, 6, 7, 9, 0, 1]

您还可以将备用数字乘以 2

arr = a.to_s.chars.map.with_index {|n,i| i.even? ? n.to_i * 2 : n.to_i }
# => [8, 4, 0, 8, 0, 4, 2, 2, 6, 4, 10, 6, 14, 9, 0, 1]

稍微改进一下，就可以用aHash来查找要相乘的数。

h = {true => 2, false => 1}
a.to_s.each_char.map.with_index {|n,i| n.to_i * h[i.even?]}

编辑

我可以解释每个步骤，但是如果您可以尝试自己弄清楚会更好。打开irb，输入a.to_s并检查输出。然后输入a.to_s.chars并检查输出等等..

Answer 3

a = 4408041234567901

even_odd = [:even, :odd].cycle
   #=> #<Enumerator: [:even, :odd]:cycle> 

如果索引从最高位（最左边）的数字开始：

a.to_s.each_char.map { |d|
  (even_odd.next == :even) ? 2*d.to_i : d.to_i }
  #=> [8, 4, 0, 8, 0, 4, 2, 2, 6, 4, 10, 6, 14, 9, 0, 1]

如果索引以个位开头：

s = a.to_s
even_odd.next if s.size.even?
s.each_char.map { |d| ( even_odd.next == :even) ? 2*d.to_i : d.to_i }
  #=> [4, 8, 0, 16, 0, 8, 1, 4, 3, 8, 5, 12, 7, 18, 0, 2] 

下面是示例的步骤，当从零开始的索引从最高位开始时。

Array#cycle将数组转换[:even, :odd]为枚举数：

even_odd = [:even, :odd].cycle
even_odd.next #=> :even
even_odd.next #=> :odd
even_odd.next #=> :even
even_odd.next #=> :odd
...

b = a.to_s
  #=> "4408041234567901" 
enum0 = b.each_char
  #=> #<Enumerator: "4408041234567901":each_char> 

枚举器enum0传递bto的数字map。我本来可以写：

b = a.to_s.chars
  # => ["4", "4", "0", "8", "0", "4", "1", "2",
  #     "3", "4", "5", "6", "7", "9", "0", "1"] 

但这会创建一个中间数组。枚举器没有，因此效率更高。继续...

enum1 = enum0.map     
  #=> #<Enumerator: #<Enumerator: "4408041234567901":each_char>:map> 

您可以将其视为“复合枚举器”。我们可以通过将其转换为数组来查看其内容：

enum1.to_a
  #=> ["4", "4", "0", "8", "0", "4", "1", "2",
  #    "3", "4", "5", "6", "7", "9", "0", "1"] 

该方法each会将枚举器的每个元素传递到块中。证明：

enum1.each { |d| (enum.next == :even) ? 2*d.to_i : d.to_i }
  # => [8, 4, 0, 8, 0, 4, 2, 2, 6, 4, 10, 6, 14, 9, 0, 1]

enum1我们可以使用Enumerator#next手动单步执行 的元素。我们将值分配给块变量d并在块中执行计算以映射数字d：

d = enum1.next
  #=> "4" 
(enum.next == :even) ? 2*d.to_i : d.to_i
  #=> (:even == :even) ? 2*"4".to_i : "4".to_i
  #=> (true) ? 8 : 4
  #=> 8 ("4" is mapped to 8)

d = enum1.next
  #=> "4" 
(enum.next == :even) ? 2*d.to_i : d.to_i
  #=> (:odd == :even) ? 2*"4".to_i : "4".to_i
  #=> (false) ? 8 : 4
  #=> 4 ("4" is mapped to 4)

d = enum1.next
  #=> "0" 
  #=> (:even == :even) ? 2*"0".to_i : "0".to_i
  #=> (true) ? 0 : 0
  #=> 8 ("0" is mapped to 0)

等等。