Disemvowel

Question

我正在测试以下问题的可能解决方案。我提出的前两个解决方案＆＃39; disembowel＆＃39; ＆安培; ＆＃39; disembowel_2＆＃39;没有正常运行。我想找出原因。

Disembowel_3是迄今为止我最喜欢的解决方案。但是如果我不明白我的前两个解决方案出了什么问题，我觉得我没有权利使用disembowel_3。

有谁可以帮我弄清楚前两个解决方案有什么问题？

# Write a function disemvowel(string), which takes in a string,
# and returns that string with all the vowels removed. Treat "y" as a
# consonant.

def disemvowel(string)
  string_array = string.split
  vowels = %w[aeiou]
  i = 0
  while i < string.length
    if vowels.include? string[i] == true
      string_array[i] =  " "
    end
    i +=1
  end

  new_string = string_array.join
  new_string = new_string.sub(/\s+/,"")
  return new_string
end


def disemvowel_2(string)
  string_array = string.split('')
  string_array.delete('a','e','i','o','u')
  return string_array.join('')
end

# This is my favorite solution.
def disemvowel_3(string)
  result = string.gsub(/[aeiou]/i, '')
  return result
end


#tests
puts disemvowel("foobar") 
puts disemvowel("ruby") 
puts disemvowel("aeiou")

Answer 1

轻微的改变会使dismvowel正常工作。这是固定的，为什么：

Disemvowel

The Bugs

1）split已更改为string.split("")。没有参数的split将按空格分割，split("")将按字符分割。通过此更改，string_array将成为字符串中每个字符的数组。这也可以使用string.chars更简洁地完成，这是首选方法。

见：

2）vowels已更改为字符串。 %w[]创建了一个单词数组，因此在使用%w[aeiou]时，vowels实际上是一个包含1个字符串"aeiou"的数组。这意味着String#include?和Array#include?都不能与每个角色进行比较。将其更改为常量字符串意味着vowels.include?可以匹配字符。

请参阅：

3）vowels.include?没有parens ，明确地与true进行比较。 Ruby工作的方式，表达式string_array[i] == true的结果传递给vowels.include?，这不是预期的。

一些可以帮助解决这个问题的风格提示：

与true的比较应该是隐含的（例如，不要使用== true）
在调用函数或方法时使用parens。

请参阅：

Omit parens for DSL and keywords; use around all other method invocations部分

4）sub更改为gsub。对sub的调用只会在字符串中进行一次替换，因此在使用＆＃34; fb r＆＃34;进行调用时，只会替换第一个空格，而将字符串＆＃34; fb r＆＃34; 。 gsub执行＆＃34;全局替换＆＃34;，在这种情况下，这正是您想要的。

请参阅：

第一个工作版

工作disemvowel函数如下所示：

def disemvowel(string)
  string_array = string.split("")
  vowels = "aeiou"
  i = 0
  while i < string.length
    if vowels.include?(string[i])
      string_array[i] =  " "
    end
    i +=1
  end

  new_string = string_array.join
  new_string = new_string.gsub(/\s+/,"")
  return new_string
end

并使用您的测试生成此输出：

fbr
rby

清理

1）支持混合元音元音。

def disemvowel_1_1(string)
  string_array = string.split("")
  vowels = "aeiouAEIOU"
  i = 0
  while i < string_array.length
    if vowels.include?(string_array[i])
      string_array[i] =  " "
    end
    i +=1
  end

  new_string = string_array.join
  new_string = new_string.gsub(/\s+/,"")
  return new_string
end

2）始终使用string_array而不是与string混合使用。 string的各种用途在使用string_array时更合适。这应该被替换。

def disemvowel_1_2(string)
  string_array = string.split("")
  vowels = "aeiouAEIOU"
  i = 0
  while i < string_array.length
    if vowels.include?(string_array[i])
      string_array[i] =  " "
    end
    i +=1
  end

  new_string = string_array.join
  new_string = new_string.gsub(/\s+/,"")
  return new_string
end

3）不要将变量用于＆＃34; aeiou＆＃34;。这是一个常量表达式，应该写成字符串文字或常量。在这种情况下，将选择一个文字字符串，因为没有用于限制在全局命名空间中使用常量的封闭范围（如果此代码插入到另一个上下文中）。

def disemvowel_1_3(string)
  string_array = string.split("")
  i = 0
  while i < string_array.length
    if "aeiouAEIOU".include?(string_array[i])
      string_array[i] =  " "
    end
    i +=1
  end

  new_string = string_array.join
  new_string = new_string.gsub(/\s+/,"")
  return new_string
end

4）用nil而不是" "替换元音字符，以取消gsub替换。

def disemvowel_1_4(string)
  string_array = string.split("")
  i = 0
  while i < string_array.length
    if "aeiouAEIOU".include?(string_array[i])
      string_array[i] =  nil
    end
    i +=1
  end

  new_string = string_array.join
  return new_string
end

5）将while循环转换为Array#each_with_index以处理数组元素

def disemvowel_1_5(string)
  string_array = string.split("")
  string_array.each_with_index do |char, i|
    if "aeiouAEIOU".include?(char)
      string_array[i] =  nil
    end
  end

  new_string = string_array.join
  return new_string
end

6）将split("")替换为String#chars，以获取要处理的字符数组。

def disemvowel_1_6(string)
  string_array = string.chars
  string_array.each_with_index do |char, i|
    if "aeiouAEIOU".include?(char)
      string_array[i] =  nil
    end
  end

  new_string = string_array.join
  return new_string
end

7）通过链接结果减少临时变量的数量。这可以最小化Ruby必须跟踪的单个变量的数量，并减少每次引用变量名时发生的变量查找。

def disemvowel_1_7(string)
  string_array = string.chars
  string_array.each_with_index do |char, i|
    if "aeiouAEIOU".include?(char)
      string_array[i] =  nil
    end
  end

  new_string = string_array.join
  return new_string
end

8）删除显式返回以使用Ruby的基于表达式的返回值。

def disemvowel_1_8(string)
  string_array = string.chars
  string_array.each_with_index do |char, i|
    if "aeiouAEIOU".include?(char)
      string_array[i] =  nil
    end
  end.join
end

9）使用Array＃map处理字符，而不是Array#each_with_index。

def disemvowel_1_9(string)
  string.chars.map {|char| "aeiouAEIOU".include?(char) ? nil : char }.join
end

Disemvowel 2

The Bugs

1）将delete替换为delete_if。 Array#delete方法只会删除完全匹配，因此在这种情况下，您必须遍历元音才能使其正常工作。但是，Array#delete_if可让您删除条件，且条件为vowels.include?(element)。

请参阅：

第一个工作版

def disemvowel_2(string)
  string_array = string.split('')
  string_array.delete_if {|element| "aeiou".include?(element) }
  string_array.join('')
end

清理

1）支持混合元音元音。

def disemvowel_2_1(string)
  string_array = string.split('')
  string_array.delete_if {|element| "aeiouAEIOU".include?(element) }
  string_array.join('')
end

2）将split("")替换为String#chars，以获取要处理的字符数组。

def disemvowel_2_2(string)
  string_array = string.chars
  string_array.delete_if {|element| "aeiouAEIOU".include?(element) }
  string_array.join('')
end

3）将join('')更改为join。 join方法已经以这种方式加入，因此额外的参数是多余的

def disemvowel_2_3(string)
  string_array = string.chars
  string_array.delete_if {|element| "aeiouAEIOU".include?(element) }
  string_array.join('')
end

4）通过链接结果减少临时变量的数量。这可以最小化Ruby必须跟踪的单个变量的数量，并减少每次引用变量名时发生的变量查找。

def disemvowel_2_4(string)
  string.chars.delete_if {|element| "aeiouAEIOU".include?(element) }.join
end

Disemvowel 4

String有一个delete方法，可以删除所有匹配的字符。鉴于元音，这是一个简单的实现：

def disemvowel_4(string)
  string.delete("aeiouAEIOU")
end

请参阅：

Array#delete_if

测试

我创建了一个像程序一样的单元测试来进行程序化自我测试，而不是仅仅将不受约束的字符串显示到控制台。这将测试函数的每个版本并报告它是否通过测试：

data = [
  ["foobar", "fbr"],
  ["ruby", "rby"],
  ["aeiou", ""],
  ["AeIoU", ""],
]

data.each do |test|
  puts "disemvowel_1   #{disemvowel_1(test[0]) == test[1] ? 'Pass' : 'Fail'}: '#{test[0]}'"
  puts "disemvowel_1_1 #{disemvowel_1_1(test[0]) == test[1] ? 'Pass' : 'Fail'}: '#{test[0]}'"
  puts "disemvowel_1_2 #{disemvowel_1_2(test[0]) == test[1] ? 'Pass' : 'Fail'}: '#{test[0]}'"
  puts "disemvowel_1_3 #{disemvowel_1_3(test[0]) == test[1] ? 'Pass' : 'Fail'}: '#{test[0]}'"
  puts "disemvowel_1_4 #{disemvowel_1_4(test[0]) == test[1] ? 'Pass' : 'Fail'}: '#{test[0]}'"
  puts "disemvowel_1_5 #{disemvowel_1_5(test[0]) == test[1] ? 'Pass' : 'Fail'}: '#{test[0]}'"
  puts "disemvowel_1_6 #{disemvowel_1_6(test[0]) == test[1] ? 'Pass' : 'Fail'}: '#{test[0]}'"
  puts "disemvowel_1_7 #{disemvowel_1_7(test[0]) == test[1] ? 'Pass' : 'Fail'}: '#{test[0]}'"
  puts "disemvowel_1_8 #{disemvowel_1_8(test[0]) == test[1] ? 'Pass' : 'Fail'}: '#{test[0]}'"
  puts "disemvowel_1_9 #{disemvowel_1_9(test[0]) == test[1] ? 'Pass' : 'Fail'}: '#{test[0]}'"
  puts "disemvowel_2   #{disemvowel_2(test[0]) == test[1] ? 'Pass' : 'Fail'}: '#{test[0]}'"
  puts "disemvowel_2_1 #{disemvowel_2_1(test[0]) == test[1] ? 'Pass' : 'Fail'}: '#{test[0]}'"
  puts "disemvowel_2_2 #{disemvowel_2_2(test[0]) == test[1] ? 'Pass' : 'Fail'}: '#{test[0]}'"
  puts "disemvowel_2_3 #{disemvowel_2_3(test[0]) == test[1] ? 'Pass' : 'Fail'}: '#{test[0]}'"
  puts "disemvowel_2_4 #{disemvowel_2_4(test[0]) == test[1] ? 'Pass' : 'Fail'}: '#{test[0]}'"
  puts "disemvowel_3   #{disemvowel_3(test[0]) == test[1] ? 'Pass' : 'Fail'}: '#{test[0]}'"
  puts "disemvowel_4   #{disemvowel_4(test[0]) == test[1] ? 'Pass' : 'Fail'}: '#{test[0]}'"
end

这将产生以下输出：

>$ ruby disemvowel.rb
disemvowel_1   Pass: 'foobar'
disemvowel_1_1 Pass: 'foobar'
disemvowel_1_2 Pass: 'foobar'
disemvowel_1_3 Pass: 'foobar'
disemvowel_1_4 Pass: 'foobar'
disemvowel_1_5 Pass: 'foobar'
disemvowel_1_6 Pass: 'foobar'
disemvowel_1_7 Pass: 'foobar'
disemvowel_1_8 Pass: 'foobar'
disemvowel_1_9 Pass: 'foobar'
disemvowel_2   Pass: 'foobar'
disemvowel_2_1 Pass: 'foobar'
disemvowel_2_2 Pass: 'foobar'
disemvowel_2_3 Pass: 'foobar'
disemvowel_2_4 Pass: 'foobar'
disemvowel_3   Pass: 'foobar'
disemvowel_4   Pass: 'foobar'
disemvowel_1   Pass: 'ruby'
disemvowel_1_1 Pass: 'ruby'
disemvowel_1_2 Pass: 'ruby'
disemvowel_1_3 Pass: 'ruby'
disemvowel_1_4 Pass: 'ruby'
disemvowel_1_5 Pass: 'ruby'
disemvowel_1_6 Pass: 'ruby'
disemvowel_1_7 Pass: 'ruby'
disemvowel_1_8 Pass: 'ruby'
disemvowel_1_9 Pass: 'ruby'
disemvowel_2   Pass: 'ruby'
disemvowel_2_1 Pass: 'ruby'
disemvowel_2_2 Pass: 'ruby'
disemvowel_2_3 Pass: 'ruby'
disemvowel_2_4 Pass: 'ruby'
disemvowel_3   Pass: 'ruby'
disemvowel_4   Pass: 'ruby'
disemvowel_1   Pass: 'aeiou'
disemvowel_1_1 Pass: 'aeiou'
disemvowel_1_2 Pass: 'aeiou'
disemvowel_1_3 Pass: 'aeiou'
disemvowel_1_4 Pass: 'aeiou'
disemvowel_1_5 Pass: 'aeiou'
disemvowel_1_6 Pass: 'aeiou'
disemvowel_1_7 Pass: 'aeiou'
disemvowel_1_8 Pass: 'aeiou'
disemvowel_1_9 Pass: 'aeiou'
disemvowel_2   Pass: 'aeiou'
disemvowel_2_1 Pass: 'aeiou'
disemvowel_2_2 Pass: 'aeiou'
disemvowel_2_3 Pass: 'aeiou'
disemvowel_2_4 Pass: 'aeiou'
disemvowel_3   Pass: 'aeiou'
disemvowel_4   Pass: 'aeiou'
disemvowel_1   Fail: 'AeIoU'
disemvowel_1_1 Pass: 'AeIoU'
disemvowel_1_2 Pass: 'AeIoU'
disemvowel_1_3 Pass: 'AeIoU'
disemvowel_1_4 Pass: 'AeIoU'
disemvowel_1_5 Pass: 'AeIoU'
disemvowel_1_6 Pass: 'AeIoU'
disemvowel_1_7 Pass: 'AeIoU'
disemvowel_1_8 Pass: 'AeIoU'
disemvowel_1_9 Pass: 'AeIoU'
disemvowel_2   Pass: 'AeIoU'
disemvowel_2_1 Pass: 'AeIoU'
disemvowel_2_2 Pass: 'AeIoU'
disemvowel_2_3 Pass: 'AeIoU'
disemvowel_2_4 Pass: 'AeIoU'
disemvowel_3   Pass: 'AeIoU'
disemvowel_4   Pass: 'AeIoU'

基准

我编写了一个基准程序来测试每个实现的性能。这是基准程序：

Times = 5_000
chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#$%^&*(),./<>?;':\"[]{}\\|-=_+`~".chars
array = Times.times.map { |n| "#{chars.sample(n)}" }

puts "============================================================="
puts RUBY_DESCRIPTION

Benchmark.bm(15) do |x|
  dismevowel_1_report =   x.report("disemvowel_1:")   { array.each {|s| disemvowel_1(s) } }
  dismevowel_1_1_report = x.report("disemvowel_1_1:") { array.each {|s| disemvowel_1_1(s) } }
  dismevowel_1_2_report = x.report("disemvowel_1_2:") { array.each {|s| disemvowel_1_1(s) } }
  dismevowel_1_3_report = x.report("disemvowel_1_3:") { array.each {|s| disemvowel_1_1(s) } }
  dismevowel_1_4_report = x.report("disemvowel_1_4:") { array.each {|s| disemvowel_1_1(s) } }
  dismevowel_1_5_report = x.report("disemvowel_1_5:") { array.each {|s| disemvowel_1_1(s) } }
  dismevowel_1_6_report = x.report("disemvowel_1_6:") { array.each {|s| disemvowel_1_1(s) } }
  dismevowel_1_7_report = x.report("disemvowel_1_7:") { array.each {|s| disemvowel_1_1(s) } }
  dismevowel_1_8_report = x.report("disemvowel_1_8:") { array.each {|s| disemvowel_1_1(s) } }
  dismevowel_1_9_report = x.report("disemvowel_1_9:") { array.each {|s| disemvowel_1_1(s) } }
  dismevowel_2_report   = x.report("disemvowel_2:")   { array.each {|s| disemvowel_2(s) } }
  dismevowel_2_1_report = x.report("disemvowel_2_1:") { array.each {|s| disemvowel_1_1(s) } }
  dismevowel_2_2_report = x.report("disemvowel_2_2:") { array.each {|s| disemvowel_1_1(s) } }
  dismevowel_2_3_report = x.report("disemvowel_2_3:") { array.each {|s| disemvowel_1_1(s) } }
  dismevowel_2_4_report = x.report("disemvowel_2_4:") { array.each {|s| disemvowel_1_1(s) } }
  dismevowel_3_report   = x.report("disemvowel_3:")   { array.each {|s| disemvowel_3(s) } }
  dismevowel_4_report   = x.report("disemvowel_4:")   { array.each {|s| disemvowel_4(s) } }
end

这是基准的输出：

=============================================================
ruby 2.2.2p95 (2015-04-13 revision 50295) [x86_64-darwin14]
                      user     system      total        real
disemvowel_1:     2.630000   0.010000   2.640000 (  3.487851)
disemvowel_1_1:   2.300000   0.010000   2.310000 (  2.536056)
disemvowel_1_2:   2.360000   0.010000   2.370000 (  2.651750)
disemvowel_1_3:   2.290000   0.010000   2.300000 (  2.449730)
disemvowel_1_4:   2.320000   0.020000   2.340000 (  2.599105)
disemvowel_1_5:   2.360000   0.010000   2.370000 (  2.473005)
disemvowel_1_6:   2.340000   0.010000   2.350000 (  2.813744)
disemvowel_1_7:   2.380000   0.030000   2.410000 (  3.663057)
disemvowel_1_8:   2.330000   0.010000   2.340000 (  2.525702)
disemvowel_1_9:   2.290000   0.010000   2.300000 (  2.494189)
disemvowel_2:     2.490000   0.000000   2.490000 (  2.591459)
disemvowel_2_1:   2.310000   0.010000   2.320000 (  2.503748)
disemvowel_2_2:   2.340000   0.010000   2.350000 (  2.608350)
disemvowel_2_3:   2.320000   0.010000   2.330000 (  2.820086)
disemvowel_2_4:   2.330000   0.010000   2.340000 (  2.735653)
disemvowel_3:     0.070000   0.000000   0.070000 (  0.070498)
disemvowel_4:     0.020000   0.000000   0.020000 (  0.018580)

结论

String#delete方法大致优于除String#gsub以外的所有手动解决方案超过100倍，并且比String#gsub快2.5倍。它非常易于使用，并且优于其他一切;这很容易成为最佳解决方案。

Answer 2

这第一个解决方案是官僚主义的，在代码和风格方面存在一些错误。

您将字符串分解为单独的char数组，但使用 string_array = string.split 进行错误处理。或 string_array = string.split（＆＃39;＆＃39;）或 string_array = string.chars （最佳选项）或 string_array = string.each_char。 to_a 即可。如果您"asdfg".split，结果将是["asdfg"]，而不是['a','s','d','f','g']，正如您所期望的那样。
然后你不使用这个（假设的）数组，但继续使用原始字符串。如果您打算这样做，为什么要尝试拆分原始字符串？
最后，您将回到使用数组，根据原始字符串中发生的情况进行更改。正如您所看到的，您继续使用太多的对象，而不是必需的。这违反了KISS原则，结果不正常。

你的第二个解决方案，虽然比第一个解决方案简单得多，但问题是 engineermnky 。 Array＃delete不带五个参数。

最后，你的第三个解决方案虽然运行良好，但可以用更简单的方式编写：

def disemvowel_3(string)
    string.gsub(/[aeiou]/i, '')
end

我一直在告诉人们，在Ruby方法的最后，你不需要明确返回。默认情况下，它将返回计算的最后一个值，无论它是什么。

如果您允许我建议，另一种可能的解决方案是以下列方式使用 Array＃reject ：

def disemvowel(str)
  vowels = %w[a e i o u]
  str.each_char.to_a.reject{ |item| vowels.include?(item) }.join
end

Answer 3

这是一种干净易懂的方法。

首先，您的元音已定义为变量。

string＃chars使您的字符串变成字符数组。

#select遍历字符串数组，查看每个项目。如果不包括该项目（！），则将其转换为小写形式的元音。 #select将该项目插入符合所需项目标准的项目数组中。

没有任何参数的#join会重新组合所有字符，但不包括元音。

这将适用于大写和小写字母。还有标点和空格。

您将获得减去元音的输入。

def disemvowl(string)
    vowels = 'aeiou'
    string.chars.select { |char| !vowels.include?(char.downcase) }.join
end


#p disemvowl('string') # => "strng"

#p disemvowl('s trin  g!?') # => "s trn  g!?"

Answer 4

以下是编写消除元音的方法的几种不同方法。它们分为破坏性和非破坏性两类。这些方法的注释提供了有关这些方法的更多详细信息。在大多数情况下，每个类别中的方法之间的区别在于格式。还有其他需要进一步详细说明的注释。我希望这会有所帮助。

# These methods are what is referred to as destructive. 
# delete!() will delete from the original item

def disemvowl(string)
    vowels = 'aeiou'
    string.each_char { |char| vowels.include?(char.downcase) ? string.delete!(char) : nil }
end

def disemvowl(string)
    vowels = 'aeiou'
    string.each_char { |char| string.delete!(char) if vowels.include?(char.downcase) }
end

def disemvowl(string)
    vowels = 'aeiou'
    string.each_char { |char|
        string.delete!(char) if vowels.include?(char.downcase)
    }
end

def disemvowl(string)
    vowels = 'aeiou'
    string.each_char do |char|
        string.delete!(char) if vowels.include?(char.downcase)
    end
end

# These are nondestructive
# The original is not modified and you are returning a string of selected items.
# Do not forget to flip your operation with (!)

def disemvowl(string)
    vowels = 'aeiou'
    string_new = ''
    string.each_char { |char| !vowels.include?(char.downcase) ? string_new += char : nil }
    string_new
end

def disemvowl(string)
     vowels = 'aeiou'
     string_new = ''
     string.each_char { |char| string_new += char if !vowels.include?(char.downcase) }
     string_new
end

def disemvowl(string)
    vowels = 'aeiou'
    string_new = ''
    string.each_char { |char| 
        string_new += char if !vowels.include?(char.downcase) 
    }
    string_new
end

def disemvowl(string)
    vowels = 'aeiou'
    string.each_char do |char|
        string.delete!(char) if !vowels.include?(char.downcase)
    end
end

# This is what I would do if nondestructive is desired.
# This was my original submission. It is explained step by step there.
# There are many ways to perform a task. 
# Because sometimes it matters how you achieve your outcome.
# I created this more elaborate response.

def disemvowl(string)
    vowels = 'aeiou'
    string.chars.select { |char| !vowels.include?(char.downcase) }.join
end

# This is what I would do if changing the original is desired. 
# This is an if else statement with Ternary Operators ? :
# I use logic as much as possible because it will out perform calling a function to do the same thing
# |thing| this is true about(thing) ? this will happen : <= or this }
# In this case I am saying |char| true(char) ? delete char from string : do nothing }

def disemvowl(string)
    vowels = 'aeiou'    
    string.each_char { |char| vowels.include?(char.downcase) ? string.delete!(char) : nil }
end


#p disemvowl('string') # => "strng"

#p disemvowl('As trIin  g!?') # => "s trn  g!?"

在Ruby中删除字符串中的元音

4 个答案:

Disemvowel

The Bugs

第一个工作版

清理

Disemvowel 2

The Bugs

第一个工作版

清理

Disemvowel 4

测试

基准

结论