Remove multiple indices from array

Note that PermutationGenerator is going away in Swift 3 and also doesn't keep the ordering the same, though perhaps it did at one time. Using the accepted answer results in [2, 6, 0, 3] which may be unexpected. A couple of alternative approaches that give the expected result of [0, 2, 3, 6] are:

let flatArr = arr.enumerate().flatMap { rmIndices.contains($0.0) ? nil : $0.1 }

or

let filterArr = arr.enumerate().filter({ !rmIndices.contains($0.0) }).map { $0.1 }

rmIndices.sort({ $1 < $0 })     

for index in rmIndices
{
    arr.removeAtIndex(index)
}

Note that I've sorted the indices in descending order. This is because everytime you remove an element E, the indices of the elements beyond E reduce by one.

For Swift 3

    var arr = [0,1,2,3,4,5,6]
    let rmIndices = [1,4,5]
    arr = arr.filter{ !rmIndices.contains($0) }
    print(arr)

if you want to produce output very fastly then you can use

    var arr = [0,1,2,3,4,5,6]
    let rmIndices = [1,4,5]
    arr = Array(Set(arr).subtracting(rmIndices))
    print(array)

But it will change order of your array

Remove elements using indexes array:

1. Array of Strings and indexes

   let animals = ["cats", "dogs", "chimps", "moose", "squarrel", "cow"]
   let indexAnimals = [0, 3, 4]
   let arrayRemainingAnimals = animals
       .enumerated()
       .filter { !indexAnimals.contains($0.offset) }
       .map { $0.element }
   
   print(arrayRemainingAnimals)
   
   //result - ["dogs", "chimps", "cow"]
   

2. Array of Integers and indexes

   var numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
   let indexesToRemove = [3, 5, 8, 12]
   
   numbers = numbers
       .enumerated()
       .filter { !indexesToRemove.contains($0.offset) }
       .map { $0.element }
   
   print(numbers)
   
   //result - [0, 1, 2, 4, 6, 7, 9, 10, 11]
   

Remove elements using element value of another array

3. Arrays of integers

   let arrayResult = numbers.filter { element in
       return !indexesToRemove.contains(element)
   }
   print(arrayResult)
   
   //result - [0, 1, 2, 4, 6, 7, 9, 10, 11]
   

4. Arrays of strings

   let arrayLetters = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
   let arrayRemoveLetters = ["a", "e", "g", "h"]
   let arrayRemainingLetters = arrayLetters.filter {
       !arrayRemoveLetters.contains($0)
   }
   
   print(arrayRemainingLetters)
   
   //result - ["b", "c", "d", "f", "i"]
   

In Swift 4:

let newArr = arr.enumerated().compactMap {
    rmIndices.contains($0.0) ? nil : $0.1
}

• enumerated() generates (index, value) pairs
• compactMap concatenates non-nil values
• In the closure, $0.0 is the index (first element of enumerated pair) as $0.1$ is the value
• compactMap gathers values whose indices are not found in rmIndices

The problem with flatmap is that it gives incorrect results if your array contains optionals.

The following is much faster than the functional style solutions provided and works with optionals. You just have to make sure rmIndices is sorted and unique. It's also fairly language agnostic.

 var numRemoved: Int = 0
 for index in rmIndices {
     let indexToRemove = index - numRemoved
     arr.remove(at: indexToRemove)
     numRemoved += 1
 }

If you need to make sure rmIndices is sorted and unique:

 rmIndices = Set(rmIndices).sorted()

Using XCTest to remove 500 elements (including the operation to ensure uniqueness and sorted):

0.006 sec

vs.

arr.enumerated().filter({ !rmIndices.contains($0.0) }).map { $0.1 }:

0.206 sec

I use this as an extension on Array

extension Array {

    mutating func remove(at indices: [Int]) {
        let rmIndices = Set(indices).sorted()
        var numRemoved: Int = 0
        for index in rmIndices {
            let indexToRemove = index - numRemoved
            self.remove(at: indexToRemove)
            numRemoved += 1
        }
    }

}