1

我有一个向量向量，用来表示一副纸牌：

[["A" "D"] ["K" "H"] ["K" "C"] ["K" "S"] ["K" "D"] ["Q" "H"] ["Q" "C"] ["Q" "S"]
 ["Q" "D"] ["J" "H"] ["J" "C"] ["J" "S"] ["J" "D"] ["T" "H"] ["T" "C"] ["T" "S"]
 ["T" "D"] ["9" "H"] ["9" "C"] ["9" "S"] ["9" "D"] ["8" "H"] ["8" "C"] ["8" "S"]
 ["8" "D"] ["7" "H"] ["7" "C"] ["7" "S"] ["7" "D"] ["6" "H"] ["6" "C"] ["6" "S"]
 ["6" "D"] ["5" "H"] ["5" "C"] ["5" "S"] ["5" "D"] ["4" "H"] ["4" "C"] ["4" "S"]
 ["4" "D"] ["3" "H"] ["3" "C"] ["3" "S"] ["3" "D"] ["2" "H"] ["2" "C"] ["2" "S"]
 ["2" "D"]]

在某些时候，我想“处理”一些牌并将这些牌从牌组中移除。

如果您想告诉我使用 seq 也可以，实际上我的原始文件是向量的 seq，所以这两种方式对我来说都没有关系。

我知道我可能想创建一个“remaining-deck”原子并从这个 seq 或向量中删除项目。

我打算开源这个，这是代码的相关部分：

(def suits ["H" "C" "S" "D"])
(def ranks ["A" "K" "Q" "J" "T" "9" "8" "7" "6" "5" "4" "3" "2"])

(def deck (for [x ranks
                y suits]
            [x y]))


;; alternative deck that creates vector:

(def deck2 (vec (for [x ranks
                y suits]
            [x y])))

;;Another way to do it: While it's fine if I have a sequence of string pairs, I'd rather use vectors of vectors because I think destructuring will work better plus I think it'll be consistent across the program. 

(def deck3 (for [x ranks
                y suits]
            (str x y)))


(def hand [(rand-nth deck) (rand-nth deck)])

(def full-hand (concat board hand))

看起来我可以通过使用一些 .indexOf 函数来连接 subvecs 并将其扔进一个原子中，但我不禁认为这是 hacky 并且 Lisp 应该能够做得比这更好。我真的无法在任何地方找到任何关于此的好信息。我知道删除和过滤，但那些似乎没有做任何事情，只是抛出错误。

编辑：为什么投反对票？我只是在发牌后尝试更新套牌。

因此，如果我代表一个较小的牌组：

[["A" "D"] ["K" "H"] ["K" "C"] ["K" "S"] ["K" "D"] ["Q" "H"] ["Q" "C"] ["Q" "S"]]

然后在从 (ex: player is deal ["Q" "S"] ["Q" "C"] 更新之后，剩余的牌组应该如下所示：

[["A" "D"] ["K" "H"] ["K" "C"] ["K" "S"] ["K" "D"] ["Q" "H"]]

这样在剩下的交易中就没有共享手牌或重复牌。

4

2 回答 2

2

我不确定我是否正确理解了你的问题，但无论我收集到什么，我都会将套牌表示为一个包裹在一个原子中的集合，并且每手牌都更新原子。

(def suits ["H" "C" "S" "D"])
(def ranks ["A" "K" "Q" "J" "T" "9" "8" "7" "6" "5" "4" "3" "2"])

(def deck (atom  (->> (for [x ranks
                            y suits]
                        [x y])
                      (into #{}))))

(defn hand []
  (-> (rand-int (count @deck))
      (drop @deck)
      (first)))

(defn play-hand []
  (swap! deck clojure.set/difference #{(hand)}))

(play-hand)
于 2013-03-23T08:09:38.533 回答
1

我知道这已经接受了一个答案，但是你确信你想在这里介绍状态吗？我会考虑deck作为参数传递给hand等。当你想并行处理双手时会发生什么？

于 2013-03-24T13:44:18.177 回答