ruby​​中字符串中所選字符替換的所有可能組合

Question

我想知道是否有一種簡單的方法以簡單的方式在ruby中完成所選字符替換的每個組合。

一個例子：

string = "this is a test" 
    subs = ['a'=>'@','i'=>'!','s'=>'$'] 
    subs.combination.each { |c| 
     string.gsub c 
    } 

會產生

"this is @ test" 
    "th!s !s a test" 
    "thi$ i$ a te$t" 
    "th!s !s @ test" 
    "thi$ i$ @ te$t" 
    "th!$ !$ a te$t" 
    "th!$ !$ @ te$t" 

感謝您的幫助！

Answer 1

string = "this is a test" 
subs = ['a'=>'@','i'=>'!','s'=>'$'] 

subs = subs.first.map(&:to_a) 
1.upto(subs.length).each do |n| 
    subs.combination(n).each do |a| 
    p a.each_with_object(string.dup){|pair, s| s.gsub!(*pair)} 
    end 
end 

Answer 2

我下面做：

string = "this is a test" 
subs = {'a'=>'@','i'=>'!','s'=>'$'} 

keys = subs.keys 
combinations = 1.upto(subs.size).flat_map { |i| keys.combination(i).to_a } 

combinations.each do |ary| 
    new_string = string.dup 
    ary.each { |c| new_string.gsub!(c,subs) } 
    puts new_string 
end 

輸出

this is @ test 
th!s !s a test 
thi$ i$ a te$t 
th!s !s @ test 
thi$ i$ @ te$t 
th!$ !$ a te$t 
th!$ !$ @ te$t 

Answer 3

我會做使用String#gsub(pattern, hash)如下：

string = "this is a test" 
subs = {'a'=>'@','i'=>'!','s'=>'$'} # copied from @ArupRakshit 
keys = subs.keys 

和核心代碼：

1.upto(keys.length).flat_map { |i| 
    keys.combination(i).flat_map { |c| string.gsub(/[#{c.join}]/, subs) } 
} 

輸出：

=> ["this is @ test", 
"th!s !s a test", 
"thi$ i$ a te$t", 
"th!s !s @ test", 
"thi$ i$ @ te$t", 
"th!$ !$ a te$t", 
"th!$ !$ @ te$t"] 

Answer 4

甲單行官能溶液

string = "this is a test" 
subs = {'a'=>'@','i'=>'!','s'=>'$'} 

(1..subs.size).flat_map { |n| subs.keys.combination(n).to_a }.map { |c| string.gsub(/[#{c.join}]/, subs) } 
# => ["this is @ test", "th!s !s a test", "thi$ i$ a te$t", "th!s !s @ test", "thi$ i$ @ te$t", "th!$ !$ a te$t", "th!$ !$ @ te$t"] 

Answer 5

的另一種方法：

string = "this is a test" 
subs = [{"a"=>"@"}, {"i"=>"!"}, {"s"=>"$"}] 

subs.repeated_combination(subs.size) 
    .map {|e| string.gsub(/./) {|c| (g = e.find {|h| h.key?(c)}) ? g[c] : c}} 
    .uniq 
    #=> ["this is @ test", "th!s !s @ test", "thi$ i$ @ te$t", "th!$ !$ @ te$t", 
    # "th!s !s a test", "th!$ !$ a te$t", thi$ i$ a te$t"] 

說明：

a = subs.repeated_combination(subs.size) 
    # Enumerator... 
    a.to_a 
    # [[{"a"=>"@"},{"a"=>"@"},{"a"=>"@"}], [{"a"=>"@"},{"a"=>"@"},{"i"=>"!"}], 
    # [{"a"=>"@"},{"a"=>"@"},{"s"=>"$"}], [{"a"=>"@"},{"i"=>"!"},{"i"=>"!"}], 
    # [{"a"=>"@"},{"i"=>"!"},{"s"=>"$"}], [{"a"=>"@"},{"s"=>"$"},{"s"=>"$"}], 
    # [{"i"=>"!"},{"i"=>"!"},{"i"=>"!"}], [{"i"=>"!"},{"i"=>"!"},{"s"=>"$"}], 
    # [{"i"=>"!"},{"s"=>"$"},{"s"=>"$"}], [{"s"=>"$"},{"s"=>"$"},{"s"=>"$"}]] 

b = a.map {|e| string.gsub(/./) {|c| (g = e.find {|h| h.key?(c)}) ? g[c] : c}} 
    #=> ["this is @ test", "th!s !s @ test", "thi$ i$ @ te$t", "th!s !s @ test", 
    # "th!$ !$ @ te$t", "thi$ i$ @ te$t", "th!s !s a test", "th!$ !$ a te$t", 
    # "th!$ !$ a te$t", "thi$ i$ a te$t"] 

要了解b的計算方式，傳遞給該塊的a第二元件：

e = [{"a"=>"@"},{"a"=>"@"},{"i"=>"!"}] 

由於該正則表達式的，/./，gsub傳遞的string每個字符c到塊

{|c| (g = e.find {|h| h.key?(c)}) ? g[c] : c} 

搜索結果由e來確定如果三個哈希中的任何一個都有c作爲關鍵字。如果找到一個，即g，則將字符c替換爲g[c];否則，角色保持不變。

請注意，e的前兩個元素是相同的。通過將第一行改爲：

subs.repeated_combination(subs.size).map(&:uniq) 

可以提高效率，但效率不是這種方法的優點之一。

返回到主計算，最後的步驟是：

b.uniq 
    #=> ["this is @ test", "th!s !s @ test", "thi$ i$ @ te$t", "th!$ !$ @ te$t", 
    # "th!s !s a test", "th!$ !$ a te$t", "thi$ i$ a te$t"]