Rotate Swift Array - swift

Question

I am trying to solve this question I found on a coding challenge website using Swift 3.
I'm sure most of you have seen it before, but in case you haven't here it is...
The idea is you take a string and rotate it x number of times. So using their example "12345" rotated 2x would be "34512"
I wrote this, but it when I print it out in Playground it just prints out the exact same string I entered.
func rotateSring(originalString: String, numberOfRotations: Int) -> String {
var tempArray: [String] = []
tempArray.append(originalString)
let count = numberOfRotations
for _ in 1...count {
for letter in tempArray {
tempArray.remove(at: 0)
tempArray.append(letter)
}
}
let newString = tempArray.joined(separator: "")
return newString
}
I also tried a variation
func rotateSring(originalString: String, numberOfRotations: Int) -> String {
var tempArray: [String] = []
tempArray.append(originalString)
let count = numberOfRotations
for _ in 1...count {
let test =tempArray.remove(at: 0)
tempArray.append(test)
}
let newString = tempArray.joined(separator: "")
return newString
}
Neither produce the desired result when I say
let testRun = rotateSring(originalString: "12345", numberOfRotations: 2)
I would like the "34512" but instead I get "12345"
If I had to guess what I am doing wrong, I think that I am just rotating the entire array from start to finish so it does move but it moves full circle.
If somebody could explain what I am doing wrong, and how I can fix it that would be great. Thank you

Answer 1

I have gone through your solution and found few mistakes. The below implementation will work.
func rotateSring(originalString: String, numberOfRotations: Int) -> String {
var tempArray: [Character] = Array(originalString.characters)
let count = numberOfRotations
for _ in 1...count {
let letter = tempArray.removeFirst()
tempArray.append(letter)
}
let newString = String(tempArray)
return newString
}
let testRun = rotateSring(originalString: "12345", numberOfRotations: 2)
Now let me explain the changes:
var tempArray: [String] = []
tempArray.append(originalString)
// to
var tempArray: [Character] = Array(originalString.characters)
In Swift, String doesn't conform to Sequence type protocol and so you need to use Character array and so when you were trying to loop over letters, you were actually looping over the whole string i.e. 12345.
// tempArray = ["12345"] not ["1", "2", "3", "4", "5"]
for letter in tempArray {
tempArray.remove(at: 0)
tempArray.append(letter)
}

Answer 2

func rotateSring(originalString: String, numberOfRotations: UInt) -> String {
if numberOfRotations == 0 {
return originalString
}
return rotateSring(originalString: originalString[originalString.index(after: originalString.startIndex)..<originalString.endIndex] + String(originalString[originalString.startIndex]),
numberOfRotations: numberOfRotations - 1)
}

Answer 3

The native String's padding function can do that for you quite efficiently :
let string = "12345"
let rotation = 2
let rotated = "".padding(toLength: string.characters.count, withPad: string, startingAt: rotation % string.characters.count)
if you also need to support negative rotation values, you simply need to calculate the appropriate positive offset:
let string = "12345"
let rotation = -3
let offset = ( rotation % string.characters.count + string.characters.count ) % string.characters.count
let rotated = "".padding(toLength: string.characters.count, withPad: string, startingAt: offset)

Answer 4

What you are doing wrongly in both tries is that you used a [String] with only one element in it - originalString. So when you remove the element at index 0, the array becomes empty.
Here is a solution of mine:
func rotateSring(originalString: String, numberOfRotations: Int) -> String {
var str = originalString
for _ in 0..<numberOfRotations {
let firstChar = str.characters.first! // temporarily store the first char
var c = str.characters.dropFirst() // remove the first char from the string
c.append(firstChar) // add the first char back to the end
str.characters = c
}
return str
}

Answer 5

Rotation by using substring(to:) and substring(from:)
The accepted answer have already covered fixing your own solution; I'll pitch in with another alternative, making use of the substring(to:) and substring(from:) methods of String to rotate a given string a supplied number of characters. The supplied String will be left-rotated (<- shift) for positive rotation numbers, and right-rotated for (-> shift) for negative numbers.
// "left-rotate" supplied string using substring concenation
// (negative supplied rotations will be applied as "right-rotations")
func rotateString(originalString: String, numberOfRotations: Int) -> String {
// rotation is a non-changing operation upon empty or single-character strings
guard case let charCount = originalString.characters.count,
charCount > 1 else { return originalString }
// remove redundant full cycle rotation, and change rotation
// direction (left -> right) in case the supplied rotations are negative.
let numberOfRotations = numberOfRotations % charCount
+ (numberOfRotations < 0 ? 1 : 0) * charCount
// use substring methods to construct the "rotated" String
if numberOfRotations != 0 {
let splitIndex = originalString
.index(originalString.startIndex, offsetBy: numberOfRotations)
return originalString.substring(from: splitIndex) +
originalString.substring(to: splitIndex)
}
return originalString
}
Example usage:
let str = "1🇯🇵345"
// left rotations
print(rotateString(originalString: str, numberOfRotations: 1)) // 🇯🇵3451
print(rotateString(originalString: str, numberOfRotations: 2)) // 3451🇯🇵
print(rotateString(originalString: str, numberOfRotations: 6)) // 🇯🇵3451
// right rotations
print(rotateString(originalString: str, numberOfRotations: -2)) // 451🇯🇵3
print(rotateString(originalString: str, numberOfRotations: -6)) // 51🇯🇵34
// no rotations (/ only full cycles)
print(rotateString(originalString: str, numberOfRotations: 5)) // 1🇯🇵345
print(rotateString(originalString: str, numberOfRotations: -5)) // 1🇯🇵345
print(rotateString(originalString: str, numberOfRotations: 0)) // 1🇯🇵345
Or, as a String extension:
extension String {
func rotated(by numberOfRotations: Int) -> String {
guard case let charCount = characters.count,
charCount > 1 else { return self }
let numberOfRotations = numberOfRotations % charCount
+ (numberOfRotations < 0 ? 1 : 0) * charCount
if numberOfRotations != 0 {
let splitIndex = index(startIndex, offsetBy: numberOfRotations)
return substring(from: splitIndex) + substring(to: splitIndex)
}
return self
}
}
/* example usage */
let str = "1🇯🇵345"
// left rotations
print(str.rotated(by: 1)) // 🇯🇵3451
print(str.rotated(by: 2)) // 3451🇯🇵
print(str.rotated(by: 6)) // 🇯🇵3451
// right rotations
print(str.rotated(by: -2)) // 451🇯🇵3
print(str.rotated(by: -6)) // 51🇯🇵34
// no rotations (/ only full cycles)
print(str.rotated(by: 5)) // 1🇯🇵345
print(str.rotated(by: -5)) // 1🇯🇵345
print(str.rotated(by: 0)) // 1🇯🇵345

Answer 6

code
extension String {
mutating func rotate(by count_: Int) {
guard count_ != 0 else { return }
if count_ < 0 {
let count = -count_ % self.count
let tailRange = index(endIndex, offsetBy: -count)..<endIndex
let tail = String(self[tailRange])
removeSubrange(tailRange)
self = tail + self
} else {
let count = count_ % self.count
let headRange = startIndex..<index(startIndex, offsetBy: count)
let head = String(self[headRange])
removeSubrange(headRange)
self = self + head
}
}
mutating func rotated(by count: Int) -> String {
rotate(by: count)
return self
}
}
Although it's not the most performant way, you can solve this with a recursive function as well:
mutating func rotate(by count_: Int) {
guard count_ >= 0 else { return rotate(by: count - (-count_ % count)) }
let count = count_ % self.count
let headRange = startIndex..<index(startIndex, offsetBy: count)
let head = String(self[headRange])
removeSubrange(headRange)
self = self + head
}
usage
var english = "ABCDEFGHIJ"
var hangeul = "ㅁ모몸마맘뫄뫔"
english.rotate(by: 3)
print(english) //DEFGHIJABC
print(hangeul.rotated(by: 1)) //모몸마맘뫄뫔ㅁ