Wie das filtern einer Liste von Tupeln in scala?

Habe ich die folgende Liste in der Scala, das gefiltert werden soll, basierend auf Kriterien, so dass, wenn es gibt alle Tupel mit identischen ersten Wert ,
Wie aus dem folgenden Beispiel möchte ich ausschließen

List((a,1), (a,2))

da ist es mit "a" wie "duplizieren".

Sie wollen entfernen Sie die beiden Bedingungen ((a,1) und (a,2)) oder nur eine (filter, andere)? Dass man die Liste((a,1), (a,2), (b,1), (b,2)) ergeben würde eine leere Liste ist, richtig?
Zumindest versuchen, nicht zu machen es so Aussehen, wie die Coursera Progfun Kursarbeit

InformationsquelleAutor Shakti | 2012-10-29

5

Dem Sie filtern möchten Ihre result mit einer Funktion, die nur verlässt unberührt diese Listen ohne doppelte "Tasten"
```
result filter noDuplicateKeys
```
Diese Filter-Funktion muss eine Liste von Paaren List[(A,B)] und true zurückgeben, nur dann, wenn das paar erste element nicht vorhanden ist, die anderswo für alle Elemente und umgesetzt werden können, wie
```
def noDuplicateKeys[A, B](xs: List[(A, B)]) = 
    (xs groupBy (_._1)).values forall {_.size < 2}
```
Es Gruppen, die Elemente in einer Map dessen Schlüssel die As und deren Werte eine entsprechende Liste der Bs gepaart mit diesem Schlüssel.

Aus diesen Werten können Sie akzeptieren nur diejenigen, die eine Größe von nicht mehr als 1
- cool .. ich dachte auf den gleichen Linien, aber war nicht in der Lage zu begreifen, in Bezug auf die scala , müssen Sie alle Schlüssel , gruppieren Sie Sie und überprüfen Sie, ob mit count < 2 (xs groupBy (._1)).Werte forall {.Größe < 2} . Vielen Dank für Eure Hilfe
- Könnten Sie mir bitte erklären, wie (_._1).values und _.size Arbeit? Die Verwendung von _. wirklich verwirrt mich. Es scheint mir, wie In manchen Kontexten, es hilft zu vermeiden, unter Bezugnahme auf eine offensichtliche Sache wie... wenn ich mich Filterung eine Liste von Menschen, die durch Mindestalter,ich würde sagen, so etwas wie humans.filter(_.age > 18) weil diese Liste nur Menschen, und ich denke, es macht es auch mehr polymorphe, im Falle einer Liste zum Beispiel hat andere Dinge, die den Menschen und ich möchte immer noch filter mit den gleichen Kriterien. Vielleicht bin ich falsch oder nicht, aber immer noch l nicht das bekommen, was geht auf in Ihrem Antwort-code.
- in diesem Fall _._1 es ist die Kurzform syntax für eine Funktion literal, ein.k.ein. anonyme Funktion. Es bedeutet, dass Sie eine Funktion definieren, die on-the-fly, ohne ihm einen Namen. Im Allgemeinen ist die erweiterte syntax wäre x => x._1 und übergeben Sie es an die groupBy Methode wie diese: xs.groupBy(x => x._1). Die groupBy-Methode erwartet eine Funktion als parameter und füttern wir Sie ein. Da diese Funktion literal verwendet nur einen parameter auf einmal, können wir vermeiden, geben Sie einen Namen mithilfe der _ Platzhalter so x => x._1 entspricht _._1
- Sie können lernen, mehr hier
- Danke. Ich vergaß zu klären, dass ich eine ziemlich gute grundlegende Verständnis von haskel, so dass ich irgendwie wissen, über die _ Betreiber, es verwirrt mich in der scala, wenn es in Kombination mit der . Betreiber (natürlich haskel ist rein funktional im Gegensatz zu scala) habe ich festgestellt, dass post, die Sie gemeinsam (heute früh) bei der recherche zu dieser Frage, ist aber ein wenig zu einfach, zu verstehen, was Los ist hier, glaube ich, was habe ich nicht bekommen, eigentlich war der groupBy-Funktion, aber ich habe das Spiel mit ihm ein wenig und jetzt ist alles ziemlich klar! 🙂
- gut, dass es ziemlich verständlich, dass die vielen Verwendungen _ verwirrt die Menschen überall, vor allem, da in haskell, die Sie brauchen keine Platzhalter zu schreiben pointfree style oder curry-Funktion...
InformationsquelleAutor pagoda_5b

Ich glaube, dass der folgende code das tut, was Sie wollen (zu entfernen nur das erste paar, richtig?):

Ich bin mit pattern-matching zu tun, wenn Sie filtern möchten, alles u tun konnte, eine Rekursion über Ihre Liste oder tun, was Kyle vorgeschlagen. Check this out:

val a = "a"                                      
val b = "b"                                     

var result =
    List(
      List(),
      List((a, 1), (a, 2)),
      List((a, 1), (b, 1)),
      List((a, 1), (b, 2)),
      List((a, 2), (b, 1)),
      List((a, 2), (b, 2)),
      List((b, 1), (b, 2)),
      List((a, 1), (a, 2), (b, 1)),
      List((a, 1), (a, 2), (b, 2)),
      List((a, 1), (b, 1), (b, 2)),
      List((a, 2), (b, 1), (b, 2)),
      List((a, 1), (a, 2), (b, 1), (b, 2))) 

val filteredResult = (for (list <- result)
    yield list match {
    case x :: y :: xys if (x._1 == y._1) =>  xys
    case _ => list
  }).distinct

Ergebnis:

//> List()
//| List((a,1), (b,1))
//| List((a,1), (b,2))
//| List((a,2), (b,1))
//| List((a,2), (b,2))
//| List((b,1))
//| List((b,2))
//| List((a,1), (b,1), (b,2))
//| List((a,2), (b,1), (b,2))
//| List((b,1), (b,2))

Distinct werden nur filter die entstandene leere Listen.

Prost!

ich glaube nicht, dass das Recht, Sie vergleichen die beiden ersten Elemente und halten der rest der Liste. was ist, wenn der Spiel ist zwischen 2. und 3. Elementen?
Gut ist das, was ich verstanden habe von Shakti ' s Frage. Ich weiß, wo seine Frage kam von (Coursera ProgFun) und ja, Sie haben, es zu tun durch die ganze Liste, in diesem Fall, meine Antwort ist nicht richtig. Aber, in Bezug auf seine Frage, es war ganz richtig, glaube ich. Prost!

InformationsquelleAutor wleao

Ich sah dies als ein herausfiltern von Elementen aus List[List[Tuple2[Char, Int]]] wo Sie ein element der Liste hat die gleichen Elemente. In diesem Fall wird ein element der Liste ist List[Tuple2[Char, Int]] was ich will, um wieder eine Boolean wenn die Elemente gleich sind. Diese List[Tuple2[Char, Int]] abgebildet werden, um das erste element des Tuple und dann-Logik wird angewandt, um die neue Liste von chars unter Verwendung von distinct und Größe zu überprüfen, ob die Elemente sind die gleichen, und behalten diejenigen, die nur aus einem element.

Den filter

filter(xs => xs.map(ys => ys._1).distinct.size != 1 || xs.size == 1)

Test data:

scala> val a = List(List(('a',1)))
a: List[List[(Char, Int)]] = List(List((a,1)))

scala> val aa = List(List(('a',1),('a',1)))
aa: List[List[(Char, Int)]] = List(List((a,1), (a,1)))

scala> val ab = List(List(('a',1),('b',1)))
ab: List[List[(Char, Int)]] = List(List((a,1), (b,1)))

scala> val aba = List(List(('a',1),('b',1),('a',1)))
aba: List[List[(Char, Int)]] = List(List((a,1), (b,1), (a,1)))

Testfälle.

scala> a.filter(xs => xs.map(ys => ys._1).distinct.size != 1 || xs.size == 1)
res34: List[List[(Char, Int)]] = List(List((a,1)))

scala> aa.filter(xs => xs.map(ys => ys._1).distinct.size != 1 || xs.size == 1)
res35: List[List[(Char, Int)]] = List()

scala> ab.filter(xs => xs.map(ys => ys._1).distinct.size != 1 || xs.size == 1)
res36: List[List[(Char, Int)]] = List(List((a,1), (b,1)))

scala> aba.filter(xs => xs.map(ys => ys._1).distinct.size != 1 || xs.size == 1)
res37: List[List[(Char, Int)]] = List(List((a,1), (b,1), (a,1)))

InformationsquelleAutor Brian

0

basiert auf der @pagoda_5b Lösung, ich denke, wir könnten ein besseres finden.

Was denkst du über:
```
def noDuplicateKeys(l: List[(Char, Int)]): Boolean = l.toMap.size == l.size

list filter noDuplicateKeys
```
😉

InformationsquelleAutor Jules Ivanic

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.