Тех собес на middle-senior IOS Developer в ****

Доступно с премиум-подпиской

Оформите премиум-подписку, чтобы получить доступ к:

• Фильтрации по компаниям
• Названиям компаний в интервью
• Видеозаписям собеседований в категории IOS Developer

Посмотреть видео в категории

Оформить премиум

(2024-07-23)

protocol Weapon { associatedtype Kind: Equatable // Swift protocols w a/t usage constraints, generic where clause func getKind() -> Kind } func compareContainerValue<C1: Weapon, C2: Weapon>(container1: C1, container2: C2) -> Bool { container1.getKind() == container.getKind()

func compareContainerValue<C1: Weapon, C2: Weapon>(container1: C1, container2: C2) -> Bool where C1.Kind == C2.Kind { return container1.getKind() == container2.getKind() }

enum Optional<T> {
    case none
    case value(T)
}

func ??<T> // nil-coalescing operator imp
////

enum Optional<T> { case none case value(T) } infix operator ?? func ??<T>(optional: Optional<T>, defaultValue: @autoclosure () -> T) -> T { switch optional { case .none: return defaultValue() case .value(let value): return value } } // Usage examples: let someValue: Optional<Int> = .value(5) let noValue: Optional<Int> = .none let result1 = someValue ?? 10 // result1 will be 5 let result2 = noValue ?? 10 // result2 will be 10

////
/*
 - номинально RAM и swap-файла хватит для того, чтобы заполнить массив (по всему циклу пройтись)
 - однако в RAM есть что-то еще
*/

var integerArray = [Int?]()
(0...999_999_999_999_999_999).forEach {
    integerArray.append($0)
}

var array = [Int]() array.reserveCapacity(1000) for i in 1...1000 { array.append(i) }

2. var integerArray = [Int?]()
let threshold = 100_000_000 // Количество элементов, после которого массив очищается

(0...999_999).forEach {
    integerArray.append($0)

    if $0 % threshold == 0 && $0 != 0 {
        print("Array count before removing: (integerArray.count)")
        integerArray.removeAll()
        print("Array cleared. Iteration: ($0)")
    }
}

extension Array where Element == Int? {

    func compactMapForInt() -> [Int] {
        var result: [Int] = []
        for i in self {
            if i != nil {
                result.append(i)
            }
        }
        return result
    }
}

et integerArray = [1,2,nil,4,nil] var mappedArray = integerArray.compactMap -> [true, true, false, true, false] // struct NilAnalyzer { let isNil: Bool } mappedArray = integerArray.compactMap -> [NilAnalyzer(isNil: false), NilAnalyzer(isNil: false), NilAnalyzer(isNil: true)...]

extension Array {
    func compactMap<T>(_ transform: (Element) -> T?) -> [T] {
        var result: [T] = []
        for value in self {
            if let transformedValue = transform(value) {
                result.append(transformedValue)
            }
        }
        return result
    }
}

let integerArray: [Int?] = [1, 2, nil, 4, nil]

// Использование для преобразования nil в true и ненулевых значений в false
let booleanArray = integerArray.compactMap { value -> Bool? in
    return value == nil ? true : false
}

print(booleanArray) // [false, false, true, false, true]

// Структура NilAnalyzer
struct NilAnalyzer {
    let isNil: Bool
}

// Использование для преобразования nil в NilAnalyzer(isNil: true) и ненулевых значений в NilAnalyzer(isNil: false)
let nilAnalyzerArray = integerArray.compactMap { value -> NilAnalyzer? in
    return NilAnalyzer(isNil: value == nil)
}

print(nilAnalyzerArray) // [NilAnalyzer(isNil: false), NilAnalyzer(isNil: false), NilAnalyzer(isNil: true), NilAnalyzer(isNil: false), NilAnalyzer(isNil: true)]

var elements = [1,2,3]
for e in elements {
    print(e)
    elements = [4,5,6]
}

class A {
    var a: A?
}

struct B {
    var b: [B]?
}

struct C {
    var c: C?
}

class C {
    var text: String = "1"
}

var value: C? = C()
var strongValue: C? = value
value?.text = "2"

let closure = {
    value?.text = "3"
}
value = nil

closure()

if let text = strongValue?.text {
    print(text)
} else {
    print("nil")
}

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)?

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 сек? print(newView.frame)

///
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)

CATransaction.begin() CATransaction.setCompletionBlock { // Код, который выполнится после завершения всех анимаций в этой транзакции } CATransaction.commit()

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")
    }
}

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)
}

var count = 0 // 2000
let group = DispatchGroup()
let countQueue = DispatchQueue(label: "countQueue", attributes: .concurrent)

group.enter()
let thread1 = Thread {
    for _ in 0...999 {
        countQueue.async(flag: .barrier) {
            count += 1
        }
    }
    group.leave()
}

group.enter()
let thread2 = Thread {
    for _ in 0...999 {
        countQueue.async(flag: .barrier) {
            count += 1
        }
    }
    group.leave()
}

thread1.start()
thread2.start()

group.notify(queue: .global()) {
    print(count)
}