ruby - 创建任意字符层次结构

Question

假设我有 4 个字符，A、P、B、N。我希望能够比较它们：

A > P > B > N > A

这将如何在 Ruby 中完成？

Answer 1

从您的评论来看，您似乎不是试图将这些元素按顺序排列，而是在其中一些元素之间定义一些二元关系。在 Ruby 中可以通过多种方式做到这一点，这取决于您以后打算如何使用该关系。

最简单的就是定义相关元素的有序对：

MAP = [
  ['A', 'P'],
  ['P', 'B'],
  ['B', 'N'],
  ['N', 'A']
]

然后在需要“比较”两个元素时使用它。

def beats? one, other
  MAP.member?([one, other])
end

beats? 'A', 'B'
# => false 
beats? 'A', 'P'
# => true 
beats? 'N', 'A'
# => true 

PS。您可以使用类似的东西从字符串生成地图

MAP = 'APBNA'.chars.each_cons(2).to_a

Answer 2

一种可能的解决方案是创建一个类，例如，characterandweight或 something。并在其中实现<=>运算符（方法）。

不要忘记在Comparable这个类中包含 mixin。

class ComparableCharacter
  include Comparable
  attr_accessor :character, :weight

  def <=>(another)
    weight <=> another.weight
  end
end

Answer 3

a = "APBN"
h = {};(0...a.size).each{|i| h[a[i].chr] = i}
b = ['A','P','A','N', 'B','P']
b.sort_by{|t| h[t] }

当然，这不适用于您的示例，因为您的排序错误 - 您永远不会有 A > P > A，但至少它向您展示了如何根据您想要的顺序进行排序。

Answer 4

如果有人感兴趣，这是我的建议（三元比较——因为比较不是二元运算！！！）：

class RockPaperScissors

  ITEMS = %W(A P B N)

  def self.compare(item, other_item)
    new(item).compare other_item
  end


  def initialize(item)

    # input validations?

    @item = item
  end

  def compare(other_item)

    # input validations?

    indexes_subtraction = ITEMS.index(@item) - ITEMS.index(other_item)

    case indexes_subtraction
    when 1, -1
      - indexes_subtraction
    else
      indexes_subtraction <=> 0
    end

  end

end

require 'test/unit'
include MiniTest::Assertions

assert_equal RockPaperScissors.compare('A', 'A'), 0
assert_equal RockPaperScissors.compare('P', 'P'), 0
assert_equal RockPaperScissors.compare('B', 'B'), 0
assert_equal RockPaperScissors.compare('N', 'N'), 0
assert_equal RockPaperScissors.compare('A', 'P'), 1
assert_equal RockPaperScissors.compare('P', 'A'), -1
assert_equal RockPaperScissors.compare('P', 'B'), 1
assert_equal RockPaperScissors.compare('B', 'P'), -1
assert_equal RockPaperScissors.compare('B', 'N'), 1
assert_equal RockPaperScissors.compare('N', 'B'), -1
assert_equal RockPaperScissors.compare('N', 'A'), 1
assert_equal RockPaperScissors.compare('A', 'N'), -1

---

解释

平等：（A，A）比较

1. 指数：iA：0；iA: 0
2. iA - iA = 0
3. A 等于 A，所以我们可以返回 0

多数：（A，P）

1. 指数：iA：0；知识产权：1
2. iA - iP = -1
3. A > P，所以我们必须得到1；我们可以使用-函数：- (-1) -> 1

少数：（P，A）

1. 指数：iP：1；iA: 0
2. iP - iA = 1
3. P < A，所以我们必须得到-1；我们可以使用-函数：- (1) -> -1

边缘情况 1：（N，A）

1. 指数：iN：3，iA：0
2. iN - iA = 3
3. N > A，所以我们必须得到1；我们可以使用<=>函数：(3 <=> 0) -> 1

边缘情况 2：（A，N）

1. 指数：iA：0，iN：3
2. iA - iN = -3
3. A < N，所以我们必须得到-1；我们可以使用<=>函数：(3 <=> 0) -> 1

剩下的就是重构：0可以0用<=>函数转换成。