Arrays 按升序排列的Ruby数组

大家好，我正在制作一个简单的函数，以升序生成浮点数组，但我想知道是否有更简单的方法来实现这一点。 我将使用它来创建一个表，这样我就可以生成随机数学问题，用拉格朗日数值方法来解决它们

拉格朗日方法使用X，F（X）和X0，其中X0必须在X的范围内，否则无法解决问题

到目前为止，这是我的代码

xn = []
#i is a random number selected from a list
i.times do
    value=rand(0.1..15.1)
    xn<<value 
end
#ordena el arreglo de manera ascendente
xn.sort!

xn=[]
#i是从列表中选择的随机数
i、 时代确实如此
值=兰特（0.1..15.1）
xn代码本身看起来很好，符合您的目的。在哪里使用这一点有上下文吗？因为“简单性”可能是由代码的上下文驱动的

比如说,

您可以配置所需的随机数数量和随机数范围。您可以从外部配置排序顺序

您可以将其封装在实用程序类中，并将其像API一样公开给其他类

如果需要一百万个随机排序的数字，您希望这些数字流式传输吗？如果是这样，就有Ruby库

。。。还有更多。上下文将是有用的。希望这有帮助
 正如席德所指出的，当你问“是否有更简单的方法”时，很大程度上取决于上下文。如果说“更简单”是为了提高效率，那么答案不仅仅是有多少行代码

如果您真的想将所有的顺序统计信息作为一个集合来查看，那么使用Ruby的块构造函数功能将您的方法转换为一行程序可能更具可读性，下面提供的实现的计时显示它稍微快一点，但只快几个百分点

但是，如果您有一个非常大的N，并且正在按顺序处理这些值，那么您可能更喜欢生成器方法。下面实现为
ordered_random_generator
的是每个元素的O（1）计算和存储，使得生成整个集合为O（N），但如果在使用每个元素后丢弃它，则为O（1）存储。如果存储元素，实际上这比基于排序的方法慢，因为在计算中计算kth根的成本很高

另一种可能是，您实际上对整组值不感兴趣，而是使用它来获取特定的分位数或顺序统计信息，例如，100个有序元素中的第10个。在这种情况下，您可以使用O（1）存储直接生成具有正确In O（1）时间的随机值

这里是各种选项的实现，显示了生成整个数组的三种方法的计时，并显示了第四种方法的分布有效性

# Your original.
# O(N log N) time due to sort, O(N) storage.
def ordered_random1(n, range_spec = 1.0..n)
  ary = []
  n.times do
    value = rand(range_spec)
    ary << value
  end
  ary.sort!
end

# Same sort-based algorithm using Ruby's Array constructor with a block.
# O(N log N) time due to sort, O(N) storage.
def ordered_random2(n, range_spec = 1.0..n)
  Array.new(n) { rand(range_spec) }.sort!
end

# Generator which uses distributional properties to generate the minimum of
# k uniforms from k = N down to 1, scaling the result down to the remaining
# sub-range of the original range.
# O(1) time per element, O(1) storage.  However, computation time has a very
# large constant due to the transcendental function evaluation for kth root.
def ordered_random_generator(n, range_spec = 1.0..n)
  x = range_spec.first
  upper = range_spec.last
  Enumerator.new do |yielder|
    n.times do |i|
      range = upper - x
      u_min = 1.0 - rand ** (1.0 / (n - i))
      x += range * u_min
      yielder.yield x
    end
  end
end

# Use generator to fill array of size N.
# O(N) time and storage.
def ordered_random3(n, range_spec = 1.0..n)
  gen = ordered_random_generator(n, range_spec)
  Array.new(n) { gen.next }
end

require 'random_variates'   # 'gem install random_variates' to get from rubygems

# Use distributional properties of uniform order statistics to directly
# generate instances of the kth of N values.
# O(1) time, O(1) storage.
def kth_of_n_generator(k:, n:, range_spec: 0.0..1.0)
  # Uniform order stats have a beta distribution. Beta is a ratio of Gammas.
  x = Gamma.new(alpha: k).next
  y = Gamma.new(alpha: n - k + 1).next
  beta = x / (x + y)
  (range_spec.last - range_spec.first) * beta + range_spec.first
end

# Time for Demos!
my_range = 0.1..15.1
puts "SAMPLE OUTPUT FOR RANGE = #{my_range}:"
puts " original: #{ordered_random1(5, my_range)}"
puts "one-liner: #{ordered_random2(5, my_range)}"
puts "generator: #{ordered_random3(5, my_range)}"
puts "direct generation of min & max using kth_of_n_generator: #{
  kth_of_n_generator(k: 1, n: 5, range_spec: my_range)
}, #{
  kth_of_n_generator(k: 5, n: 5, range_spec: my_range)
}"

REPS = 10_000
n = 9
puts "\nDEMO DISTRIBUTIONAL CORRECTNESS OF SINGLETON GENERATOR (range = 0.0..1.0)"
(1..n).each do |k|
  total = Array.new(REPS) { kth_of_n_generator(k: k, n: n) }.inject(:+)
  quantile = k.to_f / (n + 1)
  suffix = case k
    when 1
      "st"
    when 2
      "nd"
    when 3
      "rd"
    else
      "th"
  end
  print "Average of #{REPS} values of #{k}#{suffix} of #{n}: #{total / REPS} "
  puts "[Expected value is #{quantile}]"
end

require 'benchmark/ips'
[100, 10_000].each do |n|
  puts "\nBENCHMARKING ARRAYS OF SIZE #{n}"
  Benchmark.ips do |b|
    b.report(' original:') { ordered_random1(n, my_range) }
    b.report('one-liner:') { ordered_random2(n, my_range) }
    b.report('generator:') { ordered_random3(n, my_range) }
    b.compare!
  end
end

请注意，对于此处测试的两种阵列大小，生成器方法都比两种基于排序的方法慢。由于O（N）vs O（N log N）的渐近行为，对于较大的数组大小，差距正在缩小，但如果您主要关注的是速度，则可能还不足以引起兴趣
 我想把它变成一个函数，因为我会再次使用它，所以我可以创建一个包含X和F（X）值的表，我添加了更多关于这个问题的信息，就像你说的谢谢！太好了，希望答案有帮助。您标记这个RubyonRails有什么特别的原因吗？我看到的是纯Ruby，没有rails。