स्कैला में सूची में अधिकतम मूल्य का सूचकांक कैसे प्राप्त कर सकता हूं?

Question

एक स्कैला सूची के लिए [Int] मैं अधिकतम तत्व मान खोजने के लिए अधिकतम विधि को कॉल कर सकता हूं।

मैं अधिकतम तत्व की अनुक्रमणिका कैसे प्राप्त कर सकता हूं? इसके सूचकांक के साथ इस सूची को ज़िप, सबसे बड़ा पहला तत्व के साथ जिसके परिणामस्वरूप जोड़ी मिल जाए, और उस का दूसरा तत्व वापस जाने के लिए है

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

Answer 1

एक तरह से यह करने के लिए:

यह वही अब मैं कर रहा हूँ है जोड़ी:

scala> List(0, 43, 1, 34, 10).zipWithIndex.maxBy(_._1)._2 
res0: Int = 1 

यह समस्या को हल करने का सबसे प्रभावी तरीका नहीं है, लेकिन यह मूर्खतापूर्ण और स्पष्ट है।

Answer 2

भी पढ़ने के लिए होगा आसान:

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

Answer 3

दलाल मेरे पुस्तकालय! :)

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) 

अधिक इस पैटर्न यहाँ के बारे में विवरण: http://www.artima.com/weblogs/viewpost.jsp?thread=179766

Answer 4

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 

मामले में एक से अधिक अधिकतम हैं, यह पहले एक के सूचकांक देता है।

पेशेवर: आप इसे कई प्रकार के साथ उपयोग कर सकते हैं, यह केवल एक बार सूची के माध्यम से जाता है, आप खाली सूचियों के लिए अपवाद प्राप्त करने के बजाय डिफ़ॉल्ट अनुक्रमणिका की आपूर्ति कर सकते हैं।

विपक्ष: शायद आप अपवाद पसंद करते हैं :) एक लाइनर नहीं।

Answer 5

Seq के बाद से स्काला में एक समारोह है, निम्नलिखित कोड काम करता है:

list.indices.maxBy(list)