Prep

var names = ["iOS Development Swift", "android Development Kotlin"]
var words = [String]()
var myword = ""

for str in names {
    let word = str.split(separator: " ")
    for char in word {
        print(char)
    }
}

// iOS
// Development
// Swift
// android
// Development
// Kotlin

var arr = [2, 8, 4, 9, 3]

var max = arr[0]

for num in arr {
    if num > max {
        max = num
    }
}

print(max) // 9

var arr = [2, 8, 4, 9, 3]

var min = arr[0]

for num in arr {
    if num < min {
        min = num
    }
}

print(min) // 2

var arr = [2, 8, 4, 9, 3]

var max = arr[0]
var secondMax = arr[0]

for num in arr {
    if num > max {
        secondMax = max
        max = num
    } else if num > secondMax && num != max {
        secondMax = num
    }
}

print(max) // 9
print(secondMax) // 8

var name = "hey harsh"
var word = ""
var result = ""

for s in name {
    if s == " " {
        result = word + " " + result
        word = ""
    } else {
        word = String(s) + word
    }
}

result = word + " " + result
print(result) // hsrah yeh

**Add two numbers closure swift**

let addNumbers: (Int, Int) -> Int = { num1, num2 in 
    num1 + num2 
}

**Shorthand Argument Syntax**

let addNumbers: (Int, Int) -> Int = { $0 + $1 }

**To declare a generic function, place the placeholder type immediately after the function name:**

func functionName<T>(parameter: T) -> T {
    return parameter
}

Reversed Int number

var number = 12345
var reversed = 0

while number > 0 {
    let digit = number % 10
    reversed = reversed * 10 + digit
    number /= 10
}

print(reversed) // 54321

For Int (without built-in reverse methods)

func reverseInt(_ number: Int) -> Int {
    var num = number
    var reversed = 0

    while num > 0 {
        let digit = num % 10
        reversed = reversed * 10 + digit
        num /= 10
    }

    return reversed
}

print(reverseInt(12345))
// 54321

**For String

Since String is not an array, create a separate generic-friendly extension:**

func reverseString(_ str: String) -> String {
    var result = ""

    for char in str {
        result = String(char) + result
    }

    return result
}

print(reverseString("Hello"))
// olleH

Reverse generic function

func reverse<T>(_ value: T) {
    let str = "\(value)"
    var rev = ""

    for s in str {
        rev = "\(s)" + rev
    }

    print(rev)
}

reverse("harsh")
reverse("12345")
reverse("123.45")

**More Generic Version (Reverse Any Array)

If the interviewer wants a true generic solution that works for arrays of any type:**

func reverseArray<T>(_ array: [T]) -> [T] {
    var result: [T] = []

    var index = array.count - 1

    while index >= 0 {
        result.append(array[index])

        if index == 0 { break }
        index -= 1
    }

    return result
}

print(reverseArray([1, 2, 3, 4, 5]))
// [5, 4, 3, 2, 1]

print(reverseArray(["A", "B", "C"]))
// ["C", "B", "A"]

var arr = [1, 2, 3, 4, 5]
var result: [Int] = []
var index = arr.count - 1

while index >= 0 {
    result.append(arr[index])
    if index == 0 { break }
    index -= 1
}
print(result) // [5, 4, 3, 2, 1]

some solution

var scoreOne = 10
var scoreTwo = 20

func swapScores(a: inout Int, b: inout Int) {
    let temp = a
    a = b
    b = temp
}

func swapValues<T>(
    _ a: inout T,
    _ b: inout T) {

    let temp = a
    a = b
    b = temp
}

swapValues(&scoreOne, &scoreTwo)

print(scoreOne)
print(scoreTwo)

var firstName = "Harsh"
var lastName = "Kumar"

var fullName:String {
    firstName + lastName
}
print(fullName)

let numbers = [21, 34, 89, 34, 11]
let result = numbers.map({ String($0) })
print(result)

// Missing number
let arr = [1, 2, 4, 5]
let res = arr

for i in 1...arr.count {
    if !res.contains(i) {
        print("Missing number: \(i)")
    }
}

// Sorting array ascending order
var myArr = [11, 34, 23, 12, 15]
var temp = 0

for i in 0..<myArr.count {
    for j in i+1..<myArr.count {
        if myArr[i] > myArr[j] {
            temp = myArr[i]
            myArr[i] = myArr[j]
            myArr[j] = temp
        }
    }
}
print("Sorted array: \(myArr)")

// Reversed Array
let myArrTest = [2, 9, 3, 1, 6]
var counter = myArrTest.count
var reversedArray = [Int]()

for _ in 0..<counter {
    let revNumber = myArrTest[counter - 1]
    reversedArray.append(revNumber)
    counter -= 1
}

print("ReversedArray: \(reversedArray)")

Reversed function: with any data type

func printValue<T>(_ value: T) {
    let rev = "\(value)"
    var res = ""

    for s in rev {
        res = "\(s)" + res
    }

    print(res)
}

printValue(21)
printValue("Hey")
printValue(12345)

volwel count1

let text = "Hello Swift Programming"

var volwelDict: [Character: Int] = [
    "a" : 0,
    "e" : 0,
    "i" : 0,
    "o" : 0,
    "u" : 0
]

for char in text.lowercased() {
    if volwelDict[char] != nil {
        volwelDict[char]! += 1
    }
}
print(volwelDict)

volwel count2

let text = "Hello Swift Programming"
let volwels = ["a", "e", "i", "o" , "u"]

for s in text.lowercased() {
    if volwels.contains("\(s)") {
        print(s)
    }
}

Merge Sorted Arrays

var arr1 = [1,3,5]
var arr2 = [2,4,6]
var result = [Int]()

for num in arr1 {
    result.append(num)
}

for num in arr2 {
    result.append(num)
}

let res = sortedArray(data: result)
print(res)

func sortedArray(data: [Int]) -> [Int] {
    var temp = 0
    var arr: [Int] = data

    for i in 0..<arr.count {
        for j in i+1..<arr.count {
            if arr[i] > arr[j] {
                temp = arr[i]
                arr[i] = arr[j]
                arr[j] = temp
            }
        }
    }
    return arr
}
// [1,2,3,4,5,6]

Finding missing number [1,2,20]

let arr = [1,2,20]
let res = arr

let startIndex = arr[0]
let endIndex = arr[arr.count - 1]

for i in startIndex..<endIndex {
    if !res.contains(i) {
        print(i)
    }
}
// print...3...19