pyrtsa

import UIKit

struct Color {
    let color: UIColor
    init(r: CGFloat = 0.0,
         g: CGFloat = 0.0,
         b: CGFloat = 0.0,
         a: CGFloat = 1.0)
    {
        color = UIColor(red: r, green: g, blue: b, alpha: a)

pyrtsa

import Text.Printf (printf)
import Data.List (insertBy, delete)

-- Problem
-- ========
--
-- Using numbers `[1...n]`, form all sequences of length `2 * n` such that:
--
--   1. Every number appears exactly twice.
--   2. For any x < y, both occurrences of x must either precede or follow the

pyrtsa

/// Push `value` into the min-heap `xs`, as defined by the less-than
/// comparison `comp`.
public func pushHeap<T>(inout xs: [T], value: T, compare: (T, T) -> Bool) {
    xs.append(value)
    siftUp(&xs, xs.startIndex, xs.endIndex, compare, xs.count)
}
 
/// Push `value` into the min-heap `xs`, as defined by `<`.
public func pushHeap<T: Comparable>(inout xs: [T], value: T) {
    pushHeap(&xs, value) {a, b in a < b}

pyrtsa

Intro

All the Java code here comes from Algorithms, 4th Edition, by Robert Sedgewick and Kevin Wayne.

The Swift code was written by myself. Although it is mainly a direct port of the Java code :)

The goal was to see how fast Swift would compare to a language such as Java in a somewhat non-trivial case.

The input used was largeUF.txt, also provided by the Algorithms book. It is about 27mb, so I left it out of the gist :)

pyrtsa

/// Split the `Sliceable` collection `coll` into its head and tail.
/// Returns `nil` if the collection is empty.
func decompose<S : Sliceable>(coll: S)
    -> (S.Generator.Element, S.SubSlice)?
{
    let start: S.Index = coll.startIndex
    let end: S.Index = coll.endIndex
    return start == end ? nil
                        : (coll[start], coll[start.successor()..<end])
}

pyrtsa

import Foundation

// MARK: Comparable instance for NSDate
public func <(a: NSDate, b: NSDate) -> Bool {
    return a.compare(b) == .OrderedAscending
}

public func ==(a: NSDate, b: NSDate) -> Bool {
    return a.compare(b) == .OrderedSame
}

pyrtsa

import Foundation

extension String {
    func utf8() -> NSData? { return (self as NSString).dataUsingEncoding(NSUTF8StringEncoding) }
}

extension Optional {
    func flatMap<U>(transform: T -> U?) -> U? {
        if let x = self {
            return transform(x)

pyrtsa

// Hello, fellow Swift programmer!
//
// Here's a demonstration of a few ways of cleaning up the unwrapping of
// optionals in Swift.
//
// Swift is known to have both OO and functional background. Thus, there is
// probably some middle ground programming style that is *more* functional than
// Objective-C, and probably less so than Haskell. This playground tries to
// compare their differences in the pretty common scenario of dealing with
// errors or missing input.

pyrtsa

import Foundation

extension String {
    public func split(separator: String) -> [String] {
        if separator.isEmpty {
            return map(self) { String($0) }
        }
        if var pre = self.rangeOfString(separator) {
            var parts = [self.substringToIndex(pre.startIndex)]
            while let rng = self.rangeOfString(separator, range: pre.endIndex..<endIndex) {

pyrtsa

func groupBy<C: CollectionType, K: Hashable>
    (xs: C, key: C.Generator.Element -> K) -> [K:[C.Generator.Element]]
{
    var gs: [K:[C.Generator.Element]] = [:]
    for x in xs {
        let k = key(x)
        var ys = gs[k] ?? []
        ys.append(x)
        gs.updateValue(ys, forKey: k)
    }