Swiftlint autocorrect

AVL Tree/AVLTree.playground/Sources/AVLTree.swift

@@ -341,11 +341,11 @@ extension AVLTree {
       }
     } else {
       // Handle stem cases
-      if let replacement = node.leftChild?.maximum() , replacement !== node {
+      if let replacement = node.leftChild?.maximum(), replacement !== node {
         node.key = replacement.key
         node.payload = replacement.payload
         delete(node: replacement)
-      } else if let replacement = node.rightChild?.minimum() , replacement !== node {
+      } else if let replacement = node.rightChild?.minimum(), replacement !== node {
         node.key = replacement.key
         node.payload = replacement.payload
         delete(node: replacement)
@@ -354,7 +354,6 @@ extension AVLTree {
   }
 }
 
-
 // MARK: - Debugging
 
 extension TreeNode: CustomDebugStringConvertible {

AVL Tree/AVLTree.swift

@@ -341,11 +341,11 @@ extension AVLTree {
       }
     } else {
       // Handle stem cases
-      if let replacement = node.leftChild?.maximum() , replacement !== node {
+      if let replacement = node.leftChild?.maximum(), replacement !== node {
         node.key = replacement.key
         node.payload = replacement.payload
         delete(node: replacement)
-      } else if let replacement = node.rightChild?.minimum() , replacement !== node {
+      } else if let replacement = node.rightChild?.minimum(), replacement !== node {
         node.key = replacement.key
         node.payload = replacement.payload
         delete(node: replacement)
@@ -354,7 +354,6 @@ extension AVLTree {
   }
 }
 
-
 // MARK: - Debugging
 
 extension TreeNode: CustomDebugStringConvertible {

AVL Tree/Tests/TreeNodeTests.swift

@@ -27,7 +27,6 @@ class TreeNodeTests: XCTestCase {
         super.tearDown()
     }
 
-
     func testSingleNodeCreationNOPayload() {
         let treeNode = TreeNode<String, String>(key: "Building")
         XCTAssertNil(treeNode.payload, "Payload for this case should be nil")

All-Pairs Shortest Paths/APSP/APSP/Helpers.swift

@@ -7,7 +7,6 @@
 
 import Foundation
 
-
 /**
  Print a matrix, optionally specifying only the cells to display with the triplet (i, j, k) -> matrix[i][j], matrix[i][k], matrix[k][j]
  */

Array2D/Array2D.playground/Contents.swift

@@ -28,7 +28,6 @@ public struct Array2D<T> {
   }
 }
 
-
 // initialization
 var matrix = Array2D(columns: 3, rows: 5, initialValue: 0)
 

Binary Tree/BinaryTree.playground/Contents.swift

@@ -25,8 +25,6 @@ extension BinaryTree: CustomStringConvertible {
   }
 }
 
-
-
 // leaf nodes
 let node5 = BinaryTree.node(.empty, "5", .empty)
 let nodeA = BinaryTree.node(.empty, "a", .empty)
@@ -50,8 +48,6 @@ let tree = BinaryTree.node(timesLeft, "+", timesRight)
 print(tree)
 tree.count  // 12
 
-
-
 extension BinaryTree {
   public func traverseInOrder(process: (T) -> Void) {
     if case let .node(left, value, right) = self {

Bit Set/BitSet.playground/Contents.swift

@@ -29,9 +29,6 @@ print(bits)
 
 print("")
 
-
-
-
 // Bitwise operations
 
 var a = BitSet(size: 4)
@@ -69,9 +66,6 @@ print(~c)  // 0101110000000000000000000000000000000000000000000000000000000000
 (~b).cardinality  // 5
 (~c).cardinality  // 4
 
-
-
-
 var z = BitSet(size: 66)
 z.all0()        // true
 z.all1()        // false
@@ -93,8 +87,5 @@ z.all1()        // true
 z[65] = false
 z.all1()        // false
 
-
-
-
 //var bigBits = BitSet(size: 10000)
 //print(bigBits)

Bloom Filter/BloomFilter.playground/Contents.swift

@@ -47,8 +47,6 @@ public class BloomFilter<T> {
   }
 }
 
-
-
 /* Two hash functions, adapted from http://www.cse.yorku.ca/~oz/hash.html */
 
 func djb2(x: String) -> Int {
@@ -67,8 +65,6 @@ func sdbm(x: String) -> Int {
   return Int(hash)
 }
 
-
-
 /* A simple test */
 
 let bloom = BloomFilter<String>(size: 17, hashFunctions: [djb2, sdbm])

Bloom Filter/Tests/BloomFilterTests.swift

@@ -23,7 +23,6 @@ func sdbm(_ x: String) -> Int {
   return Int(hash)
 }
 
-
 class BloomFilterTests: XCTestCase {
 
   func testSingleHashFunction() {

Bounded Priority Queue/BoundedPriorityQueue.playground/Contents.swift

@@ -15,8 +15,6 @@ func < (m1: Message, m2: Message) -> Bool {
   return m1.priority < m2.priority
 }
 
-
-
 let queue = BoundedPriorityQueue<Message>(maxElements: 5)
 queue.count
 
@@ -48,8 +46,6 @@ print(queue)
 // At this point, the queue is:
 // <world:150, swift:110, hello:100, there:99, is:30, >
 
-
-
 // Try to insert an item with a really low priority. This should not get added.
 queue.enqueue(Message(name: "very", priority: -1))
 queue.count    // 5
@@ -70,8 +66,6 @@ queue.count
 queue.peek()
 print(queue)
 
-
-
 // Test dequeuing
 queue.dequeue()
 queue.count

Breadth-First Search/BreadthFirstSearch.playground/Pages/Simple example.xcplaygroundpage/Contents.swift

@@ -19,8 +19,6 @@ func breadthFirstSearch(_ graph: Graph, source: Node) -> [String] {
   return nodesExplored
 }
 
-
-
 let graph = Graph()
 
 let nodeA = graph.addNode("a")
@@ -42,6 +40,5 @@ graph.addEdge(nodeE, neighbor: nodeH)
 graph.addEdge(nodeE, neighbor: nodeF)
 graph.addEdge(nodeF, neighbor: nodeG)
 
-
 let nodesExplored = breadthFirstSearch(graph, source: nodeA)
 print(nodesExplored)

Brute-Force String Search/BruteForceStringSearch.playground/Contents.swift

@@ -22,8 +22,6 @@ extension String {
   }
 }
 
-
-
 // A few simple tests
 
 let s = "Hello, World"

Bucket Sort/BucketSort.playground/Sources/BucketSort.swift

@@ -26,7 +26,6 @@ import Foundation
 // MARK: Main algorithm
 //////////////////////////////////////
 
-
 public func bucketSort<T: Sortable>(elements: [T], distributor: Distributor, sorter: Sorter, buckets: inout [Bucket<T>]) -> [T] {
   for elem in elements {
     distributor.distribute(element: elem, buckets: &buckets)
@@ -45,7 +44,6 @@ public func bucketSort<T: Sortable>(elements: [T], distributor: Distributor, sor
 // MARK: Distributor
 //////////////////////////////////////
 
-
 public protocol Distributor {
   func distribute<T: Sortable>(element: T, buckets: inout [Bucket<T>])
 }

Bucket Sort/BucketSort.swift

@@ -45,12 +45,10 @@ fileprivate func >= <T: Comparable>(lhs: T?, rhs: T?) -> Bool {
   }
 }
 
-
 //////////////////////////////////////
 // MARK: Main algorithm
 //////////////////////////////////////
 
-
 /**
     Performs bucket sort algorithm on the given input elements.
     [Bucket Sort Algorithm Reference](https://en.wikipedia.org/wiki/Bucket_sort)
@@ -96,7 +94,6 @@ private func enoughSpaceInBuckets<T: Sortable>(_ buckets: [Bucket<T>], elements:
 // MARK: Distributor
 //////////////////////////////////////
 
-
 public protocol Distributor {
     func distribute<T: Sortable>(_ element: T, buckets: inout [Bucket<T>])
 }

Bucket Sort/Tests/Tests.swift

@@ -86,7 +86,6 @@ class TestTests: XCTestCase {
     }
 }
 
-
 //////////////////////////////////////
 // MARK: Extensions
 //////////////////////////////////////

Combinatorics/Combinatorics.playground/Contents.swift

@@ -14,8 +14,6 @@ func factorial(_ n: Int) -> Int {
 factorial(5)
 factorial(20)
 
-
-
 /*
  Calculates P(n, k), the number of permutations of n distinct symbols
  in groups of size k.
@@ -34,8 +32,6 @@ permutations(5, 3)
 permutations(50, 6)
 permutations(9, 4)
 
-
-
 /*
  Prints out all the permutations of the given array.
  Original algorithm by Niklaus Wirth.
@@ -63,8 +59,6 @@ let xyz = [ "x", "y", "z" ]
 print("\nPermutations of \(xyz):")
 permuteWirth(xyz, 2)
 
-
-
 /*
  Prints out all the permutations of an n-element collection.
 
@@ -97,8 +91,6 @@ let numbers = [0, 0, 0, 0]  // must be all zeros
 var pos = -1
 permuteSedgewick(numbers, 0, &pos)
 
-
-
 /*
  Calculates C(n, k), or "n-choose-k", i.e. how many different selections
  of size k out of a total number of distinct elements (n) you can make.
@@ -115,8 +107,6 @@ for i in 1...20 {
     print("\(20)-choose-\(i) = \(combinations(20, choose: i))")
 }
 
-
-
 /*
  Calculates C(n, k), or "n-choose-k", i.e. the number of ways to choose
  k things out of n possibilities.
@@ -134,8 +124,6 @@ func quickBinomialCoefficient(_ n: Int, choose k: Int) -> Int {
 quickBinomialCoefficient(8, choose: 2)
 quickBinomialCoefficient(30, choose: 15)
 
-
-
 /* Supporting code because Swift doesn't have a built-in 2D array. */
 struct Array2D<T> {
   let columns: Int

Convex Hull/Convex Hull/AppDelegate.swift

@@ -13,7 +13,6 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
 
     var window: UIWindow?
 
-
     func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
 
         let screenBounds = UIScreen.main.bounds
@@ -52,5 +51,4 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
         // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
     }
 
-
 }

Count Occurrences/CountOccurrences.playground/Contents.swift

@@ -32,13 +32,11 @@ func countOccurrencesOfKey(_ key: Int, inArray a: [Int]) -> Int {
   return rightBoundary() - leftBoundary()
 }
 
-
 // Simple test
 
 let a = [ 0, 1, 1, 3, 3, 3, 3, 6, 8, 10, 11, 11 ]
 countOccurrencesOfKey(3, inArray: a)
 
-
 // Test with arrays of random size and contents (see debug output)
 
 import Foundation

Counting Sort/CountingSort.playground/Contents.swift

@@ -37,5 +37,4 @@ func countingSort(array: [Int]) throws -> [Int] {
   return sortedArray
 }
 
-
 try countingSort(array: [10, 9, 8, 7, 1, 2, 7, 3])

Depth-First Search/DepthFirstSearch.playground/Pages/Simple Example.xcplaygroundpage/Contents.swift

@@ -10,8 +10,6 @@ func depthFirstSearch(_ graph: Graph, source: Node) -> [String] {
   return nodesExplored
 }
 
-
-
 let graph = Graph()
 
 let nodeA = graph.addNode("a")

DiningPhilosophers/Sources/main.swift

@@ -6,7 +6,6 @@
 //
 //
 
-
 import Dispatch
 
 let numberOfPhilosophers = 4
@@ -41,7 +40,6 @@ struct ForkPair {
     }
 }
 
-
 struct Philosophers {
     let forkPair: ForkPair
     let philosopherIndex: Int
@@ -75,7 +73,6 @@ struct Philosophers {
     }
 }
 
-
 // Layout of the table (P = philosopher, f = fork) for 4 Philosophers
 //          P0
 //       f3    f0
@@ -99,6 +96,5 @@ for semaphore in ForkPair.forksSemaphore {
     semaphore.signal()
 }
 
-
 //Wait forever
 globalSem.wait()

Graph/Graph/AdjacencyListGraph.swift

@@ -7,8 +7,6 @@
 
 import Foundation
 
-
-
 private class EdgeList<T> where T: Equatable, T: Hashable {
 
   var vertex: Vertex<T>
@@ -90,7 +88,6 @@ open class AdjacencyListGraph<T>: AbstractGraph<T> where T: Equatable, T: Hashab
     addDirectedEdge(vertices.1, to: vertices.0, withWeight: weight)
   }
 
-
   open override func weightFrom(_ sourceVertex: Vertex<T>, to destinationVertex: Vertex<T>) -> Double? {
     guard let edges = adjacencyList[sourceVertex.index].edges else {
       return nil

Knuth-Morris-Pratt/KnuthMorrisPratt.playground/Contents.swift

@@ -1,6 +1,5 @@
 //: Playground - noun: a place where people can play
 
-
 func ZetaAlgorithm(ptnr: String) -> [Int]? {
 
     let pattern = Array(ptnr.characters)