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

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

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]

def获取更大的数字（a、b）
c=[]
计数=0
而count<10则假定数组中的元素少于10个，这不是理想的解决方案。
如果a[count]>b[count]
c a[计数]
c您的代码不工作，因为您的长度是静态的
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]

def获取更大的数字（a、b）
c=[]
[a.length，b.length].min.times do | i|
如果a[i]>b[i]
好的。。。以下是您应该做的事情：

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)

def获取更大的数字（a、b）
c=[]#为答案声明空数组
对于0中的i…（a.length

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

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

它会将较大的值推送到
c
数组，让
c
数组中的较大值返回

编辑：添加了三元表达式，以便
for
只在较小的数组中循环，因为与nil（可能是数组以外任何n个索引处的值）相比会产生错误
 紧凑的解决方案是：

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
在数组上循环，生成一个新数组，将每对元素传递到块中，块返回两个元素中较大的元素以填充输出数组。
假设两个数组大小相同，只需：

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
，始终具有以下关系：

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

imho，
for
循环可能更好，因为更明显的是，从0开始，一直到数组中的最后一个元素。。。但那只是我。你会传入两个不同大小的数组吗？在这种情况下会发生什么？输出数组的长度较短，还是包含较大输入数组的未配对元素？@DanielStevens:这也是我的问题。无论如何，它应该只遍历较小的数组，因为nil比较会产生错误。如果不希望代码比较长度不等的数组，则可能会出现错误。当然，但这是不可伸缩的。一个好的程序员应该确保他的代码永远不会抛出令人讨厌的/不想要的错误。很好，但你希望这足够简单易懂。在7行程序中使用一行程序有什么意义？关键字返回是否必要？也许您正在使代码更加明确。很好的回答顺便说一句！你说得对，不需要。我通常是明确的回报。我想弄清楚什么时候函数应该返回一个值，而不是仅仅执行一个可能不会返回值的副作用。@DanielStevens，如果你的函数是
void
类型，你应该在最后一行隐式或显式地返回
nil
。在Ruby中，不需要对返回进行显式处理。我和一些人谈过，他们普遍认为Ruby中显式的
return
要么是多余的，要么不是最佳实践。结果也一样。它们根本不是有争议的问题。你可以做你想做的事，但是一些Rubiest——通常是一些编码员——宁愿有根管，也不愿被迫编写不必要的代码。你可以摆脱for循环的
-1
修复，因为你使用端点独占范围格式
。
而不是
。
。你可以在循环体中使用三元运算符来减少代码大部分如果您已经在使用它为
for
循环构造范围，为什么不呢。@DanielStevens我后来添加了三元数。当我把它放进去的时候我很懒，因为我知道初学者一开始通常不懂三元。我使用了
if/else
只是为了让它更容易理解。。。我将编辑
…
。