Ruby 如何在行尾截断int

我有一个类似于以下内容的txt文件：

f1, max, inputs: 10 2 4

f2, sum, inputs: 2 4 5

f3, prod, inputs: 6 5

我应该从最大值为10的行中找到最大值，从其中的和为11的行中打印数字的和，从其中的乘积为30的行中打印数字的和

我的代码如下所示：

f = File.open("test.txt") or die "Unable to open file..."
contentArray=[]
f.each_line {|line|
    contentArray.push line
}

i=0
while i<contentArray.size() do
    if contentArray[i].include? "max"
        print "max is here"
        i+=1
    elsif contentArray[i].include? "sum"
        print "sum is here"
        i+=1
    elsif contentArray[i].include? "prod"
        print "prod is here"
        i+=1
    end
end

content_array.each do |li|
  values = li.scan(/\b \d+ \b/x).map(&:to_i)

  operation, result = case li
          when /\b max \b/x
            ['max', values.max] 
          when /\b sum \b/x
            ['sum', values.sum]
          when /\b prod \b/x
            ['prod', values.inject(:*)]
          end
  puts "#{operation}: #{result}"
end

---

我可以找到哪一行有max、sum或prod字符串，但我不知道应该如何从末尾切掉整数并用它们进行计算。

试一试这样的东西：

content_ary.each do |content_str|
  segments_ary = content_str.split(':')
  integers_ary = segments_ary[1].strip.split(' ').map{|int_str| int_str.to_i}
  tags_ary = segments_ary[0].strip.split(',')
  case tags_ary[1].strip
  when "max"
    puts "max is here"
    puts "#{integers_ary}"
  when "sum"
    puts "sum is here"
    puts "#{integers_ary}"
  when "prod"
    puts "prod is here"
    puts "#{integers_ary}"
  end
end

首先，使用snake_盒而不是camelCase更为鲁比。因此，是内容数组，而不是内容数组

然后，执行content_ary.each do | content_str |而不是while i 其次,

将每行拆分为两个元素的数组，每个元素从“：”的左侧和右侧开始内容

integers_ary = segments_ary[1].strip.split(' ').map{|int_str| int_str.to_i}

在右侧提取整数：

  segments_ary[1]              <= selects the right-hand side
  strip                        <= removes leading and trailing white spaces
  split(' ')                   <= creates an array of strings
  map{|int_str| int_str.to_i}  <= converts the strings to integers

然后： tags_ary=段[0]。strip.split'，'

提取“：”左侧的标记

现在，用case语句代替if。。。埃尔西夫。。。埃尔西夫

代码

line.split/，*|：*|+？=\d/读取，在一个逗号上拆分行，后跟零个或多个空格，或在一个冒号上拆分行，后跟零个或多个空格，或在一个数字后面拆分行？=\d表示正向前瞻。该线路的运行方式如下

line = "f1, max, inputs: 10 2 4"
_, op, _, *a = line.split(/, *|: *| +(?=\d)/)
   #=> ["f1", "max", "inputs", "10", "2", "4"]
op #=> "max"
a  #=> ["10", "2", "4"]

范例

首先创建一个测试文件

contents =<<-_
f1, max, inputs: 10 2 4
f2, sum, inputs: 2 4 5
f3, prod, inputs: 6 5
_

FName = 'temp'
File.write(FName, contents)
  #=> 69

打印所需的结果

print_totals FName
max [10, 2, 4] = 10
sum [2, 4, 5] = 11
prod [6, 5] = 30

---

如果可以确定，第一个字段“f1”，。。。。始终以字母字符开头，一个便宜的解决方案是简单地在空格上拆分行：

fields = line.split(' ')

或

取决于你的口味

然后你就可以拿到数字了

numbers = fields.select { |element| /^\d/ =~ element }.map(&:to_i)

例如，作为一个副作用，您还可以免费获得操作符

case fields[1]
when 'sum,'
  result = numbers.reduce(:+)
when 'max,'
  ...
end

当然，这是假设输入严格符合这种格式。如果无法确保这一点，例如，因为输入文件是由人手动创建的，则应在输入格式上添加一些卫生检查。

考虑以下事项：

content_array = [
  'f1, max, inputs: 10 2 4',
  'f2, sum, inputs: 2 4 5',
  'f3, prod, inputs: 6 5'
]

我会这样解决基本问题：

f = File.open("test.txt") or die "Unable to open file..."
contentArray=[]
f.each_line {|line|
    contentArray.push line
}

i=0
while i<contentArray.size() do
    if contentArray[i].include? "max"
        print "max is here"
        i+=1
    elsif contentArray[i].include? "sum"
        print "sum is here"
        i+=1
    elsif contentArray[i].include? "prod"
        print "prod is here"
        i+=1
    end
end

content_array.each do |li|
  values = li.scan(/\b \d+ \b/x).map(&:to_i)

  operation, result = case li
          when /\b max \b/x
            ['max', values.max] 
          when /\b sum \b/x
            ['sum', values.sum]
          when /\b prod \b/x
            ['prod', values.inject(:*)]
          end
  puts "#{operation}: #{result}"
end

哪些产出：

max: 10
sum: 11
prod: 30

这样做可以在不更改代码的情况下处理更多添加到行尾的数字

如果我添加了其他记录：

'f4, prod, inputs: 6 5 4 3 2'

我会得到：

prod: 720

细分：

values = li.scan(/\b \d+ \b/x) # => ["10", "2", "4"], ["2", "4", "5"], ["6", "5"]
  .map(&:to_i)                 # => [10, 2, 4],       [2, 4, 5],       [6, 5]

---

其中/\b\d+\b/x是搜索独立数字的Regexp模式

当询问如何做某事时，我们希望您向我们展示您为解决问题所做努力的证据。当你展示你是如何循环的时候，你没有表现出任何努力去解决你所问的部分。如果没有这些，看起来你没有试着让我们为你写。见和。

prod: 720

values = li.scan(/\b \d+ \b/x) # => ["10", "2", "4"], ["2", "4", "5"], ["6", "5"]
  .map(&:to_i)                 # => [10, 2, 4],       [2, 4, 5],       [6, 5]