Ripetizione di una lista in Scala

Question

I am a Scala noob. Ho deciso di scrivere un solitario solitario Spider come primo esercizio per imparare la lingua e la programmazione funzionale in generale.

Vorrei generare un mazzo di carte casualmente mescolato contenente 1, 2 o 4 semi. Ecco quello che mi si avvicinò con:

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

che dovrebbe tornare

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

a seconda del valore di numberOfSuits, tranne che non esiste un elenco operazione "moltiplicare" che posso trovare. Mi è mancato? C'è un modo migliore per generare il mazzo completo prima di mischiare?

BTW, ho intenzione di utilizzare un'enumerazione per i semi, ma è stato più facile digitare la mia domanda con le stringhe. Prenderò la Lista generata sopra e useremo una comprensione, itererà sopra i semi e un simile elenco di "ranghi" di carte per generare un mazzo completo.

Answer 1

È necessario cercare lo scaladoc per l'oggetto List. Ha tutti i modi di metodi interessanti per la creazione di liste. Per esempio, il seguente fa esattamente quello che stavi cercando di:

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

un codice molto più bello, però, sarebbe questo (Scala 2.7):

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

Su Scala 2.8 tabulate è curry, così la sintassi corretta sarebbe:

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

Answer 2

appiattire una lista definita di liste:

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

appiattire un flusso infinito di liste, prendere i primi N elementi:

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

è possibile espandere una sequenza numerica e flatMap invece di moltiplicare.

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

Questo funziona anche in 2.7.x.

---

Modifica: dal momento che hai meno esperienza con Scala, potresti non aver ancora trovato il modello di pimp-my-library. Se si vuole moltiplicare le vostre liste molto, è possibile aggiungere una classe di conversione personalizzato:

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) 

e ora è possibile

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

(In generale, di riutilizzare tali impliciti, li dichiara in un oggetto e quindi importare MyObject._ per ottenere la conversione implicita e la classe corrispondente nell'ambito.)