Учитывая входную строку (строки) и шаблон (p), реализуйте сопоставление шаблонов с подстановочными знаками с поддержкой '?' и '*', где:
"?'
Соответствует любому отдельному символу.
'*'
Соответствует любой последовательности символов (включая пустую последовательность).
Соответствие должно охватывать всю входную строку (не частичное).

class Solution {
    typealias C = Character
    
    func isMatch(_ s: String, _ p: String) -> Bool {
        var sArray = Array(s)
        var pArray = Array(p)
        
        var sdx = 0
        var pdx = 0
        
        var starPDx = -1
        var starSDx = -1
        
        while (sdx < sArray.count) {
            if pdx < pArray.count && (sArray[sdx] == pArray[pdx] || pArray[pdx] == C("?")){
                sdx += 1
                pdx += 1
            } else if pdx < pArray.count && pArray[pdx] == C("*") {
                starPDx = pdx
                starSDx = sdx
                pdx += 1
            } else if starPDx == -1 {
                return false
            } else {
                sdx = starSDx + 1
                pdx = starPDx + 1
                starSDx = sdx
            }
        }
        return pdx < pArray.count ? !pArray[pdx ..< pArray.count].contains(where: { $0 != C("*") }) : true
    }
}

При наличии двух неотрицательных целых чисел num1 и num, представленных в виде строк, возвращает произведение num1 и num2, также представленное в виде строки.
Примечание: Вы не должны использовать какую-либо встроенную библиотеку BigInteger или преобразовывать входные данные в integer напрямую.

class Solution {
    func multiply(_ num1: String, _ num2: String) -> String {
        
        func sum(_ n1: [Int], _ n2: [Int]) -> [Int] {
            
            var res = [Int]()

            for i in 0..<max(n1.count, n2.count) {
                if res.count <= i { res.append(0) }
                if i < n1.count { res[i] += n1[i] }
                if i < n2.count { res[i] += n2[i] }

                if res[i] > 9 {
                    res[i] -= 10
                    res.append(1)
                }
            }

            return res
        }

        func mult(_ n: [Int], _ a: Int) -> [Int] {

            var res = [Int]()

            for i in n.indices {
                if res.count <= i { res.append(0) }
                res[i] += n[i] * a

                if res[i] > 9 {
                    res.append(0)
                    while res[i] > 9 {
                        res[i + 1] = res[i] / 10
                        res[i] %= 10
                    }
                }
            }

            return res
        }

        let n1 = num1.reversed().map { Int(String($0))! }
        let n2 = num2.reversed().map { Int(String($0))! }

        var res = [0]

        for i in n1.indices {
            let m = Array(repeating: 0, count: i) + mult(n2, n1[i])
            res = sum(res, m)

            while res.count > 1, res.last! == 0 {
                res.remove(at: res.count - 1)
            }
        }

        return res
            .reversed()
            .map(String.init)
            .joined()
    }
}

Вам даны заголовки двух отсортированных связанных списков list1 и list2. Объедините два списка в один отсортированный список. Список должен быть составлен путем сращивания узлов первых двух списков. Возвращает заголовок объединенного связанного списка.

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init() { self.val = 0; self.next = nil; }
 *     public init(_ val: Int) { self.val = val; self.next = nil; }
 *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
 * }
 */
class Solution {
    func mergeTwoLists(_ list1: ListNode?, _ list2: ListNode?) -> ListNode? {
        // Base case
        guard let list1 = list1 else { return list2 }
        guard let list2 = list2 else { return list1 }
        // Initialize the merged list's head and tail
        var mergedHead: ListNode?
        var mergedTail: ListNode?

        // Compare the values of the current nodes of l1 and l2
        if list1.val < list2.val {
            mergedHead = list1
            mergedTail = mergeTwoLists(list1.next, list2)
        } else {
            mergedHead = list2
            mergedTail = mergeTwoLists(list1, list2.next)
        }
        // Set the mergedHead's next pointer to the mergedTail
        mergedHead?.next = mergedTail
        // Return the mergedHead
        return mergedHead
    }
}

Учитывая n пар круглых скобок, напишите функцию для генерации всех комбинаций правильно сформированных круглых скобок.

import Foundation

func generateParenthesis(_ n: Int) -> [String] {
    var result = [String]()
    generate(current: "", open: 0, close: 0, max: n, result: &result)
    return result
}

private func generate(current: String, open: Int, close: Int, max: Int, result: inout [String]) {
    if current.count == max * 2 {
        result.append(current)
        return
    }
    
    if open < max {
        generate(current: current + "(", open: open + 1, close: close, max: max, result: &result)
    }
    
    if close < open {
        generate(current: current + ")", open: open, close: close + 1, max: max, result: &result)
    }
}

// Пример использования:
let n = 3
let combinations = generateParenthesis(n)
print(combinations)
П

Основная идея

Задача заключается в том, чтобы сгенерировать все возможные комбинации правильно сформированных круглых скобок для заданного числа пар скобок. Решение основывается на рекурсивном подходе.

Шаги решения

1. Инициализация и запуск рекурсии:
- Функция, принимающая число пар скобок (n), создает пустой массив для хранения результатов и запускает рекурсивную функцию с начальными параметрами.

2. Рекурсивная функция:
- В этой функции проверяется текущая длина строки скобок. Если длина достигла 2 * n (две скобки на каждую пару), текущая строка добавляется в массив результатов, и рекурсия завершается для этой ветви.

3. Добавление открывающей скобки:
- Если количество открытых скобок меньше максимального (n), добавляется открывающая скобка, и рекурсивная функция вызывается снова с обновленным состоянием.

4. Добавление закрывающей скобки:
- Если количество закрытых скобок меньше количества открытых, добавляется закрывающая скобка, и рекурсивная функция вызывается снова с обновленным состоянием.

Логика работы

- Рекурсивная функция строит строку скобок шаг за шагом, добавляя либо открывающую, либо закрывающую скобку, если это возможно.
- Функция следит за тем, чтобы в любой момент времени количество закрывающих скобок не превышало количество открывающих, что гарантирует правильность формирования скобок.
- Когда строка достигает длины 2 * n, она добавляется в массив результатов.

Вывод

В результате работы функции получается массив всех возможных комбинаций правильно сформированных скобок для заданного числа пар. Это достигается путем полного перебора всех возможных вариантов и отбора только тех, которые соответствуют условиям правильного формирования скобок.

Вам дан массив из k списков связанных списков, каждый связанный список отсортирован в порядке возрастания.Объедините все связанные списки в один отсортированный связанный список и верните его.

/** 
class ListNode {
    var val: Int
    var next: ListNode?
    init(_ val: Int) {
        self.val = val
        self.next = nil
    }
}

func mergeKLists(_ lists: [ListNode?]) -> ListNode? {
    var heap = [ListNode]()
    
    // Инициализируем кучу начальными значениями из всех списков
    for list in lists {
        if let node = list {
            heap.append(node)
        }
    }
    
    // Определяем компаратор для кучи
    heap.sort { $0.val < $1.val }
    
    let dummy = ListNode(0)
    var current: ListNode? = dummy
    
    while !heap.isEmpty {
        let smallest = heap.removeFirst()
        current?.next = smallest
        current = smallest
        
        if let next = smallest.next {
            var index = heap.firstIndex { $0.val > next.val } ?? heap.count
            heap.insert(next, at: index)
        }
    }
    
    return dummy.next
}

// Пример использования
let node1 = ListNode(1)
let node2 = ListNode(4)
let node3 = ListNode(5)
node1.next = node2
node2.next = node3

let node4 = ListNode(1)
let node5 = ListNode(3)
let node6 = ListNode(4)
node4.next = node5
node5.next = node6

let node7 = ListNode(2)
let node8 = ListNode(6)
node7.next = node8

let lists: [ListNode?] = [node1, node4, node7]
if let mergedList = mergeKLists(lists) {
    var current: ListNode? = mergedList
    while current != nil {
        print(current!.val, terminator: " ")
        current = current?.next
    }
}
 

Основная идея

Задача состоит в объединении нескольких отсортированных связанных списков в один отсортированный связанный список. Для этого используется приоритетная очередь (min-heap) для эффективного извлечения минимального элемента среди всех текущих головных узлов списков.

Шаги решения

1. **Определение структуры
ListNode**:
- Это стандартная структура узла связанного списка, содержащая значение (val) и указатель на следующий узел (next).
Инициализация кучичи**:
- Создаем массив heap, который будет использоваться как куча для хранения текущих головных узлов всех списков.
- Заполняем кучу начальными узлами каждого списка из входного массива lists.
Сортировка кучичи**:
- Изначально сортируем кучу по значениям узлов. Это упрощает дальнейшую вставку новых элементов в отсортированном порядке.

4. Создание фиктивного узла (dummy):
- Создаем фиктивный узел, чтобы облегчить обработку головы результирующего списка.
- Используем указатель current, который будет перемещаться по новому связанному списОбработка кучиа кучи**:
- Пока куча не пуста, извлекаем минимальный элемент (первый элемент массива).
- Присоединяем этот элемент к результирующему списку.
- Если у извлеченного узла есть следующий узел, вставляем его в кучу в правильное место, чтобы сохранить сортировку.
- Для вставки нового элемента используем бинарный поиск для нахождения правильного места вставВозвращение результирующего спискасписка**:
- Возвращаем следующий элемент от фиктивного узла (dummy.next), который является головой нового отсортированного связанного списка.

Пример использования

В примере создаются три отсортированных связанных списка:
- Первый список: 1 -> 4 -> 5
- Второй список: 1 -> 3 -> 4
- Третий список: 2 -> 6

Функция mergeKLists объединяет эти списки в один отсортированный список: 1 -> 1 -> 2 -> 3 -> 4 -> 4 -> 5 -> 6. Затем результаты выводятся в консоль.

Заключение

Этот алгоритм использует приоритетную очередь для эффективного объединения нескольких отсортированных связанных списков в один отсортированный список. Время выполнения оптимизировано за счет использования кучи для извлечения минимальных элементов и вставки новых элементов в правильном порядке.

Учитывая связанный список, поменяйте местами каждые два соседних узла и верните его голову. Вы должны решить проблему, не изменяя значения в узлах списка (т. е. изменять можно только сами узлы).

 class ListNode {
    var val: Int
    var next: ListNode?
    init(_ val: Int) {
        self.val = val
        self.next = nil
    }
}

func swapPairs(_ head: ListNode?) -> ListNode? {
    let dummy = ListNode(0)
    dummy.next = head
    var current: ListNode? = dummy
    
    while current?.next != nil && current?.next?.next != nil {
        let first = current?.next
        let second = current?.next?.next
        
        first?.next = second?.next
        second?.next = first
        current?.next = second
        
        current = first
    }
    
    return dummy.next
}

// Пример использования
let node1 = ListNode(1)
let node2 = ListNode(2)
let node3 = ListNode(3)
let node4 = ListNode(4)
node1.next = node2
node2.next = node3
node3.next = node4

if let swappedList = swapPairs(node1) {
    var current: ListNode? = swappedList
    while current != nil {
        print(current!.val, terminator: " ")
        current = current?.next
    }
}

Учитывая заголовок связанного списка, поменяйте местами узлы списка k за раз и верните измененный список.

k — целое положительное число, меньшее или равное длине связанного списка. Если количество узлов не кратно k, то пропущенные узлы в конечном итоге должны остаться такими, какие они есть.

Вы не можете изменять значения в узлах списка, можно изменять только сами узлы.

class ListNode {
    var val: Int
    var next: ListNode?
    init(_ val: Int) {
        self.val = val
        self.next = nil
    }
}

func reverseKGroup(_ head: ListNode?, _ k: Int) -> ListNode? {
    if head == nil || k == 1 {
        return head
    }
    
    let dummy = ListNode(0)
    dummy.next = head
    var current: ListNode? = dummy
    var next: ListNode?
    var prev: ListNode? = dummy
    
    // Определяем длину списка
    var count = 0
    while current?.next != nil {
        current = current?.next
        count += 1
    }
    
    while count >= k {
        current = prev?.next
        next = current?.next
        for _ in 1..<k {
            current?.next = next?.next
            next?.next = prev?.next
            prev?.next = next
            next = current?.next
        }
        prev = current
        count -= k
    }
    
    return dummy.next
}

// Пример использования
let node1 = ListNode(1)
let node2 = ListNode(2)
let node3 = ListNode(3)
let node4 = ListNode(4)
let node5 = ListNode(5)
node1.next = node2
node2.next = node3
node3.next = node4
node4.next = node5

if let reversedList = reverseKGroup(node1, 3) {
    var current: ListNode? = reversedList
    while current != nil {
        print(current!.val, terminator: " ")
        current = current?.next
    }
}

Учитывая заголовок связанного списка, поменяйте местами узлы списка k за раз и верните измененный список.

k — целое положительное число, меньшее или равное длине связанного списка. Если количество узлов не кратно k, то пропущенные узлы в конечном итоге должны остаться такими, какие они есть.

Вы не можете изменять значения в узлах списка, можно изменять только сами узлы.

class ListNode {
    var val: Int
    var next: ListNode?
    init(_ val: Int) {
        self.val = val
        self.next = nil
    }
}

func reverseKGroup(_ head: ListNode?, _ k: Int) -> ListNode? {
    if head == nil || k == 1 {
        return head
    }
    
    let dummy = ListNode(0)
    dummy.next = head
    var current: ListNode? = dummy
    var next: ListNode?
    var prev: ListNode? = dummy
    
    // Определяем длину списка
    var count = 0
    while current?.next != nil {
        current = current?.next
        count += 1
    }
    
    while count >= k {
        current = prev?.next
        next = current?.next
        for _ in 1..<k {
            current?.next = next?.next
            next?.next = prev?.next
            prev?.next = next
            next = current?.next
        }
        prev = current
        count -= k
    }
    
    return dummy.next
}

// Пример использования
let node1 = ListNode(1)
let node2 = ListNode(2)
let node3 = ListNode(3)
let node4 = ListNode(4)
let node5 = ListNode(5)
node1.next = node2
node2.next = node3
node3.next = node4
node4.next = node5

if let reversedList = reverseKGroup(node1, 3) {
    var current: ListNode? = reversedList
    while current != nil {
        print(current!.val, terminator: " ")
        current = current?.next
    }
}

1. Определение структуры ListNode:
   - Класс ListNode представляет узел связанного списка с полями для значения (val) и указателя на следующий узел (next).

2. Инициализация фиктивного узла (dummy):
   - Создаем фиктивный узел для упрощения обработки головы списка и устанавливаем его next на текущую голову спис
Определение длины спискасписка:
   - Сначала определяем длину списка, чтобы знать, сколько полных групп по k узлов можно переставить.

4. Перестановка узлов по k за раз:
   - Пока оставшихся узлов хватает для полной группы по k узлов:
     - Устанавливаем current на первый узел текущей группы, а next на второй узел.
     - Перемещаем узлы в группе, изменяя указатели так, чтобы узлы были переставлены в обратном порядке.
     - После перестановки обновляем prev для перехода к следующей группе.
     - Уменьшаем count на k, так как мы уже обработали одну Возвращение головы нового спискаого списка:
   - Возвращаем dummy.next, который теперь указывает на новую голову списка после всех перестановок.

Пример использования

В примере создается связанный список 1 -> 2 -> 3 -> 4 -> 5. После вызова функции reverseKGroup с k = 3, узлы будут переставлены группами по три: 3 -> 2 -> 1 -> 4 -> 5. Результат выводится в консоль..

Учитывая целочисленный массив чисел, отсортированный в неубывающем порядке, удалите дубликаты на месте так, чтобы каждый уникальный элемент появлялся только один раз. Относительный порядок элементов должен оставаться неизменным. Затем верните количество уникальных элементов в числах.

Считайте, что количество уникальных элементов чисел равно k. Чтобы вас приняли, вам нужно сделать следующее:

Измените массив nums так, чтобы первые k элементов nums содержали уникальные элементы в том порядке, в котором они присутствовали в nums изначально. Остальные элементы nums не важны, как и размер nums.
Вернуть К.

func removeDuplicates(_ nums: inout [Int]) -> Int {
    if nums.isEmpty { return 0 }
    
    var k = 1 // Индекс для уникальных элементов
    
    for i in 1..<nums.count {
        if nums[i] != nums[k - 1] {
            nums[k] = nums[i]
            k += 1
        }
    }
    
    return k
}

// Пример использования
var nums = [1, 1, 2, 2, 2, 3, 4, 4, 5]
let k = removeDuplicates(&nums)
print("Количество уникальных элементов:", k) // Вывод: Количество уникальных элементов: 5
print("Массив с уникальными элементами:", nums.prefix(k)) // Вывод: Массив с уникальными элементами: [1, 2, 3, 4, 5]

Учитывая целочисленный массив nums и целочисленное значение, удалите все вхождения val в nums на месте. Порядок элементов может быть изменен. Затем верните количество элементов в виде чисел, которые не равны val.

Учитывайте количество элементов в nums, которые не равны val be k. Чтобы вас приняли, вам необходимо сделать следующее:

Измените массив nums так, чтобы первые k элементов nums содержали элементы, не равные val. Остальные элементы nums не важны, как и размер nums.
Вернуть К.

func removeElement(_ nums: inout [Int], _ val: Int) -> Int {
    var k = 0 // Индекс для элементов, не равных val
    
    for i in 0..<nums.count {
        if nums[i] != val {
            nums[k] = nums[i]
            k += 1
        }
    }
    
    return k
}

// Пример использования
var nums = [3, 2, 2, 3]
let val = 3
let k = removeElement(&nums, val)
print("Количество элементов, не равных \(val):", k) // Вывод: Количество элементов, не равных 3: 2
print("Массив с элементами, не равными \(val):", nums.prefix(k)) // Вывод: Массив с элементами, не равными 3: [2, 2]

Учитывая целочисленный массив чисел, отсортированный в неубывающем порядке, удалите дубликаты на месте так, чтобы каждый уникальный элемент появлялся только один раз. Относительный порядок элементов должен оставаться неизменным. Затем верните количество уникальных элементов в числах.

Считайте, что количество уникальных элементов чисел равно k. Чтобы вас приняли, вам нужно сделать следующее:

Измените массив nums так, чтобы первые k элементов nums содержали уникальные элементы в том порядке, в котором они присутствовали в nums изначально. Остальные элементы nums не важны, как и размер nums.
Вернуть К.

func removeDuplicates(_ nums: inout [Int]) -> Int {
    if nums.isEmpty { return 0 }
    
    var k = 1 // Индекс для уникальных элементов
    
    for i in 1..<nums.count {
        if nums[i] != nums[k - 1] {
            nums[k] = nums[i]
            k += 1
        }
    }
    
    return k
}

// Пример использования
var nums = [1, 1, 2, 2, 2, 3, 4, 4, 5]
let k = removeDuplicates(&nums)
print("Количество уникальных элементов:", k) // Вывод: Количество уникальных элементов: 5
print("Массив с уникальными элементами:", nums.prefix(k)) // Вывод: Массив с уникальными элементами: [1, 2, 3, 4, 5]

- В функции removeDuplicates используется переменная k для отслеживания текущей позиции для уникальных элементов.
- Мы проходим по массиву, начиная с индекса 1, и сравниваем текущий элемент с предыдущим (на позиции k-1).
- Если текущий элемент отличается от предыдущего, мы помещаем его на позицию k и увеличиваем k.
- В конце функции возвращаем k, который содержит количество уникальных элементов.
- Пример использования показывает, как после удаления дубликатов в массиве nums получается массив с уникальными элементами и выводится их количество.

Учитывая две строки, игла и стог сена, верните индекс первого вхождения иглы в стоге сена или -1, если игла не является частью стога сена.

func findNeedleInHaystack(_ haystack: String, _ needle: String) -> Int {
    if let range = haystack.range(of: needle) {
        return haystack.distance(from: haystack.startIndex, to: range.lowerBound)
    } else {
        return -1
    }
}

// Пример использования
let haystack = "стог сена"
let needle = "игла"
let index = findNeedleInHaystack(haystack, needle)
print("Индекс первого вхождения иглы в стог сена:", index)

Учитывая два целых числа: делимое и делитель, разделите два целых числа, не используя операторы умножения, деления и модификатора.

Целочисленное деление должно сокращаться до нуля, что означает потерю дробной части. Например, 8,345 будет сокращено до 8, а -2,7335 будет сокращено до -2.

Возвращает частное после деления делимого на делитель.

Примечание. Предположим, мы имеем дело со средой, которая может хранить целые числа только в пределах 32-битного целого диапазона со знаком: [−2^31, 2^31 − 1]. В этой задаче, если частное строго больше 2^31 - 1, верните 2^31 - 1, а если частное строго меньше -2^31, верните -2^31.

func divide(_ dividend: Int, _ divisor: Int) -> Int {
    // Особые случаи: деление на ноль или делитель равен нулю
    if divisor == 0 || (dividend == Int.min && divisor == -1) {
        return Int.max
    }
    
    // Определение знака результата
    let isNegative = (dividend < 0) != (divisor < 0)
    
    // Приведение чисел к абсолютным значениям и приведение их к типу Int64,
    // чтобы избежать переполнения при работе с Int32.
    var absDividend = abs(Int64(dividend))
    let absDivisor = abs(Int64(divisor))
    
    // Инициализация результата
    var result: Int64 = 0
    
    // Выполнение деления путем вычитания
    while absDividend >= absDivisor {
        var tempDivisor = absDivisor
        var multiple: Int64 = 1
        
        // Увеличиваем делитель в два раза, пока он не станет больше чем делимое
        while absDividend >= (tempDivisor << 1) {
            tempDivisor <<= 1
            multiple <<= 1
        }
        
        // Вычитаем делитель из делимого и обновляем результат
        absDividend -= tempDivisor
        result += multiple
    }
    
    // Применяем знак к результату и проверяем на переполнение
    if isNegative {
        result = -result
    }
    
    if result > Int64(Int32.max) {
        return Int(Int32.max)
    } else if result < Int64(Int32.min) {
        return Int(Int32.min)
    } else {
        return Int(result)
    }
}

// Пример использования
let dividend = 10
let divisor = 3
let quotient = divide(dividend, divisor)
print("Частное деления \(dividend) на \(divisor) равно \(quotient)") 

Учитывая целочисленный массив nums и целочисленное значение, удалите все вхождения val в nums на месте. Порядок элементов может быть изменен. Затем верните количество элементов в виде чисел, которые не равны val.

Учитывайте количество элементов в nums, которые не равны val be k. Чтобы вас приняли, вам необходимо сделать следующее:

Измените массив nums так, чтобы первые k элементов nums содержали элементы, не равные val. Остальные элементы nums не важны, как и размер nums.
Вернуть К.

func removeElement(_ nums: inout [Int], _ val: Int) -> Int {
    var k = 0 // Индекс для элементов, не равных val
    
    for i in 0..<nums.count {
        if nums[i] != val {
            nums[k] = nums[i]
            k += 1
        }
    }
    
    return k
}

// Пример использования
var nums = [3, 2, 2, 3]
let val = 3
let k = removeElement(&nums, val)
print("Количество элементов, не равных \(val):", k) // Вывод: Количество элементов, не равных 3: 2
print("Массив с элементами, не равными \(val):", nums.prefix(k)) // Вывод: Массив с элементами, не равными 3: [2, 2]

1. Функция removeElement:
- Принимает массив nums и значение val, которое нужно удалить.
- Инициализирует переменную k для отслеживания индекса элементов, которые не равны val.
- Проходит по массиву nums и для каждого элемента, который не равен val, помещает его на позицию k и увеличивает k.
- Возвращает k, который представляет количество элементов, не равных val.

2. Пример использования:
- Создается массив nums с элементами [3, 2, 2, 3] и значение val = 3.
- Функция вызывается с этими параметрами, и результат (количество элементов, не равных val и измененный массив nums) выводится на экран.

Этот код эффективно решает задачу удаления всех вхождений значения val из массива nums на месте и возвращает количество элементов, которые не равны val, что соответствует требованиям задачи.

Вам дана строка s и массив строк-слов. Все строки слов имеют одинаковую длину.

Объединенная строка — это строка, которая в точности содержит все строки любой перестановки объединенных слов.

Например, если слова = ["ab", "cd", "ef"], то "abcdef", "abefcd", "cdabef", "cdefab", "efabcd" и "efcdab" являются объединенными строками. «acdbef» не является объединенной строкой, поскольку не является объединением какой-либо перестановки слов.
Возвращает массив начальных индексов всех объединенных подстрок в s. Вы можете вернуть ответ в любом порядке.

class Solution {
    func findSubstring(_ s: String, _ words: [String]) -> [Int] {

        let len = words.first!.count
        let cnt = words.count

        guard s.count >= cnt * len else { return [] }
        
        let s = Array(s)
        let words = words.map(Array.init)
        let wf = words.reduce(into: [[Character]: Int]()) { $0[$1, default: 0] += 1 }
        let ws = Set(words)
        var res = [Int]()

        for i in 0...(s.count - cnt * len) {

            var sf = [[Character]: Int]()
            var j = i

            for _ in 0..<cnt {

                let w = Array(s[j..<j + len])
                guard ws.contains(w) else { break }

                let old = sf[w, default: 0]
                guard old + 1 <= wf[w]! else { break }

                sf[w] = old + 1
                j += len
            }

            guard j == i + cnt * len, sf == wf else { continue }
            res.append(i)
        }

        return res
    }
}

Учитывая две строки, игла и стог сена, верните индекс первого вхождения иглы в стоге сена или -1, если игла не является частью стога сена.

func findNeedleInHaystack(_ haystack: String, _ needle: String) -> Int {
    if let range = haystack.range(of: needle) {
        return haystack.distance(from: haystack.startIndex, to: range.lowerBound)
    } else {
        return -1
    }
}

// Пример использования
let haystack = "стог сена"
let needle = "игла"
let index = findNeedleInHaystack(haystack, needle)
print("Индекс первого вхождения иглы в стог сена:", index)

1. Функция findNeedleInHaystack:
- Принимает две строки: haystack (стог сена) и needle (игла).
- Использует метод range(of:) для поиска первого вхождения подстроки needle в строке haystack.
- Если подстрока найдена (range не равен nil), вычисляется индекс первого символа подстроки needle в строке haystack с помощью метода distance(from:to:).
- Возвращается найденный индекс.
- Если подстрока не найдена, возвращается -1.
Пример использованияия:
- Создается строка haystack с текстом "стог сена".
- Создается строка needle с текстом "игла".
- Функция вызывается с этими строками, и результат (индекс или -1) выводится на экран.

Этот код эффективно находит первое вхождение подстроки в строке, сохраняя относительный порядок символов и возвращая соответствующий индекс или -1, если подстрока не найдена.