दिलचस्प पोस्ट
PostgreSQL / नोडजेएस के साथ परिणाम की सरणी के रूप में जुड़ें टेबल Google डिस्क एंड्रॉइड एपीआई का उपयोग करते हुए Google ड्राइव पर एक फ़ाइल कैसे हटाई जाए श्रोता को अनब्लेंड कैसे करें जो event.preventDefault () (jQuery का उपयोग कर रहा है) को बुला रहा है? एक इंट में अंकों की संख्या प्राप्त करने का तरीका? एंकर लिंक के अंदर बटन फ़ायरफ़ॉक्स में काम करता है, लेकिन इंटरनेट एक्सप्लोरर में नहीं? आलसी एंड्रॉइड (शुरुआती स्तर) में सूची दृश्य पर छवि लोड करें? C ++ विधि से उद्देश्य-सी विधि को कॉल करना? संकेतक, स्मार्ट पॉइंटर्स या साझा पॉइंटर? एंड्रॉइड पर दो तरह प्रमाणन SSL सॉकेट के लिए क्लाइंट / सर्वर प्रमाणपत्र का उपयोग करना क्या मुझे संभवत: समानांतर स्ट्रीम का उपयोग करना चाहिए? MySQL में कार्डिनलता क्या है? अलग-अलग राज्य के लिए छवि बटन पृष्ठभूमि छवि कैसे सेट करें? कैसे पता कैसे एक संकेतक ढेर या स्टैक को इंगित करता है? हाशमैप कुंजी के रूप में केस असंवेदनशील स्ट्रिंग ट्विटर बूटस्ट्रैप सूचना संदेश बंद करें और फिर से खोलें

स्विफ्ट सरणी में एक तत्व की घटनाओं को कैसे गिनें?

मैंने इस के कुछ उदाहरणों को देखा है लेकिन उन सभी को यह जानने के लिए भरोसा है कि आप किस तत्व को घटनाओं की गिनती करना चाहते हैं मेरी सरणी गतिशील रूप से उत्पन्न होती है इसलिए मेरे पास जानने का कोई तरीका नहीं है कि मैं कौन से तत्व को उन घटनाओं की गणना करना चाहता हूं (मैं उन सभी की घटनाओं को गिनना चाहता हूं)। क्या कोई सलाह दे सकता है?

अग्रिम में धन्यवाद

संपादित करें:

शायद मुझे स्पष्ट होना चाहिए था, सरणी में कई भिन्न स्ट्रिंग्स होंगे (जैसे ["FOO", "FOO", "BAR", "FOOBAR"]

मैं कैसे अग्रिम में हैं, यह जानने के बिना मैं foo, bar और foobar की घटनाओं को कैसे गिना सकता हूं?

वेब के समाधान से एकत्रित समाधान "स्विफ्ट सरणी में एक तत्व की घटनाओं को कैसे गिनें?"

स्विफ्ट 3 और स्विफ्ट 2:

आप अपनी [String] में प्रत्येक आइटम के लिए गिनती के लिए [String: Int] टाइप करने के एक शब्दकोश का उपयोग कर सकते हैं:

 let arr = ["FOO", "FOO", "BAR", "FOOBAR"] var counts: [String: Int] = [:] for item in arr { counts[item] = (counts[item] ?? 0) + 1 } print(counts) // "[BAR: 1, FOOBAR: 1, FOO: 2]" for (key, value) in counts { print("\(key) occurs \(value) time(s)") } 

उत्पादन:

 BAR occurs 1 time(s) FOOBAR occurs 1 time(s) FOO occurs 2 time(s) 

स्विफ्ट 4:

स्विफ्ट 4 की शुरुआत (एसई -10165) में एक शब्दकोश के साथ एक डिफ़ॉल्ट मान शामिल करने की क्षमता है, और परिणामस्वरूप मूल्य को += और += जैसे कार्यों के साथ बदल दिया जा सकता है:

 counts[item] = (counts[item] ?? 0) + 1 

हो जाता है:

 counts[item, default: 0] += 1 

इससे forEach उपयोग की जाने वाली एक संक्षिप्त पंक्ति में गणना कार्य करना आसान होता है:

 let arr = ["FOO", "FOO", "BAR", "FOOBAR"] var counts: [String: Int] = [:] arr.forEach { counts[$0, default: 0] += 1 } print(counts) // "["FOOBAR": 1, "FOO": 2, "BAR": 1]" 
 array.filter{$0 == element}.count 

मैंने स्विफ्ट 2 को ओइएसडक का जवाब दिया।

16/04/14 मैंने इस कोड को स्विफ्ट 2.2 में अपडेट किया

16/10/11 स्विफ्ट 3 में अपडेट किया गया


Hashable:

 extension Sequence where Self.Iterator.Element: Hashable { private typealias Element = Self.Iterator.Element func freq() -> [Element: Int] { return reduce([:]) { (accu: [Element: Int], element) in var accu = accu accu[element] = accu[element]?.advanced(by: 1) ?? 1 return accu } } } 

Equatable:

 extension Sequence where Self.Iterator.Element: Equatable { private typealias Element = Self.Iterator.Element func freqTuple() -> [(element: Element, count: Int)] { let empty: [(Element, Int)] = [] return reduce(empty) { (accu: [(Element, Int)], element) in var accu = accu for (index, value) in accu.enumerated() { if value.0 == element { accu[index].1 += 1 return accu } } return accu + [(element, 1)] } } } 

प्रयोग

 let arr = ["a", "a", "a", "a", "b", "b", "c"] print(arr.freq()) // ["b": 2, "a": 4, "c": 1] print(arr.freqTuple()) // [("a", 4), ("b", 2), ("c", 1)] 

 for (k, v) in arr.freq() { print("\(k) -> \(v) time(s)") } // b -> 2 time(s) // a -> 4 time(s) // c -> 1 time(s) for (element, count) in arr.freqTuple() { print("\(element) -> \(count) time(s)") } // a -> 4 time(s) // b -> 2 time(s) // c -> 1 time(s) 

स्विफ्ट 4 के साथ, आपकी ज़रूरतों के अनुसार, आप 6 के बाद के खेल का मैदान कोडों में से एक चुन सकते हैं ताकि किसी सरणी में हैशणीय वस्तुओं की घटनाओं की गणना कर सकें।


# 1। Array का उपयोग reduce(into:_:) और Dictionary subscript(_:default:) (स्विफ्ट 4 की आवश्यकता है)

 let array = [4, 23, 97, 97, 97, 23] let reducedArray = array.reduce(into: [:]) { counts, number in counts[number, default: 0] += 1 } print(reducedArray) // [4: 1, 23: 2, 97: 3] 

# 2। repeatElement(_:count:) फ़ंक्शन, zip(_:_:) फ़ंक्शन, Dictionary init(_:uniquingKeysWith:) initializer और एक Dictionary लौटने का उपयोग करना (स्विफ्ट 4 की आवश्यकता है)

 let array = [4, 23, 97, 97, 97, 23] let repeated = repeatElement(1, count: array.count) //let repeated = Array(repeating: 1, count: array.count) // also works let zipSequence = zip(array, repeated) let dictionary = Dictionary(zipSequence, uniquingKeysWith: { (current, new) in return current + new }) //let dictionary = Dictionary(zipSequence, uniquingKeysWith: +) // also works print(dictionary) // prints [4: 1, 23: 2, 97: 3] 

# 3। एक Dictionary init(grouping:by:) का उपयोग करना init(grouping:by:) आरंभकर्ता) और ट्यूप्ले के एक Array को लौटाना (स्विफ्ट 4 की आवश्यकता होती है)

 let array = [4, 23, 97, 97, 97, 23] let dictionary = Dictionary(grouping: array, by: { $0 }) let newArray = dictionary.map { (key: Int, value: [Int]) in return (key, value.count) } print(newArray) // prints: [(4, 1), (23, 2), (97, 3)] 

# 4। लूप का उपयोग करना और एक Dictionary लौटाना

 extension Array where Element: Hashable { func countForElements() -> [Element: Int] { var counts = [Element: Int]() for element in self { counts[element] = (counts[element] ?? 0) + 1 } return counts } } let array = [4, 23, 97, 97, 97, 23] print(array.countForElements()) // prints [4: 1, 23: 2, 97: 3] 

# 5। NSCountedSet का उपयोग करना, map पद्धति और NSCountedSet एक Array को लौटाना (फाउंडेशन की आवश्यकता होती है)

 import Foundation extension Array where Element: Hashable { func countForElements() -> [(Element, Int)] { let countedSet = NSCountedSet(array: self) let res = countedSet.objectEnumerator().map { (object: Any) -> (Element, Int) in return (object as! Element, countedSet.count(for: object)) } return res } } let array = [4, 23, 97, 97, 97, 23] print(array.countForElements()) // prints [(97, 3), (4, 1), (23, 2)] 

# 6। NSCountedSet , AnyIterator का उपयोग करना और ट्यूपल्स का एक Array लौटाना (फाउंडेशन की आवश्यकता है)

 import Foundation extension Array where Element: Hashable { func counForElements() -> Array<(Element, Int)> { let countedSet = NSCountedSet(array: self) var countedSetIterator = countedSet.objectEnumerator().makeIterator() let anyIterator = AnyIterator<(Element, Int)> { guard let element = countedSetIterator.next() as? Element else { return nil } return (element, countedSet.count(for: element)) } return Array<(Element, Int)>(anyIterator) } } let array = [4, 23, 97, 97, 97, 23] print(array.counForElements()) // [(97, 3), (4, 1), (23, 2)] 

क्रेडिट:

  • स्विफ्ट विंग्स
  • संग्रह पर जेनेरिक, शब्दकोश का उपयोग करते हुए

NSCountedSet का उपयोग करें उद्देश्य-सी में:

 NSCountedSet* countedSet = [[NSCountedSet alloc] initWithArray:array]; for (NSString* string in countedSet) NSLog (@"String %@ occurs %zd times", string, [countedSet countForObject:string]); 

मुझे लगता है कि आप इसे स्वयं स्विफ्ट में अनुवाद कर सकते हैं

कैसा रहेगा:

 func freq<S: SequenceType where S.Generator.Element: Hashable>(seq: S) -> [S.Generator.Element:Int] { return reduce(seq, [:]) { (var accu: [S.Generator.Element:Int], element) in accu[element] = accu[element]?.successor() ?? 1 return accu } } freq(["FOO", "FOO", "BAR", "FOOBAR"]) // ["BAR": 1, "FOOBAR": 1, "FOO": 2] 

यह सामान्य है, इसलिए यह आपके तत्व के साथ काम करेगा, जब तक कि यह असभ्य है:

 freq([1, 1, 1, 2, 3, 3]) // [2: 1, 3: 2, 1: 3] freq([true, true, true, false, true]) // [false: 1, true: 4] 

और, अगर आप अपने तत्वों को नहीं बना सकते हैं, तो आप इसे ट्यूपल्स के साथ कर सकते हैं:

 func freq<S: SequenceType where S.Generator.Element: Equatable>(seq: S) -> [(S.Generator.Element, Int)] { let empty: [(S.Generator.Element, Int)] = [] return reduce(seq, empty) { (var accu: [(S.Generator.Element,Int)], element) in for (index, value) in enumerate(accu) { if value.0 == element { accu[index].1++ return accu } } return accu + [(element, 1)] } } freq(["a", "a", "a", "b", "b"]) // [("a", 3), ("b", 2)] 

एक अन्य तरीका फ़िल्टर विधि का उपयोग करना होगा। मुझे लगता है कि सबसे सुरुचिपूर्ण

 var numberOfOccurenses = countedItems.filter( { if $0 == "FOO" || $0 == "BAR" || $0 == "FOOBAR" { return true }else{ return false } }).count 

मैं भीतरी छोरों से बचने के लिए और जितना संभव हो उसका उपयोग करना चाहता हूं। इसलिए यदि हमारे पास स्ट्रिंग सरणी है, तो हम घटनाओं को गिनने के लिए निम्नलिखित कार्य कर सकते हैं

 var occurances = ["tuples", "are", "awesome", "tuples", "are", "cool", "tuples", "tuples", "tuples", "shades"] var dict:[String:Int] = [:] occurances.map{ if let val: Int = dict[$0] { dict[$0] = val+1 } else { dict[$0] = 1 } } 

प्रिंट

 ["tuples": 5, "awesome": 1, "are": 2, "cool": 1, "shades": 1] 

स्विफ्ट 4

 let array = ["FOO", "FOO", "BAR", "FOOBAR"] // Merging keys with closure for conflicts let mergedKeysAndValues = Dictionary(zip(array, repeatElement(1, count: array)), uniquingKeysWith: +) // mergedKeysAndValues is ["FOO": 2, "BAR": 1, "FOOBAR": 1] 

गिनती सॉर्ट में पहला कदम

 var inputList = [9,8,5,6,4,2,2,1,1] var countList : [Int] = [] var max = inputList.maxElement()! // Iniate an array with specific Size and with intial value. // We made the Size to max+1 to integrate the Zero. We intiated the array with Zeros because it's Counting. var countArray = [Int](count: Int(max + 1), repeatedValue: 0) for num in inputList{ countArray[num] += 1 } print(countArray)