Comment puis-je trouver l'indice de la valeur maximale dans une Liste Scala?

Pour un Scala List[Int] je peux appeler la méthode max pour trouver le maximum de la valeur de l'élément.

Comment puis-je trouver l'index de l'élément maximum?

C'est ce que je fais maintenant:

val max = list.max 
val index = list.indexOf(max)

sonne comme un étrange cas d'utilisation. peut-être que l'utilisation besoin d'une triés structure de données?
Oui, vous avez un point sur l'étrange cas, vous pourriez dire que c'est "l'odeur de code" comme le max aurait pu être trouvé lors de la génération de la liste de la première place. Pas assez d'espace pour aller dans pourquoi elle semble mal ici, dans ce petit espace, je vais peut-être mettre à jour la réponse plus tard.

InformationsquelleAutor Phil | 2012-12-23

38

Une façon de le faire est de zip la liste avec ses indices, trouver la paire avec le plus grand premier élément, et le retour le deuxième élément de la paire:
```
scala> List(0, 43, 1, 34, 10).zipWithIndex.maxBy(_._1)._2
res0: Int = 1
```
Ce n'est pas le moyen le plus efficace pour résoudre le problème, mais il est idiomatiques et clair.
- merde, exactement ce que j'allais dire... j'ai ajouté un cas x.zipWithIndex.maxBy{ case (i,v) => v }._2
InformationsquelleAutor Travis Brown
9

Depuis Seq est une fonction de la Scala, le code suivant fonctionne:
```
list.indices.maxBy(list)
```
- Départ Scala 2.13, une version de la manipulation vide listes pourrait être: list.indices.maxByOption(list)
InformationsquelleAutor Yuichiroh

même plus facile à lire serait:

   val g = List(0, 43, 1, 34, 10)
   val g_index=g.indexOf(g.max)

InformationsquelleAutor xhudik

  def maxIndex[ T <% Ordered[T] ] (list : List[T]) : Option[Int] = list match {
    case Nil => None
    case head::tail => Some(
        tail.foldLeft((0, head, 0)){
            case ((indexOfMaximum, maximum, index), elem) =>
              if(elem > maximum) (index, elem, index + 1)
              else (indexOfMaximum, maximum, index + 1)
        }._1
    )
  }   //> maxIndex: [T](list: List[T])(implicit evidence$2: T => Ordered[T])Option[Int]


    maxIndex(Nil)                            //> res0: Option[Int] = None
    maxIndex(List(1,2,3,4,3))                //> res1: Option[Int] = Some(3)
    maxIndex(List("a","x","c","d","e"))      //> res2: Option[Int] = Some(1)

    maxIndex(Nil).getOrElse(-1)              //> res3: Int = -1
    maxIndex(List(1,2,3,4,3)).getOrElse(-1)  //> res4: Int = 3
    maxIndex(List(1,2,2,1)).getOrElse(-1)    //> res5: Int = 1

Dans le cas où il y a plusieurs maximums, elle renvoie le premier indice.

Avantages:Vous pouvez l'utiliser avec plusieurs types, il passe par la liste qu'une seule fois, vous pouvez fournir un index par défaut au lieu de se faire exception pour vider les listes.

Inconvénients:Peut-être vous préférez des exceptions 🙂 Pas un one-liner.

Bonjour, où puis-je lire sur le sens de la <% et <: les opérateurs, c'est assez dur de faire une recherche sur Google (ou n'importe où) pour les opérateurs qui ne sont pas des mots. Aussi, je pense que vous pourriez peut-être utiliser tailrec dans votre réponse (exemple). Je vous remercie.
Trouvé!!! Désolé pour le demander.

InformationsquelleAutor Keyel

Pimp ma bibliothèque! 🙂

class AwesomeList(list: List[Int]) {
  def getMaxIndex: Int = {
    val max = list.max
    list.indexOf(max)
  }
}

implicit def makeAwesomeList(xs: List[Int]) = new AwesomeList(xs)
                                              //> makeAwesomeList: (xs: List[Int])scalaconsole.scratchie1.AwesomeList

//Now we can do this:
List(4,2,7,1,5,6) getMaxIndex             //> res0: Int = 2

//And also this:
val myList = List(4,2,7,1,5,6)            //> myList  : List[Int] = List(4, 2, 7, 1, 5, 6)
myList getMaxIndex                        //> res1: Int = 2

//Regular list methods also work
myList filter (_%2==0)                    //> res2: List[Int] = List(4, 2, 6)

Plus de détails à propos de ce modèle ici: http://www.artima.com/weblogs/viewpost.jsp?thread=179766

Alors qu'il est facile d'écrire, n'est-il pas passer par la liste deux fois?
Oui, vous avez raison. J'ai une façon d'obtenir le max dans une itération à travers la liste, mais je pense que la lisibilité en prend un grand coup avec que. Aussi, il s'agit d'utiliser maliste(index) afin d'extraire l'élément en particulier et je ne suis pas sûr de savoir comment efficace qui est

InformationsquelleAutor Plasty Grove

Vous devez vous connecter pour publier un commentaire.