алгоритмы
func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
var frequencyMap = [Int: Int]()
// Подсчет частоты встречаемости каждого элемента
for num in nums {
frequencyMap[num, default: 0] += 1
}
// Сортировка словаря по убыванию частоты встречаемости
let sortedFrequency = frequencyMap.sorted { $0.value > $1.value }
// Взятие первых k элементов
let topKFrequentElements = sortedFrequency.prefix(k)
// Получение ключей (элементов) из пар ключ-значение
let result = topKFrequentElements.map { $0.key }
return result
}
// Пример использования:
let nums = [1, 1, 1, 2, 2, 3]
let k = 2
let result = topKFrequent(nums, k)
print(result) // Выведет [1, 2]
Этот алгоритм работает следующим образом:
1. **Подсчет частоты встречаемости:** Прежде всего, проходим по всем элементам массива `nums` и подсчитываем частоту встречаемости каждого элемента, используя словарь `frequencyMap`. Ключами словаря являются элементы массива, а значениями - количество их встреч в массиве.
2. **Сортировка по частоте:** После того как мы подсчитали частоту встречаемости каждого элемента, сортируем словарь `frequencyMap` по убыванию значений (частоты встречаемости). Это позволяет нам найти самые часто встречающиеся элементы.
3. **Взятие k наиболее часто встречающихся элементов:** Мы берем первые k элементов из отсортированного словаря, используя метод `prefix(k)`. Это даст нам k элементов с самыми высокими частотами встречаемости.
4. **Получение ключей:** Наконец, мы извлекаем ключи (элементы) из пар ключ-значение, представленных первыми k элементами отсортированного словаря. Эти ключи и составляют итоговый массив с k наиболее часто встречающимися элементами.
Таким образом, мы эффективно находим k наиболее часто встречающихся элементов массива `nums`, используя подсчет частоты встречаемости и сортировку.
weak var people: People? = People()
people?.sayHello()
people = nil
///
let main = DispatchQueue.main
let serial = DispatchQueue(label: "serial")
let concurrent = DispatchQueue(label: "concurrent", attributes: .concurrent)
main.async {
print(1)
}
main.async {
print(2)
serial.async {
print(3)
}
serial.sync {
print(4)
concurrent.sync {
print(5)
concurrent.sync {
print(6)
}
serial.sync {
print(7)
}
}
}
}
serial.sync {
print(8)
}
// 8 1 2 3 4 5 6 deadlock
///
protocol Weapon {
associatedtype Kind: Equatable
func getKind() -> Kind
}
func compareContainerValue<C1: Weapon, C2: Weapon>(container1: C1, container2: C2) -> Bool {
container1.getKind() == container2.getKind()
}
class X: Equatable { /**/ }
class Y: Equatable { /**/ }
X() == Y()
///
enum CustomOptional<T>: ExpressibleByNilLiteral {
case some(T)
case none
func forceUnwrap() {
}
static func ?? (input: T) {
}
static func == <T: Equatable>(lhs: T, rhs: T) -> Bool {
switch (lhs, rhs) {
case (.none, .none): return true
case (.some(T), .some(T)): return T == T
default: return false
}
}
}
///
extension Collection -> лучше глянуть в доке эппла (!) {
subscript safe(index: Int) -> Element? {
guard index >= 0 && index < endIndex else {
return nil
}
return self[index]
}
}
var dict: [String: Int?] = [
"one": 1,
"two": 2,
"none": nil
]
print(dict.count) // что тут выведется? 3
dict["two"] = .some(nil)
dict["none"] = .some(nil)
print(dict.count) // а здесь? 3
extension Array {
func compactMap(input: [Int?], action: () -> ) -> [Int] {
var result: [Int] = []
for number in input {
if let number {
result.append(number)
}
}
return result
}
}
let integerArray = [0,1,3,4]
let booleanArray = integerArray.compactMap { $0.isMultiple(of: 2) ? true : false }
// Создать функцию для создания строки, содержащей символы по четным индексам (0, 2, 4, 6, 8, ...) из заданной строки.
// asdfg -> adg
func newStr(input: String) -> String {
var result = ""
var characterArray: [Character] = []
for character in input {
characterArray.append(character)
}
for character in characterArray.indices {
if character % 2 == 0 {
result += String(characterArray[character])
}
}
return result
}
///
let newView = UIView(frame: CGRect(x: 100, y: 100, width: 100, height: 100))
newView.backgroundcolor = .red
newView.layer.bounds.size = CGSize(width: 30, height: 30)
// 1. Что будет на экране?
// 2. Что выведет print(newView.frame)?
// reloadSections() - выполнить код после того как пройдет анимация
///
let newView = UIView(frame: CGRect(x: 100, y: 100, width: 100, height: 100))
UIView.animate(withDuration: 5) {
self.newView.frame = CGRect(x: 100, y: 600, width: 100, height: 100)
}
...
// Посередине анимации (через 2.5 сек после вызова анимации) вызываем sleep(10)
/// Если тормозит коллекция или таблица, то в чем причина и куда смотреть
////
var elements = [1,2,3]
for e in elements {
print(e)
elements = [4,5,6]
}
// 1 1
// 2 5
// 3 6
class A {
var a: A?
}
struct B {
var b: [B]?
}
struct C {
var c: C?
}
class Node<T> {
public var value: T
public var next: Node?
init(data: T, next: Node? = nil) {
self.value = data
self.next = next
}
var last: Node? {
}
}
let list = Node<Int>(data: 1, next: Node<Int>(data: 2, next: Node<Int>(data: 3)))
let last = list.last // 3
class TestClass {
var name = ""
var block1: (()->Void)?
var block2: (()->Void)?
func test() {
self.block1 = {
self.block2 = { [weak self] in
print(self)
}
self.block2?()
}
self.block1?()
}
deinit {
print("deinit")
}
}
let testObject: TestClass? = TestClass()
testObject?.test()
testObject = nil
class People {
var name: String = "Bill"
func sayHello() {
doAction {
print("Hello my name is (self.name)")
}
}
private func doAction(closure: @escaping () -> Void) {
DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
closure()
}
}
deinit {
print("People deiniting")
}
}