Repetición de una lista en Scala

Question

Soy un novato de Scala. Decidí escribir un solucionador de spider solitario como primer ejercicio para aprender el lenguaje y la programación funcional en general.

Me gustaría generar una baraja barajada aleatoriamente que contenga 1, 2 o 4 palos. Esto es lo que ocurrió:

val numberOfSuits = 1 
(List("clubs", "diamonds", "hearts", "spades").take(numberOfSuits) * 4).take(4) 

que debe devolver

List("clubs", "clubs", "clubs", "clubs") 
List("clubs", "diamonds", "clubs", "diamonds") 
List("clubs", "diamonds", "hearts", "spades") 

dependiendo del valor de numberOfSuits, excepto que no hay lista de "multiplicar" operación que puedo encontrar. ¿Lo extrañé? ¿Hay una mejor manera de generar el mazo completo antes de barajar?

Por cierto, planeo usar una enumeración para los trajes, pero fue más fácil escribir mi pregunta con cuerdas. Tomaré la lista que se generó arriba y usaré para comprensión, iterar sobre los palos y una lista similar de "rangos" de cartas para generar un mazo completo.

Answer 1

Debe buscar el scaladoc para el objeto List. Tiene todas las maneras de métodos interesantes para la creación de listas. Por ejemplo, la siguiente es exactamente lo que estaba tratando de:

List.flatten(List.make(4, List("clubs", "diamonds", "hearts", "spades").take(numberOfSuits))).take(4) 

un código mucho más agradable, sin embargo, sería la siguiente (Scala 2.7):

val suits = List("clubs", "diamonds", "hearts", "spades") 
List.tabulate(4, i => suits.apply(i % numberOfSuits)) 

En Scala 2,8 tabulate es al curry, por lo la sintaxis correcta sería:

List.tabulate(4)(i => suits.apply(i % numberOfSuits)) 

Answer 2

aplana un listas finitas de listas:

scala> List.fill(2)(List(1, 2, 3, 4)).flatten 
res18: List[Int] = List(1, 2, 3, 4, 1, 2, 3, 4) 

aplanar un flujo infinito de listas, dar los primeros N elementos:

scala> Stream.continually(List(1, 2, 3, 4)).flatten.take(8).toList 
res19: List[Int] = List(1, 2, 3, 4, 1, 2, 3, 4) 

Answer 3

pueden ampliar una secuencia numérica y flatMap en lugar de multiplicar.

scala> (1 to 3).flatMap(_=>List(1,2,3,4).take(2)).take(4) 
res1: Seq[Int] = List(1, 2, 1, 2) 

Esto también funciona en 2.7.x.

---

edición: ya que eres menos experiencia con Scala, es posible que todavía no han llegado a través del patrón proxeneta-mi-biblioteca. Si desea multiplicar sus listas mucho, puede agregar una clase de conversión personalizada:

class MultipliableList[T](l: List[T]) { 
    def *(n: Int) = (1 to n).flatMap(_=>l).toList 
} 
implicit def list2multipliable[T](l: List[T]) = new MultipliableList[T](l) 

y ahora puede hacerlo

scala> List(1,2,3)*4 
res2: List[Int] = List(1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3) 

(En general, la reutilización de dichos implícitos, declararlos en un objeto y luego importe MyObject._ para obtener la conversión implícita y la clase correspondiente en el alcance.)