Ruby on rails 在ruby中合并到数组不工作

输出 [0,2,4,6,8][0,3,6,9]

我需要像[0,0,2,3,4,6,6,8,9]这样的输出 使用SORTER

a.concat（b）

将永远改变

a

相反，您可以让

merge

返回一个新数组，其中包含

a

和

b

def get_firstArray
    a = Array.new(5)

    number =Array.new(5){ |index| index * 2 }
    return  print number
    puts
end
def get_secondtArray
    a = Array.new(4)

    number =A rray.new(4){ |index| index * 3 }
    return print number
    puts
end
a = get_firstArray
b = get_secondtArray

def merge(a, b)

    mer= a.concat b
     return mer
end

a.concat（b）

将永远改变

a

相反，您可以让

merge

返回一个新数组，其中包含

a

和

b

def get_firstArray
    a = Array.new(5)

    number =Array.new(5){ |index| index * 2 }
    return  print number
    puts
end
def get_secondtArray
    a = Array.new(4)

    number =A rray.new(4){ |index| index * 3 }
    return print number
    puts
end
a = get_firstArray
b = get_secondtArray

def merge(a, b)

    mer= a.concat b
     return mer
end

a.concat（b）

将永远改变

a

相反，您可以让

merge

返回一个新数组，其中包含

a

和

b

def get_firstArray
    a = Array.new(5)

    number =Array.new(5){ |index| index * 2 }
    return  print number
    puts
end
def get_secondtArray
    a = Array.new(4)

    number =A rray.new(4){ |index| index * 3 }
    return print number
    puts
end
a = get_firstArray
b = get_secondtArray

def merge(a, b)

    mer= a.concat b
     return mer
end

a.concat（b）

将永远改变

a

相反，您可以让

merge

返回一个新数组，其中包含

a

和

b

def get_firstArray
    a = Array.new(5)

    number =Array.new(5){ |index| index * 2 }
    return  print number
    puts
end
def get_secondtArray
    a = Array.new(4)

    number =A rray.new(4){ |index| index * 3 }
    return print number
    puts
end
a = get_firstArray
b = get_secondtArray

def merge(a, b)

    mer= a.concat b
     return mer
end

返回

nil

，因此您希望返回

number

而不是

print number

。在

return

之后不执行任何操作，因此可以删除方法末尾的

put

。方法自动返回最后一条语句的结果，因此不需要

return

或

number

变量。你在方法中创建了两次数组，所以我们可以去掉第一个。您永远不会调用

merge

方法，该方法也不需要

return

语句。方法名不是标准的驼峰大小写，即类似于

get\u first\u array

的内容将匹配Ruby标准。您永远不会对合并的数组进行排序。把这些放在一起，你会得到如下结果：

def get_first_array
  Array.new(5) {|index| index * 2 }
end

def get_second_array
  Array.new(4) {|index| index * 3 }
end

def merge(a, b)
  (a+b).sort
end

a = get_first_array    # [0, 2, 4, 6, 8]
b = get_second_array   # [0, 3, 6, 9]

c = merge(a, b)        # [0, 0, 2, 3, 4, 6, 6, 8, 9]  

作为旁注，以下是我将如何从头开始编写这篇文章（主要区别在于不使用单行程序的方法：

def evens
  Array.new(5) { |index| index * 2 }
end

def triples
  Array.new(4) { |index| index * 3 }
end

e = evens
t = triples

def merge(a, b)
  a.concat b
end
puts merge(e, t).sort

返回

nil

，因此您希望返回

number

而不是

print number

。执行

return

后不执行任何操作，因此您可以删除方法末尾的

put

。方法自动返回最后一条语句的结果，因此您不需要

return

或

numberr

变量。您在方法中创建了两次数组，因此我们可以去掉第一个。您从未调用

merge

方法，该方法也不需要

return

语句。方法名称不是标准的驼峰大小写，即类似

get\u first\u array

之类的东西会匹配Ruby标准。您永远不会这样做r对合并的数组进行排序。将这些数组放在一起，最终得到如下结果：

def get_first_array
  Array.new(5) {|index| index * 2 }
end

def get_second_array
  Array.new(4) {|index| index * 3 }
end

def merge(a, b)
  (a+b).sort
end

a = get_first_array    # [0, 2, 4, 6, 8]
b = get_second_array   # [0, 3, 6, 9]

c = merge(a, b)        # [0, 0, 2, 3, 4, 6, 6, 8, 9]  

作为旁注，以下是我将如何从头开始编写这篇文章（主要区别在于不使用单行程序的方法：

def evens
  Array.new(5) { |index| index * 2 }
end

def triples
  Array.new(4) { |index| index * 3 }
end

e = evens
t = triples

def merge(a, b)
  a.concat b
end
puts merge(e, t).sort

返回

nil

，因此您希望返回

number

而不是

print number

。执行

return

后不执行任何操作，因此您可以删除方法末尾的

put

。方法自动返回最后一条语句的结果，因此您不需要

return

或

numberr

变量。您在方法中创建了两次数组，因此我们可以去掉第一个。您从未调用

merge

方法，该方法也不需要

return

语句。方法名称不是标准的驼峰大小写，即类似

get\u first\u array

之类的东西会匹配Ruby标准。您永远不会这样做r对合并的数组进行排序。将这些数组放在一起，最终得到如下结果：

def get_first_array
  Array.new(5) {|index| index * 2 }
end

def get_second_array
  Array.new(4) {|index| index * 3 }
end

def merge(a, b)
  (a+b).sort
end

a = get_first_array    # [0, 2, 4, 6, 8]
b = get_second_array   # [0, 3, 6, 9]

c = merge(a, b)        # [0, 0, 2, 3, 4, 6, 6, 8, 9]  

作为旁注，以下是我将如何从头开始编写这篇文章（主要区别在于不使用单行程序的方法：

def evens
  Array.new(5) { |index| index * 2 }
end

def triples
  Array.new(4) { |index| index * 3 }
end

e = evens
t = triples

def merge(a, b)
  a.concat b
end
puts merge(e, t).sort

返回

nil

，因此您希望返回

number

而不是

print number

。执行

return

后不执行任何操作，因此您可以删除方法末尾的

put

。方法自动返回最后一条语句的结果，因此您不需要

return

或

numberr

变量。您在方法中创建了两次数组，因此我们可以去掉第一个。您从未调用

merge

方法，该方法也不需要

return

语句。方法名称不是标准的驼峰大小写，即类似

get\u first\u array

之类的东西会匹配Ruby标准。您永远不会这样做r对合并的数组进行排序。将这些数组放在一起，最终得到如下结果：

def get_first_array
  Array.new(5) {|index| index * 2 }
end

def get_second_array
  Array.new(4) {|index| index * 3 }
end

def merge(a, b)
  (a+b).sort
end

a = get_first_array    # [0, 2, 4, 6, 8]
b = get_second_array   # [0, 3, 6, 9]

c = merge(a, b)        # [0, 0, 2, 3, 4, 6, 6, 8, 9]  

作为旁注，以下是我将如何从头开始编写这篇文章（主要区别在于不使用单行程序的方法：

def evens
  Array.new(5) { |index| index * 2 }
end

def triples
  Array.new(4) { |index| index * 3 }
end

e = evens
t = triples

def merge(a, b)
  a.concat b
end
puts merge(e, t).sort

---

这个问题归结为一种组合排序数组

a

和

b

，从而对结果数组进行排序。自然的解决方案是

（a+b）.sort

，但考虑到

a

和

b

已经排序，这是相对低效的。合并两个排序的数组必须是一个相当常见的要求，因此我考虑了如何高效地完成这项工作

我选择的方法非常简单（这有点令人失望）；很可能有更好（或至少更干净）的算法我不知道。顺便说一句，我考虑了一下以前的

Enumerable#slice_

是否可以利用，但结果是空的

def get_first_array
  Array.new(5) {|index| index * 2 }
end

def get_second_array
  Array.new(4) {|index| index * 3 }
end

def merge(a, b)
  (a+b).sort
end

a = get_first_array   
b = get_second_array   

c = merge(a, b)

print c

def merge_排序（a、b）
sa，sb=a码，b码
ia=ib=0
c=[]
环道
（返回c+a[ia..-1]）如果（ib==sb）
（返回c+b[ib..-1]）如果（ia==sa）
如果a[ia]c这个问题可以归结为一种组合排序数组
a
和
b
，从而对结果数组进行排序。自然的解决方案是
（a+b）.sort
，但考虑到
a
和
b
已经排序，这是相对低效的。合并两个排序的数组必须是一个相当常见的要求，因此我考虑了如何高效地完成这项工作

我决定的方式非常直截了当（这有点令人失望）；很可能会有