-2

我有一个数组[2, 4, 6, 8, 3]，我需要将其转换为输出流，如下所示：

2 4 6 8 3

转换为字符串并切断逗号和引号并没有帮助，因为如果它是字符串，它总是打印为“2 4 6 8 3”。

这是给定的输入：

5
2 4 6 8 3

这是我写的代码

def  insertionSort( ar) 
    key = ar.last    
    (ar.size-2).downto(0){ 
        |x|
        if(key < ar[x])
            ar[x+1] = ar[x]
            p ar
        else
            ar[x+1] = key
            p ar
            break
        end
    }
end
# Tail starts here
count = gets.to_i
ar = gets.strip.split.map {|i| i.to_i}

insertionSort( ar )

我的输出：

[2, 4, 6, 8, 8]
[2, 4, 6, 6, 8]
[2, 4, 4, 6, 8]
[2, 3, 4, 6, 8]

预期输出：

2 4 6 8 8 
2 4 6 6 8 
2 4 4 6 8 
2 3 4 6 8

测试结果：失败

4

3 回答 3

2

您的问题根本不清楚，但是，也许这就是您想要的：

ary = [2, 4, 6, 8, 3]
ary.join(' ') # => "2 4 6 8 3"
ary * ' ' # => "2 4 6 8 3"

也许你不明白如何循环？

ary = [2, 4, 6, 8, 3]

5.times do
  puts ary.join(' ')
end
# >> 2 4 6 8 3
# >> 2 4 6 8 3
# >> 2 4 6 8 3
# >> 2 4 6 8 3
# >> 2 4 6 8 3

或者您可能不了解命令行应用程序如何读取 STDIN？

在编写管道时处理 STDIN 很有用：将一个小型专用应用程序链接到另一个，并让它们共同完成一项大任务是 *nix 系统的基本前提。尝试做所有事情的单体应用程序是编写/维护和使用的主要 PITA。

如果您想从 STDIN 或键盘读取单行输入，gets则很好。如果您想阅读一系列内容，请查看 Ruby 的 ARGF 类，并非常熟悉其工作方式STDIN和$stdin工作方式。

编写 Ruby 命令行脚本很容易，但是，就像在 Perl、Python 或 C 中编写一样，您必须知道如何访问传入的数据、它是什么类型的数据（始终是字符串）以及它是如何访问的结构化：由换行符 ( "\n") 或回车+换行符 ( ) 终止的字符"\r\n"。

也许你不明白如何to_i工作？

"2 4 6 8 3".to_i # => 2
"24683".to_i # => 24683
"2_4_6_8_3".to_i # => 24683

to_i从第一个字符开始读取字符串并继续，直到找到一个非数字。因此，在上面的示例中，2是第一个字符串中的第一个数字，后跟一个空格。该空格是非数字，因此to_i停止处理并仅返回2。在第二个示例中，没有空格，因此to_i处理整个字符串并将其作为单个值返回。第三，因为 Ruby 和其他一些语言一样，接受_作为数字字符串的一部分，to_i所以再次返回完整的值。_用于标记值中的逗号位置，例如1_000_000.

当您编写更多代码时，请花时间将其写得清晰干净。您需要能够减少视觉噪音并使其易于进入大脑的代码。Ruby 使编写易于理解的干净和富有表现力的代码变得容易，但糟糕的编码风格会使 Ruby 代码很快变得不可读，尤其是对于我们这些习惯于看到它以惯用风格​​编写的人来说。

这不是试图修复你的算法，它只是为了展示你应该如何设计你的代码：

def insertion_sort(ar)

  key = ar.last    

  (ar.size - 2).downto(0) { |x|
    if (key < ar[x])
      ar[x + 1] = ar[x]
      p ar
    else
      ar[x + 1] = key
      p ar
      break
    end
  }

end

# Tail starts here
count = gets.to_i

ar = gets.strip.split.map { |i| i.to_i }

insertion_sort(ar)
  1. 方法总是用snake_case 编写，而不是CamelCase。
  2. 使用空格；它使您的眼睛和大脑逻辑中断，有助于定义正在发生的事情。运算符和控制结构受益于前后、上下的空格。
  3. 使用空格缩进，制表位设置为 2 个空格。这是 Ruby 标准。为什么是那些？人们在不同编辑器之间移动代码时的一致性；如果您在专业的编码公司工作，您可能会发现更严格的编码标准。
于 2013-10-28T18:29:44.677 回答
0

阅读您引用的 HackerRank “插入点”问题后，输入似乎来自标准输入。如果您的代码包括

s = gets

它会等你输入一个字符串。假设您输入1 2 3 4（没有引号）。然后s将举行"1 2 3 4\n"。

如果要将其转换为数组：

a = s.split # => ["1","2","3","4"]

如果您希望 的元素a是整数，而不是字符串：

a.map! {|e| e.to_i} # => [1,2,3,4]

其中（从 Ruby 版本 1.9 开始）也可以写成：

a.map!(&:to_i) # => [1,2,3,4]

“Ruby 方式”将链接这些操作：

a = gets.split.map(&:to_i) # => [1,2,3,4]

请注意，我们现在不需要!地图。

如果你希望这个数组是i一些（现有数组）的行b

b[i] = a
于 2013-10-28T19:02:36.257 回答
0 
 > a = [1, 2, 3, 4]
 > puts "[#{a.join(', ')}]"

=> [1, 2, 3, 4]

不适用于多维数组或数组中的数组。

 > a = [1, 2, [3, 4, 5, 6], [7, 8, 9]]
 > puts "[#{a.join(', ')}]"

=> [1, 2, 3, 4, 5, 6, 7, 8, 9]

但是，如果你这样做，它应该适用于多维数组：

示例 1：

 > a = [1, 2, [3, 4, 5, 6], [7, 8, 9]]
 > a.each do |sub_a|
 >   puts "[#{a.join(', ')}]"
 > end

=> [1, 2, [3, 4, 5, 6], [7, 8, 9]]

示例 2：

 > a = [1, [2, [3, 4, [5, 6, 7, 8], 9, 0]], 'x', 'y', 'z']
 > a.each do |sub_a|
 >   puts "[#{a.join(', ')}]"
 > end

=> [1, [2, [3, 4, [5, 6, 7, 8], 9, 0]], "x", "y", "z"]
于 2013-10-28T18:35:07.233 回答