如何比較特定索引處單獨數組的元素？

我有兩個數組，我想從每個數組中的相同位置返回更大的數字。如何比較特定索引處單獨數組的元素？

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]

應該返回： ç== [23，64，53，17，88]

很顯然，我的代碼不能正常工作，什麼是指增加索引位置的最佳方式？

也有興趣知道更簡單的方法來做到這一點。

來源

2015-11-13 Eats Indigo

你會有兩個不同大小的數組傳入嗎？在這種情況下應該發生什麼？輸出數組的長度較短，還是包含較大輸入數組的未配對元素？ –

@DanielStevens：那也是我的問題。無論如何，它只應該遍歷較小的數組，因爲零比較會引發錯誤。 – Charles

如果代碼不期望比較長度不等的數組，則可能需要一個錯誤。 –

由於靜態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]

此解決方案假定如果數組大小不相等，則要將剩餘的數據丟棄。

來源

2015-11-13 00:56:22 yez

imho，'for'循環可能會更好，因爲更明顯的是，你從0開始，直到數組中的最後一個元素......但這只是我。 – Charles

好吧......這裏就是你應該做：

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索引，大概）會引發錯誤。

來源

2015-11-13 00:57:38 Charles

你可以去除for循環的'-1'固定，你使用的是終點獨佔範圍格式'...'而不是'..'。 –

您可以在循環體中使用三元運算符來減少代碼體積。爲什麼不呢，如果你已經用它來構造for循環的範圍。 –

@DanielStevens我後來添加了三元組。當我把它放進去時，我很懶，因爲我知道初學者一開始通常不會理解三元論。我使用'if/else'只是爲了讓它更容易理解......我將編輯'...'。 – Charles

的緊湊的解決方案是：

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陣列，以產生一個新的陣列上，每對穿入塊，它返回兩個元素中較大的一個來填充輸出數組。

來源

2015-11-13 01:01:34

太棒了，但是你希望這件事足夠簡單明白。 7線課程中的單線課程有什麼意義？ – Charles

關鍵字_return_是否必要？也許你正在使代碼更加明確。很好回答btw！ –

你是對的，這是不需要的。我一般都很清楚回報。我希望清楚什麼時候函數應該返回一個值，而不是隻執行一個可能不會返回值的副作用。 –

假定兩個陣列具有相同的尺寸，只需：

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

來源

2015-11-13 02:26:56

如何比較特定索引處單獨數組的元素？

回答

相關問題