Question

我有两个数组，我想从每个数组中的相同位置返回较大的数字。

def get_larger_numbers(a, b)
c = []
count = 0
    while count < 10 #assumes there are less than 10 elements in an array, not an ideal solution.
        if a[count] > b[count]
            c << a[count]
        elsif b[count] > a[count]
            c << b[count]
        else #if numbers are the same
            c << a[count]
        end
    count+= 1
    end
return c
end

 a = [13, 64, 15, 17, 88]
 b = [23, 14, 53, 17, 80]

应该返回： c == [23,64,53,17,88]

显然，我的代码不起作用，什么是引用增加索引位置的最佳方式？

也有兴趣了解更简单的方法。

Answer 1

由于您拥有静态10长度，因此您的代码无效。相反，我建议你使代码更频繁地循环。

def get_larger_numbers(a,b)
  c = []

  [a.length, b.length].min.times do |i|
    if a[i] > b[i]
      c << a[i]
    else
      c << b[i]
    end
  end

  c
end

a = [13, 64, 15, 17, 88]
b = [23, 14, 53, 17, 80]

get_larger_numbers(a,b)
#=> [23, 64, 53, 17, 88]

此解决方案假设如果数组大小不相同，则需要将其余部分抛弃。

Answer 2

好的......这是你应该做的事情：

def get_larger_numbers(a, b)
  c = [] #declare empty array for answer
  for i in 0...(a.length < b.length ? a.length : b.length) #see EDIT note
    c << (a[i] > b[i] ? a[i] : b[i])
  end
  c #this is an implicit return
end

 a = [13, 64, 15, 17, 88]
 b = [23, 14, 53, 17, 80]

puts get_larger_numbers(a,b)

这将执行for循环，该循环将从0到a的长度。是的，它假设它们的长度相同。我认为这就是你想要的。

无论如何，有一个简单的三元组比较两个数组中每个元素的值，一次一个索引。

它会将更大的值推送到c数组，让您在c数组中返回更大的值。

编辑：添加了三元表达式，以便for仅循环通过较小的数组，因为与nil（这可能是数组之外的任何n索引）相比，会引发错误。

Answer 3

紧凑的解决方案是：

def get_larger_numbers(a, b)
    return a.zip(b).map{|x, y| (x >= y) ? x : y } # Return optional, added for clarity
end

a = [13, 64, 15, 17, 88]
b = [23, 14, 53, 17, 80]

p get_larger_numbers(a, b)

请注意，这假定输入数组的长度相同。如果数组的长度不相等，则可以截断为较短数组的长度，或者使用较大数组的不成对元素填充结尾。当前代码会抛出一个错误，让你知道你已经遇到了这个未指明的情况。

至于它是如何工作的，zip将两个数组的元素配对，因此a.zip(b)变为：

[[13, 23], [64, 14], [15, 53], [17, 17], [88, 80]]

然后用map循环遍历数组以生成一个新数组，将每一对传递到块中，该块返回两个元素中较大的一个以填充输出数组。

Answer 4

假设两个数组的大小相同，只需：

def largest_by_position(a,b)
  a.zip(b).map(&:max)
end

largest_by_position([13, 64, 15, 17, 88], [23, 14, 53, 17, 80])
  #=> [23, 64, 53, 17, 88]

或者，制作操作线：

[a,b].transpose.map(&:max)

对于等大小数组a和b，Enumerable#zip和Array#transpose始终具有此yin and yang关系：

a.zip(b) == [a,b].transpose #=> true

如何在特定索引处比较单独数组的元素？

4 个答案: