Extract the elements from array and put back them to another array.?

Use [0...5] to create an ArraySlice and then Array to convert that back to an array:

var arrayElemts = ["1","2","3","4","5","6","7","8","9","10","11"]

let first = Array(arrayElemts[0...5])
let second = Array(arrayElemts[6...10])

print(first)   // ["1", "2", "3", "4", "5", "6"]
print(second)  // ["7", "8", "9", "10", "11"]

The easiest option is the following:

let partition1 = array.filter { Int($0) ?? 0 <= 5 }
let partition2 = array.filter { Int($0) ?? 0 > 5 }

Conversion to numbers should be the first step though. You should never work with strings as if they were numbers.

let numbers = array.flatMap { Int($0) }

let partition1 = numbers.filter { $0 <= 5 }
let partition2 = numbers.filter { $0 > 5 }

If we suppose the array is sorted, there are easier options:

let sorted = numbers.sorted()
let partition1: [Int]
let partition2: [Int]

if let partition2start = sorted.index(where: { $0 > 5 }) {
    partition1 = Array(sorted.prefix(upTo: partition2start))
    partition2 = Array(sorted.suffix(from: partition2start))
} else {
    partition1 = sorted
    partition2 = []
}

which is what the native partition method can do:

var numbers = array.flatMap { Int($0) }
let index = numbers.partition { $0 > 5 }
let partition1 = Array(numbers.prefix(upTo: index))
let partition2 = Array(numbers.suffix(from: index))

Note the method changes the original array.

Breaking the array up into N-sized chunks

The other answers show you how to "statically" partition the original array in different arrays using ArraySlice:s. Given your description, possibly you want to, generally, break up your original array into N-sized chunks (here: n = 5).

We could use the sequence(state:next) to implement such a chunk(bySize:) method as an extension to Collection:

extension Collection {
    func chunk(bySize size: IndexDistance) -> [SubSequence] {
        precondition(size > 0, "Chunk size must be a positive integer.")
        return sequence(
            state: (startIndex, index(startIndex, offsetBy: size, limitedBy: endIndex) ?? endIndex),
            next: { indices in
            guard indices.0 != self.endIndex else { return nil }
            indices.1 = self.index(indices.0, offsetBy: size, limitedBy: self.endIndex) ?? self.endIndex
            return (self[indices.0..<indices.1], indices.0 = indices.1).0
        }).map { $0 }
    }
}

Applied to your example:

var arrayElements = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11"]
let partitions = arrayElements.chunk(bySize: 5)
/* [["1", "2", "3", "4", "5"],
    ["6", "7", "8", "9", "10"],
    ["11"]] */

The chunk(bySize:) method will break up the array into bySize-sized chunks, as well as (possible) a smaller chunk for the final partition.

However, as much as I'd like to try to use the sequence(state:next) function (not needing to use any mutable intermediate variables other than state), the implementation above is quite bloated and difficult to read, so (as for so many other cases ...) we are probably better off simply using a while loop:

extension Collection {
    func chunk(bySize size: IndexDistance) -> [SubSequence] {
        precondition(size > 0, "Chunk size must be a positive integer.")
        var chunks: [SubSequence] = []
        var from = startIndex
        while let to = index(from, offsetBy: size, limitedBy: endIndex) {
            chunks.append(self[from..<to])
            from = to
        }
        if from != endIndex { chunks.append(self[from..<endIndex]) }
        return chunks
    }
}

lol I don't see why there are so complicated answers here (Consider the "array" variable as is -> [Int], not [Any]) So the first approach is just for Number types. The second one should do it

Simply:

let array = [0,1,2,3,4,5,6,7,8,9,10]
//For instance..
var arrayA = ["A","B","C","D","E","F","G"]

//First 6 elements
let arrayOfFirstFour = array.filter({
    return $0 <= 5 ? true : false
})

//Remaining  elements:
let restOfArray = array.filter({
    return $0 > 5 ? true : false
})

let elementsToFourth = arrayA.prefix(upTo: 4)
let elementsAfterFourth = arrayA.suffix(from: 4)
print(arrayOfFirstFour)
print(restOfArray)
print(elementsToFourth)
print(elementsAfterFourth)

//[0, 1, 2, 3, 4, 5]
//[6, 7, 8, 9, 10]
//["A", "B", "C", "D"]
//["E", "F", "G"]