;;; ================================
;;;  CMPU-145, Spring 2013
;;;  Asmt. 7 Helper File
;;; ================================
;;;  Extends some of the card functionality of "asmt5-helper.txt".

(load "asmt5-helper.txt")

;;;  Numerical ranks and suits

(define *ranks* '(1 2 3 4 5 6 7 8 9 10 11 12 13))
(define *suits* '(0 1 2 3))

;;;  Symbols for the ranks and suits

(define *rank-syms* '(A 2 3 4 5 6 7 8 9 10 J Q K))
(define *suit-syms* '(C D H S))

;;;  CARD->RANK-SYM
;;; ---------------------------
;;;  INPUT:  C, a card (i.e., number from 0 to 51)
;;;  OUTPUT:  A symbol representing the rank of the card (e.g., A, 2, 3..)

(define card->rank-sym
  (lambda (c)
    (nth *rank-syms* (- (rank c) 1))))

;;;  CARD->SUIT-SYM
;;; ----------------------------
;;;  Same as above, except returns a symbol representing the
;;;  suit of the card (e.g., C, D, H or S).

(define card->suit-sym
  (lambda (c)
    (nth *suit-syms* (suit c))))

;;;  CARD-FROM-RANK-AND-SUIT
;;; ------------------------------------------------
;;;  INPUTS:  RANK, a number from 1 to 13
;;;           SUIT, a number from 0 to 3
;;;  OUTPUT:  The corresponding card, as a number from 0 to 51

(define card-from-rank-and-suit
  (lambda (rank suit)
    (+ (* 13 suit) rank -1)))

;;;  CARD->STRING
;;; -----------------------------
;;;  INPUT:  C, a card (i.e., number from 0 to 51)
;;;  OUTPUT:  A string representation of that card (e.g., "3D" or "KC")

(define card->string
  (lambda (c)
    (format "~S~S " (card->rank-sym c) (card->suit-sym c))))

;;;  CARDS->STRING
;;; ----------------------------------------
;;;  INPUT:  CARDS, a list of numbers, each from 0 to 51
;;;  OUTPUT:  A string representation of the cards

(define cards->string
  (lambda (cards)
    (apply string-append
           (map card->string cards))))

;;; ==============================

;;;  HAS-FULL-HOUSE?  --  Seen in Lab 8
;;; -------------------------------------
;;;  INPUT:  CARDS, a list of 5 cards (i.e., numbers from 0 to 51)
;;;  OUTPUT:  #t, if CARDS has a full house.

(define has-full-house?
  (lambda (cards)
    (let ((sorted-ranks (sort (map rank cards) <=)))
      ;; Pattern is either:  (X X X Y Y) or (X X Y Y Y)
      (or (and (= (first sorted-ranks) 
                  (third sorted-ranks))
               (= (fourth sorted-ranks)
                  (fifth sorted-ranks)))
          (and (= (first sorted-ranks)
                  (second sorted-ranks))
               (= (third sorted-ranks)
                  (fifth sorted-ranks)))))))