最常见的数组元素 [英] Most common array elements
问题描述
我需要在数组中找到最常见(模态)的元素.
I need to find the most common (modal) elements in an array.
我能想到的最简单的方法是为每个唯一元素设置变量,并为每个元素分配一个计数变量,每次在遍历数组的 for 循环中记录时该变量都会增加.
The simplest way I could think of was to set variables for each unique element, and assign a count variable for each one, which increases every time it is recorded in a for loop which runs through the array.
可惜数组的大小未知,会很大,所以这个方法没用.
Unfortunately the size of the array is unknown and will be very large, so this method is useless.
我在 Objective-C 中遇到过类似的问题,它使用 NSCountedSet 方法对数组元素进行排序.不幸的是,我对编程很陌生,只能将第一行翻译成 Swift.
I have come across a similar question in Objective-C that uses an NSCountedSet method to rank the array elements. Unfortunately I am very new to programming, and could only translate the first line into Swift.
建议的方法如下:
var yourArray: NSArray! // My swift translation
NSCountedSet *set = [[NSCountedSet alloc] initWithArray:yourArray];
NSMutableDictionary *dict=[NSMutableDictionary new];
for (id obj in set) {
[dict setObject:[NSNumber numberWithInteger:[set countForObject:obj]]
forKey:obj]; //key is date
}
NSLog(@"Dict : %@", dict);
NSMutableArray *top3=[[NSMutableArray alloc]initWithCapacity:3];
//which dict obj is = max
if (dict.count>=3) {
while (top3.count<3) {
NSInteger max = [[[dict allValues] valueForKeyPath:@"@max.intValue"] intValue];
for (id obj in set) {
if (max == [dict[obj] integerValue]) {
NSLog(@"--> %@",obj);
[top3 addObject:obj];
[dict removeObjectForKey:obj];
}
}
}
}
NSLog(@"top 3 = %@", top3);
在我的程序中,我需要在数组中找到前五个地名.
In my program I will need to find the top five place names in an array.
推荐答案
edit: now with Swift 2.0 below
edit: now with Swift 2.0 below
不是最有效的解决方案,而是一个简单的解决方案:
Not the most efficient of solutions but a simple one:
let a = [1,1,2,3,1,7,4,6,7,2]
var frequency: [Int:Int] = [:]
for x in a {
// set frequency to the current count of this element + 1
frequency[x] = (frequency[x] ?? 0) + 1
}
let descending = sorted(frequency) { $0.1 > $1.1 }
descending
现在由一对数组组成:值和频率,首先排序最频繁.所以前 5 个"将是前 5 个条目(假设有 5 个或更多不同的值).源数组有多大无关紧要.
descending
now consists of an array of pairs: the value and the frequency,
sorted most frequent first. So the "top 5" would be the first 5 entries
(assuming there were 5 or more distinct values). It shouldn't matter how big the source array is.
这是一个适用于任何序列的通用函数版本:
Here's a generic function version that would work on any sequence:
func frequencies
<S: SequenceType where S.Generator.Element: Hashable>
(source: S) -> [(S.Generator.Element,Int)] {
var frequency: [S.Generator.Element:Int] = [:]
for x in source {
frequency[x] = (frequency[x] ?? 0) + 1
}
return sorted(frequency) { $0.1 > $1.1 }
}
frequencies(a)
<小时>
对于 Swift 2.0,您可以将该函数改编为协议扩展:
For Swift 2.0, you can adapt the function to be a protocol extension:
extension SequenceType where Generator.Element: Hashable {
func frequencies() -> [(Generator.Element,Int)] {
var frequency: [Generator.Element:Int] = [:]
for x in self {
frequency[x] = (frequency[x] ?? 0) + 1
}
return frequency.sort { $0.1 > $1.1 }
}
}
a.frequencies()
对于 Swift 3.0:
For Swift 3.0:
extension Sequence where Self.Iterator.Element: Hashable {
func frequencies() -> [(Self.Iterator.Element,Int)] {
var frequency: [Self.Iterator.Element:Int] = [:]
for x in self {
frequency[x] = (frequency[x] ?? 0) + 1
}
return frequency.sorted { $0.1 > $1.1 }
}
}
这篇关于最常见的数组元素的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!