greed.rb

def score(dice)	
  compute_singles(dice) + compute_triples(dice)  
end

def compute_singles(diceRoll)
	result = 0
	diceRoll.each do |roll|
		result+= single_value(roll)
  	end
  	result
end

SINGLE_VALUES = { 1 => 100 , 5 => 50}
def single_value(roll)
	return SINGLE_VALUES[roll] if SINGLE_VALUES.keys.include?(roll)
	0
end 

def compute_triples(diceRoll)
	result   = 0
	asString = diceRoll.sort.to_s
	for points in (1..6) do	
	  ocurrences=diceRoll.count(points)
	  if ( ocurrences>=3 )
	      result	  +=  calculate_triple_score(points)
	  end
  	end
  	result
end 

TRIPLE_FACTOR               = 100
SPECIAL_TRIPLE_SCORES       = {1=>1000}

def calculate_triple_score(points)
	tripleScore = ( points * TRIPLE_FACTOR ) 
	if SPECIAL_TRIPLE_SCORES.keys.include?(points)
		tripleScore = SPECIAL_TRIPLE_SCORES[points] 
	end
	tripleScore - score_of_triple_as_singles(points)
end 

def score_of_triple_as_singles(points)
	single_value(points) * 3
end

  rollScore = 0
  rollScore = rollScore  + FIVE_VALUE   if roll == 5
  rollScore = rollScore + ONE_VALUE if roll == 1

no necesitas sumar rollscore. Por otra parte, lo extraería a otro método, lo mismo que el tripleScore. Extract till you drop, que diría uncle bob. ;) Ayudaría a tener que pensar menos para entender lo que hace el código.

Lo de ordenar el array pasar a string y usar una regex es un hack bastante guarro :D, y como mínimo debería estar escondido bajo un método. De todas formas, prefiero contar los números. Una forma mejor de como lo hice yo es usando count(points)

Me gusta un poco más, pero que haya 2 veces un "if roll == 5" y "if roll == 1" hace que me de la sensación que algo se puede refactorizar ahí. Si mañana tengo que contar también para el 6 lo cambio en los 2 sitios?

vengaaaaa le voy a dar una vuelta a ver que os parece

def single_value(roll)
return SINGLE_VALUES[roll] if SINGLE_VALUES.keys.include?(roll)
0
end

Me parece bastante feo este método. No conozco a fondo ruby, he hecho sólo las ruby koans, pero seguro que hay formas más elegantes de hacer eso mismo. Eso del 0 ahí suelto sin más, como que me chirría un poco

una duda que me asalta ... si tengo 2 o mas triples este codigo me los calculara? Parece como que para los tres primeros si que lo calcula pero los otros restantes se quedaran como simples. Es la primera vez que veo ruby un poco a fondo e igual me pierdo algo ....

he hecho un fork aunque no se porque me ha salido con unos cuantos ((())) de mas :-P
Sin embargo me inclino a dividir la tirada desde un principio entre dados con menos de tres y luego todos los trios (aunque sean repetidos p.e. [1 1 1 1 1 1] = 2000 y no 1300) y calcular cada uno por su lado, siguiendo lo que hariamos si nosotros hicieramos el calculo.

El ejercicio dice que viene 5 número nada más si no recuerdo mal. Yo lo hice para más triples, pero si el enunciado no te lo marca es tontería hacer código de más

pues si, aunque si se hace generico y con menos codigo al mismo tiempo ... ;-)

le he dado una vuelta y le he quitado unas cuantas lineas mas, haciendolo para n triples de paso

clojure 1 - ruby 0 :-P https://gist.github.com/766918