0%

14 Swift Task

Posted on Edited on In

Optional, Enum



Combine Optional Strings and return a non Optional String

1
2
3
4
5
6
func combineStrings(str1: String?, str2: String?, str3: String?) -> String {
    (str1 ?? "") + (str2 ?? "") + (str3 ?? "")
}

combineStrings(str1: "AB", str2: "CD", str3: "EF")
// "ABCDEF"

Calculate using enumeration

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
enum Arithmetic {
    case addition, subtraction, multiplication, division
    
    func calculate(_ firstNumber: Double, _ secondNumber: Double) -> Double {
        switch self {
        case .addition:
            return firstNumber + secondNumber
        case .subtraction:
            return firstNumber - secondNumber
        case .multiplication:
            return firstNumber * secondNumber
        case .division:
            return firstNumber / secondNumber
        }
    }
}

Arithmetic.addition.calculate(10, 5)
// 15

Arithmetic.subtraction.calculate(10, 5)
// 5

Arithmetic.multiplication.calculate(10, 5)
// 50

Arithmetic.division.calculate(10, 5)
// 2

Convert celcius to fahrenheit and kelvin using enumertaion

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
enum Temperature {
    case celcius(Double), fahrenheit(Double), kelvin(Double)
    
    func toCelcius() -> Double {
        switch self {
        case .celcius(let celcius):
            return celcius
        case .fahrenheit(let fahrenheit):
            return (fahrenheit - 32) * 5 / 9
        case .kelvin(let kelvin):
            return kelvin + 273
        }
    }
}

Temperature.celcius(100).toCelcius()
// 100

Temperature.fahrenheit(100).toCelcius()
// 37.77777777777778

Temperature.kelvin(100).toCelcius()
// 373

Calculate using enumeration and recursive call

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
indirect enum ArithmeticExpression {
  case number(Int)
  case addition(ArithmeticExpression, ArithmeticExpression)
  case multiplication(ArithmeticExpression, ArithmeticExpression)
}

let five = ArithmeticExpression.number(5)
let four = ArithmeticExpression.number(4)
let sum = ArithmeticExpression.addition(five, four)
let product = ArithmeticExpression.multiplication(sum, ArithmeticExpression.number(2))

func evaluate(_ expression: ArithmeticExpression) -> Int {
    switch expression {
    case .number(let number):
        return number
    case .addition(let firstNumber, let secondNumber):
        return evaluate(firstNumber) + evaluate(secondNumber)
    case .multiplication(let firstNumber, let secondNumber):
        return evaluate(firstNumber) * evaluate(secondNumber)
    }
}

evaluate(five)
// 5

evaluate(sum)
// 9

evaluate(product)
// 18