Was ist Scala, um herauszufinden, ob alle Elemente eines Arrays die gleiche Länge haben?

Question

Ich bin neu in Scala und sehr alt zu Java und hatte etwas Verständnis mit FP-Sprachen wie "Haskell" zu arbeiten.

Hier frage ich mich, wie dies mit Scala zu implementieren. Es gibt eine Liste von Elementen in einem Array, alle sind Strings und ich möchte nur wissen, ob es einen Weg gibt, wie ich das in Scala auf eine FP-Weise machen kann. Hier ist meine aktuelle Version, die funktioniert ...

def checkLength(vals: Array[String]): Boolean = { 
    var len = -1 
    for(x <- conts){ 
    if(len < 0) 
     len = x.length() 
    else{ 
     if (x.length() != len) 
     return false 
     else 
     len = x.length() 
    } 
    } 
    return true; 
} 

Und ich bin mir ziemlich sicher, dass es ein besserer Weg, dies zu tun in Scala/FP ...

Answer 1

list.forall(str => str.size == list(0).size) 

Edit: Hier ist eine Definition, die als possilbe als General ist und erlaubt auch zu prüfen, ob eine andere Eigenschaft als die Länge ist das gleiche für alle Elemente:

def allElementsTheSame[T,U](f: T => U)(list: Seq[T]) = { 
    val first: Option[U] = list.headOption.map(f(_)) 
    list.forall(f(_) == first.get) //safe to use get here! 
} 

type HasSize = { val size: Int } 
val checkLength = allElementsTheSame((x: HasSize) => x.size)_ 

checkLength(Array("123", "456")) 

checkLength(List(List(1,2), List(3,4))) 

Answer 2

Tipp: Verwenden Sie forall, ob alle Elemente zu bestimmen, in der Sammlung ein bestimmtes Prädikat erfüllen (zB Längengleichheit).

Answer 3

Wenn Sie wissen, dass Ihre Listen sind immer nicht leer, ein gerades forall funktioniert gut. Wenn Sie dies nicht tun, fügen Sie einfach Folgendes hinzu:

Jetzt werden Listen mit der Länge Null als wahr zurückgegeben, anstatt Ausnahmen auszugeben.

Answer 4

Hier ist ein weiterer Ansatz:

def check(list:List[String]) = list.foldLeft(true)(_ && list.head.length == _.length) 

Answer 5

Da jeder so kreativ zu sein scheint, ich werde auch kreativ zu sein. :-)

def checkLength(vals: Array[String]): Boolean = vals.map(_.length).removeDuplicates.size <= 1 

Wohlgemerkt, removeDuplicates wird wahrscheinlich distinct auf Scala 2.8 genannt werden.

Answer 6

Just my € 0,02

def allElementsEval[T, U](f: T => U)(xs: Iterable[T]) = 
    if (xs.isEmpty) true 
    else { 
    val first = f(xs.head) 
    xs forall { f(_) == first } 
    } 

Dies funktioniert mit jedem Iterable wertet f die minimale Anzahl von Zeiten möglich ist, und während der Block nicht curried werden kann, kann der Typ Rückschließer den Block Parametertyp schließen.

"allElementsEval" should "return true for an empty Iterable" in { 
    allElementsEval(List[String]()){ x => x.size } should be (true) 
    } 
    it should "eval the function at each item" in { 
    allElementsEval(List("aa", "bb", "cc")) { x => x.size } should be (true) 
    allElementsEval(List("aa", "bb", "ccc")) { x => x.size } should be (false) 
    } 
    it should "work on Vector and Array as well" in { 
    allElementsEval(Vector("aa", "bb", "cc")) { x => x.size } should be (true) 
    allElementsEval(Vector("aa", "bb", "ccc")) { x => x.size } should be (false) 
    allElementsEval(Array("aa", "bb", "cc")) { x => x.size } should be (true) 
    allElementsEval(Array("aa", "bb", "ccc")) { x => x.size } should be (false) 
    } 

Es ist nur schade, dass head :: tail Mustervergleich für Iterables so schleichend ausfällt.

Answer 7

list.groupBy{_.length}.size == 1 

Sie konvertieren die Liste in eine Zuordnung von Gruppen von Strings gleicher Länge. Wenn alle Strings dieselbe Länge haben, wird die Karte nur eine solche Gruppe enthalten.

Das nette Ding mit dieser Lösung ist, dass Sie nichts über die Länge der Zeichenfolgen wissen müssen, und sie nicht zu, sagen wir, der ersten Zeichenfolge compapre. Es funktioniert gut auf einer leeren Zeichenfolge, in diesem Fall gibt es false zurück (wenn das ist, was Sie wollen ..)