poker_odds 0.1.1 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 727beb1f40c45f4ab9b77d0a2b7c21da81b8fc8105414f516fdb04bed4e4bded
-  data.tar.gz: 107c85dabd7f0c4a68900fef7fe91e1d55604422e58403d5b95dfc3323838478
+  metadata.gz: f204234da42a8bd00fd9d1407dc188a9ea79856591b1bedb2e9c7d2d9c22cb34
+  data.tar.gz: b0884f1224a3e5655b92b3d602551c42fd42a89d9d0779d4331da8585c03f767
 SHA512:
-  metadata.gz: 41eecbb09877d4da4e99adacacb539f620b3616ace9584ad8c6cdc0a5d952b2db48e33f6b34fbecf4b36c8e9a0300541762c43ddf77871f4e9ffc848eaab89f5
-  data.tar.gz: b0e379b966eab71eb0d1eddac1f43cc54ff59f2357daf7f371598a8467b77d8da6ed63a6581685bf2c1cd9ad7cb4341a686df68c6d2147fa2d3bb231a196a1ab
+  metadata.gz: 2d980e663b61d2a91c6f7a68e5d8ab58873f927260f208162040dcee38043988ca3581a68b4253f78f32fa046ac0426ba59234357e4cdef5f6577cd203445b0f
+  data.tar.gz: 11738e7f2a97870f45c7db7aa9c33b12409780d971d513aef0ec7f6cfc85d1541a762f0ecfc8fdc8e4bc3e4649356753386733f57bb7c958546dcafd676b2cc6

data/README.md

@@ -2,7 +2,7 @@
 
 Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/poker_odds`. To experiment with that code, run `bin/console` for an interactive prompt.
 
-TODO: Delete this and the text above, and describe your gem
+ポーカーのエクイティが分かる
 
 ## Installation
 
@@ -23,22 +23,14 @@ Or install it yourself as:
 ## Usage
 
 ```
-round = PokerOdds::Round.new(flop: 'Ah 9h Jd', turn: '3d')
-round.add_hand("9d 9c")
-round.add_hand("Kd Kc")
+round = PokerOdds::Hand.new(flop: 'Ah 9h Jd', turn: '3d')
+round.player='9d 9c, Kd Kc'
 
 round.equities
 # =>
-[{:hand=>[{:rank=>"K", :suit=>:d}, {:rank=>"K", :suit=>:c}],
-  :win_rate=>0.045454545454545456,
-  :lose_rate=>0.9545454545454546,
-  :tie_rate=>0.0,
-  :outs=>[{:suit=>:s, :rank=>"K"}, {:suit=>:h, :rank=>"K"}]},
- {:hand=>[{:rank=>"9", :suit=>:d}, {:rank=>"9", :suit=>:c}],
-  :win_rate=>0.9545454545454546,
-  :lose_rate=>0.045454545454545456,
-  :tie_rate=>0.0,
-  :outs=>[]}]
+{[#<PokerTrump::Card:0x00007fedc3889ab0 @rank="9", @suit=:d>, #<PokerTrump::Card:0x00007fedc38898f8 @rank="9", @suit=:c>]=>{:win_rate=>0.9545454545454546, :lose_rate=>0.045454545454545456, :tie_rate=>0.0},
+ [#<PokerTrump::Card:0x00007fedc3889650 @rank="K", @suit=:d>, #<PokerTrump::Card:0x00007fedc38894e8 @rank="K", @suit=:c>]=>
+  {:win_rate=>0.045454545454545456, :lose_rate=>0.9545454545454546, :tie_rate=>0.0, :outs=>[#<PokerTrump::Card:0x00007feda08a3208 @rank="K", @suit=:s>, #<PokerTrump::Card:0x00007feda08a2bc8 @rank="K", @suit=:h>]}}
 
 ```
 

data/lib/poker_odds/hand.rb

@@ -0,0 +1,165 @@
+module PokerOdds
+  class Hand
+    include Virtus.model
+
+    attribute :player_hands, Array, default: []
+    attribute :flop_cards, PokerTrump::Cards
+    attribute :turn_card, PokerTrump::Card
+    attribute :river_card, PokerTrump::Card
+
+    attribute :expose_cards, PokerTrump::Cards
+
+    def player=(str)
+      self.player_hands = str.split(',').map do |s|
+        PokerTrump::Cards.from_string(s.lstrip)
+      end
+      self
+    end
+
+    def flop=(str)
+      self.flop_cards = PokerTrump::Cards.from_string(str)
+      self
+    end
+
+    def turn=(str)
+      self.turn_card = PokerTrump::Card.from_string(str)
+      self
+    end
+
+    def river=(s)
+      self.river_cards = PokerTrump::Card.from_string(str)
+      self
+    end
+
+    def equities
+      z = deck.each_with_object({}) do |card, a|
+        scores = player_hands.each_with_object({}) do |player_hand, h|
+          cards = player_hand
+          cards = cards.add_cards(flop_cards)
+          cards = cards.add_card(turn_card)
+          cards = cards.add_card(card)
+
+          h[cards.score] ||= []
+          h[cards.score] << player_hand
+        end
+
+        a[card] = {}
+        if scores.keys.size == 1
+          a[card][:tie_hands] = player_hands
+        else
+          mk = scores.keys.max
+          a[card][:win_hands] = scores[mk]
+          a[card][:lose_hands] = scores.each_with_object([]) do |(k,v), a|
+            next if k == mk
+
+            a.concat(v)
+          end
+        end
+      end
+
+      s = z.size.to_f
+
+      player_hands.each_with_object({}) do |player_hand, h|
+        win_hands = z.select { |a,b| b[:win_hands]&.include?(player_hand) }
+        win_rate = win_hands.size / s
+        h[player_hand] = {}
+        h[player_hand][:win_rate] = win_rate
+        h[player_hand][:lose_rate] = z.count { |a,b| b[:lose_hands]&.include?(player_hand) } / s
+        h[player_hand][:tie_rate] = z.count { |a,b| b[:tie_hands]&.include?(player_hand) } / s
+        h[player_hand][:outs] = win_hands.keys if win_rate < 0.5
+      end
+    end
+
+    def flop_equities
+      z = deck.combination(2).each_with_object({}) do |cs, a|
+        scores = player_hands.each_with_object({}) do |player_hand, h|
+          cards = player_hand
+          cards = cards.add_cards(flop_cards)
+
+          cs.each { |c| cards = cards.add_card(c) }
+
+          h[cards.score] ||= []
+          h[cards.score] << player_hand
+        end
+
+        a[cs] = {}
+        if scores.keys.size == 1
+          a[cs][:tie_hands] = player_hands
+        else
+          mk = scores.keys.max
+          a[cs][:win_hands] = scores[mk]
+          a[cs][:lose_hands] = scores.each_with_object([]) do |(k,v), a|
+            next if k == mk
+
+            a.concat(v)
+          end
+        end
+      end
+
+      s = z.size.to_f
+
+      player_hands.each_with_object({}) do |player_hand, h|
+        win_hands = z.select { |a,b| b[:win_hands]&.include?(player_hand) }
+        win_rate = win_hands.size / s
+        h[player_hand] = {}
+        h[player_hand][:win_rate] = win_rate
+        h[player_hand][:lose_rate] = z.count { |a,b| b[:lose_hands]&.include?(player_hand) } / s
+        h[player_hand][:tie_rate] = z.count { |a,b| b[:tie_hands]&.include?(player_hand) } / s
+        h[player_hand][:outs] = win_hands.keys if win_rate < 0.5
+      end
+    end
+
+    def preflop_equities
+      ran = deck.combination(5).to_a
+      z = 10000.times.with_object({}) do |i, a|
+        cs = ran.sample
+        scores = player_hands.each_with_object({}) do |player_hand, h|
+          cards = player_hand
+
+          cs.each { |c| cards = cards.add_card(c) }
+
+          h[cards.score] ||= []
+          h[cards.score] << player_hand
+        end
+
+        a[cs] = {}
+        if scores.keys.size == 1
+          a[cs][:tie_hands] = player_hands
+        else
+          mk = scores.keys.max
+          a[cs][:win_hands] = scores[mk]
+          a[cs][:lose_hands] = scores.each_with_object([]) do |(k,v), a|
+            next if k == mk
+
+            a.concat(v)
+          end
+        end
+      end
+
+      s = z.size.to_f
+
+      player_hands.each_with_object({}) do |player_hand, h|
+        win_hands = z.select { |a,b| b[:win_hands]&.include?(player_hand) }
+        win_rate = win_hands.size / s
+        h[player_hand] = {}
+        h[player_hand][:win_rate] = win_rate
+        h[player_hand][:lose_rate] = z.count { |a,b| b[:lose_hands]&.include?(player_hand) } / s
+        h[player_hand][:tie_rate] = z.count { |a,b| b[:tie_hands]&.include?(player_hand) } / s
+        h[player_hand][:outs] = win_hands.keys if win_rate < 0.5
+      end
+    end
+
+    def deck
+      cards = PokerTrump::Cards.new_deck
+      cards.delete_cards!(expose_cards) unless expose_cards.size == 0
+      player_hands.each do |player_hand|
+        cards.delete_cards!(player_hand)
+      end
+      cards.delete_cards!(flop_cards) unless flop_cards.size == 0
+      cards.delete_card!(turn_card) if !!turn_card
+      cards.delete_card!(river_card) if !!river_card
+
+      cards
+    end
+  end
+end

data/lib/poker_odds/version.rb

@@ -1,3 +1,3 @@
 module PokerOdds
-  VERSION = "0.1.1"
+  VERSION = "0.1.4"
 end

data/lib/poker_odds.rb

@@ -1,9 +1,8 @@
-require 'hashie'
-require 'active_support/all'
+require 'virtus'
+require 'poker_trump'
+
 require_relative "poker_odds/version"
-require_relative 'poker_odds/card'
-require_relative 'poker_odds/cards'
-require_relative 'poker_odds/round'
+require_relative 'poker_odds/hand'
 
 module PokerOdds
   class Error < StandardError; end

data/poker_odds.gemspec

@@ -40,6 +40,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "pry"
-  spec.add_dependency "hashie"
-  spec.add_dependency 'activesupport'
+
+  spec.add_dependency 'virtus'
+  spec.add_dependency 'poker_trump'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: poker_odds
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.4
 platform: ruby
 authors:
 - kyohah
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-07 00:00:00.000000000 Z
+date: 2022-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: hashie
+  name: virtus
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -81,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: poker_trump
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -112,9 +112,7 @@ files:
 - bin/console
 - bin/setup
 - lib/poker_odds.rb
-- lib/poker_odds/card.rb
-- lib/poker_odds/cards.rb
-- lib/poker_odds/round.rb
+- lib/poker_odds/hand.rb
 - lib/poker_odds/version.rb
 - poker_odds.gemspec
 homepage: https://github.com/kyohah/poker_odds
@@ -123,7 +121,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/kyohah/poker_odds
   source_code_uri: https://github.com/kyohah/poker_odds
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -138,8 +136,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.2.32
+signing_key:
 specification_version: 4
 summary: Write a short summary, because RubyGems requires one.
 test_files: []

data/lib/poker_odds/card.rb

@@ -1,39 +0,0 @@
-module PokerOdds
-  class Card < Hash
-    include Hashie::Extensions::Coercion
-    include Hashie::Extensions::MergeInitializer
-    include Hashie::Extensions::MethodAccess
-
-    RANKS = %w[A 2 3 4 5 6 7 8 9 T J Q K].freeze
-    SUITS = %i[s h d c].freeze
-
-    RANK_VALUE = {
-      '2' => 2,
-      '3' => 3,
-      '4' => 4,
-      '5' => 5,
-      '6' => 6,
-      '7' => 7,
-      '8' => 8,
-      '9' => 9,
-      'T' => 10,
-      'J' => 11,
-      'Q' => 12,
-      'K' => 13,
-      'A' => 14
-    }
-
-    coerce_key :rank, String
-    coerce_key :suit, Symbol
-
-    class << self
-      def string_parse(string)
-        Card.new(rank: string[0], suit: string[1])
-      end
-    end
-
-    def rank_value
-      RANK_VALUE[rank]
-    end
-  end
-end

data/lib/poker_odds/cards.rb

@@ -1,232 +0,0 @@
-module PokerOdds
-  class Cards < Array
-    include Comparable
-    DeleteError = Class.new(StandardError)
-
-    STRAIGHT_PATTERNS = (6..14).to_a.reverse.map { |i| (0..4).map {|j| i - j }  }.push([5,4,3,2,14]).map { |a| /#{a[0]}.+#{a[1]}.+#{a[2]}.+#{a[3]}.+#{a[4]}/ }.freeze
-
-    class << self
-      def new_deck
-        new(Card::RANKS.flat_map do |rank|
-          Card::SUITS.map do |suit|
-            Card.new(suit: suit, rank: rank)
-          end
-        end)
-      end
-
-      def string_parse(string)
-        a = string.split.map do |s|
-          Card.new(rank: s[0], suit: s[1])
-        end
-
-        new(a)
-      end
-
-      def json_parse(json)
-        h = JSON.parse(json)
-
-        b = h.map { |a| Card.new(rank: a['rank'].to_sym, suit: a['suit'].to_sym) }
-
-        Hands.new(b)
-      end
-    end
-
-    def delete_card!(card)
-      i = index(card)
-      raise DeleteError if i.nil?
-
-      delete_at(i)
-      self
-    end
-
-    def delete_card(card)
-      i = index(card)
-      raise DeleteError if i.nil?
-
-      clone_cards = clone
-      clone_cards.delete_at(i)
-
-      clone_cards
-    end
-
-    def delete_cards!(cards)
-      cards.each { |t| delete_card!(t) }
-      self
-    end
-
-    def delete_cards(cards)
-      clone_cards = clone
-      cards.each { |t| clone_cards.delete_card!(t) }
-      clone_cards
-    end
-
-    def add_card(card)
-      clone_cards = clone
-      clone_cards.push(card)
-    end
-
-    def add_card!(card)
-      push(card)
-    end
-
-    def add_cards(cards)
-      clone_cards = clone
-
-      cards.each { |card| clone_cards.add_card!(card) }
-      clone_cards
-    end
-
-    def add_cards!(cards)
-      cards.each { |card| add_card!(card) }
-      self
-    end
-
-    def sort_by_suit
-      @sort_by_suit ||= self.class.new(sort_by { |card| [card.suit, card.rank_value] }.reverse)
-    end
-
-    def sort_by_rank
-      @sort_by_rank ||= self.class.new(sort_by { |card| [card.rank_value, card.suit] }.reverse)
-    rescue => e
-      binding.pry
-    end
-
-    def to_s
-      map { |c| "#{c.rank}#{c.suit}" }.join(' ')
-    end
-
-    def to_s_rank_value
-      map(&:rank_value).join(' ')
-    end
-
-    def group_by_suit
-      @group_by_suit ||= group_by(&:suit).each_with_object({}) { |(k, v), h| h[k] = self.class.new(v).sort_by_rank }
-    end
-
-    def royal_flush_rate
-      [10, 0,0,0,0,0] if /A(.) K\1 Q\1 J\1 T\1/.match?(sort_by_suit.to_s)
-    end
-
-    def straight_flush_rate
-      group_by_suit.each do |k, v|
-        next if v.size < 5
-
-        a = v.straight_rate
-        if a
-          return [9, a[1], a[2], a[3], a[4], a[5]]
-        end
-      end
-      nil
-    end
-
-    def four_of_a_kind_rate
-      a = sort_by_rank.to_s.match(/(.). \1. \1. \1./)
-
-      if a
-        b = (a.pre_match + a.post_match).match(/(\S)/).to_s
-
-        [8, PokerOdds::Card::RANK_VALUE[a[1]], PokerOdds::Card::RANK_VALUE[b.to_s], 0, 0,0]
-      end
-    end
-
-    def full_house_rate
-      case sort_by_rank.to_s
-      when /(.). \1. \1. (.*)(.). \3./
-        [7, PokerOdds::Card::RANK_VALUE[$1], PokerOdds::Card::RANK_VALUE[$3], 0, 0,0]
-      when /((.). \2.) (.*)((.). \5. \5.)/
-        [7, PokerOdds::Card::RANK_VALUE[$5], PokerOdds::Card::RANK_VALUE[$2], 0, 0,0]
-      else
-        nil
-      end
-    end
-
-    def flush_rate
-      group_by_suit.each do |k, v|
-        next if v.size < 5
-
-        return [6, v[0].rank_value, v[1].rank_value, v[2].rank_value, v[3].rank_value, v[4].rank_value]
-      end
-
-      nil
-    end
-
-    def straight_rate
-      a = sort_by_rank.to_s.match(/(?<_A>A.+K.+Q.+J.+T)|(?<_K>K.+Q.+J.+T.+9)|(?<_Q>Q.+J.+T.+9.+8)|(?<_J>J.+T.+9.+8.+7)|(?<_T>T.+9.+8.+7.+6)|(?<_9>9.+8.+7.+6.+5)|(?<_8>8.+7.+6.+5.+4)|(?<_7>7.+6.+5.+4.+3)|(?<_6>6.+5.+4.+3.+2)|(?<_5>A.+5.+4.+3.+2)/)
-      if a
-        case k
-        when :_A
-          [5, *PokerOdds::Card::RANK_VALUE.values_at('A', 'K', 'Q','J', 'T')]
-        when :_K
-          [5, *PokerOdds::Card::RANK_VALUE.values_at('K', 'Q', 'J','T', '9')]
-        when :_Q
-          [5, *PokerOdds::Card::RANK_VALUE.values_at('Q', 'J', 'T','9', '8')]
-        when :_J
-          [5, *PokerOdds::Card::RANK_VALUE.values_at('J', 'T', '9','8', '7')]
-        when :_T
-          [5, *PokerOdds::Card::RANK_VALUE.values_at('T', '9', '8','7', '6')]
-        when :_9
-          [5, *PokerOdds::Card::RANK_VALUE.values_at('9', '8', '7','6', '5')]
-        when :_8
-          [5, *PokerOdds::Card::RANK_VALUE.values_at('8', '7', '6','5', '4')]
-        when :_7
-          [5, *PokerOdds::Card::RANK_VALUE.values_at('7', '6', '5','4', '3')]
-        when :_6
-          [5, *PokerOdds::Card::RANK_VALUE.values_at('6', '5', '4','3', '2')]
-        when :_5
-          [5, *PokerOdds::Card::RANK_VALUE.values_at('5', '4', '3','2', 'A')]
-        end
-      else
-        nil
-      end
-    end
-
-    def three_of_a_kind_rate
-      md = sort_by_rank.to_s.match(/(.). \1. \1./)
-
-      if md
-        arranged_hand = (md.pre_match + md.post_match).strip.squeeze(" ")
-
-        [4, PokerOdds::Card::RANK_VALUE[md[1]], PokerOdds::Card::RANK_VALUE[arranged_hand[0]], PokerOdds::Card::RANK_VALUE[arranged_hand[3]], 0, 0]
-      else
-        nil
-      end
-    end
-
-    def two_pair_rate
-      md = sort_by_rank.to_s.match(/(.). \1.(.*?) (.). \3./)
-
-      if md
-        arranged_hand = (md.pre_match + ' ' + md[2] + ' ' + md.post_match).strip.squeeze(" ")
-        [3, PokerOdds::Card::RANK_VALUE[md[1]], PokerOdds::Card::RANK_VALUE[md[3]], PokerOdds::Card::RANK_VALUE[arranged_hand[0]], 0, 0]
-      else
-        nil
-      end
-    end
-
-    def one_pair_rate
-      md = sort_by_rank.to_s.match(/(.). \1./)
-
-      if md
-        arranged_hand = (md.pre_match + ' ' + md.post_match).strip.squeeze(" ")
-
-        [2, PokerOdds::Card::RANK_VALUE[md[1]], PokerOdds::Card::RANK_VALUE[arranged_hand[0]], PokerOdds::Card::RANK_VALUE[arranged_hand[3]], PokerOdds::Card::RANK_VALUE[arranged_hand[6]], 0]
-      else
-        nil
-      end
-    end
-
-    def high_card_rate
-      arranged_hand = sort_by_rank.to_s
-
-      [1, PokerOdds::Card::RANK_VALUE[arranged_hand[0]], PokerOdds::Card::RANK_VALUE[arranged_hand[3]], PokerOdds::Card::RANK_VALUE[arranged_hand[6]], PokerOdds::Card::RANK_VALUE[arranged_hand[9]], PokerOdds::Card::RANK_VALUE[arranged_hand[12]]]
-    end
-
-    def score
-      @score ||= royal_flush_rate || straight_flush_rate || four_of_a_kind_rate || full_house_rate || flush_rate || straight_flush_rate || three_of_a_kind_rate || two_pair_rate || one_pair_rate || high_card_rate
-    end
-
-    def <=>(other_cards)
-      score <=> other_cards.score
-    end
-  end
-end

data/lib/poker_odds/round.rb

@@ -1,108 +0,0 @@
-module PokerOdds
-  class Round < Hash
-    include Hashie::Extensions::Coercion
-    include Hashie::Extensions::MergeInitializer
-    include Hashie::Extensions::MethodAccess
-
-    coerce_key :hands, Array
-    coerce_key :flop_cards, PokerOdds::Cards
-    coerce_key :turn_card, PokerOdds::Card
-    coerce_key :river_card, PokerOdds::Card
-
-    coerce_key :expose_cards, PokerOdds::Cards
-
-    # class << self
-    #   def flop =(h)
-
-    #   end
-    # end
-
-    def initialize(**arg)
-      self.flop=arg[:flop] if arg[:flop]
-      self.turn=arg[:turn] if arg[:turn]
-      self.river=arg[:river] if arg[:river]
-
-      self[:hands] ||= []
-      self[:expose_cards] ||= PokerOdds::Cards.new
-      self[:flop_cards] ||= PokerOdds::Cards.new
-      self[:turn_card] ||= PokerOdds::Card.new
-      self[:river_card] ||= PokerOdds::Card.new
-    end
-
-    def add_hand(s)
-      self[:hands] << PokerOdds::Cards.string_parse(s)
-      self
-    end
-
-    def flop=(s)
-      self[:flop_cards] = PokerOdds::Cards.string_parse(s)
-      self
-    end
-
-    def turn=(s)
-      self[:turn_card] = PokerOdds::Card.string_parse(s)
-      self
-    end
-
-    def river=(s)
-      self[:river_cards] = PokerOdds::Card.string_parse(s)
-      self
-    end
-
-    def equities
-      z = deck.each_with_object({}) do |card, a|
-        scores = hands.each_with_object({}) do |hand, h|
-          cards = hand
-          cards = cards.add_cards(flop_cards)
-          cards = cards.add_card(turn_card)
-          cards = cards.add_card(card)
-
-          if h[cards.score].present?
-            h[cards.score] << hand
-          else
-            h[cards.score] = [hand]
-          end
-        end
-
-        a[card] = {}
-        if scores.keys.size == 1
-          a[card][:tie_hands] = hands
-        else
-          mk = scores.keys.max
-          a[card][:win_hands] = scores[mk]
-          a[card][:lose_hands] = scores.each_with_object([]) do |(k,v), a|
-            next if k == mk
-
-            a.concat(v)
-          end
-        end
-      end
-
-      s = z.size.to_f
-
-      hands.each_with_object({}) do |hand, h|
-        win_hands = z.select { |a,b| b[:win_hands]&.include?(hand) }
-        win_rate = win_hands.size / s
-        h = {}
-        h[:hand] = hand
-        h[:win_rate] = win_rate
-        h[:lose_rate] = z.count { |a,b| b[:lose_hands]&.include?(hand) } / s
-        h[:tie_rate] = z.count { |a,b| b[:tie_hands]&.include?(hand) } / s
-        h[:outs] = win_hands.keys if win_rate > 0.5
-      end
-    end
-
-    def deck
-      cards = Cards.new_deck
-      cards.delete_cards!(expose_cards) if expose_cards
-      hands.each do |hand|
-        cards.delete_cards!(hand)
-      end
-      cards.delete_cards!(flop_cards) if flop_cards.present?
-      cards.delete_card!(turn_card) if turn_card.present?
-      cards.delete_card!(river_card) if river_card.present?
-
-      cards
-    end
-  end
-end