Skip to content

Instantly share code, notes, and snippets.

@mathewa6

mathewa6/SwiftTour.swift

Created June 29, 2014 03:24
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save mathewa6/4d5cdae212cf0ed12955 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save mathewa6/4d5cdae212cf0ed12955 to your computer and use it in GitHub Desktop.
Download ZIP
"A Swift Tour" : Experiment solutions
Raw
SwiftTour.swift
import Cocoa
println("Hello World")
//Experiment
let explicitFloat: Float = 4;
let width = explicitFloat
let label = "The width is "
//Experiment: Error
let widthLabel = label + String(width)
let name: String = "JCDenton"
//Experiment
let floatCalcString = "The value needed is \(width + 8.0) and his name is \(name)"
var shoppingList = ["catfish", "testItem"]
var dictList = [ "Name" : name,
"Title" : "Badass"]
//Experiment
var optionalName: String? //= "Appleseed"
var greeting = "Hello"
if let name = optionalName {
greeting = "Hello \(name)"
}
else {
greeting = "Name is nil"
}
let interestingNumbers = [
"Primes" : [2,3,5,7,9],
"Fibonacci" : [1,1,2,3,5,8,13]
]
//Experiment
var largest = 0
var largestKind: String?
for (kind,numbers) in interestingNumbers {
for number in numbers {
if number > largest {
largest = number
largestKind = kind
}
}
}
//Experiment
func greet(name: String, day: String, special: String) -> String
{
return "Hello \(name), \(day)'s special is \(special)'"
}
greet("D", "Sunday", "Stir fried veggies")
//Experiment
func averageOfNumbers(numbers: Float...) -> Float
{
var avg: Float = 0
for number in numbers {
avg += number
}
return avg / Float(numbers.count)
}
func hasAnyMatches(list: Int[], condition:(Int -> Bool)) -> Bool
{
for number in list {
if condition(number) {
return true
}
}
return false
}
func lessThanTen(number: Int) -> Bool
{
return number < 10
}
//Experiment
numbers.map({
(number: Int) -> Int in
var result = 1
if number%2 == 0 {
result = 3 * number
}
else {
result = 0
}
return result
})
sort(numbers) {$0 > $1}
//Experiment
class GenericShape {
var numberOfSides: Int = 0
var name: String
let type = "Shape"
init(name: String)
{
self.name = name
}
func description() -> String
{
return "A shape with \(self.numberOfSides) sides"
}
}
class Square: GenericShape {
var sideLength: Double
init(sideLength: Double, name: String)
{
self.sideLength = sideLength
super.init(name: name)
self.numberOfSides = 4
}
func area() -> Double
{
return self.sideLength*self.sideLength
}
override func description() -> String
{
return "A square with sides of length \(self.sideLength)"
}
}
//Experiment
class Circle: GenericShape {
var radius:Double
init(radius: Double, name: String)
{
self.radius = radius
super.init(name: name)
}
func area() -> Double
{
return M_PI * pow(self.radius, 2.0)
}
override func description() -> String
{
return "A circle of radius \(self.radius)"
}
}
class EquilateralTriangle: GenericShape {
var sideLength: Double
var perimeter: Double {
get {
return 3.0 * self.sideLength
}
set {
self.sideLength = newValue/3.0
}
}
init(sideLength: Double, name: String)
{
self.sideLength = sideLength
super.init(name: name)
self.numberOfSides = 3
}
override func description() -> String
{
return "A triangle with all sides of length \(self.sideLength)"
}
}
enum Rank: Int {
case Ace = 1
case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
case Jack, Queen, King
func description() -> String
{
switch self {
case .Ace:
return "Ace"
case .Jack:
return "Jack"
case .Queen:
return "Queen"
case .King:
return "King"
default:
return String(self.toRaw())
}
}
//Experiment
func isEqual(rank: Rank) -> Bool
{
return self.toRaw() == rank.toRaw()
}
}
enum Suit {
case Spades, Hearts, Diamonds, Clubs
func description() -> String
{
switch self {
case .Spades:
return "Spades"
case .Hearts:
return "Hearts"
case .Diamonds:
return "Diamonds"
case .Clubs:
return "Clubs"
}
}
func list() -> Suit[]
{
return [Spades,Hearts, Diamonds, Clubs]
}
//Experiment
func color() -> String
{
switch self {
case .Spades, .Clubs:
return "Black"
case .Diamonds, .Hearts:
return "Red"
}
}
}
struct Card {
var rank: Rank
var suit: Suit
init(rank: Rank, suit: Suit)
{
self.rank = rank
self.suit = suit
}
func description() -> String
{
return "The \(self.rank.description()) of \(self.suit.description())"
}
//Experiment
func createDeck() -> Card[]
{
var arrayCard = Card[]()
for rankInc: Int in 1..14 {
for suitInc: Suit in suit.list() {
arrayCard.append(Card(rank: Rank.fromRaw(rankInc)!, suit: suitInc))
}
Rank.fromRaw(rankInc).description
}
return arrayCard
}
}
//Experiment
enum ServerResponse {
case Result(String, String)
case Timeout(Int)
case Error(String)
}
let success = ServerResponse.Result("6:00AM", "8:04PM")
let connection = ServerResponse.Timeout(60)
let failure = ServerResponse.Error("Good. I hate Cheese")
switch connection {
case let .Result(sunrise, sunset):
let serverResponse = "Sunrise is at \(sunrise) Sunset is at \(sunset)"
case let .Timeout(delay):
let serverResponse = "You took too long : \(delay) seconds"
case let .Error(error):
let serverResponse = "Failure... \(error)"
}
protocol ExampleProtocol {
var description: String { get }
mutating func adjust()
}
//Experiment
enum SimpleEnum: ExampleProtocol {
case Enum1, Enum2(String)
var description: String {
get {
return "A simple Enumeration"
}
set {
description = newValue
}
}
mutating func adjust()
{
description = "of Stuff"
}
}
//Experiment
extension Double {
var absolute: Double {
return abs(self)
}
}
//Experiment
func anyCommonElements<T,U where T: Sequence, U: Sequence,
T.GeneratorType.Element: Equatable, T.GeneratorType.Element == U.GeneratorType.Element>(lhs: T, rhs: U) -> (Bool, Array<T.GeneratorType.Element>)
{
var commonElements = Array<T.GeneratorType.Element>()
for lhsItem in lhs {
for rhsItem in rhs {
if lhsItem == rhsItem {
commonElements.append(lhsItem)
}
}
}
return (!commonElements.isEmpty, commonElements)
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment