Любой другой массив нечетных чисел в Swift

Question

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

func odd(from start: Int, to end: Int) -> [Int] {
    let list = [Int](stride(from: start, to: end+1, by: 2))
    return list
}

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

func alternatingOdd(from start: Int, to end: Int) -> [Int] {
    var list = odd(from: start, to: end)
    // ... black magic trickery turns removes every other number from list... 
    return list
}

Вызов этой функции примерно так: alternatingOdd(from: 1, to: 25) вернет массив [1, 5, 9, 13, 17, 21, 25].

По сути, я спрашиваю: как бы я аккуратно удалил все остальные элементы из массива?

РЕДАКТИРОВАТЬ : функция «нечетный» не всегда возвращает нечетный массив на основе пользовательского ввода.Он возвращает только массив значений, увеличенный на 2 через диапазон.

Как мне сделать пуленепробиваемый и убедиться, что он всегда возвращает только нечетные числа?То есть каждый элемент в массиве не должен делиться равномерно на два.

Answer 1

Вы можете эффективно вырезать каждый второй элемент (произвольного) массива, сопоставляя каждый второй массив index с соответствующим массивом элемент:

func everySecond<T>(of array: [T]) -> [T] {
    return stride(from: array.startIndex, to: array.endIndex, by: 2).map { array[$0] }
}

Примеры:

print(everySecond(of: [1, 3, 2, 6, 4, 6])) // [1, 2, 4]
print(everySecond(of: ["H", "E", "L", "L", "O"])) // ["H", "L", "O"]

Теперь вы можете использовать это в своей функции как

func alternatingOdd(from start: Int, to end: Int) -> [Int] {
    let odds = odd(from: start, to: end)
    return everySecond(of: odds)
}

Answer 2

Вместо создания массивов с помощью stride filter с помощью оператора по модулю

Функция odd сохраняет нечетные числа

func odd(from start: Int, to end: Int) -> [Int] {
    return (start...end).filter{$0 % 2 == 1}
}

Функция alternatingOdd использует compactMap для фильтрации индексов

func alternatingOdd(from start: Int, to end: Int) -> [Int] {
    let list = odd(from: start, to: end)
    return list.indices.compactMap{$0 % 2 == 0 ? list[$0] : nil }
}

Answer 3

Вы можете получить любое другое нечетное число за один раз, и более эффективно, таким образом:

func alternatingOdd(from start: Int, to end: Int) -> [Int] {
    guard start >= 0  else { return [] }

    let oddStart = (start % 2 == 0 ? 1 : 0) + start

    return Array(stride(from: oddStart, through: end, by: 4))
}

alternatingOdd(from: 1, to: 25)  //[1, 5, 9, 13, 17, 21, 25]

Вы даже можете изменить количество нечетных чисел, которое вы бы сбросили:

func alternatingOdd(from start: Int, to end: Int, every step: Int) -> [Int] {
    guard start >= 0, step > 0  else { return [] }

    let oddStart = (start % 2 == 0 ? 1 : 0) + start

    return Array(stride(from: oddStart, through: end, by: 2 * step))
}

alternatingOdd(from: 1, to: 25, every: 2)  //[1, 5, 9, 13, 17, 21, 25]
alternatingOdd(from: 1, to: 25, every: 3)  //[1, 7, 13, 19, 25]

Для диапазонов, начинающихся с отрицательного числа, вы можете вернуть только положительные нечетные числа, если они есть, таким образом:

func alternatingOdd(from start: Int, to end: Int, every step: Int) -> [Int] {
    guard step > 0  else { return [] }

    let oddStart = max((start % 2 == 0 ? 1 : 0) + start, 1)

    return Array(stride(from: oddStart, through: end, by: 2 * step))
}

alternatingOdd(from: -3, to: 10, every: 2)  //[1, 5, 9]
alternatingOdd(from: -3, to: 25, every: 4)  //[1, 9, 17, 25]