I have an array, I want to do some filtering in it, however, it gives me a runtime error. Is there any alternative way of doing this? (without using closures)
var arr = [4,5,6,7]
for i in 0..<arr.count - 1 {
if arr[i] > 2 {
arr.remove(at: i)
}
}
print(arr)
Think about what your code does.
if arr[i] > 2 { //#2
arr.remove(at: i)
}
}
At #1, it looks at the current number of elements in the array and sets the end value of the loop to 3. So the loop will run from 0 to 3.
At #2, each element in the array is greater than 2, so it gets removed from the array.
At i == 0 the 4 is removed. Now there are 3 elements
At i == 1, the
5 is removed. Now there are 2 elements
At i == 2, it attempts to
fetch an element at index 2, and crashes with an index out of range
error.
You are mutating the array as you attempt to iterate through it. Don't do that.
As others have said, use filter instead:
arr = arr.filter { $0 <= 2 }
If you really want to use a for loop and remove elements via index, loop through the array backwards:
var arr = [4,5,6,7]
for index in stride(from: arr.count-1, to: -1, by: -1) {
let thisValue = arr[index]
print("arr[\(index)]=\(thisValue)")
if thisValue > 2 {
arr.remove(at: index)
print("->> removing \(thisValue) from arr at index \(index)")
}
}
print("\nAfter for loop, arr contains \(arr.count) items")
arr.forEach {
print($0)
}
That ouputs:
arr[3]=7
->> removing 7 from arr at index 3
arr[2]=6
->> removing 6 from arr at index 2
arr[1]=5
->> removing 5 from arr at index 1
arr[0]=4
->> removing 4 from arr at index 0
After for loop, arr contains 0 items
This is a great example of why mutation is best avoided.
If you're manipulating an array and iterating over it at the same time, the index values are going to be invalid, because what was at index 4, will now be at index 3 if you delete something at position 1.
You can do it without 'using closures':
var idxToRemove: [Int] = []
for (idx, i) in arr.enumerated() {
if i > 2 {
idxToRemove.append(idx)
}
}
for i in idxToRemove.reversed() {
arr.remove(at: i)
}
But what you want is: let arr = [4,5,6,7].filter { $0 <= 2 }
var arr = [4, 5, 6, 7]
arr = arr.filter { $0 <= 2 }
print(arr)
Working on a project to recreate a game Mastermind. I need to compare two arrays, and running into some struggles.
I need to output two integers for the flow of the game to work,
the first integer is the number of correct choices where the index matches. The code I have for this appears to be working
pairs = #code.zip(guess)
correct_position_count = pairs.select { |pair| pair[0] == pair[1] }.count
Where pairs is equal to a 4 element array and the guess is also a 4 element array
The second part I am having a bit of trouble with on how to do the comparison and return an array. The integer should represent where the two arrays index don't match (the above code block but !=) and confirm whether the guess array excluding any exact index matches has any elements included with the code array once again excluding the exact index matches.
Any help would be greatly appreciated!
I am not completely sure to understand your problem but if I understood well, you've two arrays, solution with the solution and guess with the current guess of the player.
Now, let's assume that the solution is 1234 and that the guess is 3335.
solution = [1, 2, 3, 4]
guess = [3, 3, 3, 5]
an element by element comparison produces an array of booleans.
diff = guess.map.with_index { |x,i| x == solution[i] }
# = [false, false, true, false]
Now, you can easily compute the number of good digits diff.count true and the number of wrong digits diff.count false. And, in case you need the index of the false and/or true values you can do
diff.each_index.select { |i| diff[i] } # indexes with true
# = [2]
diff.each_index.select { |i| !diff[i] } # indexes with false
# = [0, 1, 3]
You can count all digit matches ignoring their positions and then subtract exact matches.
pairs = #code.zip(guess)
correct_position_count = pairs.select { |pair| pair[0] == pair[1]}.count
any_position_count = 0
code_digits = #code.clone # protect #code from modifying
guess.each do |digit|
if code_digits.include?(digit)
code_digits.delete_at(code_digits.find_index(digit)) # delete the found digit not to count it more than once
any_position_count += 1
end
end
inexact_position_count = any_position_count - correct_position_count
puts "The first value: #{correct_position_count}"
puts "The second value: #{inexact_position_count}"
When I use the for loop in Playground, everything worked fine, until I changed the first parameter of for loop to be the highest value. (iterated in descending order)
Is this a bug? Did any one else have it?
for index in 510..509
{
var a = 10
}
The counter that displays the number of iterations that will be executions keeps ticking...
Xcode 6 beta 4 added two functions to iterate on ranges with a step other than one:
stride(from: to: by:), which is used with exclusive ranges and stride(from: through: by:), which is used with inclusive ranges.
To iterate on a range in reverse order, they can be used as below:
for index in stride(from: 5, to: 1, by: -1) {
print(index)
}
//prints 5, 4, 3, 2
for index in stride(from: 5, through: 1, by: -1) {
print(index)
}
//prints 5, 4, 3, 2, 1
Note that neither of those is a Range member function. They are global functions that return either a StrideTo or a StrideThrough struct, which are defined differently from the Range struct.
A previous version of this answer used the by() member function of the Range struct, which was removed in beta 4. If you want to see how that worked, check the edit history.
Apply the reverse function to the range to iterate backwards:
For Swift 1.2 and earlier:
// Print 10 through 1
for i in reverse(1...10) {
println(i)
}
It also works with half-open ranges:
// Print 9 through 1
for i in reverse(1..<10) {
println(i)
}
Note: reverse(1...10) creates an array of type [Int], so while this might be fine for small ranges, it would be wise to use lazy as shown below or consider the accepted stride answer if your range is large.
To avoid creating a large array, use lazy along with reverse(). The following test runs efficiently in a Playground showing it is not creating an array with one trillion Ints!
Test:
var count = 0
for i in lazy(1...1_000_000_000_000).reverse() {
if ++count > 5 {
break
}
println(i)
}
For Swift 2.0 in Xcode 7:
for i in (1...10).reverse() {
print(i)
}
Note that in Swift 2.0, (1...1_000_000_000_000).reverse() is of type ReverseRandomAccessCollection<(Range<Int>)>, so this works fine:
var count = 0
for i in (1...1_000_000_000_000).reverse() {
count += 1
if count > 5 {
break
}
print(i)
}
For Swift 3.0 reverse() has been renamed to reversed():
for i in (1...10).reversed() {
print(i) // prints 10 through 1
}
Updated for Swift 3
The answer below is a summary of the available options. Choose the one that best fits your needs.
reversed: numbers in a range
Forward
for index in 0..<5 {
print(index)
}
// 0
// 1
// 2
// 3
// 4
Backward
for index in (0..<5).reversed() {
print(index)
}
// 4
// 3
// 2
// 1
// 0
reversed: elements in SequenceType
let animals = ["horse", "cow", "camel", "sheep", "goat"]
Forward
for animal in animals {
print(animal)
}
// horse
// cow
// camel
// sheep
// goat
Backward
for animal in animals.reversed() {
print(animal)
}
// goat
// sheep
// camel
// cow
// horse
reversed: elements with an index
Sometimes an index is needed when iterating through a collection. For that you can use enumerate(), which returns a tuple. The first element of the tuple is the index and the second element is the object.
let animals = ["horse", "cow", "camel", "sheep", "goat"]
Forward
for (index, animal) in animals.enumerated() {
print("\(index), \(animal)")
}
// 0, horse
// 1, cow
// 2, camel
// 3, sheep
// 4, goat
Backward
for (index, animal) in animals.enumerated().reversed() {
print("\(index), \(animal)")
}
// 4, goat
// 3, sheep
// 2, camel
// 1, cow
// 0, horse
Note that as Ben Lachman noted in his answer, you probably want to do .enumerated().reversed() rather than .reversed().enumerated() (which would make the index numbers increase).
stride: numbers
Stride is way to iterate without using a range. There are two forms. The comments at the end of the code show what the range version would be (assuming the increment size is 1).
startIndex.stride(to: endIndex, by: incrementSize) // startIndex..<endIndex
startIndex.stride(through: endIndex, by: incrementSize) // startIndex...endIndex
Forward
for index in stride(from: 0, to: 5, by: 1) {
print(index)
}
// 0
// 1
// 2
// 3
// 4
Backward
Changing the increment size to -1 allows you to go backward.
for index in stride(from: 4, through: 0, by: -1) {
print(index)
}
// 4
// 3
// 2
// 1
// 0
Note the to and through difference.
stride: elements of SequenceType
Forward by increments of 2
let animals = ["horse", "cow", "camel", "sheep", "goat"]
I'm using 2 in this example just to show another possibility.
for index in stride(from: 0, to: 5, by: 2) {
print("\(index), \(animals[index])")
}
// 0, horse
// 2, camel
// 4, goat
Backward
for index in stride(from: 4, through: 0, by: -1) {
print("\(index), \(animals[index])")
}
// 4, goat
// 3, sheep
// 2, camel
// 1, cow
// 0, horse
Notes
#matt has an interesting solution where he defines his own reverse operator and calls it >>>. It doesn't take much code to define and is used like this:
for index in 5>>>0 {
print(index)
}
// 4
// 3
// 2
// 1
// 0
Check out On C-Style For Loops Removed from Swift 3
Swift 4 onwards
for i in stride(from: 5, to: 0, by: -1) {
print(i)
}
//prints 5, 4, 3, 2, 1
for i in stride(from: 5, through: 0, by: -1) {
print(i)
}
//prints 5, 4, 3, 2, 1, 0
With Swift 5, according to your needs, you may choose one of the four following Playground code examples in order to solve your problem.
#1. Using ClosedRange reversed() method
ClosedRange has a method called reversed(). reversed() method has the following declaration:
func reversed() -> ReversedCollection<ClosedRange<Bound>>
Returns a view presenting the elements of the collection in reverse order.
Usage:
let reversedCollection = (0 ... 5).reversed()
for index in reversedCollection {
print(index)
}
/*
Prints:
5
4
3
2
1
0
*/
As an alternative, you can use Range reversed() method:
let reversedCollection = (0 ..< 6).reversed()
for index in reversedCollection {
print(index)
}
/*
Prints:
5
4
3
2
1
0
*/
#2. Using sequence(first:next:) function
Swift Standard Library provides a function called sequence(first:next:). sequence(first:next:) has the following declaration:
func sequence<T>(first: T, next: #escaping (T) -> T?) -> UnfoldFirstSequence<T>
Returns a sequence formed from first and repeated lazy applications of next.
Usage:
let unfoldSequence = sequence(first: 5, next: {
$0 > 0 ? $0 - 1 : nil
})
for index in unfoldSequence {
print(index)
}
/*
Prints:
5
4
3
2
1
0
*/
#3. Using stride(from:through:by:) function
Swift Standard Library provides a function called stride(from:through:by:). stride(from:through:by:) has the following declaration:
func stride<T>(from start: T, through end: T, by stride: T.Stride) -> StrideThrough<T> where T : Strideable
Returns a sequence from a starting value toward, and possibly including, an end value, stepping by the specified amount.
Usage:
let sequence = stride(from: 5, through: 0, by: -1)
for index in sequence {
print(index)
}
/*
Prints:
5
4
3
2
1
0
*/
As an alternative, you can use stride(from:to:by:):
let sequence = stride(from: 5, to: -1, by: -1)
for index in sequence {
print(index)
}
/*
Prints:
5
4
3
2
1
0
*/
#4. Using AnyIterator init(_:) initializer
AnyIterator has an initializer called init(_:). init(_:) has the following declaration:
init(_ body: #escaping () -> AnyIterator<Element>.Element?)
Creates an iterator that wraps the given closure in its next() method.
Usage:
var index = 5
guard index >= 0 else { fatalError("index must be positive or equal to zero") }
let iterator = AnyIterator({ () -> Int? in
defer { index = index - 1 }
return index >= 0 ? index : nil
})
for index in iterator {
print(index)
}
/*
Prints:
5
4
3
2
1
0
*/
If needed, you can refactor the previous code by creating an extension method for Int and wrapping your iterator in it:
extension Int {
func iterateDownTo(_ endIndex: Int) -> AnyIterator<Int> {
var index = self
guard index >= endIndex else { fatalError("self must be greater than or equal to endIndex") }
let iterator = AnyIterator { () -> Int? in
defer { index = index - 1 }
return index >= endIndex ? index : nil
}
return iterator
}
}
let iterator = 5.iterateDownTo(0)
for index in iterator {
print(index)
}
/*
Prints:
5
4
3
2
1
0
*/
For Swift 2.0 and above you should apply reverse on a range collection
for i in (0 ..< 10).reverse() {
// process
}
It has been renamed to .reversed() in Swift 3.0
In Swift 4 and latter
let count = 50//For example
for i in (1...count).reversed() {
print(i)
}
Swift 4.0
for i in stride(from: 5, to: 0, by: -1) {
print(i) // 5,4,3,2,1
}
If you want to include the to value:
for i in stride(from: 5, through: 0, by: -1) {
print(i) // 5,4,3,2,1,0
}
If one is wanting to iterate through an array (Array or more generally any SequenceType) in reverse. You have a few additional options.
First you can reverse() the array and loop through it as normal. However I prefer to use enumerate() much of the time since it outputs a tuple containing the object and it's index.
The one thing to note here is that it is important to call these in the right order:
for (index, element) in array.enumerate().reverse()
yields indexes in descending order (which is what I generally expect). whereas:
for (index, element) in array.reverse().enumerate() (which is a closer match to NSArray's reverseEnumerator)
walks the array backward but outputs ascending indexes.
as for Swift 2.2 , Xcode 7.3 (10,June,2016) :
for (index,number) in (0...10).enumerate() {
print("index \(index) , number \(number)")
}
for (index,number) in (0...10).reverse().enumerate() {
print("index \(index) , number \(number)")
}
Output :
index 0 , number 0
index 1 , number 1
index 2 , number 2
index 3 , number 3
index 4 , number 4
index 5 , number 5
index 6 , number 6
index 7 , number 7
index 8 , number 8
index 9 , number 9
index 10 , number 10
index 0 , number 10
index 1 , number 9
index 2 , number 8
index 3 , number 7
index 4 , number 6
index 5 , number 5
index 6 , number 4
index 7 , number 3
index 8 , number 2
index 9 , number 1
index 10 , number 0
You can consider using the C-Style while loop instead. This works just fine in Swift 3:
var i = 5
while i > 0 {
print(i)
i -= 1
}
var sum1 = 0
for i in 0...100{
sum1 += i
}
print (sum1)
for i in (10...100).reverse(){
sum1 /= i
}
print(sum1)
You can use reversed() method for easily reverse values.
var i:Int
for i in 1..10.reversed() {
print(i)
}
The reversed() method reverse the values.
Reversing an array can be done with just single step .reverse()
var arrOfnum = [1,2,3,4,5,6]
arrOfnum.reverse()
This will works decrement by one in reverse order.
let num1 = [1,2,3,4,5]
for item in nums1.enumerated().reversed() {
print(item.offset) // Print the index number: 4,3,2,1,0
print(item.element) // Print the value :5,4,3,2,1
}
Or you can use this index, value property
let num1 = [1,2,3,4,5]
for (index,item) in nums1.enumerated().reversed() {
print(index) // Print the index number: 4,3,2,1,0
print(item) // Print the value :5,4,3,2,1
}
For me, this is the best way.
var arrayOfNums = [1,4,5,68,9,10]
for i in 0..<arrayOfNums.count {
print(arrayOfNums[arrayOfNums.count - i - 1])
}
How do I return all the index value of elements in an array that have the same string values in them?
For example:
myarray=[tree, bean, bean, bunny, frog, bean, soup]
If I searched for "bean" using something myarray.index(bean) it would return 1. If I did the same search using myarray.rindex(bean) it would return 5.
I need the method to myarray.{does this method exist?}(bean) that would return [1, 2, 5].
Any suggestions?
You can use #each_with_index (create pair of string, index), then #map (iterate over the pairs and if it matches, then return index, otherwise return nil) and finally #compact (remove nil values) the array.
myarray.each_with_index.map{|x,i| x == "bean"? i : nil}.compact
Slightly simpler soulution and a better one also in terms of efficiency would be probably this one with #each_index.
myarray.each_index.select{|x| myarray[x] == "bean"}
Btw. you should name the variable my_array, not myarray.
Simple & easy to understand solution given below
myarray = [:tree, :bean, :bean, :bunny, :frog, :bean, :soup]
result = []
search_for = :bean
myarray.each_with_index() { |element, index| result << index if element == search_for }
p result
Output
[1, 2, 5]