Programming Challenge: Are You a Swift Ninja? Part 2

Start by defining a function that takes two parameters, the latter being an empty string by default. You’ll use this second parameter to accumulate the result of the function.

Every recursive call to your function will move one character from the input string input to the result string result — reversing the order characters appear in the text.

When there are no more characters in the input text, that means you’ve moved them all to the result, so you need to stop recursing.

Want to see it? Here’s the complete solution:

func reverseString (input: String, output: String="") -> String {
  if input.isEmpty {
    return output
  } else {
    return reverseString(
      input.substringToIndex(input.endIndex.predecessor()),
      output: output + input.substringFromIndex(input.endIndex.predecessor()))
    }
  }
}

First you check if input is empty – this is your stop condition. If yes, then just return output with the accumulated result.

If input still has characters, then remove the last one from input and add that character to output. Call the function recursively with these new input and output parameters.

To better understand how the function works look at the parameters of each recursive call:

(Marin Todorov, )
(Marin Todoro, v)
(Marin Todor, vo)
(Marin Todo, vor)
(Marin Tod, voro)
(Marin To, vorod)
(Marin T, vorodo)
(Marin , vorodoT)
(Marin, vorodoT )
(Mari, vorodoT n)
(Mar, vorodoT ni)
(Ma, vorodoT nir)
(M, vorodoT nira)
(, vorodoT niraM)

Give yourself for trying out the code in a Playground and producing the text output from above. Note: you’ll need to add a println() somewhere.

For this solution, write a recursive function that takes the following parameters: a Character, a String to accumulate the result, and a Double to set the desired length of the resulting string:

func charMult(char: Character, result: String, length: Double) -> String {
    if Int64(countElements(result)) < Int64(length) {
        return charMult(char, result+char, length)
    } else {
        return result
    }
}

This function is very similar to what you developed in the previous challenge. It keeps recursively calling itself and adding one more character to the accumulator until the length of the result equals the given length parameter.

When you reach the target length, you just return the result.

In the function above, you need to define the length parameter as a Double because when you write an integer constant in your code (i.e. 10, 4, or 2014) Swift will by default cast it to a Double value.

In order to have your “*” operator work for on a character and an integer like this:

"x" * 20

… you have to make it work for a Character on the left side and a Double on the right side. It may feel a bit strange, but you’ll soon find it’s part of what makes Swift very powerful.

Finally, overload the operator itself and make it use your charMult(char: Character, result: String, length: Double) function:

@infix func * (left: Character, right: Double) -> String {
    return charMult(left, "", right)
}

You declare a function with the operator itself as the name (func *) and declare it to be an @infix. Infix functions take their parameters from their left and right side instead of having them in a list surround by brackets.

You declare that the left side of “*” should be a Character and right side a Double, and that the result of the operation is a String. You declare all this as you would declare any normal function.

For the body of the operator overload, you just call charMult(char: Character, result: String, length: Double) and return the result.

Give the new operator a try in a Playground, try fun things like these:

"-" * 10 + ">" //prints an arrow
"%" + "~" * 6  //prints a worm
"Z" * 20       //gets sleeping

Give yourself for trying the above examples in a Playground.

Use the fact that doWork() returns a boolean result, and therefore may be used in a logical expression.

Logical expressions can be used on a separate line of code in a playground, and their result will show up in the output area.

To solve this problem, use a logical expression instead of a control structure like if or switch.

Modern languages don’t evaluate parts of a logical expression that don’t change the result of the expression as a whole. For example, if the result of the expression is already clear halfway through evaluating it, the rest is just ignored.

What does that really mean?

Consider this expression:

true && true && false && true & true

Let’s start evaluating the values two by two from left to right:

//evaluate first two elements
true && true -> true
 
//evaluate  result so far + third element
true && false -> false

At this point the result is false. The runtime can look ahead and see that only “&&” operators follow, and since the current result is false- – the result could never be true.

At this point, the runtime stops evaluating the expression and simply takes false as the result.

Since you now understand the basic concept of control flow via expressions, have a look at the solution to the original problem:

func reportSuccess() -> Bool {
    println("success!")
    return true
}
 
func reportError() -> Bool {
    println("error")
    return true
}
 
doWork() && reportSuccess() || reportError()

You declare two functions: one prints “success!” and one prints “error”. Let’s have a look at what happens when doWork() returns either boolean value:

When doWork() returns true

Evaluate the expression in the following order:

1. doWork() returns true, so there’s a chance for “&&” to result in either false or true depending on the value of reportSuccess().
2. reportSuccess() is evaluated and prints “success!”.
3. The result of doWork() && reportSuccess() is true.
4. Follows an || operator, but since its left side is already true the value of the right side does not affect the end result, so it’s never evaluated.

When doWork() returns false

Evaluate the expression with the following steps:

1. doWork() returns false, so the result of “&&” is already false. reportSuccess() is never evaluated.
2. Since the result so far is false the right side of the || has chance to turn the result into true so it gets evaluated.
3. When evaluated reportError() prints out “error”.

Your swapElementAtIndex function needs to take a single Int parameter, and to return another function. The second function also takes in a single Int parameter and can use the two parameters to swap the elements in the array at the given indexes.

Since arrayWithElementAtIndexToFront always swaps an element to the one at index 0 you can pre-fabricate a function that provides the parameter to swapElementAtIndex – it’s always 0!

Let’s start by defining swapElementAtIndex.

As you can see from the requirements, the function takes one Int parameter, and its result is a function that also takes one Int parameter. Define this by simply chaining “->” in the function definition, like so:

extension Array {
  func swapElementAtIndex(index: Int) -> (Int) -> Array {
    //code
  }
}

The code above declares swapElementAtIndex(index:Int), which returns a function with one Int param — and returns an array of the same type as the original array Array.

So, how do you return a function from swapElementAtIndex(index:Int)? Sure, you could define a nested function and return it, but there’s a more elegant solution.

Try just returning a closure with the same number of parameters as the expected function.

In the example above, replace the comment “//code” with:

return { withIndex in
  var result = self
  if index < self.count && withIndex < self.count {
    (result[index], result[withIndex]) = (result[withIndex], result[index])
  }
  return result
}

The closure takes one parameter withIndex and swaps the elements at indexes index and withIndex. You’ve already done this several times by now, so it should feel like second nature by now :]

To be able to modify the contents of the array you need to get a mutable copy of it. To get one just declare a local variable and the copy is automatically mutable due to the use of the var keyword.

The next step is to declare the rest of the required functions. But you can’t use func anymore…

Don’t furrow your brow — class and structure variables can be functions too, so you can skip using the keyword func and use var instead.

You’re going to pre-fabricate two variables to call swapElementAtIndex(index:Int).

Add inside the extension code:

var arrayWithElementAtIndexToFront: (Int) -> Array {
  return swapElementAtIndex(0 as Int) 
}
 
var arrayWithElementAtIndexToBack: (Int) -> Array {
  return swapElementAtIndex((self.count-1) as Int) 
}

What these two new functions do is pre-fill one of the parameters required to call swapElementAtIndex(index: Int)(withIndex: Int) (therefore the term “partial function application”).

And that’s all it takes for this solution.

You learned how to create a curried function, and then how to prefabricate other functions out of it using partial application. Good job!