Arrays 如何在Ruby中找到max而不使用；“最大值”；功能

我需要在不使用

max

方法的情况下找到数组的最大值。现在我有：

def max(arr)
  largest_num = arr(1)
  arr.each do |num|
    if element >= largest_num
      largest_num = num
    else
      largest_num = largest_num
    end
    puts largest_num
  end

  my_numbers = [20, 30, 40, 50]
  puts max(my_numbers)
end

---

为什么不直接使用

排序

和

最后一个

array = [3,7,2,4,6,1,8,5]
array.sort.last
#=> 8

---

为什么不直接使用

排序

和

最后一个

array = [3,7,2,4,6,1,8,5]
array.sort.last
#=> 8

---

如果您被告知应该使用

排序

和

最后一个

，那么答案很简单：

2.1.1 :003 > [2,3,1,4,8,6].sort.last
=> 8

如果要在方法中使用，请执行以下操作：

def max(arr); arr.sort.last; end

2.1.1 :004 > def max(arr); arr.sort.last; end
=> :max 
2.1.1 :005 > max([2,1,3])
=> 3 

---

如果您被告知应该使用

排序

和

最后一个

，那么答案很简单：

2.1.1 :003 > [2,3,1,4,8,6].sort.last
=> 8

如果要在方法中使用，请执行以下操作：

def max(arr); arr.sort.last; end

2.1.1 :004 > def max(arr); arr.sort.last; end
=> :max 
2.1.1 :005 > max([2,1,3])
=> 3 

---

如果要求您使用

排序

和

最后一个

，则以下答案对您无效

arr.sort.last

效率很低，因为它需要对整个数组进行排序，而您需要的是最大的数组。尝试以下方法：

arr.reduce{|largest, num| if num > largest then num else largest end}

num_arr = [1,2,3,4,5]
num_arr.reduce(0){|sum, num| sum + num} #=> 15

---

reduce

函数（别名为

inject

）用于将数组“缩减”为单个对象。要实现sum，您可以执行以下操作：

arr.reduce{|largest, num| if num > largest then num else largest end}

num_arr = [1,2,3,4,5]
num_arr.reduce(0){|sum, num| sum + num} #=> 15

0

是总和的起始值，然后对于每个元素，块将使用到目前为止的总和和数组中的元素运行。然后将块的结果（

sum+num

返回，因为在ruby中，最后一条语句是隐式返回的）设置为下一个元素的

sum

的新值。

sum

的最终值是返回的值

这类似于：

sum = 0
sum = sum + num_arr[0]
sum = sum + num_arr[1]
sum = sum + num_arr[2]
sum = sum + num_arr[3]
sum = sum + num_arr[4]

---

如果未指定起始值，则第一个元素将作为起始值。因此，在我的

reduce

解决方案中，第一个元素被设置为“最大的”，然后依次为每个元素传递最大的元素，或者如果元素大于当前最大的元素，则它将成为新的最大元素。

如果需要使用

排序

和

最后一个

，那么下面的答案对你不适用

arr.sort.last

效率很低，因为它需要对整个数组进行排序，而您需要的是最大的数组。尝试以下方法：

arr.reduce{|largest, num| if num > largest then num else largest end}

num_arr = [1,2,3,4,5]
num_arr.reduce(0){|sum, num| sum + num} #=> 15

---

reduce

函数（别名为

inject

）用于将数组“缩减”为单个对象。要实现sum，您可以执行以下操作：

arr.reduce{|largest, num| if num > largest then num else largest end}

num_arr = [1,2,3,4,5]
num_arr.reduce(0){|sum, num| sum + num} #=> 15

0

是总和的起始值，然后对于每个元素，块将使用到目前为止的总和和数组中的元素运行。然后将块的结果（

sum+num

返回，因为在ruby中，最后一条语句是隐式返回的）设置为下一个元素的

sum

的新值。

sum

的最终值是返回的值

这类似于：

sum = 0
sum = sum + num_arr[0]
sum = sum + num_arr[1]
sum = sum + num_arr[2]
sum = sum + num_arr[3]
sum = sum + num_arr[4]

如果未指定起始值，则第一个元素将作为起始值。因此，在我的

reduce

解决方案中，第一个元素被设置为“最大”，然后依次为每个元素传递最大的元素，或者如果元素大于当前最大的元素，则它成为新的最大元素

---

有人告诉我应该使用.sort和.last，但不太确定从哪里开始

编程时，自我启动非常重要。这是一个基本特征，因为该领域和所有技术都在快速发展。我还建议您阅读“”，尤其是如果您想将堆栈溢出用作资源的话

以下是如何学习使用Ruby进行实验并自学：

Ruby与它捆绑在一起。在命令行中键入

irb

，它将打开并向您显示提示。在这个提示下，您可以输入Ruby表达式并查看结果。我的提示可能与您的不同，因为我的提示是定制的，但您可以了解如何使用它：

$ irb
irb(main):001:0>

要将数组分配给变量，请执行以下操作：

irb(main):001:0> my_numbers = [20, 30, 40, 50]
=> [20, 30, 40, 50]

通过输入变量名称并按Return或Enter键，我可以查看分配给

my_number

的值：

我可以在

我的\u编号上使用方法进行试验

：

irb(main):003:0> my_numbers.shuffle
=> [50, 30, 40, 20]

这就把数组随机化了。它没有更改my_numbers，它只洗牌数组并按洗牌顺序输出一个新数组：

irb(main):004:0> my_numbers
=> [20, 30, 40, 50]

每次运行shuffle时，它都会随机化数组并返回另一个数组：

irb(main):005:0> my_numbers.shuffle
=> [50, 20, 30, 40]
irb(main):006:0> my_numbers.shuffle
=> [40, 20, 30, 50]

由于要使用

排序

和

最后一个

来查找最大值，因此最好从无序数组开始。测试

排序
：

irb(main):009:0> my_numbers.shuffle.sort
=> [20, 30, 40, 50]

数组在洗牌后进行排序

以下是
last
的作用：

irb(main):010:0> my_numbers.last
=> 50

现在你知道的足够多了，可以自己去弄清楚了

有人告诉我应该使用.sort和.last，但不太确定从哪里开始

编程时，自我启动非常重要。这是一个基本特征，因为该领域和所有技术都在快速发展。我还建议您阅读“”，尤其是如果您想将堆栈溢出用作资源的话

以下是如何学习使用Ruby进行实验并自学：

Ruby与它捆绑在一起。在命令行中键入
irb
，它将打开并向您显示提示。在这个提示下，您可以输入Ruby表达式并查看结果。我的提示可能与您的不同，因为我的提示是定制的，但您可以了解如何使用它：

$ irb
irb(main):001:0>

要将数组分配给变量，请执行以下操作：

irb(main):001:0> my_numbers = [20, 30, 40, 50]
=> [20, 30, 40, 50]

通过输入变量名称并按Return或Enter键，我可以查看分配给
my_number
的值：

我可以在
我的\u编号上使用方法进行试验
：

irb(main):003:0> my_numbers.shuffle
=> [50, 30, 40, 20]

这就把数组随机化了。它没有更改my_numbers
，它只洗牌数组并按洗牌顺序输出一个新数组：

irb(main):004:0> my_numbers
=> [20, 30, 40, 50]

每次运行shuffle

时，它都会随机化数组并返回另一个数组：

irb(main):005:0> my_numbers.shuffle
=> [50, 20, 30, 40]
irb(main):006:0> my_numbers.shuffle
=> [40, 20, 30, 50]

由于要使用

排序

和

最后一个

来查找最大值，因此最好从无序数组开始。测试

排序
：

irb(main):009:0> my_numbers.shuffle.sort
=> [20, 30, 40, 50]

阵列是sor