algorithm - Ruby 编程测验

Question

请帮我解决ruby程序

让我们假设您有三个字符串 s1、s2 和 s3。现在编码 F(s1, s2, s3) 应该是 s1 的最短连续子序列，这样它具有 s2 的所有字符而没有 s3 的字符。s2 有唯一字符

例如:s1 = "peeeeloisagood", s2 = "le", s3 = "z"。 Ans = el

Answer 1

这应该可以做到。 (不要被我在@AFaderDarkly 之前发布的事实所迷惑，他有类似的答案。我原来的答案有一个缺陷。当我注意到它时，我删除了我的答案并着手修复。在我完成之前暗中发布修复，但直到我取消删除修改后的答案我才知道。)

代码

def find_it(s1,s2,s3)
  arr = s1.chars
  good = s2.chars
  bad = s3.chars    
  (good.size..arr.size).each { |n| arr.each_cons(n) { |c|
    return c.join if (good-c).empty? && (c-bad) == c } }
  nil
end

示例

find_it("peeeeloisagood", "le", "z") #=> "el"
find_it("abcdezfherdzn", "def", "z") #=> "fherd"

解释

令 s1、s2 和 s3 与上面的第二个示例相同:

s1 = "abcdezfherdzn"
s2 = "def"
s3 = "z"

我们将首先查看长度为2(s2 的大小)的s1 的子字符串。如果我们找到包含 s2 的所有字母的一个，我们就完成了(因为它不能包含 s3 的任何字母)。如果我们没有找到匹配项，我们将查看长度为 3 的 s1 的子字符串。如果我们找到一个包含 s2 的所有字母但不包含 s3 的子字符串，我们就完成了，依此类推。如果 s1 的任何长度的子串都不包含 s2 的所有字母且不包含 s3 的任何字母，则 nil 返回。

arr = s1.chars
  #=> ["a", "b", "c", "d", "e", "z", "f", "h", "e", "r", "d", "z", "n"]
good = s2.chars
  #=> ["d", "e", "f"]
bad = s3.chars    
  #=> ["z"]

enum1 = (good.size..arr.size).each
  #=>   (3..13).each
  #=>   #<Enumerator: 3..13:each>

我们可以将枚举器转换为数组，并将其传递到其 block 中:

enum1.to_a
  #=> [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

这个枚举器首先将 3 传递给它的 block 并将其分配给 block 变量:

n = 3

enum2 = arr.each_cons(n)
  #=>   #<Enumerator: ["a", "b", "c", "d", "e", "z", "f", "h",
  #                    "e", "r", "d", "z", "n"]:each_cons(3)> 
enum2.to_a
  #=> [["a", "b", "c"], ["b", "c", "d"], ["c", "d", "e"], ["d", "e", "z"],
  #    ["e", "z", "f"], ["z", "f", "h"], ["f", "h", "e"], ["h", "e", "r"],
  #    ["e", "r", "d"], ["r", "d", "z"], ["d", "z", "n"]]

它首先将 ["a", "b", "c"] 传递到 block 中并将其分配给 block 变量:

c = ["a", "b", "c"]

并执行

return c.join if (good-c).empty? && (c-bad) == c 
  #=> return "abc" if (["d", "e", "f"]-["a", "b", "c"]).empty? &&
  #                   (["a", "b", "c"] - ["z"]) == ["a", "b", "c"]
  #=> return "abc" if (["d", "e", "f"]).empty? && 
                      (["a", "b", "c"]) == ["a", "b", "c"]
  #=> return "abc" if false and true
  #=> false

这一直持续到数组 ["d", "e", "z", "f"] 出现，此时我们获得:

return c.join if (good-c).empty? && (c-bad) == c 
  #=> return "dezf" if (["d", "e", "f"]-["d", "e", "z", "f"]).empty? &&
                       (["d", "e", "z", "f"]-["z"]) == ["d", "e", "z", "f"]
  #=> return "dezf" if [].empty? && ["d", "e", "f"] == ["d", "e", "z", "f"]
  #=> return "dezf" if true && false
  #=> false

因此我们也拒绝该子字符串，这次是因为 z 的存在。

当我们到达

c = ["f", "h", "e", "r", "d"]

我们得到:

 return c.join if (good-c).empty? && (c-bad) == c 
   #=> return "fherd" if (["d", "e", "f"]-["f", "h", "e", "r", "d"]).empty? &&
                (["f", "h", "e", "r", "d"]-["z"]) == ["f", "h", "e", "r", "d"]
   #=> return "fherd" if [].empty? &&
                 ["f", "h", "e", "r", "d"] == ["f", "h", "e", "r", "d"]
   #=>return "fherd" if true && true

因此返回 "fherd"。