1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206

require File.expand_path(File.dirname(__FILE__) + '/edgecase')

# Greed is a dice game where you roll up to six dice to accumulate
# points.  The following "score" function will be used calculate the
# score of a single roll of the dice.
#
# A greed roll is scored as follows:
#
# * A set of three ones is 1000 points
#
# * A set of three numbers (other than ones) is worth 100 times the
#   number. (e.g. three fives is 500 points).
#
# * A one (that is not part of a set of three) is worth 100 points.
#
# * A five (that is not part of a set of three) is worth 50 points.
#
# * A set of four numbers is worth the triple score multiply by 2.     
#
# * A set of five numbers is worth the triple score multiply by 4.     
#
# * A set of six numbers is worth the triple score multiply by 8.     
#
# * A set of three pairs is worth 800 points
#
# * A straight is worth  1200 points.
#
# * Everything else is worth 0 points.
#
#
# Examples:
#
# score([1,1,1,5,1]) => 1150 points
# score([2,3,4,6,2]) => 0 points
# score([3,4,5,3,3]) => 350 points
# score([1,5,1,2,4]) => 250 points
# score([2,2,2,2,6]) => 400 points
# score([4,4,4,4,4]) => 1600 points
# score([6,6,6,6,6,6]) => 4800 points
# score([1,2,3,4,5,6]) => 1200 points
# score([1,1,3,3,6,6]) => 800 points
#
# More scoring examples are given in the tests below:
#
# Your goal is to write the score method.

def score rolls_result
  result = 0

  rules = [:three_pairs_score, :straight_score, :triple_quadruple_quintuple_sextuple_score, :single_double_score]  
  rules.each do |rule|
    rule_method = method(rule)
    rule_result, stop_rule = rule_method.call rolls_result
    result += rule_result
    break if stop_rule
  end

  return result  
end

def rolls_results_count_from rolls_result
  raise ArgumentError, "rolls_result have more then 6 rolls: #{rolls_result}" unless rolls_result.length <= 6
  results_count = { 1 => 0, 2 => 0, 3 => 0, 4 => 0, 5 => 0, 6 => 0 }
  rolls_result.each { |roll_result| results_count[roll_result] += 1 }
  return results_count
end

def three_pairs_score rolls_result
  results_count = rolls_results_count_from rolls_result

  return 800, true if results_count.select { |roll_result, count|  count == 2 }.length == 3
  return 0
end

def straight_score rolls_result
  results_count = rolls_results_count_from rolls_result

  return 1200, true if results_count.select { |roll_result, count|  count == 1 }.length == 6
  return 0
end

def triple_quadruple_quintuple_sextuple_score rolls_result
  results_count = rolls_results_count_from rolls_result
  hat_trick_points  =  { 1 => 1000, 2 => 200, 3 => 300, 4 => 400, 5 => 500, 6 => 600 }

  result = 0

  hat_trick_points.each do |roll_result, points| 
    result = result +
           points * results_count[roll_result].div(3) +
             points * results_count[roll_result].div(4) +
             points * results_count[roll_result].div(5) * 2 +
             points * results_count[roll_result].div(6) * 3       
  end  

  return result
end

def single_double_score rolls_result
  results_count = rolls_results_count_from rolls_result
  single_points = { 1 => 100, 5 => 50 }

  result = 0

  single_points.each do |roll_result, points| 
    result += points * results_count[roll_result].modulo(6).modulo(5).modulo(4).modulo(3)
  end

  return result  
end

class AboutScoringProject < EdgeCase::Koan

  def test_score_of_a_single_roll_of_5_is_50
    assert_equal 50, single_double_score([5])
  end

  def test_score_of_a_single_roll_of_1_is_100
    assert_equal 100, single_double_score([1])
  end

  def test_score_of_multiple_1s_and_5s_is_the_sum_of_individual_scores
    assert_equal 300, single_double_score([1,5,5,1])
  end

  def test_score_of_single_2s_3s_4s_and_6s_are_zero
    assert_equal 0, single_double_score([2,3,4,6])
  end
  
  
  def test_score_of_a_triple_1_is_1000
    assert_equal 1000, triple_quadruple_quintuple_sextuple_score([1,1,1])
  end

  def test_score_of_other_triples_is_100x
    assert_equal 100*2, triple_quadruple_quintuple_sextuple_score([2,2,2])
    assert_equal 100*3, triple_quadruple_quintuple_sextuple_score([3,3,3])
    assert_equal 100*4, triple_quadruple_quintuple_sextuple_score([4,4,4])
    assert_equal 100*5, triple_quadruple_quintuple_sextuple_score([5,5,5])
    assert_equal 100*6, triple_quadruple_quintuple_sextuple_score([6,6,6])
  end

  def test_score_of_a_quadruple_1_is_2000
    assert_equal 2000, triple_quadruple_quintuple_sextuple_score([1,1,1,1])
  end

  def test_score_of_other_quadruple_is_200x
    assert_equal 200*2, triple_quadruple_quintuple_sextuple_score([2,2,2,2])
    assert_equal 200*3, triple_quadruple_quintuple_sextuple_score([3,3,3,3])
    assert_equal 200*4, triple_quadruple_quintuple_sextuple_score([4,4,4,4])
    assert_equal 200*5, triple_quadruple_quintuple_sextuple_score([5,5,5,5])
    assert_equal 200*6, triple_quadruple_quintuple_sextuple_score([6,6,6,6])
  end

  def test_score_of_a_quintuple_1_is_4000
    assert_equal 4000, triple_quadruple_quintuple_sextuple_score([1,1,1,1,1])
  end

  def test_score_of_other_quintuple_is_400x
    assert_equal 400*2, triple_quadruple_quintuple_sextuple_score([2,2,2,2,2])
    assert_equal 400*3, triple_quadruple_quintuple_sextuple_score([3,3,3,3,3])
    assert_equal 400*4, triple_quadruple_quintuple_sextuple_score([4,4,4,4,4])
    assert_equal 400*5, triple_quadruple_quintuple_sextuple_score([5,5,5,5,5])
    assert_equal 400*6, triple_quadruple_quintuple_sextuple_score([6,6,6,6,6])
  end
  
  def test_score_of_a_sextuple_1_is_8000
    assert_equal 8000, triple_quadruple_quintuple_sextuple_score([1,1,1,1,1,1])
  end
  
  def test_score_of_other_sextuple_is_800x
    assert_equal 800*2, triple_quadruple_quintuple_sextuple_score([2,2,2,2,2,2])
    assert_equal 800*3, triple_quadruple_quintuple_sextuple_score([3,3,3,3,3,3])
    assert_equal 800*4, triple_quadruple_quintuple_sextuple_score([4,4,4,4,4,4])
    assert_equal 800*5, triple_quadruple_quintuple_sextuple_score([5,5,5,5,5,5])
    assert_equal 800*6, triple_quadruple_quintuple_sextuple_score([6,6,6,6,6,6])
  end

  def test_score_of_three_pairs_is_800
    assert_equal [800, true], three_pairs_score([2,2,3,3,6,6])  
    assert_equal [800, true], three_pairs_score([1,1,5,5,6,6])  
  end
  
  def test_score_of_a_straight_is_1200
    assert_equal [1200, true], straight_score([1,2,3,4,5,6])  
  end

  def test_score_of_an_empty_list_is_zero
    assert_equal 0, score([])
  end

  def test_score_of_mixed_is_sum
    assert_equal 0, score([2,3,3,4,6,6])
    assert_equal 250, score([1,1,5,2,3,4])
    assert_equal 500, score([2,2,2,3,3,3])
    assert_equal 600, score([5,5,5,1])
    assert_equal 1000, score([5,5,5,5,4])
    assert_equal 2050, score([1,1,1,5,1])
    assert_equal 2450, score([6,6,6,6,6,5])
    assert_equal 3200, score([4,4,4,4,4,4])  
    assert_equal 1200, score([1,2,3,4,5,6])  
    assert_equal 800, score([1,1,5,5,6,6])  
  end
  

end