如何使用Ruby在数组中查找相同的项？

我有一个这样的数组

@arr  =  ["Ac", "Ba", "Ca", "Dd", "aC", "bD", "cA", "dD"] 

@arr = ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"] 

如果第一封信是大写的，我想交换一下。在这种情况下，Ac变成cA、Ba->aB等。 这就变成这样了

@arr  =  ["Ac", "Ba", "Ca", "Dd", "aC", "bD", "cA", "dD"] 

@arr = ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"] 

然后我想找到相同的项目。在这种情况下，有两种，cA和dD

@newarr = ["cA", "dD"]

到目前为止，我得到的是：

@firstarr = @arr.map{|item| 
      if item[0] =~ /[A-Z]/
        item = item[1]+item[0]
      else
        itme = item
      end
    }

这给

@firstarr = ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"]

---

对于您的倒车标准：

foo = @arr.map do |x|
  (x[0].downcase!).nil? ? x : x.reverse
end
# => ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"]

foo.select { |x| foo.count(x) > 1 }.uniq
# => ["cA", "aC", "dD"]

downcase返回
nil
，使用此，上述代码检查
x[0]
是否可以处于停机状态-d；如果是，这意味着第一个字符是大写的，它与单词相反，否则返回相同的单词

关于复制标准：

foo = @arr.map do |x|
  (x[0].downcase!).nil? ? x : x.reverse
end
# => ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"]

foo.select { |x| foo.count(x) > 1 }.uniq
# => ["cA", "aC", "dD"]

对于您的倒车标准：

foo = @arr.map do |x|
  (x[0].downcase!).nil? ? x : x.reverse
end
# => ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"]

foo.select { |x| foo.count(x) > 1 }.uniq
# => ["cA", "aC", "dD"]

downcase返回
nil
，使用此，上述代码检查
x[0]
是否可以处于停机状态-d；如果是，这意味着第一个字符是大写的，它与单词相反，否则返回相同的单词

关于复制标准：

foo = @arr.map do |x|
  (x[0].downcase!).nil? ? x : x.reverse
end
# => ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"]

foo.select { |x| foo.count(x) > 1 }.uniq
# => ["cA", "aC", "dD"]

对于您的倒车标准：

foo = @arr.map do |x|
  (x[0].downcase!).nil? ? x : x.reverse
end
# => ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"]

foo.select { |x| foo.count(x) > 1 }.uniq
# => ["cA", "aC", "dD"]

downcase返回
nil
，使用此，上述代码检查
x[0]
是否可以处于停机状态-d；如果是，这意味着第一个字符是大写的，它与单词相反，否则返回相同的单词

关于复制标准：

foo = @arr.map do |x|
  (x[0].downcase!).nil? ? x : x.reverse
end
# => ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"]

foo.select { |x| foo.count(x) > 1 }.uniq
# => ["cA", "aC", "dD"]

对于您的倒车标准：

foo = @arr.map do |x|
  (x[0].downcase!).nil? ? x : x.reverse
end
# => ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"]

foo.select { |x| foo.count(x) > 1 }.uniq
# => ["cA", "aC", "dD"]

downcase返回
nil
，使用此，上述代码检查
x[0]
是否可以处于停机状态-d；如果是，这意味着第一个字符是大写的，它与单词相反，否则返回相同的单词

关于复制标准：

foo = @arr.map do |x|
  (x[0].downcase!).nil? ? x : x.reverse
end
# => ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"]

foo.select { |x| foo.count(x) > 1 }.uniq
# => ["cA", "aC", "dD"]

一种旨在提高阅读能力的方法：

代码

arr = ["Ac", "Ba", "Ca", "Dd", "aC", "bD", "cA", "dD"] 

new_arr = arr.map { |str| str[0] == str[0].upcase ? str.reverse : str }
  #=> ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"]

new_arr.group_by { |e| e }
       .select { |_,v| v.size > 1 }
       .keys
  #=> ["cA", "aC", "dD"]  

解释

new\u arr
的计算非常简单

new_arr = ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"]

a = new_arr.group_by { |e| e }
  #=> { "cA"=>["cA", "cA"], "aB"=>["aB"], "aC"=>["aC", "aC"],
  #     "dD"=>["dD", "dD"], "bD"=>["bD"] }

b = a.select { |_,v| v.size > 1 }
  #=> { "cA"=>["cA", "cA"], "aC"=>["aC", "aC"], "dD"=>["dD", "dD"] }

b.keys
  #=> ["cA", "aC", "dD"]

一种旨在提高阅读能力的方法：

代码

arr = ["Ac", "Ba", "Ca", "Dd", "aC", "bD", "cA", "dD"] 

new_arr = arr.map { |str| str[0] == str[0].upcase ? str.reverse : str }
  #=> ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"]

new_arr.group_by { |e| e }
       .select { |_,v| v.size > 1 }
       .keys
  #=> ["cA", "aC", "dD"]  

解释

new\u arr
的计算非常简单

new_arr = ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"]

a = new_arr.group_by { |e| e }
  #=> { "cA"=>["cA", "cA"], "aB"=>["aB"], "aC"=>["aC", "aC"],
  #     "dD"=>["dD", "dD"], "bD"=>["bD"] }

b = a.select { |_,v| v.size > 1 }
  #=> { "cA"=>["cA", "cA"], "aC"=>["aC", "aC"], "dD"=>["dD", "dD"] }

b.keys
  #=> ["cA", "aC", "dD"]

一种旨在提高阅读能力的方法：

代码

arr = ["Ac", "Ba", "Ca", "Dd", "aC", "bD", "cA", "dD"] 

new_arr = arr.map { |str| str[0] == str[0].upcase ? str.reverse : str }
  #=> ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"]

new_arr.group_by { |e| e }
       .select { |_,v| v.size > 1 }
       .keys
  #=> ["cA", "aC", "dD"]  

解释

new\u arr
的计算非常简单

new_arr = ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"]

a = new_arr.group_by { |e| e }
  #=> { "cA"=>["cA", "cA"], "aB"=>["aB"], "aC"=>["aC", "aC"],
  #     "dD"=>["dD", "dD"], "bD"=>["bD"] }

b = a.select { |_,v| v.size > 1 }
  #=> { "cA"=>["cA", "cA"], "aC"=>["aC", "aC"], "dD"=>["dD", "dD"] }

b.keys
  #=> ["cA", "aC", "dD"]

一种旨在提高阅读能力的方法：

代码

arr = ["Ac", "Ba", "Ca", "Dd", "aC", "bD", "cA", "dD"] 

new_arr = arr.map { |str| str[0] == str[0].upcase ? str.reverse : str }
  #=> ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"]

new_arr.group_by { |e| e }
       .select { |_,v| v.size > 1 }
       .keys
  #=> ["cA", "aC", "dD"]  

解释

new\u arr
的计算非常简单

new_arr = ["cA", "aB", "aC", "dD", "aC", "bD", "cA", "dD"]

a = new_arr.group_by { |e| e }
  #=> { "cA"=>["cA", "cA"], "aB"=>["aB"], "aC"=>["aC", "aC"],
  #     "dD"=>["dD", "dD"], "bD"=>["bD"] }

b = a.select { |_,v| v.size > 1 }
  #=> { "cA"=>["cA", "cA"], "aC"=>["aC", "aC"], "dD"=>["dD", "dD"] }

b.keys
  #=> ["cA", "aC", "dD"]

你试过什么？可能的重复和你试过什么？可能的重复和你试过什么？可能的重复和你试过什么？可能的重复