二十一点中牌的总价值

Question

我正在编写一个二十一点纸牌游戏，试图慢慢让自己回到 Swift。

我正在尝试获取玩家手中的牌的总价值。

我遇到的问题是，当我遇到一个可以是 1 或 11 的 ace 时，我不确定在对其进行 XCTest 时如何解释这一点。

// Card model
struct Card {
    
    // Suit enumerated
    enum Suit : Character {
        case spades = "♠", hearts = "♡", diamonds = "♢", clubs = "♣"
    }
    
    // Rank enumerated
    enum Rank : Int {
        case two = 2, three, four, five, six, seven, eight, nine, ten
        case jack, queen, king, ace
                    
        struct Values {
            let first: Int, second : Int?
        }
        
        var values: Values {
            switch self {
            case .ace:
                return Values(first: 1, second: 11)
            case .jack, .queen, .king:
                return Values(first: 10, second: nil)
            default:
                return Values(first: self.rawValue, second: nil)
            }
        }
    }
    
    let rank: Rank, suit : Suit
    
    var value : Rank.Values {
        return self.rank.values
    }
}

当我来测试它时，

// XCTest
func testSumOfCardsEquals21() {
    let card1 = Card(rank: .jack, suit: .diamonds) //10
    let card2 = Card(rank: .four, suit: .diamonds) //4
    let card3 = Card(rank: .three, suit: .diamonds) //3
    let card4 = Card(rank: .ace, suit: .diamonds) //1 or 11
    
    let hand = [card1, card2, card3, card4]
    
    var total = 0
    for card in hand {
        let values = card.value
        if (values.second == nil) {
            total += values.first
        } else {
            let secondValue = values.second!
            total += secondValue
        }
    }
    
    // expected 21
    XCTAssertEqual(total, 21) // this will fail and return 28
}

在这种情况下，你希望 A 的值较低。

在您可能只有一张牌（A）的情况下，您希望它很高。

我不知道如何解决这样的测试要求。

...

为了澄清，当一张牌可以有两个值时，如何制作一个函数，测试计算手牌的总价值以返回预期的 21 总价值？

我感谢您的帮助和时间。

Answer 1

那手牌的点数是 18，而不是 21。

Values 类型可能没有用——这些牌实际上没有原始值。

如果不先收集所有卡片，您就无法知道如何计算分数。

enum Rank: CaseIterable {
  case two, three, four, five, six, seven, eight, nine, ten
  case jack, queen, king
  case ace
}

struct Hand {
  init<Cards: Sequence>(cards: Cards) where Cards.Element == Card {
    let reduction = cards.reduce(into: (score: 0, aceCount: 0)) {
      switch $1.rank {
      case .jack, .queen, .king:
        $0.score += 10
      case .ace:
        $0.score += 1
        $0.aceCount += 1
      default:
        $0.score += try! $1.rank.caseIndex + 2
      }
    }

    var score = reduction.score
    reduction.aceCount.iterations
      .prefix { score <= 12 }
      .forEach { score += 9 }
    self.score = score
  }

  let score: Int
}

Hand(cards: [card1, card2, card3, card4]).score

---

public extension ExpressibleByIntegerLiteral where Self: Strideable, Stride: SignedInteger {
  /// *This many* iterations that produce no values.
  var iterations: LazyMapSequence<Range<Self>, Void> {
    (0..<self).lazy.map { _ in }
  }
}

public extension CaseIterable where Self: Equatable {
  /// The first match for this case in `allCases`.
  /// - Throws: `AllCasesError<Self>.noIndex`
  var caseIndex: AllCases.Index {
    get throws {
      do { return try Self.allCases.firstIndex(of: self).unwrapped }
      catch { throw AllCasesError.noIndex(self) }
    }
  }
}

public enum AllCasesError<Case: CaseIterable>: Error {
  /// No `AllCases.Index` corresponds to this case.
  case noIndex(Case)
}

public extension Optional {
  /// Represents that an `Optional` was `nil`.
  enum UnwrapError: Error {
    case `nil`
    case typeMismatch
  }

  /// [An alterative to overloading `??` to throw errors upon `nil`.](
  /// https://forums.swift.org/t/unwrap-or-throw-make-the-safe-choice-easier/14453/7)
  /// - Note: Useful for emulating `break`, with `map`, `forEach`, etc.
  /// - Throws: `UnwrapError` when `nil`.
  var unwrapped: Wrapped {
    get throws {
      switch self {
      case let wrapped?:
        return wrapped
      case nil:
        throw UnwrapError.nil
      }
    }
  }
}