Small tweaks to the text and code

Don't need to have a duplicate copy of Stack in this folder

Author: hollance

README.markdown

@@ -91,6 +91,7 @@ Bad sorting algorithms (don't use these!):
 
 - [Greatest Common Divisor (GCD)](GCD/). Special bonus: the least common multiple.
 - [Permutations and Combinations](Combinatorics/). Get your combinatorics on!
+- [Shunting Yard Algorithm](Shunting Yard/). Convert infix expressions to postfix.
 - Statistics
 
 ### Machine learning

Shunting Yard/README.markdown

@@ -1,29 +1,24 @@
 # Shunting Yard Algorithm
 
-Any mathematical expression that we write is expressed in a notation known as Infix Notation.
+Any mathematical expression that we write is expressed in a notation known as *infix notation*.
 
 For example:
 
 **A + B * C**
 
-In the above expression the operator is placed between operands hence the expression is said to be in Infix form.
-If you think about it any expression that you write on a piece of paper will always be in infix form. This is what we humans understand.
+In the above expression the operator is placed between operands, hence the expression is said to be in *infix* form. If you think about it, any expression that you write on a piece of paper will always be in infix form. This is what we humans understand.
 
-Now, think about the way the above expression is evaluated, you would first multiply B and C then add the result to A. This is because multiplication has
-higher precedence than addition. We humans can easily understand the precedence of operators, but a machine needs to be given instructions about each operator. If you were to 
-write an algorithm that parsed and evaluated the infix notation you will realize that it's a tedious process. You'd have to parse the expression
-multiple times to know what operation to perform first. As the number of operators increase so does the complexity.
+When the above expression is evaluated, you would first multiply **B** and **C**, and then add the result to **A**. This is because multiplication has higher precedence than addition. We humans can easily understand the precedence of operators, but a machine needs to be given instructions about each operator. 
 
-##  Postfix notations / Reverse Polish Notation 
+If you were to write an algorithm that parsed and evaluated the infix notation you will realize that it's a tedious process. You'd have to parse the expression multiple times to know what operation to perform first. As the number of operators increase so does the complexity.
 
-An expression when represented in postfix form will not have any brackets and neither will you have to worry about scanning for operator precedence. This makes it easy for the computer to evaluate
-expressions since the order in which the operator need to be applied is fixed.
+## Postfix notations / Reverse Polish Notation 
 
-For example:
+In postfix notation, also known as Reverse Polish Notation or RPN, the operators come after the corresponding operands. Here is the postfix representation of the example from the previous section:
 
 **A B C * +**
 
-The above is the postfix representation of the example in the previous section. The operators come after the corresponding operands.
+An expression when represented in postfix form will not have any brackets and neither will you have to worry about scanning for operator precedence. This makes it easy for the computer to evaluate expressions, since the order in which the operators need to be applied is fixed.
 
 ### Evaluating a postfix expression
 
@@ -33,12 +28,11 @@ A stack is used to evaluate a postfix expression. Here is the pseudocode:
 2. If the token is an operand, push it into the stack
 3. If the token is a binary operator,
     1. Pop the two top most operands from the stack
-    2. Apply the binary operator with thetwo operands
+    2. Apply the binary operator to the two operands
     3. Push the result into the stack
-4. Finally, the value of the whole postfix
-   expression remains in the stack
+4. Finally, the value of the whole postfix expression remains in the stack
 
-Using the above psuedocode the evaluation on the stack would be as follows:
+Using the above pseudocode, the evaluation on the stack would be as follows:
 
 | Expression    | Stack   |
 | ------------- | --------|
@@ -51,34 +45,36 @@ Using the above psuedocode the evaluation on the stack would be as follows:
 
 Where **D = B * C** and **E = A + D.**
 
-As seen above a postfix operation is relatively easy to evaluate as the order in which the operators need to be applied is predecided.
+As seen above, a postfix operation is relatively easy to evaluate as the order in which the operators need to be applied is pre-decided.
 
-## Shunting yard algorithm
+## Dijkstra's shunting yard algorithm
 
-The Shunting yard algorithm was invented by Edsger Dijkstra to convert an infix expression to postfix. Many calculators use this algorithm to convert the expression being entered to postfix form.
+The shunting yard algorithm was invented by Edsger Dijkstra to convert an infix expression to postfix. Many calculators use this algorithm to convert the expression being entered to postfix form.
 
 Here is the psedocode of the algorithm:
 
-1. For all the input tokens
+1. For all the input tokens:
     1. Read the next token
     2. If token is an operator (x)
         1. While there is an operator (y) at the top of the operators stack and either (x) is left-associative and its precedence is less or equal to that of (y), or (x) is right-associative and its precedence is less than (y)
             1. Pop (y) from the stack
             2. Add (y) output buffer
         2. Push (x) on the stack
-    3. Else If token is left parenthesis, then push it on the stack
-    4. Else If token is a right parenthesis
+    3. Else if token is left parenthesis, then push it on the stack
+    4. Else if token is a right parenthesis
         1. Until the top token (from the stack) is left parenthesis, pop from the stack to the output buffer
         2. Also pop the left parenthesis but don’t include it in the output buffer
     7. Else add token to output buffer
 2. While there are still operator tokens in the stack, pop them to output
 
 ### How does it work
 
-Let's take a small example and see how the psuedocode works. 
+Let's take a small example and see how the pseudocode works. 
 
 **4 + 4 * 2 / ( 1 - 5 )**
 
+The following table describes the precedence and the associativity for each operator. The same values are used in the algorithm.
+
 | Operator | Precedence   | Associativity   |
 | ---------| -------------| ----------------|
 | ^        | 10           | Right           |
@@ -87,25 +83,28 @@ Let's take a small example and see how the psuedocode works.
 | +        | 0            | Left            |
 | -        | 0            | Left            |
 
-The above table describes the precedence and the associativity for each operator. The same values are used in the algorithm.
+Here we go:
 
 | Token | Action                                      | Output            | Operator stack |
 |-------|---------------------------------------------|-------------------|----------------|
-| 3     | Add token to output                         | 4                 |                |
+| 4     | Add token to output                         | 4                 |                |
 | +     | Push token to stack                         | 4                 | +              |
 | 4     | Add token to output                         | 4 4               | +              |
 | *     | Push token to stack                         | 4 4               | * +            |
 | 2     | Add token to output                         | 4 4 2             | * +            |
-| /     | * Pop stack to output * Push token to stack | 4 4 2 *           | / +            |
+| /     | Pop stack to output, Push token to stack | 4 4 2 *           | / +            |
 | (     | Push token to stack                         | 4 4 2 *           | ( / +          |
 | 1     | Add token to output                         | 4 4 2 * 1         | ( / +          |
 | -     | Push token to stack                         | 4 4 2 * 1         | - ( / +        |
 | 5     | Add token to output                         | 4 4 2 * 1 5       | - ( / +        |
-| )     | * Pop stack to output * Pop stack           | 4 4 2 * 1 5 -     | /  +           |
+| )     | Pop stack to output, Pop stack           | 4 4 2 * 1 5 -     | /  +           |
 | end   | Pop entire stack to output                  | 4 4 2 * 1 5 - / + |                |
 
+We end up with the postfix expression:
+
+** 4 4 2 * 1 5 - / + **
 
-# See Also
+# See also
 
 [Shunting yard algorithm on Wikipedia](https://en.wikipedia.org/wiki/Shunting-yard_algorithm)
 

Shunting Yard/Shunting Yard.playground/Contents.swift renamed to Shunting Yard/ShuntingYard.playground/Contents.swift

@@ -1,7 +1,5 @@
 //: Playground - noun: a place where people can play
 
-import Foundation
-
 internal enum OperatorAssociativity {
   case LeftAssociative
   case RightAssociative
@@ -54,19 +52,18 @@ public enum TokenType: CustomStringConvertible {
 }
 
 public struct OperatorToken: CustomStringConvertible {
-  
-  var operatorType: OperatorType
+  let operatorType: OperatorType
 
   init(operatorType: OperatorType) {
     self.operatorType = operatorType
   }
 
-  var precedance: Int {
+  var precedence: Int {
     switch operatorType {
       case .Add, .Subtract:
         return 0
       case .Divide, .Multiply, .Percent:
-        return 5;
+        return 5
       case .Exponent:
         return 10
     }
@@ -87,22 +84,15 @@ public struct OperatorToken: CustomStringConvertible {
 }
 
 func <=(left: OperatorToken, right: OperatorToken) -> Bool {
-  if left.precedance <= right.precedance {
-    return true
-  }
-  return false
+  return left.precedence <= right.precedence
 }
 
 func <(left: OperatorToken, right: OperatorToken) -> Bool {
-  if left.precedance < right.precedance {
-    return true
-  }
-  return false
+  return left.precedence < right.precedence
 }
 
 public struct Token: CustomStringConvertible {
-  
-  var tokenType: TokenType
+  let tokenType: TokenType
 
   init(tokenType: TokenType) {
     self.tokenType = tokenType
@@ -136,9 +126,9 @@ public struct Token: CustomStringConvertible {
 
   var operatorToken: OperatorToken? {
     switch tokenType {
-    case .Operator(let operatorToken):
+      case .Operator(let operatorToken):
         return operatorToken
-    default:
+      default:
         return nil
     }
   }
@@ -149,8 +139,7 @@ public struct Token: CustomStringConvertible {
 }
 
 public class InfixExpressionBuilder {
-  
-  private var expression = Array<Token>()
+  private var expression = [Token]()
 
   public func addOperator(operatorType: OperatorType) -> InfixExpressionBuilder {
     expression.append(Token(operatorType: operatorType))
@@ -172,66 +161,62 @@ public class InfixExpressionBuilder {
     return self
   }
 
-  public func build() -> Array<Token> {
+  public func build() -> [Token] {
     // Maybe do some validation here
     return expression
   }
 }
 
 // This returns the result of the shunting yard algorithm
-public func reversePolishNotation(expression: Array<Token>) -> String {
-  
+public func reversePolishNotation(expression: [Token]) -> String {
+
   var tokenStack = Stack<Token>()
   var reversePolishNotation = [Token]()
 
   for token in expression {
     switch token.tokenType {
       case .Operand(_):
         reversePolishNotation.append(token)
-        break
+
       case .OpenBracket:
         tokenStack.push(token)
-        break
+
       case .CloseBracket:
-        while tokenStack.count > 0 {
-          if let tempToken = tokenStack.pop() where !tempToken.isOpenBracket {
-            reversePolishNotation.append(tempToken)
-          } else {
-            break
-          }
+        while tokenStack.count > 0, let tempToken = tokenStack.pop() where !tempToken.isOpenBracket {
+          reversePolishNotation.append(tempToken)
         }
-        break
+
       case .Operator(let operatorToken):
-          
         for tempToken in tokenStack.generate() {
           if !tempToken.isOperator {
             break
           }
 
           if let tempOperatorToken = tempToken.operatorToken {
-              
             if operatorToken.associativity == .LeftAssociative && operatorToken <= tempOperatorToken
                 || operatorToken.associativity == .RightAssociative && operatorToken < tempOperatorToken {
-                    
               reversePolishNotation.append(tokenStack.pop()!)
             } else {
               break
             }
           }
         }
-        
         tokenStack.push(token)
-        break
     }
   }
 
   while tokenStack.count > 0 {
     reversePolishNotation.append(tokenStack.pop()!)
   }
 
-  return reversePolishNotation.map({token in
-    return token.description
-  }).joinWithSeparator(" ")
+  return reversePolishNotation.map({token in token.description}).joinWithSeparator(" ")
 }
 
-print(reversePolishNotation(InfixExpressionBuilder().addOperand(3).addOperator(.Add).addOperand(4).addOperator(.Multiply).addOperand(2).addOperator(.Divide).addOpenBracket().addOperand(1).addOperator(.Subtract).addOperand(5).addCloseBracket().addOperator(.Exponent).addOperand(2).addOperator(.Exponent).addOperand(3).build()))
+
+// Simple demo
+
+let expr = InfixExpressionBuilder().addOperand(3).addOperator(.Add).addOperand(4).addOperator(.Multiply).addOperand(2).addOperator(.Divide).addOpenBracket().addOperand(1).addOperator(.Subtract).addOperand(5).addCloseBracket().addOperator(.Exponent).addOperand(2).addOperator(.Exponent).addOperand(3).build()
+
+print(expr.description)
+print(reversePolishNotation(expr))
+