Swift: algorithm to append items in array - arrays

Question

I need to append items to an array using a specific algorithm:
with start index == 2 and separator == 5
for example input array:
["1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1"]
for example output array:
["1", "1", "X", "1", "1", "1", "1", "1", "X", "1", "1", "1", "1", "1", "X", "1", "1", "1", "1"]
here is my code, but I can not find a way to make it work properly, looking forward to some help
var mixStartIndex = 2
var mixSeparator = 5
let array = ["1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1"]
var result = [AnyObject]()
for (index, item) in array.enumerated() {
if (index > mixStartIndex+mixSeparator && index % mixSeparator == 0) || index == mixStartIndex {
result.append("X" as AnyObject)
}
result.append(item as AnyObject)
}
print(result)
PS I am working with objects, just made example with strings for simplicity

Answer 1

You are missing to append the input array as a part of the output array
Try adding this
else
{
result.append(array[index])
}
Update :
changing the condition to if (((index-mixStartIndex)%mixSeparator)==0 || index == mixStartIndex) works for the fifth index
var mixStartIndex = 2
var mixSeparator = 6
func mix(array: [String]) -> [String] {
guard !array.isEmpty else { return array }
var result = [String]()
for (index, _) in array.enumerated() {
if (((index-mixStartIndex)%mixSeparator)==0 || index == mixStartIndex) {
result.append("X")
}
else
{
result.append(array[index])
}
}
return result
}

Answer 2

This works and is simpler than the accepted answer:
extension Array {
func example(start: Index, seperator: Index, insert: Element) -> [Element] {
var result = self
var index = start
while index < result.count {
result.insert(insert, at: index)
index += seperator + 1
}
return result
}
// a functional solution
func example2(start: Index, seperator: Index, insert: Element) -> [Element] {
return self.enumerated().flatMap { offset, element in
offset == start || offset > start && (offset - start) % seperator == 0 ? [insert, element] : [element]
}
}
}
print(array.example(start: mixStartIndex, seperator: mixSeparator, insert: "X"))
print(array.example2(start: mixStartIndex, seperator: mixSeparator, insert: "X"))

Answer 3

Here is another one, a little more straightforward.
let array = ["1","1","1","1","1","1","1","1","1","1","1","1","1","1","1"]
let result = array.enumerated().flatMap{ ($0.offset - 1) % 5 == 0 ? [$0.element, "X"] : [$0.element]}
print(result)

Answer 4

A functional solution to create an array where elements are inserted into the resulting array:
let result: [String] = array.enumerated().reduce(into:[]) { acc, elm in
let tempo = ((elm.offset - 2) % 5 == 0 ? ["X"] : []) + [elm.element]
acc.append(contentsOf: tempo)
}
If instead of inserting you'd like to replace the elements :
let result = array.enumerated().map {
($0.offset - 2) % 6 == 0 ? "X" : $0.element
}
Array.insert(_:at:)
We could use the built-in function Array.insert(_:at:)
let newCount = array.count > 2 ? array.count + 1 + (array.count - 3) / 6 : array.count
var index = 2
let mixSeparator = 6
var result = array
while index < newCount {
result.insert("X", at: index)
index += mixSeparator
}
But that would be inefficient, not only because you the whole array and then start inserting, but also because insert(_:at:) is an O(n) operation. Meaning that all the elements after the index of insertion should be shifted. A more efficient solution would be to do the insertion iteratively :
Iterative insert
Here is a pretty easy to understand iterative solution :
let array = ["1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1"]
var result = array
let x = "X"
let startIndex = 2
let step = 6
var count = 0
var index = 2
while index < array.count {
result[index] = x
count += 1
index += step
}
result.append(contentsOf: Array(repeating: "1", count: count))
Or, if you'd like to create the result array in one go :
let newCount = array.count > 2 ? array.count + 1 + (array.count - 3) / 6 : array.count
var result = [String]()
result.reserveCapacity(newCount)
let startIndex = 2
let step = 6
var nextIndexToPutX = startIndex
var index = 0
while index < newCount {
if index == nextIndexToPutX {
result.append("X")
nextIndexToPutX += step
} else {
result.append("1")
}
index += 1
}
Replace iteratively
var result = [String]()
result.reserveCapacity(array.count)
var nextIndexToPutX = 2
let step = 6
var index = 0
while index < array.count {
if index == nextIndexToPutX {
result.append("X")
nextIndexToPutX += step
} else {
result.append(array[index])
}
index += 1
}