Question

想要取整数的整数并将所有偶数（索引）整数乘以2。我认为最好的方法是先将fixnum转换为数组。因此，请说出以下16位数：a = 4408041234567901

我知道我可以：

a.to_s.split('')

将返回＆＃39; a＆＃39;一系列的弦乐＆＃39;数字。但后来我不能跟进：

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

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

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]

稍微提高一点，您可以使用Hash找到要乘的数字。

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将b的数字传递给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>

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

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]

我们可以使用Enumerator#next手动逐步浏览enum1的元素。我们将值分配给块变量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)

等等。

将所有偶数索引的整数乘以2

3 个答案: