Wiederholen eine Liste, in der Scala

Ich bin ein Scala noob. Ich haben beschlossen, schreiben ein spider solitaire solver als erste übung die Sprache zu lernen und die funktionale Programmierung im Allgemeinen.

Möchte ich generieren, die einem zufällig gemischten Kartenstapel mit 1, 2 oder 4 Anzüge. Hier ist, was ich kam mit:

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

welche zurückgeben sollte

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

je nach dem Wert von numberOfSuits, außer es gibt keine Liste mit "multiplizieren" - operation, die ich finden kann. Hab ich es vermissen? Gibt es eine bessere Art und Weise zu erzeugen, das komplette deck vor dem mischen?

BTW, ich plan auf dem verwenden einer Enumeration für die Anzüge, aber es war leichter zu geben auf meine Frage mit den Saiten. Ich werde die Liste oben generierten und mit einem für das Verständnis, Durchlaufen die Anzüge und eine ähnliche Liste Karte "gehört" zu generieren, die ein komplettes deck.

Der interessante Teil dieses Projektes wird die Schaffung der unveränderlichen Generationen der tableau (aktuelle layout der Karten). Ich bitte das aktuelle tableau für eine Liste von regelgemäßen Zügen, kehrte als Tupel von (Spalte Quelle Spalte "Ziel", und die source-position). Ich habe dann gelten zu den jeweils aktuellen tableau in a recursive fashion mit einer Art mini-max-Algorithmus zum finden der "besten" zu bewegen. Ich will auch die Karte Objekt unveränderlich, so der tableaus ("tableaux?") haben, um zu wissen, ob eine Karte aufgedeckt ist.

InformationsquelleAutor Ralph | 2010-03-22

scala

7

Sollten Sie schauen, bis die scaladoc für das Objekt List. Es hat alle Arten von interessanten Methoden für die Erstellung von Listen. Zum Beispiel, der folgende tut genau das, was Sie wollten:
```
List.flatten(List.make(4, List("clubs", "diamonds", "hearts", "spades").take(numberOfSuits))).take(4)
```
Einen viel schöneren code, jedoch wäre dies (Scala 2.7):
```
val suits = List("clubs", "diamonds", "hearts", "spades")
List.tabulate(4, i => suits.apply(i % numberOfSuits))
```
Auf Scala 2.8 tabulate ist Curry, so dass die richtige syntax wäre:
```
List.tabulate(4)(i => suits.apply(i % numberOfSuits))
```
- Ich habe versucht, Ihr Beispiel, bekomme aber einen Fehler auf 2.8.0.Beta1-prerelease. In der Tat, ich bekomme diese Fehlermeldung auf den meisten samples der Liste.Tabellieren die ich finden kann. Was gibt? scala> Liste.Tabellieren(4, i => passt.gelten(i % numberOfSuits)) <Konsole>:5: Fehler: fehlender parameter-Typ-Liste.Tabellieren(4, i => passt.gelten(i % numberOfSuits)) scala> Liste.Tabellieren(4, (i:Int) => passt.gelten(i % numberOfSuits)) <Konsole>:7: Fehler: überladene Methode Wert Tabellieren mit alternativen....nicht angewandt werden kann (Int,(Int) => java.lang.String) Liste.Tabellieren(4, (i:Int) => passt.gelten(i % numberOfSuits)) ^
- Die syntax leicht verändert von 2,7 auf 2,8. Siehe die Antwort bearbeitet.
- Lustig dass du das erwähnst. Ich habe vergessen, dass die singleton-docs waren an der Unterseite des Pakets doc-Seiten. Im Kommentar schrieb ich oben, ich kam mit der GENAUE gleiche Antwort, die Sie bot zunächst oben.
- Dieser code hier List.tabulate(4, i => suits.apply(i % numberOfSuits)) erfordert nicht apply nennen. Ich würde dies ändern, um List.tabulate(4, i => suits(i % numberOfSuits))
- ja, ich downvoted.
InformationsquelleAutor Daniel C. Sobral
18

Glätten einer endlichen Listen von Listen:
```
scala> List.fill(2)(List(1, 2, 3, 4)).flatten
res18: List[Int] = List(1, 2, 3, 4, 1, 2, 3, 4)
```
Reduzieren unendlichen Strom von Listen, nehmen Sie die ersten N Elemente:
```
scala> Stream.continually(List(1, 2, 3, 4)).flatten.take(8).toList
res19: List[Int] = List(1, 2, 3, 4, 1, 2, 3, 4)
```
- Dies ist eine neue Methode in der 2.8.0? Ich konnte es nicht funktioniert, aber das Tat: val Anzüge = List("Kreuz", "Karo", "Herz", "Pik"); Liste.flatten(List.machen(4, Anzüge.nehmen Sie(1))), wo die "1" ist die numberOfSuits Wert.
- Ja, einige von diesen sind neu in 2.8.
InformationsquelleAutor retronym
6

Können Sie eine numerische Sequenz und flatMap statt sich zu vermehren.
```
scala> (1 to 3).flatMap(_=>List(1,2,3,4).take(2)).take(4)
res1: Seq[Int] = List(1, 2, 1, 2)
```
Funktioniert dies in 2.7.x auch.

Edit: da Sie weniger Erfahrung mit Scala, vielleicht sind Sie noch nicht gekommen, über die pimp-my-library-pattern. Wenn Sie wollen multiplizieren Sie Ihre Listen eine Menge, können Sie fügen Sie eine benutzerdefinierte Konvertierung-Klasse:
```
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)
```
und jetzt können Sie
```
scala> List(1,2,3)*4
res2: List[Int] = List(1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3)
```
(In der Regel, um die Wiederverwendung solcher implicits, deklarieren Sie diese in einem Objekt und importieren Sie dann MyObject._ um die implizite Konvertierung und die entsprechende Klasse im Umfang.)

InformationsquelleAutor Rex Kerr

Wenn Sie cats Bibliothek, können Sie Gebrauch machen von Semigroup's Methode combineN. Es repeates eine Liste N Zeiten.

import cats.implicits._
import cats.syntax.semigroup._

scala> List("clubs", "diamonds", "hearts", "spades").combineN(2)
res1: List[String] = List(clubs, diamonds, hearts, spades, clubs, diamonds, hearts, spades)

InformationsquelleAutor Mikhail Golubtsov

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.