सूची में 2 प्रविष्टियों की तुलना करें - स्कैला, मैपिंग

फ़ाइल का प्रत्येक पंक्ति मानचित्र बनाने के लिए उपयोग किया जाता हैकुंजी के रूप में स्टॉक प्रतीक के साथ प्रवेश, और मूल्य के रूप में पूर्णांक की एक सूची। संरचना का प्रकार मानचित्र [स्ट्रिंग, सूची [Int]] है। वर्तमान में मेरी प्रणाली सूची में एक प्रविष्टि की खोज कर सकती है और इसके लिए अलग-अलग परिणाम प्रदर्शित कर सकती है। हालांकि मैं सूची में 2 की तुलना कैसे करूं? मैं इस सूची में 2 आइटम की तुलना कैसे करूं? कृपया मेरे पास नीचे दिया गया कोड ढूंढें, मैं इस बात की सराहना करता हूं कि मैं आपके मूल्यांकन के लिए कोड प्रदान करना चाहता हूं लेकिन मुझे यकीन नहीं है कि इसे कैसे शुरू किया जाए। किसी भी और हर मदद की सराहना की।

/**
* Created by Andre on 10/11/2016.
*/
import scala.io.Source
import scala.io.StdIn.readInt
import scala.io.StdIn.readLine
import scala.collection.immutable.ListMap
import scala.util.Try

object StockMarket extends App {

// *******************************************************************************************************************
// application logic

// read data from file
val mapdata = readFile("data.txt")
// print data to check it"s been read in correctly
//println(mapdata)

// define menu options as a Map of actions
// for each menu item:
// key is an Int, the value that will be read from the input
// value is a function () => Boolean, i.e. no params and returns Boolean
val actionMap = Map[Int, () => Boolean](1 -> handleOne, 2 -> handleTwo, 3 -> handleThree, 4 -> handleFour, 5 -> handleFive, 6 -> handleSix, 8-> handleEight)

// loop to read input and invoke menu option
// uses function readOption to show menu and read input
// uses function menu to invoke menu action
// will terminate if menu returns false
var opt = 0
do {
opt = readOption
} while (menu(opt))



// *******************************************************************************************************************
// FUNCTIONS FOR MENU

// shows menu and reads input
def readOption: Int = {
println(
"""|Please select one of the following:
|  1 - show All stock levels
|  2 - Show Selected Stock Level
|  3 - Show Highest Stock Level
|  4 - Show Lowest Stock Level
|  5 - Show Current Stock Level
|  6 - Show Average Stock Level
|  8 - quit""".stripMargin)
readInt()
}

// invokes selected menu option
// finds corresponding function to invoke in action map using get
// pattern matching used as get returns an Option
def menu(option: Int): Boolean = {
actionMap.get(option) match {
case Some(f) => f()
case None =>
println("Sorry, that command is not recognized")
true
}
}

// handlers for menu options
def handleOne(): Boolean = {
mnuShowPoints(currentPoints)
true
}

def handleTwo(): Boolean = {
mnuShowPointsForStock(allStockLevel)
true
}

def handleThree(): Boolean = {
mnuShowSingleDataStock(highestStockLevel)
true
}

def handleFour(): Boolean = {
mnuShowSingleDataStock(lowestStockLevel)
true
}

def handleFive(): Boolean = {
mnuShowSingleDataStock(currentStockLevel)
true
}

def handleSix(): Boolean = {
mnuShowSingleDataStock(averageStockLevel)
true
}

def handleEight(): Boolean = {
println("selected quit") // returns false so loop terminates
false
}





// *******************************************************************************************************************
// UTILITY FUNCTIONS
//GETS THE DATA FROM THE DATA.TXT
def readFile(filename: String): Map[String, List[Int]] = {
processInput(Source.fromFile(filename).getLines)
}
def processInput(lines: Iterator[String]): Map[String, List[Int]] = {
Try {
lines.foldLeft(Map[String, List[Int]]()) { (acc, line) =>

val splitline = line.split(",").map(_.trim).toList
acc.updated(splitline.head, splitline.tail.map(_.toInt))
}
}.getOrElse {
println("Sorry, an exception happened.")
Map()
}
}





// *******************************************************************************************************************
// FUNCTIONS THAT INVOKE ACTION AND INTERACT WITH USER
// each of these functions accepts user input if required for an operation,
// invokes the relevant operation function and displays the results

def mnuShowPoints(f:() => Map[String,List[Int]]) = {
f() foreach {case (x,y) => println(s"$x: $y")}
}
//Returns a list value
def mnuShowPointsForStock(f: (String) => (String,List[Int])) = {
print("Stock > ")
val data = f(readLine)
println(s"${data._1}: ${data._2}")
}

// Returns a single result, not a list
def mnuShowSingleDataStock(f: (String) => (String,Int)) = {
print("Stock > ")
val data = f(readLine)
println(s"${data._1}: ${data._2}")
}

//functionality to find the last tail element, the "Current" stock price
def findLast(list:List[Int]) = list.last


//Function to find the average
def average(list:List[Int]): Double = list.sum.toDouble / list.size



// *******************************************************************************************************************
// OPERATION FUNCTIONS
// each of these performs the required operation on the data and returns
// the results to be displayed - does not interact with user

def currentPoints():Map[String,List[Int]] = {
// sort map by value in descending order -
ListMap(mapdata.toSeq.sortWith(_._1 < _._1):_*)
}


def allStockLevel(team: String): (String, List[Int]) =
(team, mapdata.get(team).getOrElse(List.empty))


//Shows Highest Stock
def highestStockLevel(stock: String): (String, Int) =
(stock, mapdata.get(stock).map(_.max).getOrElse(0))

//Shows the Lowest Stock
def lowestStockLevel(stock: String): (String, Int) =
(stock, mapdata.get(stock).map(_.min).getOrElse(0))


//Show last element in the list, most current
def currentStockLevel (stock: String): (String, Int) = {
(stock, mapdata.get (stock).map(findLast(_)).getOrElse(0))
}

//Show last element in the list, most current
def averageStockLevel (stock: String): (String, Int) = {
(stock, mapdata.get (stock).map(average(_).toInt).getOrElse(0))
}



}

उत्तर:

संपादित

टिप्पणी में अनुरोध के रूप में।

"उदाहरण के लिए" एसके 1 "और फिर एक और मूल्य," एसके 2 "और यह 2 सूचियों की तुलना करेगा और जो बड़ा होगा"

def largestList(a: String, b: String): Option[List[Int]] = {
(map.get(a), map.get(b)) match {
case (Some(alist), Some(blist)) => Some(List(alist, blist).maxBy(_.size))
case _ => None
}
}

val map = Map("stock1" -> List(1, 2), "stock2" -> List(3, 4, 5))

scala> largestList("stock1", "stock2")
res24: Option[List[Int]] = Some(List(3, 4, 5))

पुराना जवाब

मुझे लगता है कि एक नक्शा दिया गया है Map[String, List[Int]] आप मूल्य में मूल्यों का उपयोग करके मानचित्र खोजना चाहते हैं (सूची [Int])

उदाहरण के लिए यदि आप कुंजी प्राप्त करना चाहते हैं, तो मूल्य संख्या जो दो नंबर 1, 2 युक्त मान के साथ करें

map.filter { case (k, v) => v.exists(Set(1, 2)) }

स्कैला आरपीएल

scala> val map = Map("stock1" -> List(1, 2), "stock2" -> List(3, 4, 5))
map: Map[String, List[Int]] = Map("stock1" -> List(1, 2), "stock2" -> List(3, 4, 5))

scala> map.filter { case (k, v) => v.exists(Set(3, 4))}
res20: Map[String, List[Int]] = Map("stock2" -> List(3, 4, 5))