let implicitDouble = 70.0
let explicitDouble: Double = 70 

var implicitDouble = 70.0
let explicitDouble: Double = 70

var apple:Int = 1
var orange:Int = 3
print("I have \(apple) apples and \(orange) oranges")
// I have 1 apples and 3 oranges

let httpStatus = (statusCode:200, description: "okay")
print("status code is \(httpStatus.statusCode) and messgae is \(httpStatus.description)}")

// dictionary
var emptyDictionary = [String : Float]()
emptyDictionary["name"] = 1
print(emptyDictionary)
// ["name": 1.0]

// list
var tempt = [Any]()
tempt.append("a")
tempt.append(1)
print(tempt)
// ["a", 1]

let possibleNumber = "123"
if let actualNumber = Int(possibleNumber) {
    print(print("The string \"\(possibleNumber)\" has an integer value of \(actualNumber)"))
}else{
    print("The string \"\(possibleNumber)\" couldn't be converted to an integer")
}
// "The string "123" has an integer value of 123"

let optionalInt: Int?
print(optionalInt)
// nil

if let number = optionalInt {
	print("value is assgined!")
}
// (nothing printed)

let number: Int? = Int("42")
print(number)
// Optional(42)
print("upwrap the number : \(number!)")
// 42

let defaultValue = "default"
let outputOptional = optionalInt ?? defaultValue
print(outputOptional)
// default

let assumedString : String! =  "implicitly unwrapped optional string"

let optionalString = assumedString 
let implicitString: String = assumedString // implicitString가 타입을 String으로 명시했기 때문에 assumedString(implicitly unwrapped optinal)가 값을 forced-upwrapping한 후 변수에 할당함

print(optionalString) 
// Optional("implicitly unwrapped optional string") // 여전히 optinal 타입
print(implicitString)
// implicitly unwrapped optional string

let names = ["Anna","Alex", "Brian", "Jack"]
let numberOfPeople = names.count
for i in 0..<numberOfPeople {
    print("Person \(i+1) is called \(names[i])")
}
//Person 1 is called Anna
//Person 2 is called Alex
//Person 3 is called Brian
//Person 4 is called Jack

for name in names[2...]{
    print(name)
}
//Brian
//Jack

let oneSideRange = ...5
print(oneSideRange.contains(7))
// false

let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
    if score > 50 {
        teamScore += 3
    } else {
        teamScore += 1
    }
}
print(teamScore)
//11

let vegetable = "red pepper"

switch vegetable {
case "celery":
    print("throw it away")
case "cucumber", "watercress":
    print("make a sandwitch")
case let x where x.hasSuffix("pepper"): // assign value to x if value has "pepper" at the back
    print("Is it a spicy \(x)?")
default:
    "everything goes well with soup."
}
// Is it a spicy red pepper?

let interestingNumbers = [
    "Prime" : [2,3,5,7,11,13],
    "Fibonacci" : [1,1,2,3,5,8],
    "Square" : [1,4,9,16,25]
]
var largest = 0
var largestKeys : String?
for (key, numbers) in interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
            largestKeys = key
            
        }
    }
}
print("largest number : \(largest) in key : \(largestKeys)")
//largest number : 25 in key : Optional("Square")

var n = 2
while n < 100 {
    n *= 2
}
print(n)
// 128

var m = 2
repeat {
    m *= 2
} while m < 100
print(m)
// 128

var total = 0
for i in 0..<4 {
    total += i
}
print(total)
// 6

total = 0
for i in 0...4{
    total += i
}
print(total)
// 10

func greet(person: String, day: String) -> String {
    return "Hello \(person), today is \(day)."
}
print(greet(person: "Christina", day: "Sunday"))
// Hello Christina, today is Sunday.

func menu(_ person: String, lunch meal: String) -> String {
    return "Hello \(person), today's meal is \(meal)."
}
print(menu("Chris", lunch: "salad"))
// Hello Chris, today's meal is salad.

func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
    var min = scores[0]
    var max = scores[0]
    var sum = 0
    
    for score in scores {
        if score > max {
            max = score
        } else if score < min {
            min = score
        }
        sum += score
    }
    return (min, max, sum)
}

let statistics = calculateStatistics(scores: [5,3,100,3,9])
print(statistics.min)
// 3
print(statistics.0)
// 3

func hasAnyMatches(list: [Int], condition: (Int) -> Bool) -> Bool {
    for item in list {
        if condition(item) {
            return true
        }
    }
    return false
}
func lessThanTen(number: Int) -> Bool {
    return number < 10
}
var numbers = [20,19,7,12]
print(hasAnyMatches(list: numbers, condition: lessThanTen))
//true

func makeIncrementer() -> ((Int) -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncrementer()
print(increment(7)) // increment 변수는 곧 addOne 함수
// 8

var numbers = [20,19,7,12]
let oddNumbers = numbers.map({ (number: Int) -> Int in
                                if number % 2 == 1 {
                                    return 0
                                } else {
                                    return number
                                }
})
print(oddNumbers)
//[20, 0, 0, 12]

// simple closure(No parameter type, return type, and return statement) when closure has a single statement
let mappedNumbers = numbers.map({ number in 3 * number
})
print(mappedNumbers)
// [60, 57, 21, 36]

// simple closure using parameter index 
let ascendingNumbers = numbers.sorted{ $0 < $1 }
print(ascendingNumbers)
// [7, 12, 19, 20]

class NamedShape {
    var numberOfSides: Int = 0
    var name: String // require initializer
    
    init(name: String) { // initializer
        self.name = name
    }
    
    func simpleDescription() -> String { // method
        return "A shape with \(numberOfSides) sides."
    }
}

var namedShape = NamedShape(name: "Triangle") // instance
namedShape.numberOfSides = 3
print(namedShape.simpleDescription())
// A shape with 3 sides.

class Square: NamedShape {
    var sideLength: Double
    
    init(sideLength: Double, name: String){
        self.sideLength = sideLength
        super.init(name: name) // overrid initializer
        numberOfSides = 4
    }
    
    func area() -> Double {
        return sideLength * sideLength
    }
    
    override func simpleDescription() -> String { // override method
        return "A square with sides of length \(sideLength)"
    }
}
let test = Square(sideLength: 5.2, name: "my test square")
print(test.area())
// A shape triangle with 3 sides.
print(test.simpleDescription())
// A shape with 3 sides.

class EquilateralTriangle: NamedShape {
    var sideLength: Double = 0.0
    
    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 3
    }
    
    var perimeter: Double {
        get {
            return 3.0 * sideLength
        }
        set {
            sideLength = newValue / 3.0
        }
    }
    
    override func simpleDescription() -> String {
        return "A equilateral triangle with sides of length \(sideLength)"
    }
}

var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
print(triangle.perimeter)
// 9.3
triangle.perimeter = 9.9
print(triangle.sideLength)
// 3.3

// willSet을 사용해 triangle과 square의 sideLength가 항상 일치시키기

class TriangleAndSquare {
    var triangle: EquilateralTriangle {
        willSet {
            square.sideLength = newValue.sideLength
        }
    }
    
    var square: Square {
        willSet {
            triangle.sideLength = newValue.sideLength
        }
    }
    
    init(size: Double, name: String){
        square = Square(sideLength: size, name: name)
        triangle = EquilateralTriangle(sideLength: size, name: name)
    }
}

var triangleAndSquare = TriangleAndSquare(size: 10, name: "another teset shape")
print(triangleAndSquare.square.sideLength)
// 10
print(triangleAndSquare.triangle.sideLength)
// 10
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
print(triangleAndSquare.triangle.sideLength)
// 50