Shift Swift Array

Question

Array of Colors

let colorArray = [
    UIColor.redColor(),
    UIColor.orangeColor(),
    UIColor.yellowColor(),
    UIColor.greenColor(),
    UIColor.blueColor()
]

The goal is to shift the array:

To start with a different color.
To preserve the circular order of colors.

Example #1

If we wanted to start with the orange color (the color at index 1 in the original array), the array would look like this:

let colorArray = [
    UIColor.orangeColor(),
    UIColor.yellowColor(),
    UIColor.greenColor(),
    UIColor.blueColor(),
    UIColor.redColor(),
]

Example #2

If we wanted to start with the green color (the color at index 3 in the original array), the array would look like this:

let colorArray = [
    UIColor.greenColor(),
    UIColor.blueColor(),
    UIColor.redColor(),
    UIColor.orangeColor(),
    UIColor.yellowColor()
]

just remove the colours before the colour you want to start with, then just append them to the end of the array? — Fonix
– Fonix, Commented Jul 22, 2015 at 5:43

Benno Kress · Accepted Answer · 2017-06-24 17:29:15Z

Short & clear Swift 3 & 4 solution I came up with:

extension Array {

    func shifted(by shiftAmount: Int) -> Array<Element> {

        // 1
        guard self.count > 0, (shiftAmount % self.count) != 0 else { return self }

        // 2
        let moduloShiftAmount = shiftAmount % self.count
        let negativeShift = shiftAmount < 0
        let effectiveShiftAmount = negativeShift ? moduloShiftAmount + self.count : moduloShiftAmount

        // 3
        let shift: (Int) -> Int = { return $0 + effectiveShiftAmount >= self.count ? $0 + effectiveShiftAmount - self.count : $0 + effectiveShiftAmount }

        // 4
        return self.enumerated().sorted(by: { shift($0.offset) < shift($1.offset) }).map { $0.element }

    }

}

Explanation:

Arrays with no elements and shifts producing the identity of the original array are returned immediately
To get the effective shift amount regardless of the amount passed with the function, we do some modulo calculation to get rid of shifts that would rotate the elements in the array more than once (e.g. in an Array with 5 Objects, a shift of +7 is the same as a shift of +2). Since we always want to shift to the right, in order to be done with one simple function instead of two, negative inputs have to be dealt with (e.g. in an Array with 5 Objects, a shift of -2 is the same as a shift of +3). Therefore we adjust the negative results of the modulo calculation by the length of the array. Of course those 3 lines could be done in one, but I wanted to make this as readable as possible.
Now we prepare the actual shift by taking the index ($0) of element and returning the shifted index by adding the amount calculated in step 2. If the new index lands outside of the array length, it needs to be wrapped around to the front.
And finally we apply all the preparation to our array with some trickery: enumerated() gives us an array of tuples [(offset: Int, element: Int)], which is simply the original index of every element and the element itself. We then sort this enumerated array by the manipulated offset (aka the element's index) via applying the function from step 3. Lastly we get rid of the enumeration by mapping the sorted elements back into an array.

This extension works with arrays of any type. Examples:

let colorArray = [
    UIColor.red,
    UIColor.orange,
    UIColor.yellow,
    UIColor.green,
    UIColor.blue
]

let shiftedColorArray = [
    UIColor.green,
    UIColor.blue,
    UIColor.red,
    UIColor.orange,
    UIColor.yellow
]

colorArray.shifted(by: 2) == shiftedColorArray // returns true

[1,2,3,4,5,6,7].shifted(by: -23) // returns [3,4,5,6,7,1,2]

I like optimization on your solution. Is it possible to refactor this extension to mutate existing array instead of creating new one? @benno-kress
Yes, totally. This extension contains both methods: gist.github.com/bennokress/a12f967e809575be3820c76578640143

yalewzj · Accepted Answer · 2015-09-27 08:21:35Z

10

I know this might be late. But the easiest way to rotate or shift an array is

func shifter(shiftIndex: Int) {
   let strArr: [String] = ["a","b","c","d"]
   var newArr = strArr[shiftIndex..<strArr.count]
   newArr += strArr[0..<shiftIndex]       
   println(newArr)  }

shifter(2) //[c, d, a, b] you can modify the function to take array as input

edited Sep 27, 2015 at 8:21

answered Sep 27, 2015 at 7:15

yalewzj

1,17915 silver badges22 bronze badges

2 Comments

v-i-s-h-a-l Over a year ago

getting error: Cannot subscript a value of type '[CGColor]' with an index of type 'CountableRange<Int>' My code is: ``` guard let indexOfStartColor = possibleColors.index(of: startColor) else { return } let index = indexOfStartColor.distance(to: 0) rotatedColors = possibleColors[index..<possibleColors.count] rotatedColors += possibleColors[0..<index]```

StackUnderflow Over a year ago

Does not shift with negative index i.e. the other way!

0x141E · Accepted Answer · 2015-07-22 07:18:45Z

3

You can extend Array to include a method to return an array containing the elements of the original array rotated by one element:

extension Array {
    func rotate(shift:Int) -> Array {
        var array = Array()
        if (self.count > 0) {
            array = self
            if (shift > 0) {
                for i in 1...shift {
                    array.append(array.removeAtIndex(0))
                }
            }
            else if (shift < 0) {
                for i in 1...abs(shift) {
                    array.insert(array.removeAtIndex(array.count-1),atIndex:0)
                }
            }
        }
        return array
    }
}

To shifts the elements of an array once

let colorArray:[UIColor] = [
    .redColor(),
    .orangeColor(),
    .yellowColor(),
    .greenColor(),
    .blueColor()
]

let z = colorArray.rotate(1)

// z is [.orangeColor(), .yellowColor(), .greenColor(), .blueColor(), .redColor()]

and twice

let z = colorArray.rotate(2)

// z is [.yellowColor(), .greenColor(), .blueColor(), .redColor(), .orangeColor()]

edited Jul 22, 2015 at 7:18

answered Jul 22, 2015 at 6:18

0x141E

12.7k2 gold badges43 silver badges54 bronze badges

1 Comment

Leo Dabus Over a year ago

This would crash with an empty array

ULazdins · Accepted Answer · 2019-12-11 09:29:09Z

3

A variation of @zizutg's answer, that can shift in both directions (positive and negative)

extension Array {
    public func shifted(by index: Int) -> Array {
        let adjustedIndex = index %% self.count

        return Array(self[adjustedIndex..<self.count] + self[0..<adjustedIndex])
    }
}

// True modulo function https://stackoverflow.com/a/41180619/683763
infix operator %%
public func %%(_ dividend: Int, _ divisor: Int) -> Int {
    precondition(divisor > 0, "modulus must be positive")
    let reminder = dividend % divisor
    return reminder >= 0 ? reminder : reminder + divisor
}

answered Dec 11, 2019 at 9:29

ULazdins

2,0554 gold badges26 silver badges33 bronze badges

Comments

Ted Park · Accepted Answer · 2015-07-22 06:22:39Z

2

You can iterate by handling starting index.

func iterate<T>(array:Array<T>, start:Int, callback:(T) -> ()) {
    let count = array.count
    for index in start..<(start + count) {
        callback(array[index % count])
    }
}

If you want to start from index 3

iterate(colors, 3, { (color) -> () in println("color - \(color)")})

answered Jul 22, 2015 at 6:22

Ted Park

212 bronze badges

Collectives™ on Stack Overflow

Shift Swift Array

Array of Colors

Example #1

Example #2

5 Answers 5

2 Comments

2 Comments

1 Comment

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

Array of Colors

Example #1

Example #2

5 Answers 5

2 Comments

2 Comments

1 Comment

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related