算术序列 Ruby

Question

这是一个代码，用于查找等差数列的缺失序列并找到共同的差异，并检查它是增加还是减少序列。接受用户输入以进行进一步操作

例如：输入数组元素

2 4 6 10 12 14

缺少的数字是 8 而不是

输入数组元素

2

4

6

10

12

14

缺少的数字是 8

    puts "enter arithmetic sequence"
    o = Array.new
    x = gets.chomp
    item = x.split(" ")
    o.push(item)
    puts "#{o}"
    len = o.length
    sum = (len + 1) * (o[0] + o[len - 1]) / 2
    summ = 0
    o.each { |a| summ+=a }
    res = sum - summ
    if(o[1]>o[0])
      puts "its an increasing sequence"
    else
      puts "its a decreasing sequence"
    end
    common_difference = o[1] - o[0]
    puts "Common difference is #{common_difference}"
    puts "missing number is #{res}"

sum common difference 之类的操作是有效的，但要求是我们需要在一行中获取用户输入，而不是在多行中，将其拆分并存储在一个数组中。 对于求和，我使用了实际总和 - 目标总和方法。

Main issue is that it rise an error

`*': Array can't be coerced into Integer

如何使用to_i方法或Integer方法将字符串格式的数组元素转换为int

Expected Output


i/p 2 4 6 8 12 14


o/p


missing number 10

Answer 1

试试这个：

def missing_number(arr)
  ((arr.size + 1) * (arr.first + arr.last))/2 - arr.sum
end

missing_number [2, 4, 6, 10, 12, 14]      #=> 8
missing_number [11, 8, 5, 2, -4, -7]      #=> -1
missing_number [1.2, 2.0, 2.4, 2.8, 3.2]  #=> 1.6000000000000014

假设arr 没有丢失任何值。例如，

arr = [2, 4, 6, 8, 10, 12, 14]

然后：

arr.sum
  #=> 56

其中，因为它是一个算术级数，我们可以替代地计算如下：

(arr.size * (arr.first + arr.last))/2
  #=> 56

其实

arr = [2, 4, 6, 10, 12, 14]

和

arr.sum
  #=> 48

正如我上面解释的，我们可以计算插入缺失值后arr的值的总和如下：

((arr.size + 1) * (arr.first + arr.last))/2
  #=> 56

因此缺失值等于56 - 48 #=> 8。

---

这是另一种查找缺失值的方法，效率稍低，但具有避免舍入错误的优点（因为只使用了加法和除以 2，后者通过位移位完成）。

def missing_number(arr)
  arr.each_cons(2).max_by { |a,b| (b-a).abs }.sum/2
end

missing_number [2, 4, 6, 10, 12, 14]     #=> 8
missing_number [11, 8, 5, 2, -4, -7]     #=> -1
missing_number [1.2, 2.0, 2.4, 2.8, 3.2] #=> 1.6

假设

arr = [11, 8, 5, 2, -4, -7]

步骤如下。

enum = arr.each_cons(2)
  #=> #<Enumerator: [11, 8, 5, 2, -4, -7]:each_cons(2)>

通过将枚举转换为数组，我们可以看到枚举器将生成​​并传递给Enumerable#max_by 的 (5) 个值：

enum.to_a
  #=> [[11, 8], [8, 5], [5, 2], [2, -4], [-4, -7]]

接下来让我们看看 max_by 将比较的值：

enum.map { |a,b| (b-a).abs }
  #=> [3, 3, 3, 6, 3]

因此我们得到以下结果：

c = enum.max_by { |a,b| (b-a).abs }
  #=> [2, -4]

最后两步计算2和-4的平均值：

d = c.sum
  #=> -2
d/2
  #=> -1

Answer 2

要求是我们需要在一行中获取用户输入，而不是在多行中，将其拆分并存储在一个数组中

gets.chomp 返回一个删除了尾随换行符的字符串，例如（第二行是用户输入）

x = gets.chomp
2 4 6 8 12 14

x #=> "2 4 6 8 12 14"

split 将该字符串转换为数组：

x.split
#=> ["2", "4", "6", "8", "12", "14"]

缺少的是转换为整数。要转换数组的每个元素，有map：

x.split.map { |s| s.to_i }
#=> => [2, 4, 6, 8, 12, 14]

或其简写符号：

x.split.map(&:to_i)
#=> => [2, 4, 6, 8, 12, 14]

应用于您的代码：

puts "enter arithmetic sequence"

x = gets.chomp
o = x.split.map(&:to_i)

puts "#{o}"
# ...

请注意，无需创建空数组。您可以将map 的结果分配给o。

您的其余代码似乎按预期工作。但是您应该查看Cary Swoveland's answer 以更简洁地找到丢失的元素。