स्विफ्ट में एक ऐरे में अधिकतम खोजने का सही तरीका


121

मुझे अब तक एक सरल (लेकिन संभावित रूप से महंगा) तरीका मिला है:

var myMax = sort(myArray,>)[0]

और मुझे स्कूल में कैसे करना सिखाया गया:

var myMax = 0
for i in 0..myArray.count {
    if (myArray[i] > myMax){myMax = myArray[i]}
}

क्या स्विफ्ट में एक पूर्णांक सरणी से अधिकतम मूल्य प्राप्त करने का एक बेहतर तरीका है? आदर्श रूप से कुछ ऐसा है जो रूबी के रूप में एक पंक्ति है.max


आप एक विस्तार लिखें।
gnasher729

हाँ, एक पंक्ति maxElement(myArray):। देखें कि वर्तमान में नीचे (रुडोल्फ एडमकोविक) का दूसरा उत्तर क्या है।
leekaiinthesky

यो परिवर्तन है कि इस के
matgabor

@mattymcgee मैंने स्वीकृत उत्तर को अपडेट कर दिया है।
चार्ली ईगन

जवाबों:


299

दिया हुआ:

let numbers = [1, 2, 3, 4, 5]

स्विफ्ट 3:

numbers.min() // equals 1
numbers.max() // equals 5

स्विफ्ट 2:

numbers.minElement() // equals 1
numbers.maxElement() // equals 5

2
केवल Comparableवस्तुओं पर काम करता है , इसलिए NSDecimalNumberउदाहरण के लिए काम नहीं करेगा।
माइकल हर्नस

2
क्या यह सिर्फ मैं है या स्विफ्ट 2 में ये कार्य मौजूद नहीं हैं?
लिरॉन याहदव

@LironYahdav अब वे विधियाँ हैं। फिक्स्ड। धन्यवाद!
रुडोल्फ एडमकोविच

2
नोट स्विफ्ट 3 में इनका नाम बदलकर बस min()और कर दिया गया है max()
जम्मों १०'१६

1
@Jezzamon संख्या में स्विफ्ट 3 तरीकों minElementऔर maxElementको नाम दिया गया minऔर max। देखें: github.com/apple/swift-evolution/blob/master/proposals/… मैं आपके भ्रम को समझता हूं, क्योंकि मुक्त कार्य minऔर maxअभी भी मौजूद हैं। उदाहरण के लिए देखें, gist.github.com/lorentey/d679064cb29df4558534d619319a1d9e
jemmons

95

अद्यतन: स्विफ्ट में दिखाई देने के बाद से यह संभवतः स्वीकृत उत्तर होना चाहिए maxElement


सर्वशक्तिमान का उपयोग करें reduce:

let nums = [1, 6, 3, 9, 4, 6];
let numMax = nums.reduce(Int.min, { max($0, $1) })

इसी तरह:

let numMin = nums.reduce(Int.max, { min($0, $1) })

reduceएक पहला मान लेता है जो आंतरिक संचयकर्ता चर के लिए प्रारंभिक मूल्य है, फिर संचयकर्ता और सरणी के प्रत्येक तत्व के लिए उत्तीर्ण फ़ंक्शन (यहां, यह अनाम है) को लागू करता है, और संचयकर्ता में नए मान को संग्रहीत करता है। अंतिम संचायक मान फिर लौटा दिया जाता है।


1
मुझे इसकी ही चाहत थी। ऐसा बहुत कुछ है जो iBook में नहीं लगता है!
चार्ली इगन

2
वे सिर्फ सामान्य कार्यात्मक प्रोग्रामिंग तकनीक हैं, वे स्विफ्ट के लिए विशिष्ट नहीं हैं।
जीन-फिलिप पेलेट

10
@ जीन-फिलिप्पेलेट आप वास्तव में इसे सरल बना सकते हैं: nums.reduce(Int.min, max)चूँकि maxप्रोटोटाइप पहले से ही उस प्रकार से मेल खाता है जो reduceउम्मीद कर रहा है
drewag

क्या कोई कारण है कि यह डबल्स के सरणियों के साथ काम नहीं करता है?
निकोलस

3
न्यूनतम / अधिकतम फ़ंक्शन हस्ताक्षर संयोजन से मेल खाते हैं: पैरामीटर हस्ताक्षर ताकि आप केवल फ़ंक्शन को स्वयं पास कर सकें:let numMax = nums.reduce(Int.min, combine: max)
Leslie Godwin

38

स्विफ्ट 5 के साथ, Arrayअन्य की तरह Sequenceप्रोटोकॉल अनुरूप वस्तुओं ( Dictionary, Set, आदि), दो तरीकों कहा जाता हैmax() और max(by:)जो अनुक्रम में अधिकतम तत्व को वापस करता है या nilयदि अनुक्रम खाली है।


# 1। का उपयोग करते हुए Arrayकी max()विधि

तो करने के लिए अपने अनुक्रम अनुरूप अंदर तत्व प्रकार Comparableप्रोटोकॉल (यह हो सकता है String, Float, Characterया अपने कस्टम वर्ग या struct में से एक), तो आप का उपयोग करने के लिए सक्षम हो जाएगा max()कि निम्नलिखित है घोषणा :

@warn_unqualified_access func max() -> Element?

अनुक्रम में अधिकतम तत्व देता है।

निम्नलिखित खेल का मैदान कोड का उपयोग करने के लिए दिखा max():

let intMax = [12, 15, 6].max()
let stringMax = ["bike", "car", "boat"].max()

print(String(describing: intMax)) // prints: Optional(15)
print(String(describing: stringMax)) // prints: Optional("car")
class Route: Comparable, CustomStringConvertible {

    let distance: Int
    var description: String { return "Route with distance: \(distance)" }

    init(distance: Int) {
        self.distance = distance
    }

    static func ==(lhs: Route, rhs: Route) -> Bool {
        return lhs.distance == rhs.distance
    }

    static func <(lhs: Route, rhs: Route) -> Bool {
        return lhs.distance < rhs.distance
    }

}

let routes = [
    Route(distance: 20),
    Route(distance: 30),
    Route(distance: 10)
]

let maxRoute = routes.max()
print(String(describing: maxRoute)) // prints: Optional(Route with distance: 30)

# 2। का उपयोग करते हुएArray की max(by:)विधि

यदि आपके अनुक्रम के अंदर मौजूद तत्व प्रकार Comparableप्रोटोकॉल के अनुरूप नहीं है, तो आपको max(by:)निम्नलिखित घोषणा करने के लिए उपयोग करना होगा :

@warn_unqualified_access func max(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows -> Element?

अनुक्रम में अधिकतम तत्व देता है, दिए गए विधेय का उपयोग तत्वों के बीच तुलना के रूप में करता है।

निम्नलिखित खेल का मैदान कोड का उपयोग करने के लिए दिखा max(by:):

let dictionary = ["Boat" : 15, "Car" : 20, "Bike" : 40]

let keyMaxElement = dictionary.max(by: { (a, b) -> Bool in
    return a.key < b.key
})

let valueMaxElement = dictionary.max(by: { (a, b) -> Bool in
    return a.value < b.value
})

print(String(describing: keyMaxElement)) // prints: Optional(("Car", 20))
print(String(describing: valueMaxElement)) // prints: Optional(("Bike", 40))
class Route: CustomStringConvertible {

    let distance: Int
    var description: String { return "Route with distance: \(distance)" }

    init(distance: Int) {
        self.distance = distance
    }

}

let routes = [
    Route(distance: 20),
    Route(distance: 30),
    Route(distance: 10)
]

let maxRoute = routes.max(by: { (a, b) -> Bool in
    return a.distance < b.distance
})

print(String(describing: maxRoute)) // prints: Optional(Route with distance: 30)

स्विफ्ट 3 में "मैक्सिमम" का नाम बदलकर "मैक्स" कर दिया गया है
निकोलई हेनरिकेन

16

अन्य उत्तर सभी सही हैं, लेकिन यह मत भूलो कि आप संग्रह संचालकों का उपयोग भी कर सकते हैं, इस प्रकार है:

var list = [1, 2, 3, 4]
var max: Int = (list as AnyObject).valueForKeyPath("@max.self") as Int

आप उसी तरह से औसत भी पा सकते हैं:

var avg: Double = (list as AnyObject).valueForKeyPath("@avg.self") as Double

यह सिंटैक्स कुछ अन्य समाधानों की तुलना में कम स्पष्ट हो सकता है, लेकिन यह देखना दिलचस्प है कि -valueForKeyPath:अभी भी इसका उपयोग किया जा सकता है :)


11

आप के साथ उपयोग कर सकते हैं reduce:

let randomNumbers = [4, 7, 1, 9, 6, 5, 6, 9]
let maxNumber = randomNumbers.reduce(randomNumbers[0]) { $0 > $1 ? $0 : $1 } //result is 9

4
var numbers = [1, 2, 7, 5];    
var val = sort(numbers){$0 > $1}[0];

2
मेरे लिए यह बहुत अच्छा लगता हैvar myMax = sort(myArray,>)[0]
चार्ली इगन

3
सॉर्ट बहुत अधिक उपरि है।
v3232

4

स्विफ्ट 1.2 (और शायद पहले) के साथ अब आपको उपयोग करने की आवश्यकता है:

let nums = [1, 6, 3, 9, 4, 6];
let numMax = nums.reduce(Int.min, combine: { max($0, $1) })

दोहरे मूल्यों के साथ काम करने के लिए मैंने कुछ इस तरह का उपयोग किया:

let nums = [1.3, 6.2, 3.6, 9.7, 4.9, 6.3];
let numMax = nums.reduce(-Double.infinity, combine: { max($0, $1) })

1
आप बस यह भी कर सकते हैं let numMax = nums.reduce(-Double.infinity, combine: max), अधिकतम फ़ंक्शन हस्ताक्षर गठबंधन: पैरामीटर हस्ताक्षर से मेल खाता है।
लेस्ली गॉडविन

3

स्विफ्ट 2.0 में, minElementऔर प्रोटोकॉल के maxElementतरीके बन जाते हैं SequenceType, आपको उन्हें कॉल करना चाहिए जैसे:

let a = [1, 2, 3]
print(a.maxElement()) //3
print(a.minElement()) //1

का उपयोग करते हुए maxElementएक समारोह के रूप की तरह maxElement(a)है अनुपलब्ध अब।

स्विफ्ट का सिंटैक्स फ्लक्स में है, इसलिए मैं सिर्फ एक्सकोड वर्जन 7 बीटा 6 में इसकी पुष्टि कर सकता हूं

भविष्य में इसे संशोधित किया जा सकता है, इसलिए मेरा सुझाव है कि आप इन विधियों का उपयोग करने से पहले डॉक्टर से बेहतर जांच करेंगे।


3

स्विफ्ट 3.0

आप इस कोड को प्रोग्रामेटिक रूप से आज़मा सकते हैं।

func getSmallAndGreatestNumber() -> Void {

    let numbers = [145, 206, 116, 809, 540, 176]
    var i = 0
    var largest = numbers[0]
    var small = numbers[0]
    while i < numbers.count{

        if (numbers[i] > largest) {
            largest = numbers[i]
        }
        if (numbers[i] < small) {
            small = numbers[i]
        }
        i = i + 1
    }
    print("Maximum Number ====================\(largest)")// 809
    print("Minimum Number ====================\(small)")// 116
}


0

स्विफ्ट 3/4 के लिए अपडेट किया गया:

सरणी से अधिकतम खोजने के लिए कोड की सरल रेखाओं के नीचे का उपयोग करें;

var num = [11, 2, 7, 5, 21]
var result = num.sorted(){
    $0 > $1
}
print("max from result: \(result[0])") // 21

-1

आप अपनी सरणी को सॉर्ट भी कर सकते हैं और फिर उपयोग array.firstया कर सकते हैंarray.last


5
यह कम्प्यूटेशनल रूप से धीमा है। आप रैखिक समय में अधिकतम पा सकते हैं।
चार्ली एगन

मैं एक बहुत नया @CharlieEgan हूं, क्या आप रैखिक समय की व्याख्या कर सकते हैं या मुझे एक ट्यूटोरियल की ओर इशारा कर सकते हैं। बहुत बहुत धन्यवाद
Saad Ghadir

some टाइम कॉम्पलेक्सिटी ’( en.wikipedia.org/wiki/Time_complexity ) के आसपास कुछ पढ़ते हैं । यह भी लायक पढ़ने है: bigocheatsheet.com । कुछ अच्छे उदाहरण यहाँ दिए गए हैं: khanacademy.org/computing/computer-science/algorithms
चार्ली इगन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.