如何在Clojure中使用频率来组合相同的频率并显示一次？

Question

I making a poker hands game in clojure. I have to define a function such that such that it returns the ranks in the descending order. For example: order ["2H" "3S" "6C" "5D" "4D"] should return (6 5 4 3 2). But if there is a two-pair like this: ["5H" "AD" "5C" "7D" "AS"] then it should return (14 5 7), but mine returns [14 14 7 5 5], how can I correct this? It should work in the same way for other cases of poker hands as well like for a full house it should give the rank of the three of a kind and the rank of the two of a kind. So, for this I have written:

(defn order
                [hand]
                "Return a list of the ranks, sorted highest first"
                (let [ranks (reverse (sort (map #(.indexOf "--23456789TJQKA" %)
                                                (map #(str (first %)) hand))))]
                  (if (= ranks [14 5 4 3 2])
                    [5 4 3 2 1]
                    (into [] ranks))))

I have also written all the other poker hand functions like flush?, straight? etc.

Also, I have to define another function such that it takes two orders like '(8 5 9) '(8 7 3) and returns true if the first has the larger value of the first difference, else false. Could someone please give me an idea how to do this?

Answer 1

Updated to show sorting by count, then rank:

(defn ->r [hand]
  (let [ranks (zipmap "23456789TJKQA" (range 2 15)) ; creates a map like {\2 2, .... \A 14}
        count-then-rank
          (fn [x y] (compare 
                      [(second y) (first y)] 
                      [(second x) (first x)]))]
    (->> hand
         (map (comp ranks first)) ; returns the rank for each card eg: '(5 14 5 7 14)
         frequencies              ; returns a map of rank vs count eg: {5 2, 14 2, 7 1}
         (sort count-then-rank)   ; becomes a sorted list of tuples eg: '([14 2] [5 2] [7 1])
         (map first))))           ; extract the first value each time eg: '(14 5 7)

For a more complete solution, you can use the frequencies to determine if you have 4 of a kind, 3 of a kind, full house etc.

Updated with more info on straight and straight flush:

For a straight, one approach is:

1. Extract the ranks so you would have a list like '(14 3 2 4 5)
2. Sort this list to get '(2 3 4 5 14)
3. Get the first element: 2, and the last element 14
4. Construct a range from 2 (inclusive) to 15 (exclusive) to get '(2 3 4 5 6 7 8 9 10 11 12 13 14)
5. Compare against the sorted sequence. In this case the result is false.
6. Retry, but first replace 14 with 1.
   • replace => '(1 3 2 4 5)
   • sort => '(1 2 3 4 5)
   • (range 1 6) => '(1 2 3 4 5)
   • This time, the range and the sorted list match, so this is a straight.

---

(defn straight? [cards]                             ; eg: ["AH" "3H" "2H" "4H" "5H"] 
  (let [ranks (zipmap "23456789TJKQA" (range 2 15))
        ranks-only (map (comp ranks first) cards)   ; eg: '(14 3 2 4 5)
        ace-high (sort ranks-only)                  ; eg: '(2 3 4 5 14)
        ace-low (sort (replace {14 1} ranks-only))  ; eg: '(1 2 3 4 5)
        consecutive #(= (range (first %) (inc (last %))) %)] ; eg: (= (range 1 6) '(1 2 3 4 5))
    (or (consecutive ace-high)
        (consecutive ace-low))))

For a flush, simply extract all the suits, and then ensure they are all equal:

(defn flush? [cards] 
    (apply = (map second cards)))  ; this is when suit is the second character

Now, simply combine these two boolean conditions to determine if this is a straight flush

(defn straight-flush? [cards]
     (and (straight? cards) (flush? cards)))

See if you can solve 4clojure best hand puzzle , to open up a large number of different ways to tackle this. When I solved this, I used similar, but not identical functions.

Spoiler a more complete solution (using suit first "D7" instead of rank first "7D") is below

https://github.com/toolkit/4clojure-solutions/blob/master/src/puzzle_solutions/best_hand.clj

Answer 2

I think frequencies will get you closer to what you're looking for.

user=> (frequencies [14 14 7 5 5])
{14 2, 7 1, 5 2}

You could use this for sorting :

user=> (sort-by (frequencies [14 14 7 5 5]) [14 14 7 5 5])
(7 14 14 5 5)

And then you could use distinct :

user=> (distinct [14 14 7 5 5])
(14 7 5)

Putting all of these together should get you exactly what you want. I'll leave that as an exercise for the reader. When I'm stuck wondering if there's an easy way to do something, I often turn to Clojure's cheatsheet .