func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
    }
    return false
}

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    var left = 0
    var right = sorted.count - 1
    while left < right {
        let diff = abs(sorted[left] - sorted[right])
        if diff < threshold {
            return true
        }
        if diff < threshold {
            return true
        }
        left += 1
        right -= 1
    }
    return false
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
    }
    return false
}
```

### 解法二：双指针

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    var left = 0
    var right = sorted.count - 1
    while left < right {
        let diff = abs(sorted[left] - sorted[right])
        if diff < threshold {
            return true
        }
        if diff < threshold {
            return true
        }
        left += 1
        right -= 1
    }
    return false
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    guard numbers.count > 1 else {
        return false
    }
    
    var sorted = numbers
    sorted.sort()
    
    for i in 1..<numbers.count {
        if abs(sorted[i] - sorted[i - 1]) < threshold {
            return true
        }
    }
    
    return false
}

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    guard numbers.count > 1 else {
        return false
    }
    
    var sorted = numbers
    sorted.sort()
    
    var left = 0
    var right = numbers.count - 1
    
    while left < right {
        if abs(sorted[left] - sorted[left + 1]) < threshold {
            return true
        }
        left += 1
        
        if abs(sorted[right] - sorted[right - 1]) < threshold {
            return true
        }
        right -= 1
    }
    
    return false
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    guard numbers.count > 1 else {
        return false
    }
    
    var sorted = numbers
    sorted.sort()
    
    for i in 1..<numbers.count {
        if abs(sorted[i] - sorted[i - 1]) < threshold {
            return true
        }
    }
    
    return false
}
```

### 解法二：双指针

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    guard numbers.count > 1 else {
        return false
    }
    
    var sorted = numbers
    sorted.sort()
    
    var left = 0
    var right = numbers.count - 1
    
    while left < right {
        if abs(sorted[left] - sorted[left + 1]) < threshold {
            return true
        }
        left += 1
        
        if abs(sorted[right] - sorted[right - 1]) < threshold {
            return true
        }
        right -= 1
    }
    
    return false
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var sorted = numbers
    sorted.sort()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
    }
    return false
}

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var sorted = numbers
    sorted.sort()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
        let index = binarySearch(sorted, target: sorted[i], left: i + 1)
        if index != -1 && abs(sorted[index] - sorted[i]) < threshold {
            return true
        }
    }
    return false
}

func binarySearch(numbers: [Double], target: Double, left: Int) -> Int {
    var left = left
    var right = numbers.count - 1
    while left <= right {
        let mid = left + (right - left) / 2
        if numbers[mid] > target {
            right = mid - 1
        } else {
            left = mid + 1
        }
    }
    return left
}

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var sorted = numbers
    sorted.sort()
    var left = 0
    var right = 1
    while right < sorted.count {
        let diff = abs(sorted[left] - sorted[right])
        if diff < threshold {
            return true
        }
        if right == sorted.count - 1 {
            left += 1
            right = left + 1
        } else {
            right += 1
        }
    }
    return false
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var sorted = numbers
    sorted.sort()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
    }
    return false
}
```

### 解法二：二分查找

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var sorted = numbers
    sorted.sort()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
        let index = binarySearch(sorted, target: sorted[i], left: i + 1)
        if index != -1 && abs(sorted[index] - sorted[i]) < threshold {
            return true
        }
    }
    return false
}

func binarySearch(numbers: [Double], target: Double, left: Int) -> Int {
    var left = left
    var right = numbers.count - 1
    while left <= right {
        let mid = left + (right - left) / 2
        if numbers[mid] > target {
            right = mid - 1
        } else {
            left = mid + 1
        }
    }
    return left
}
```

### 解法三：双指针

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    var sorted = numbers
    sorted.sort()
    var left = 0
    var right = 1
    while right < sorted.count {
        let diff = abs(sorted[left] - sorted[right])
        if diff < threshold {
            return true
        }
        if right == sorted.count - 1 {
            left += 1
            right = left + 1
        } else {
            right += 1
        }
    }
    return false
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
    }
    return false
}

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
        let index = binarySearch(sorted, target: sorted[i], left: i + 1)
        if index != nil && diff < abs(sorted[index!] - sorted[i + 1]) {
            return true
        }
    }
    return false
}

func binarySearch(numbers: [Double], target: Double, left: Int) -> Int? {
    var left = left
    var right = numbers.count - 1
    while left <= right {
        let mid = (left + right) / 2
        if numbers[mid] == target {
            return mid
        } else if numbers[mid] < target {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    return nil
}

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    var left = 0
    var right = 1
    while right < sorted.count {
        let diff = abs(sorted[left] - sorted[right])
        if diff < threshold {
            return true
        }
        if diff < abs(sorted[left] - sorted[left + 1]) {
            left += 1
        }
        right += 1
    }
    return false
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
    }
    return false
}
```

### 解法二：二分查找

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
        let index = binarySearch(sorted, target: sorted[i], left: i + 1)
        if index != nil && diff < abs(sorted[index!] - sorted[i + 1]) {
            return true
        }
    }
    return false
}

func binarySearch(numbers: [Double], target: Double, left: Int) -> Int? {
    var left = left
    var right = numbers.count - 1
    while left <= right {
        let mid = (left + right) / 2
        if numbers[mid] == target {
            return mid
        } else if numbers[mid] < target {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    return nil
}
```

### 解法三：双指针

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    var left = 0
    var right = 1
    while right < sorted.count {
        let diff = abs(sorted[left] - sorted[right])
        if diff < threshold {
            return true
        }
        if diff < abs(sorted[left] - sorted[left + 1]) {
            left += 1
        }
        right += 1
    }
    return false
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
    }
    return false
}

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    var left = 0
    var right = 1
    while right < sorted.count {
        let diff = abs(sorted[left] - sorted[right])
        if diff < threshold {
            return true
        }
        if diff > threshold {
            left += 1
            right = left + 1
        } else {
            right += 1
        }
    }
    return false
}

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
        let index = binarySearch(sorted, target: sorted[i], left: i + 1)
        if index != -1 && abs(sorted[index] - sorted[i + 1]) < threshold {
            return true
        }
    }
    return false
}

func binarySearch(numbers: [Double], target: Double, left: Int) -> Int {
    var left = left
    var right = numbers.count - 1
    while left <= right {
        let mid = (left + right) / 2
        if numbers[mid] > target {
            right = mid - 1
        } else if numbers[mid] < target {
            left = mid + 1
        } else {
            return mid
        }
    }
    return -1
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
    }
    return false
}
```

### 解法二：双指针

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    var left = 0
    var right = 1
    while right < sorted.count {
        let diff = abs(sorted[left] - sorted[right])
        if diff < threshold {
            return true
        }
        if diff > threshold {
            left += 1
            right = left + 1
        } else {
            right += 1
        }
    }
    return false
}
```

### 解法三：二分查找

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
        let index = binarySearch(sorted, target: sorted[i], left: i + 1)
        if index != -1 && abs(sorted[index] - sorted[i + 1]) < threshold {
            return true
        }
    }
    return false
}

func binarySearch(numbers: [Double], target: Double, left: Int) -> Int {
    var left = left
    var right = numbers.count - 1
    while left <= right {
        let mid = (left + right) / 2
        if numbers[mid] > target {
            right = mid - 1
        } else if numbers[mid] < target {
            left = mid + 1
        } else {
            return mid
        }
    }
    return -1
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
    }
    return false
}

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
        let index = binarySearch(sorted, target: sorted[i] + threshold)
        if index != -1 && abs(sorted[i] - sorted[index]) < threshold {
            return true
        }
        let index = binarySearch(sorted, target: sorted[i] - threshold)
        if index != -1 && abs(sorted[i] - sorted[index]) < threshold {
            return true
        }
    }
    return false
}

func binarySearch(_ nums: [Double], target: Double) -> Int {
    var left = 0
    var right = nums.count - 1
    while left < right {
        let mid = (left + right) / 2
        if nums[mid] < target {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
    }
    return false
}
```

### 解法二：二分查找

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
        let index = binarySearch(sorted, target: sorted[i] + threshold)
        if index != -1 && abs(sorted[i] - sorted[index]) < threshold {
            return true
        }
        let index = binarySearch(sorted, target: sorted[i] - threshold)
        if index != -1 && abs(sorted[i] - sorted[index]) < threshold {
            return true
        }
    }
    return false
}

func binarySearch(_ nums: [Double], target: Double) -> Int {
    var left = 0
    var right = nums.count - 1
    while left < right {
        let mid = (left + right) / 2
        if nums[mid] < target {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left
}
```

### 解法三：滑动窗口

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
        let index = binarySearch(sorted, target: sorted[i] + threshold)
        if index != -1 && abs(sorted[i] - sorted[index]) < threshold {
            return true
        }
        let index = binarySearch(sorted, target: sorted[i] - threshold)
        if index != -1 && abs(sorted[i] - sorted[index]) < threshold {
            return true
        }
    }
    return false
}

func binarySearch(_ nums: [Double], target: Double) -> Int {
    var left = 0
    var right = nums.count - 1
    while left < right {
        let mid = (left + right) / 2
        if nums[mid] < target {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
    }
    return false
}

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
        let left = binarySearch(sorted, target: sorted[i], left: 0, right: i)
        let right = binarySearch(sorted, target: sorted[i + 1], left: i + 1, right: sorted.count - 1)
        if left != nil && right != nil {
            return true
        }
    }
    return false
}

func binarySearch(numbers: [Double], target: Double, left: Int, right: Int) -> Double? {
    if left > right {
        return nil
    }
    let mid = (left + right) / 2
    if numbers[mid] > target {
        return binarySearch(numbers, target: target, left: left, right: mid - 1)
    } else if numbers[mid] < target {
        return binarySearch(numbers, target: target, left: mid + 1, right: right)
    } else {
        return numbers[mid]
    }
}

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    var left = 0
    var right = 1
    while right < sorted.count {
        let diff = abs(sorted[left] - sorted[right])
        if diff < threshold {
            return true
        }
        if left == right {
            right += 1
        } else {
            left += 1
            right += 1
        }
    }
    return false
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
    }
    return false
}
```

### 解法二：二分查找

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
        let left = binarySearch(sorted, target: sorted[i], left: 0, right: i)
        let right = binarySearch(sorted, target: sorted[i + 1], left: i + 1, right: sorted.count - 1)
        if left != nil && right != nil {
            return true
        }
    }
    return false
}

func binarySearch(numbers: [Double], target: Double, left: Int, right: Int) -> Double? {
    if left > right {
        return nil
    }
    let mid = (left + right) / 2
    if numbers[mid] > target {
        return binarySearch(numbers, target: target, left: left, right: mid - 1)
    } else if numbers[mid] < target {
        return binarySearch(numbers, target: target, left: mid + 1, right: right)
    } else {
        return numbers[mid]
    }
}
```

### 解法三：双指针

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    var left = 0
    var right = 1
    while right < sorted.count {
        let diff = abs(sorted[left] - sorted[right])
        if diff < threshold {
            return true
        }
        if left == right {
            right += 1
        } else {
            left += 1
            right += 1
        }
    }
    return false
}
```

### 解法四：滑动窗口

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    var left = 0
    var right = 1
    while right < sorted.count {
        let diff = abs(sorted[left] - sorted[right])
        if diff < threshold {
            return true
        }
        if left == right {
            right += 1
        } else {
            left += 1
            right += 1
        }
    }
    return false
}
```

### 解法五：桶

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
    }
    return false
}

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
        let index = binarySearch(sorted, target: sorted[i], left: i + 1, right: sorted.count - 1)
        if index != -1 && diff < abs(sorted[i] - sorted[index]) {
            return true
        }
    }
    return false
}

func binarySearch(numbers: [Double], target: Double, left: Int, right: Int) -> Int {
    var left = left
    var right = right
    while left <= right {
        let mid = left + (right - left) / 2
        if numbers[mid] > target {
            right = mid - 1
        } else if numbers[mid] < target {
            left = mid + 1
        } else {
            return mid
        }
    }
    return -1
}

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let buckets = [Int](repeating: 0, count: 100)
    for number in numbers {
        let bucket = Int(number * 100)
        buckets[bucket] += 1
    }
    for i in 0..<buckets.count - 1 {
        let diff = abs(Double(i) / 100 - Double(i + 1) / 100)
        if diff < threshold {
            return true
        }
        if buckets[i] > 0 {
            let count = buckets[i]
            for j in 0..<count {
                let index = binarySearch(buckets, target: Double(i) / 100, left: 0, right: buckets.count - 1)
                if index != -1 && diff < abs(Double(i) / 100 - Double(index) / 100) {
                    return true
                }
            }
        }
    }
    return false
}

func binarySearch(buckets: [Int], target: Double, left: Int, right: Int) -> Int {
    var left = left
    var right = right
    while left <= right {
        let mid = left + (right - left) / 2
        if buckets[mid] > target {
            right = mid - 1
        } else if buckets[mid] < target {
            left = mid + 1
        } else {
            return mid
        }
    }
    return -1
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
    }
    return false
}
```

### 解法二：二分查找

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let sorted = numbers.sorted()
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
        let index = binarySearch(sorted, target: sorted[i], left: i + 1, right: sorted.count - 1)
        if index != -1 && diff < abs(sorted[i] - sorted[index]) {
            return true
        }
    }
    return false
}

func binarySearch(numbers: [Double], target: Double, left: Int, right: Int) -> Int {
    var left = left
    var right = right
    while left <= right {
        let mid = left + (right - left) / 2
        if numbers[mid] > target {
            right = mid - 1
        } else if numbers[mid] < target {
            left = mid + 1
        } else {
            return mid
        }
    }
    return -1
}
```

### 解法三：桶排序

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    let buckets = [Int](repeating: 0, count: 100)
    for number in numbers {
        let bucket = Int(number * 100)
        buckets[bucket] += 1
    }
    for i in 0..<buckets.count - 1 {
        let diff = abs(Double(i) / 100 - Double(i + 1) / 100)
        if diff < threshold {
            return true
        }
        if buckets[i] > 0 {
            let count = buckets[i]
            for j in 0..<count {
                let index = binarySearch(buckets, target: Double(i) / 100, left: 0, right: buckets.count - 1)
                if index != -1 && diff < abs(Double(i) / 100 - Double(index) / 100) {
                    return true
                }
            }
        }
    }
    return false
}

func binarySearch(buckets: [Int], target: Double, left: Int, right: Int) -> Int {
    var left = left
    var right = right
    while left <= right {
        let mid = left + (right - left) / 2
        if buckets[mid] > target {
            right = mid - 1
        } else if buckets[mid] < target {
            left = mid + 1
        } else {
            return mid
        }
    }
    return -1
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    guard numbers.count > 1 else {
        return false
    }
    
    var sorted = numbers
    sorted.sort()
    
    for i in 1..<numbers.count {
        let diff = abs(sorted[i] - sorted[i - 1])
        if diff < threshold {
            return true
        }
    }
    
    return false
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    guard numbers.count > 1 else {
        return false
    }
    
    var sorted = numbers
    sorted.sort()
    
    for i in 1..<numbers.count {
        let diff = abs(sorted[i] - sorted[i - 1])
        if diff < threshold {
            return true
        }
    }
    
    return false
}
```

func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    guard numbers.count > 1 else {
        return false
    }
    
    var sorted = numbers
    sorted.sort()
    
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
    }
    
    return false
}

```swift
// Check if in given array of numbers, are any two numbers closer to each other than
// given threshold.
// hasCloseElements(numbers: [1.0, 2.0, 3.0], threshold: 0.5) == false
// hasCloseElements(numbers: [1.0, 2.8, 3.0, 4.0, 5.0, 2.0], threshold: 0.3) == true
func hasCloseElements(numbers: [Double], threshold: Double) -> Bool {
    guard numbers.count > 1 else {
        return false
    }
    
    var sorted = numbers
    sorted.sort()
    
    for i in 0..<sorted.count - 1 {
        let diff = abs(sorted[i] - sorted[i + 1])
        if diff < threshold {
            return true
        }
    }
    
    return false
}
```

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var current = ""
    var stack = [String]()
    for char in parenString {
        if char == "(" {
            stack.append("(")
        } else if char == ")" {
            if let last = stack.popLast() {
                if last == "(" {
                    result.append(current)
                    current = ""
                } else {
                    current += last
                }
            }
        } else {
            current += char
        }
    }
    result.append(current)
    return result
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var current = ""
    var stack = [String]()
    for char in parenString {
        if char == "(" {
            stack.append("(")
        } else if char == ")" {
            if let last = stack.popLast() {
                if last == "(" {
                    result.append(current)
                    current = ""
                } else {
                    current += last
                }
            }
        } else {
            current += char
        }
    }
    result.append(current)
    return result
}
```

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var current = ""
    var stack = [String]()
    for char in parenString {
        if char == "(" {
            stack.append("(")
            current += char
        } else if char == ")" {
            if stack.count > 0 {
                stack.removeLast()
                current += char
            } else {
                result.append(current)
                current = ""
            }
        } else {
            current += char
        }
    }
    if current != "" {
        result.append(current)
    }
    return result
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var current = ""
    var stack = [String]()
    for char in parenString {
        if char == "(" {
            stack.append("(")
            current += char
        } else if char == ")" {
            if stack.count > 0 {
                stack.removeLast()
                current += char
            } else {
                result.append(current)
                current = ""
            }
        } else {
            current += char
        }
    }
    if current != "" {
        result.append(current)
    }
    return result
}
```

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var current = ""
    var stack = [String]()
    for char in parenString {
        if char == "(" {
            stack.append("(")
            current += char
        } else if char == ")" {
            if stack.count == 0 {
                result.append(current)
                current = ""
            } else {
                stack.removeLast()
                current += char
            }
        } else {
            current += char
        }
    }
    if current != "" {
        result.append(current)
    }
    return result
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var current = ""
    var stack = [String]()
    for char in parenString {
        if char == "(" {
            stack.append("(")
            current += char
        } else if char == ")" {
            if stack.count == 0 {
                result.append(current)
                current = ""
            } else {
                stack.removeLast()
                current += char
            }
        } else {
            current += char
        }
    }
    if current != "" {
        result.append(current)
    }
    return result
}
```

func separateParenGroups(parenString: String) -> [String] {
    let parenString = parenString.replacingOccurrences(of: " ", with: "")
    var result = [String]()
    var current = ""
    var level = 0
    for char in parenString {
        if char == "(" {
            level += 1
            current += char
        } else if char == ")" {
            level -= 1
            current += char
            if level == 0 {
                result.append(current)
                current = ""
            }
        } else {
            current += char
        }
    }
    return result
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    let parenString = parenString.replacingOccurrences(of: " ", with: "")
    var result = [String]()
    var current = ""
    var level = 0
    for char in parenString {
        if char == "(" {
            level += 1
            current += char
        } else if char == ")" {
            level -= 1
            current += char
            if level == 0 {
                result.append(current)
                current = ""
            }
        } else {
            current += char
        }
    }
    return result
}
```

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var current = ""
    var stack = [String]()
    for char in parenString {
        if char == "(" {
            stack.append(current)
            current = ""
        } else if char == ")" {
            if current.isEmpty {
                current = stack.removeLast()
            } else {
                current += ")"
            }
        } else {
            current += char
        }
    }
    if !current.isEmpty {
        stack.append(current)
    }
    while !stack.isEmpty {
        result.append(stack.removeLast())
    }
    return result
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var current = ""
    var stack = [String]()
    for char in parenString {
        if char == "(" {
            stack.append(current)
            current = ""
        } else if char == ")" {
            if current.isEmpty {
                current = stack.removeLast()
            } else {
                current += ")"
            }
        } else {
            current += char
        }
    }
    if !current.isEmpty {
        stack.append(current)
    }
    while !stack.isEmpty {
        result.append(stack.removeLast())
    }
    return result
}
```

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var current = ""
    var stack = [String]()
    for char in parenString {
        if char == "(" {
            stack.append(current)
            current = ""
        } else if char == ")" {
            current = stack.removeLast() + current
        } else {
            current += String(char)
        }
    }
    
    for item in stack {
        result.append(item)
    }
    result.append(current)
    return result
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var current = ""
    var stack = [String]()
    for char in parenString {
        if char == "(" {
            stack.append(current)
            current = ""
        } else if char == ")" {
            current = stack.removeLast() + current
        } else {
            current += String(char)
        }
    }
    
    for item in stack {
        result.append(item)
    }
    result.append(current)
    return result
}
```

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var current = ""
    var stack = [String]()
    
    for char in parenString {
        if char == "(" {
            stack.append(current)
            current = ""
        } else if char == ")" {
            current = stack.removeLast() + current
        } else {
            current += String(char)
        }
    }
    
    for str in stack {
        result.append(str)
    }
    
    return result
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var current = ""
    var stack = [String]()
    
    for char in parenString {
        if char == "(" {
            stack.append(current)
            current = ""
        } else if char == ")" {
            current = stack.removeLast() + current
        } else {
            current += String(char)
        }
    }
    
    for str in stack {
        result.append(str)
    }
    
    return result
}
```

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var current = ""
    var stack = [String.Element]()
    for char in parenString {
        if char == "(" {
            stack.append(char)
        } else if char == ")" {
            while !stack.isEmpty && stack.last != "(" {
                current.append(stack.removeLast())
            }
            if !stack.isEmpty && stack.last == "(" {
                stack.removeLast()
                result.append(current)
                current = ""
            }
        } else {
            current.append(char)
        }
    }
    while !stack.isEmpty {
        current.append(stack.removeLast())
    }
    result.append(current)
    return result
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var current = ""
    var stack = [String.Element]()
    for char in parenString {
        if char == "(" {
            stack.append(char)
        } else if char == ")" {
            while !stack.isEmpty && stack.last != "(" {
                current.append(stack.removeLast())
            }
            if !stack.isEmpty && stack.last == "(" {
                stack.removeLast()
                result.append(current)
                current = ""
            }
        } else {
            current.append(char)
        }
    }
    while !stack.isEmpty {
        current.append(stack.removeLast())
    }
    result.append(current)
    return result
}
```

func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var current = ""
    var stack = [String]()
    for char in parenString {
        if char == "(" {
            stack.append(current)
            current = ""
        } else if char == ")" {
            current = stack.removeLast() + current
        } else {
            current += String(char)
        }
    }
    stack.append(current)
    for s in stack {
        result.append(s)
    }
    return result
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    var result = [String]()
    var current = ""
    var stack = [String]()
    for char in parenString {
        if char == "(" {
            stack.append(current)
            current = ""
        } else if char == ")" {
            current = stack.removeLast() + current
        } else {
            current += String(char)
        }
    }
    stack.append(current)
    for s in stack {
        result.append(s)
    }
    return result
}
```

func separateParenGroups(parenString: String) -> [String] {
    let parenString = parenString.replacingOccurrences(of: " ", with: "")
    var result = [String]()
    var current = ""
    var stack = [String]()
    
    for char in parenString {
        if char == "(" {
            stack.append(current)
            current = ""
        } else if char == ")" {
            current = stack.removeLast() + current
        } else {
            current += String(char)
        }
    }
    
    for str in stack {
        result.append(str)
    }
    
    return result
}

```swift
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the array of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// separateParenGroups(parenString: "( ) (( )) (( )( ))") == ["()", "(())", "(()())"]
func separateParenGroups(parenString: String) -> [String] {
    let parenString = parenString.replacingOccurrences(of: " ", with: "")
    var result = [String]()
    var current = ""
    var stack = [String]()
    
    for char in parenString {
        if char == "(" {
            stack.append(current)
            current = ""
        } else if char == ")" {
            current = stack.removeLast() + current
        } else {
            current += String(char)
        }
    }
    
    for str in stack {
        result.append(str)
    }
    
    return result
}
```

func truncateNumber(number: Double) -> Double {
    return number - Double(Int(number))
}

func truncateNumber(number: Double) -> Double {
    return Double(Int(number))
}

func truncateNumber(number: Double) -> Double {
    return number.truncatingRemainder(dividingBy: 1)
}

func truncateNumber(number: Double) -> Double {
    return number.floor()
}

func truncateNumber(number: Double) -> Double {
    return number.rounded(.down)
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    return number - Double(Int(number))
}
```

### 解法二

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return Double(Int(number))
}
```

### 解法三

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return number.truncatingRemainder(dividingBy: 1)
}
```

### 解法四

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return number.floor()
}
```

### 解法五

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return number.rounded(.down)
}
```

### 解法六

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return number.floor()
}
```

### 解法七

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return number.truncatingRemainder(dividingBy: 1)
}
```

### 解法八

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return number.truncatingRemainder(dividingBy: 1)
}
```

### 解法九

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return number.truncatingRemainder(dividingBy: 1)
}
```

### 解法十

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always

func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer) + (number - Double(integer))
}

func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer) + (number - Double(integer))
}
```

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}
```

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}
```

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}
```

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}
```

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}
```

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}
```

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}
```

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}
```

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func tr

func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer) + (number - Double(integer))
}

func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer) + (number - Double(integer))
}
```

### 解法二

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}
```

### 解法三

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}
```

### 解法四

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}
```

### 解法五

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}
```

### 解法六

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}
```

### 解法七

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}
```

### 解法八

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}
```

### 解法九

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    return Double(integer)
}
```

### 解法十

```swift
// Given

func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    let decimal = number - integer
    return decimal
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    let decimal = number - integer
    return decimal
}
```

func truncateNumber(number: Double) -> Double {
    let integerPart = Int(number)
    let decimalPart = number - integerPart
    return decimalPart
}

func truncateNumber(number: Double) -> Double {
    let integerPart = Int(number)
    return Double(integerPart)
}

func truncateNumber(number: Double) -> Double {
    let integerPart = Int(number)
    let decimalPart = number - integerPart
    return decimalPart < 0.5 ? integerPart : integerPart + 1
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    let integerPart = Int(number)
    let decimalPart = number - integerPart
    return decimalPart
}
```

### 解法二：

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integerPart = Int(number)
    return Double(integerPart)
}
```

### 解法三：

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integerPart = Int(number)
    let decimalPart = number - integerPart
    return decimalPart < 0.5 ? integerPart : integerPart + 1
}
```

### 解法四：

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integerPart = Int(number)
    let decimalPart = number - integerPart
    return decimalPart < 0.5 ? integerPart : integerPart + 1
}
```

### 解法五：

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integerPart = Int(number)
    let decimalPart = number - integerPart
    return decimalPart < 0.5 ? integerPart : integerPart + 1
}
```

### 解法六：

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integerPart = Int(number)
    let decimalPart = number - integerPart
    return decimalPart < 0.5 ? integerPart : integerPart + 1
}
```

### 解法七：

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integerPart = Int(number)
    let decimalPart = number - integerPart
    return decimalPart < 0.5 ? integerPart : integerPart + 1
}
```

### 解法八：

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    let integerPart = Int(number)
    let decimalPart = number - integerPart
    return decimalPart < 0.

func truncateNumber(number: Double) -> Double {
    let integerPart = Int(number)
    let decimalPart = number - integerPart
    return decimalPart
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    let integerPart = Int(number)
    let decimalPart = number - integerPart
    return decimalPart
}
```

func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    let decimal = number - integer
    return decimal
}

func truncateNumber(number: Double) -> Int {
    let integer = Int(number)
    return integer
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    let integer = Int(number)
    let decimal = number - integer
    return decimal
}
```

### 解法二

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Int {
    let integer = Int(number)
    return integer
}
```

### 解法三

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Int {
    let integer = Int(number)
    return integer
}
```

### 解法四

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Int {
    let integer = Int(number)
    return integer
}
```

### 解法五

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Int {
    let integer = Int(number)
    return integer
}
```

### 解法六

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Int {
    let integer = Int(number)
    return integer
}
```

### 解法七

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Int {
    let integer = Int(number)
    return integer
}
```

### 解法八

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Int {
    let integer = Int(number)
    return integer
}
```

### 解法九

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Int {
    let integer = Int(number)
    return integer
}
```

### 解法十

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover

func truncateNumber(number: Double) -> Double {
    return number - Double(Int(number))
}

func truncateNumber(number: Double) -> Double {
    return Double(Int(number))
}

func truncateNumber(number: Double) -> Double {
    return number.truncatingRemainder(dividingBy: 1)
}

func truncateNumber(number: Double) -> Double {
    return number.floor()
}

func truncateNumber(number: Double) -> Double {
    return number.rounded(.down)
}

func truncateNumber(number: Double) -> Double {
    return number.rounded(.toNearest(0))
}

func truncateNumber(number: Double) -> Double {
    return number.rounded(.toNearest(1))
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    return number - Double(Int(number))
}
```

### 解法二

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return Double(Int(number))
}
```

### 解法三

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return number.truncatingRemainder(dividingBy: 1)
}
```

### 解法四

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return number.floor()
}
```

### 解法五

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return number.rounded(.down)
}
```

### 解法六

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return number.rounded(.toNearest(0))
}
```

### 解法七

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return number.rounded(.toNearest(1))
}
```

### 解法八

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return number.rounded(.toNearest(1))
}
```

### 解法九

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return number.rounded(.toNearest(1))
}
```

### 解法十

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
//

func truncateNumber(number: Double) -> Double {
    return Double(Int(number))
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    return Double(Int(number))
}
```

### 解法二

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return Double(Int(number))
}
```

### 解法三

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return Double(Int(number))
}
```

### 解法四

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return Double(Int(number))
}
```

### 解法五

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return Double(Int(number))
}
```

### 解法六

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return Double(Int(number))
}
```

### 解法七

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return Double(Int(number))
}
```

### 解法八

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return Double(Int(number))
}
```

### 解法九

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) -> Double {
    return Double(Int(number))
}
```

### 解法十

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the integer part of the number.
// truncateNumber(number: 3.5) == 3
func truncateNumber(number: Double) ->

func truncateNumber(number: Double) -> Double {
    return Double(Int(number))
}

```swift
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// truncateNumber(number: 3.5) == 0.5
func truncateNumber(number: Double) -> Double {
    return Double(Int(number))
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for op in operations {
        balance += op
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for op in operations {
        balance += op
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for op in operations {
        balance += op
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for op in operations {
        balance += op
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for op in operations {
        balance += op
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for op in operations {
        balance += op
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for op in operations {
        balance += op
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for op in operations {
        balance += op
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for op in operations {
        balance += op
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for op in operations {
        balance += op
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for op in operations {
        balance += op
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for op in operations {
        balance += op
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for operation in operations {
        balance += operation
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for op in operations {
        balance += op
        if balance < 0 {
            return true
        }
    }
    return false
}

```swift
// You're given an array of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// belowZero(operations: [1, 2, 3]) == false
// belowZero(operations: [1, 2, -4, 5]) == true
func belowZero(operations: [Int]) -> Bool {
    var balance = 0
    for op in operations {
        balance += op
        if balance < 0 {
            return true
        }
    }
    return false
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}

class Solution {
    func findMedianSortedArrays(_ nums1: [Int], _ nums2: [Int]) -> Double {
        let total = nums1.count + nums2.count
        let mid = total / 2
        let nums = nums1 + nums2
        nums.sort()
        if total % 2 == 0 {
            return Double(nums[mid - 1] + nums[mid]) / 2
        } else {
            return Double(nums[mid])
        }
    }
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 代码

```swift
class Solution {
    func findMedianSortedArrays(_ nums1: [Int], _ nums2: [Int]) -> Double {
        let total = nums1.count + nums2.count
        let mid = total / 2
        let nums = nums1 + nums2
        nums.sort()
        if total % 2 == 0 {
            return Double(nums[mid - 1] + nums[mid]) / 2
        } else {
            return Double(nums[mid])
        }
    }
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}

class Solution {
    func findMaxAverage(_ nums: [Int], _ k: Int) -> Int {
        var sum = 0
        for i in 0..<k {
            sum += nums[i]
        }
        var maxSum = sum
        for i in k..<nums.count {
            sum = sum - nums[i-k] + nums[i]
            maxSum = max(maxSum, sum)
        }
        return maxSum / k
    }
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 代码

```swift
class Solution {
    func findMaxAverage(_ nums: [Int], _ k: Int) -> Int {
        var sum = 0
        for i in 0..<k {
            sum += nums[i]
        }
        var maxSum = sum
        for i in k..<nums.count {
            sum = sum - nums[i-k] + nums[i]
            maxSum = max(maxSum, sum)
        }
        return maxSum / k
    }
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    return numbers.map { abs(median - $0) }.reduce(0, +) / Double(numbers.count)
}

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let quantile = numbers.sorted()[numbers.count / 4]
    return numbers.map { abs(quantile - $0) }.reduce(0, +) / Double(numbers.count)
}

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let quantile = numbers.sorted()[numbers.count / 8]
    return numbers.map { abs(quantile - $0) }.reduce(0, +) / Double(numbers.count)
}

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let quantile = numbers.sorted()[numbers.count * 3 / 4]
    return numbers.map { abs(quantile - $0) }.reduce(0, +) / Double(numbers.count)
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 解法二：中位数

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    return numbers.map { abs(median - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 解法三：分位数

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the 0.5-quantile of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (0.5-quantile in this case):
// MAD = average | x - x_0.5-quantile |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let quantile = numbers.sorted()[numbers.count / 4]
    return numbers.map { abs(quantile - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 解法四：分位数

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the 0.25-quantile of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (0.25-quantile in this case):
// MAD = average | x - x_0.25-quantile |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let quantile = numbers.sorted()[numbers.count / 8]
    return numbers.map { abs(quantile - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 解法五：分位数

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the 0.75-quantile of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (0.75-quantile in this case):
// MAD = average | x - x_0.75-quantile |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let quantile = numbers.sorted()[numbers.count * 3 / 4]
    return numbers.map { abs(quantile - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 解法六：分位数

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the 0.9-quantile of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (0.9-quantile in this case):
// MAD = average | x - x_0.9-quantile |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDev

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 解法二

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 解法三

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 解法四

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 解法五

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 解法六

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 解法七

```swift
//

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 代码

```swift
class Solution {
    func calculateMKAverage(_ m: Int, _ nums: [Int]) -> Int {
        guard m > 0 else {
            return 0
        }
        guard nums.count >= m else {
            return -1
        }
        let n = nums.count
        let k = m - 1
        let max = nums.max()!
        let min = nums.min()!
        let range = max - min + 1
        let total = (range + 1) * range / 2
        let sum = nums.reduce(0, +)
        let sumMinusMin = sum - min * n
        let sumMinusMinPlusRange = sumMinusMin + range * (n - 1)
        let sumMinusMinPlusRangeDivide = sumMinusMinPlusRange / n
        let sumMinusMinPlusRangeDividePlusOne = sumMinusMinPlusRangeDivide + 1
        let sumMinusMinPlusRangeDividePlusOneDivide = sumMinusMinPlusRangeDividePlusOne / range
        let sumMinusMinPlusRangeDividePlusOneDividePlusOne = sumMinusMinPlusRangeDividePlusOneDivide + 1
        let sumMinusMinPlusRangeDividePlusOneDividePlusOneDivide = sumMinusMinPlusRangeDividePlusOneDividePlusOne / range
        let sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOne = sumMinusMinPlusRangeDividePlusOneDividePlusOneDivide + 1
        let sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDivide = sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOne / range
        let sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDividePlusOne = sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDivide + 1
        let sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDividePlusOneDivide = sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDividePlusOne / range
        let sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOne = sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDividePlusOneDivide + 1
        let sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOneDivide = sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOne / range
        let sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOne = sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOneDivide + 1
        let sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOneDivide = sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOne / range
        let sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOne = sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOne / range
        let sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOneDivide = sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOne / range
        let sumMinusMinPlusRangeDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOneDividePlusOne = sumMinusMinPlusRangeDivide

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs( $0 - mean ) }.reduce(0, +) / Double(numbers.count)
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs( $0 - mean ) }.reduce(0, +) / Double(numbers.count)
}
```

### 代码

```swift
class Solution {
    func calculateMKAverage(_ m: Int, _ nums: [Int]) -> Int {
        guard m > 0 else {
            return 0
        }
        guard nums.count > m else {
            return -1
        }
        let n = nums.count
        let k = m - 1
        let total = nums.reduce(0, +)
        let mean = total / Double(n)
        let sum = nums.map { $0 - mean }.reduce(0, +)
        let min = sum / Double(n - k)
        let max = sum / Double(n - k + 1)
        let minIndex = nums.map { $0 - min }.reduce(0, +) / Double(n - k)
        let maxIndex = nums.map { $0 - max }.reduce(0, +) / Double(n - k + 1)
        let minIndex = Int(minIndex.rounded(.down))
        let maxIndex = Int(maxIndex.rounded(.up))
        let minValue = nums[minIndex]
        let maxValue = nums[maxIndex]
        let minIndex = nums.map { $0 - minValue }.reduce(0, +) / Double(n - k)
        let maxIndex = nums.map { $0 - maxValue }.reduce(0, +) / Double(n - k + 1)
        let minIndex = Int(minIndex.rounded(.down))
        let maxIndex = Int(maxIndex.rounded(.up))
        let minValue = nums[minIndex]
        let maxValue = nums[maxIndex]
        let minIndex = nums.map { $0 - minValue }.reduce(0, +) / Double(n - k)
        let maxIndex = nums.map { $0 - maxValue }.reduce(0, +) / Double(n - k + 1)
        let minIndex = Int(minIndex.rounded(.down))
        let maxIndex = Int(maxIndex.rounded(.up))
        let minValue = nums[minIndex]
        let maxValue = nums[maxIndex]
        let minIndex = nums.map { $0 - minValue }.reduce(0, +) / Double(n - k)
        let maxIndex = nums.map { $0 - maxValue }.reduce(0, +) / Double(n - k + 1)
        let minIndex = Int(minIndex.rounded(.down))
        let maxIndex = Int(maxIndex.rounded(.up))
        let minValue = nums[minIndex]
        let maxValue = nums[maxIndex]
        let minIndex = nums.map { $0 - minValue }.reduce(0, +) / Double(n - k)
        let maxIndex = nums.map { $0 - maxValue }.reduce(0, +) / Double(n - k + 1)
        let minIndex = Int(minIndex.rounded(.down))
        let maxIndex = Int(maxIndex.rounded(.up))
        let minValue = nums[minIndex]
        let maxValue = nums[maxIndex]
        let minIndex = nums.map { $0 - minValue }.reduce(0, +) / Double(n - k)
        let maxIndex = nums.map { $0 - maxValue }.reduce(0, +) / Double(n - k + 1)
        let minIndex = Int(minIndex.rounded(.down))
        let maxIndex = Int(maxIndex.rounded(.up))
        let minValue = nums[minIndex]
        let maxValue = nums[maxIndex]
        let minIndex = nums.map { $0 - minValue }.reduce(0, +) / Double(n - k)
        let maxIndex = nums.map { $0 - maxValue

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}

class Solution {
    func findMaxAverage(_ nums: [Int], _ k: Int) -> Int {
        var sum = 0
        for i in 0..<k {
            sum += nums[i]
        }
        var maxSum = sum
        for i in k..<nums.count {
            sum = sum - nums[i - k] + nums[i]
            maxSum = max(maxSum, sum)
        }
        return maxSum / k
    }
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 代码

```swift
class Solution {
    func findMaxAverage(_ nums: [Int], _ k: Int) -> Int {
        var sum = 0
        for i in 0..<k {
            sum += nums[i]
        }
        var maxSum = sum
        for i in k..<nums.count {
            sum = sum - nums[i - k] + nums[i]
            maxSum = max(maxSum, sum)
        }
        return maxSum / k
    }
}
```

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    return numbers.map { abs(median - $0) }.reduce(0, +) / Double(numbers.count)
}

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let bucketSize = 10
    let bucketCount = Int(ceil(Double(numbers.count) / Double(bucketSize)))
    var buckets = [Int]()
    for i in 0..<bucketCount {
        buckets.append(0)
    }
    for number in numbers {
        let bucketIndex = Int(floor(Double(number) / Double(bucketSize)))
        buckets[bucketIndex] += 1
    }
    var sum = 0.0
    for (index, bucket) in buckets.enumerated() {
        let bucketStart = Double(index) * Double(bucketSize)
        let bucketEnd = Double(index + 1) * Double(bucketSize)
        let bucketMean = (bucketStart + bucketEnd) / 2
        let bucketAbsoluteDifference = bucket.map { abs(bucketMean - Double($0)) }.reduce(0, +)
        sum += Double(bucketAbsoluteDifference) * Double(bucket.count)
    }
    return sum / Double(numbers.count)
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 解法二：中位数

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    return numbers.map { abs(median - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 解法三：分桶

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let bucketSize = 10
    let bucketCount = Int(ceil(Double(numbers.count) / Double(bucketSize)))
    var buckets = [Int]()
    for i in 0..<bucketCount {
        buckets.append(0)
    }
    for number in numbers {
        let bucketIndex = Int(floor(Double(number) / Double(bucketSize)))
        buckets[bucketIndex] += 1
    }
    var sum = 0.0
    for (index, bucket) in buckets.enumerated() {
        let bucketStart = Double(index) * Double(bucketSize)
        let bucketEnd = Double(index + 1) * Double(bucketSize)
        let bucketMean = (bucketStart + bucketEnd) / 2
        let bucketAbsoluteDifference = bucket.map { abs(bucketMean - Double($0)) }.reduce(0, +)
        sum += Double(bucketAbsoluteDifference) * Double(bucket.count)
    }
    return sum / Double(numbers.count)
}
```

### 解法四：分桶 + 滑动窗口

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let bucketSize = 10
    let bucketCount = Int(ceil(Double(numbers.count) / Double(bucketSize)))
    var buckets = [Int]()
    for i in 0..<bucketCount {
        buckets.append(0)
    }
    for number in numbers {
        let bucketIndex = Int(floor(Double(number) / Double(bucketSize)))
        buckets[bucketIndex] += 1
    }
    var sum = 0.0
    var windowStart = 0
    var windowEnd = 0
    while windowEnd < numbers.count {
        let bucketStart = Double(windowStart)
        let bucketEnd = Double(windowEnd)
        let bucketMean = (bucketStart + bucketEnd) / 2
        let bucketAbsoluteDifference = buckets[windowStart].map { abs(bucketMean - Double($0)) }.reduce(0, +)
        sum +=

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    return numbers.map { abs(median - $0) }.reduce(0, +) / Double(numbers.count)
}

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let bucketSize = 10
    let bucketCount = Int(ceil(Double(numbers.count) / Double(bucketSize)))
    var buckets = [Int]()
    for _ in 0..<bucketCount { buckets.append(0) }
    for number in numbers {
        let bucketIndex = Int(ceil(Double(number) / Double(bucketSize)))
        buckets[bucketIndex] += 1
    }
    var sum = 0.0
    for (index, bucket) in buckets.enumerated() {
        let bucketMean = Double(index) * bucketSize + Double(index) * bucketSize / 2
        let bucketAbsoluteDifference = Double(bucket) * bucketSize / 2
        sum += bucketAbsoluteDifference
    }
    return sum / Double(numbers.count)
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.map { abs(mean - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 解法二：中位数

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    return numbers.map { abs(median - $0) }.reduce(0, +) / Double(numbers.count)
}
```

### 解法三：分桶

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let bucketSize = 10
    let bucketCount = Int(ceil(Double(numbers.count) / Double(bucketSize)))
    var buckets = [Int]()
    for _ in 0..<bucketCount { buckets.append(0) }
    for number in numbers {
        let bucketIndex = Int(ceil(Double(number) / Double(bucketSize)))
        buckets[bucketIndex] += 1
    }
    var sum = 0.0
    for (index, bucket) in buckets.enumerated() {
        let bucketMean = Double(index) * bucketSize + Double(index) * bucketSize / 2
        let bucketAbsoluteDifference = Double(bucket) * bucketSize / 2
        sum += bucketAbsoluteDifference
    }
    return sum / Double(numbers.count)
}
```

### 解法四：分桶 + 滑动窗口

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let bucketSize = 10
    let bucketCount = Int(ceil(Double(numbers.count) / Double(bucketSize)))
    var buckets = [Int]()
    for _ in 0..<bucketCount { buckets.append(0) }
    for number in numbers {
        let bucketIndex = Int(ceil(Double(number) / Double(bucketSize)))
        buckets[bucketIndex] += 1
    }
    var sum = 0.0
    var windowSum = 0.0
    var windowStart = 0
    for (index, bucket) in buckets.enumerated() {
        let bucketMean = Double(index) * bucketSize + Double(index) * bucketSize / 2
        let bucketAbsoluteDifference = Double(bucket) * bucketSize / 2
        sum += bucketAbsoluteDifference
        if index - windowStart >= 2 {
            let windowMean = windowSum / Double(index - windowStart)
            let windowAbsoluteDifference = Double(index - windowStart) * bucketSize / 2
            sum -= windowAbsoluteDifference
            windowSum -= numbers[windowStart]
            windowStart += 1
        }

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.reduce(0, { abs($0 - mean) + abs($1 - mean) }) / Double(numbers.count)
}

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    return numbers.reduce(0, { abs($0 - median) + abs($1 - median) }) / Double(numbers.count)
}

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let buckets = numbers.reduce(into: [Int: [Double]]()) {
        let bucket = $0[0] ?? 0
        let count = $0[1] ?? 0
        $0[0] = bucket + 1
        $0[1] = count + 1
        $0[bucket] = ($0[bucket] ?? []) + [$1]
    }
    let mean = buckets.reduce(0, { $0 + $1.value.reduce(0, +) / Double($1.value.count) })
    return buckets.reduce(0, { $0 + $1.value.reduce(0, { abs($0 - mean) + abs($1 - mean) }) }) / Double(numbers.count)
}

func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let buckets = numbers.reduce(into: [Int: [Double]]()) {
        let bucket = $0[0] ?? 0
        let count = $0[1] ?? 0
        $0[0] = bucket + 1
        $0[1] = count + 1
        $0[bucket] = ($0[bucket] ?? []) + [$1]
    }
    let median = buckets.reduce(0, { $0 + $1.value.reduce(0, +) / Double($1.value.count) })
    return buckets.reduce(0, { $0 + $1.value.reduce(0, { abs($0 - median) + abs($1 - median) }) }) / Double(numbers.count)
}

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let mean = numbers.reduce(0, +) / Double(numbers.count)
    return numbers.reduce(0, { abs($0 - mean) + abs($1 - mean) }) / Double(numbers.count)
}
```

### 解法二：中位数

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let median = numbers.sorted()[numbers.count / 2]
    return numbers.reduce(0, { abs($0 - median) + abs($1 - median) }) / Double(numbers.count)
}
```

### 解法三：分桶

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let buckets = numbers.reduce(into: [Int: [Double]]()) {
        let bucket = $0[0] ?? 0
        let count = $0[1] ?? 0
        $0[0] = bucket + 1
        $0[1] = count + 1
        $0[bucket] = ($0[bucket] ?? []) + [$1]
    }
    let mean = buckets.reduce(0, { $0 + $1.value.reduce(0, +) / Double($1.value.count) })
    return buckets.reduce(0, { $0 + $1.value.reduce(0, { abs($0 - mean) + abs($1 - mean) }) }) / Double(numbers.count)
}
```

### 解法四：分桶

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the median of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (median in this case):
// MAD = average | x - x_median |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0
func meanAbsoluteDeviation(numbers: [Double]) -> Double {
    let buckets = numbers.reduce(into: [Int: [Double]]()) {
        let bucket = $0[0] ?? 0
        let count = $0[1] ?? 0
        $0[0] = bucket + 1
        $0[1] = count + 1
        $0[bucket] = ($0[bucket] ?? []) + [$1]
    }
    let median = buckets.reduce(0, { $0 + $1.value.reduce(0, +) / Double($1.value.count) })
    return buckets.reduce(0, { $0 + $1.value.reduce(0, { abs($0 - median) + abs($1 - median) }) }) / Double(numbers.count)
}
```

### 解法五：分桶

```swift
// For a given array of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// meanAbsoluteDeviation(numbers: [1.0, 2.0, 3.0, 4.0]) == 1.0

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    if numbers.count == 1 {
        return numbers
    }
    return [numbers[0], delimeter] + intersperse(numbers: numbers[1..<numbers.count], delimeter: delimeter)
}

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    if numbers.count == 1 {
        return numbers
    }
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}
```

### 解法二：递归

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    if numbers.count == 1 {
        return numbers
    }
    return [numbers[0], delimeter] + intersperse(numbers: numbers[1..<numbers.count], delimeter: delimeter)
}
```

### 解法三：迭代

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}
```

### 解法四：递归 + 迭代

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    if numbers.count == 1 {
        return numbers
    }
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}
```

### 解法五：迭代 + 递归

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}
```

### 解法六：迭代 + 递归 + 迭代

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    if numbers.count == 1 {
        return numbers
    }
    var result = [Int]()
    result.append(numbers[0])
    for number in numbers[1..<numbers.count] {
        result.append(delimeter)
        result.append(number)
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}
```

### 解法二：递归

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    if numbers.count == 1 {
        return numbers
    }
    var result = [Int]()
    result.append(numbers[0])
    for number in numbers[1..<numbers.count] {
        result.append(delimeter)
        result.append(number)
    }
    return result
}
```

### 解法三：迭代

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}
```

### 解法四：递归

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    if numbers.count == 1 {
        return numbers
    }
    var result = [Int]()
    result.append(numbers[0])
    for number in numbers[1..<numbers.count] {
        result.append(delimeter)
        result.append(number)
    }
    return result
}
```

### 解法五：迭代

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    if numbers.count == 1 {
        return numbers
    }
    return [numbers[0], delimeter] + intersperse(numbers: numbers[1..<numbers.count], delimeter: delimeter)
}

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    if numbers.count == 1 {
        return numbers
    }
    var stack = [Int]()
    stack.append(numbers[0])
    for number in numbers[1..<numbers.count] {
        stack.append(delimeter)
        stack.append(number)
    }
    return stack
}

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    var i = 0
    while i < numbers.count {
        result.append(numbers[i])
        if i < numbers.count - 1 {
            result.append(delimeter)
        }
        i += 1
    }
    return result
}

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    var stack = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
        stack.append(number)
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}
```

### 解法二：递归

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    if numbers.count == 1 {
        return numbers
    }
    return [numbers[0], delimeter] + intersperse(numbers: numbers[1..<numbers.count], delimeter: delimeter)
}
```

### 解法三：递归 + 栈

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    if numbers.count == 1 {
        return numbers
    }
    var stack = [Int]()
    stack.append(numbers[0])
    for number in numbers[1..<numbers.count] {
        stack.append(delimeter)
        stack.append(number)
    }
    return stack
}
```

### 解法四：迭代

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    var i = 0
    while i < numbers.count {
        result.append(numbers[i])
        if i < numbers.count - 1 {
            result.append(delimeter)
        }
        i += 1
    }
    return result
}
```

### 解法五：迭代 + 栈

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    var stack = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
        stack.append(number)
    }
    return result
}
```

### 解法六：迭代 + 数组

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func inters

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    guard numbers.count > 0 else {
        return []
    }
    var result = [Int]()
    for index in 0..<numbers.count {
        result.append(numbers[index])
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}

class Solution {
    func reverseWords(_ s: String) -> String {
        let array = s.split(separator: " ")
        var result = [String]()
        for str in array {
            if str.count > 0 {
                result.append(String(str.reversed()))
            }
        }
        return result.joined(separator: " ")
    }
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    guard numbers.count > 0 else {
        return []
    }
    var result = [Int]()
    for index in 0..<numbers.count {
        result.append(numbers[index])
        if index < numbers.count - 1 {
            result.append(delimeter)
        }
    }
    return result
}
```

### 解题思路

### 代码

```swift
class Solution {
    func reverseWords(_ s: String) -> String {
        let array = s.split(separator: " ")
        var result = [String]()
        for str in array {
            if str.count > 0 {
                result.append(String(str.reversed()))
            }
        }
        return result.joined(separator: " ")
    }
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    if numbers.isEmpty {
        return []
    }
    let first = numbers.removeFirst()
    return [first] + intersperse(numbers: numbers, delimeter: delimeter) + [delimeter]
}

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    var index = 0
    while index < numbers.count {
        result.append(numbers[index])
        if index > 0 {
            result.append(delimeter)
        }
        index += 1
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}
```

### 解法二：递归

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    if numbers.isEmpty {
        return []
    }
    let first = numbers.removeFirst()
    return [first] + intersperse(numbers: numbers, delimeter: delimeter) + [delimeter]
}
```

### 解法三：迭代

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    var index = 0
    while index < numbers.count {
        result.append(numbers[index])
        if index > 0 {
            result.append(delimeter)
        }
        index += 1
    }
    return result
}
```

### 解法四：递归 + 迭代

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    if numbers.isEmpty {
        return []
    }
    let first = numbers.removeFirst()
    return [first] + intersperse(numbers: numbers, delimeter: delimeter) + [delimeter]
}
```

### 解法五：递归 + 迭代

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    if numbers.isEmpty {
        return []
    }
    let first = numbers.removeFirst()
    return [first] + intersperse(numbers: numbers, delimeter: delimeter) + [delimeter]
}
```

### 解法六：迭代

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    var index = 0
    while index < numbers.count {
        result.append(numbers[index])
        if index > 0 {
            result.append(delimeter)
        }
        index += 1
    

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 && result.last! == delimeter {
            result.append(delimeter)
        }
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 && result.last! == delimeter {
            result.append(delimeter)
        }
    }
    return result
}
```

func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}

```swift
// Insert a number 'delimeter' between every two consecutive elements of input array `numbers'
// intersperse(numbers: [] as [Int], delimeter: 4) == [] as [Int]
// intersperse(numbers: [1, 2, 3], delimeter: 4) == [1, 4, 2, 4, 3]
func intersperse(numbers: [Int], delimeter: Int) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        if result.count > 0 {
            result.append(delimeter)
        }
    }
    return result
}
```

func parseNestedParens(parenString: String) -> [Int] {
    let parens = parenString.map { $0 == "(" ? 1 : -1 }
    var maxLevel = 0
    var levels = [Int]()
    for i in 0..<parens.count {
        let level = parens[i] + maxLevel
        if level < 0 {
            maxLevel = 0
        } else {
            maxLevel = max(maxLevel, level)
        }
        levels.append(maxLevel)
    }
    return levels
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    let parens = parenString.map { $0 == "(" ? 1 : -1 }
    var maxLevel = 0
    var levels = [Int]()
    for i in 0..<parens.count {
        let level = parens[i] + maxLevel
        if level < 0 {
            maxLevel = 0
        } else {
            maxLevel = max(maxLevel, level)
        }
        levels.append(maxLevel)
    }
    return levels
}
```

func parseNestedParens(parenString: String) -> [Int] {
    var result = [Int]()
    var maxDepth = 0
    var depth = 0
    for char in parenString {
        switch char {
        case "(":
            depth += 1
            if depth > maxDepth {
                maxDepth = depth
            }
        case ")":
            depth -= 1
        default:
            break
        }
    }
    
    for _ in parenString {
        result.append(maxDepth)
    }
    return result
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    var result = [Int]()
    var maxDepth = 0
    var depth = 0
    for char in parenString {
        switch char {
        case "(":
            depth += 1
            if depth > maxDepth {
                maxDepth = depth
            }
        case ")":
            depth -= 1
        default:
            break
        }
    }
    
    for _ in parenString {
        result.append(maxDepth)
    }
    return result
}
```

func parseNestedParens(parenString: String) -> [Int] {
    var result = [Int]()
    var maxLevel = 0
    var level = 0
    for char in parenString {
        if char == "(" {
            level += 1
            if level > maxLevel {
                maxLevel = level
            }
        } else if char == ")" {
            level -= 1
        }
        result.append(maxLevel)
    }
    return result
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    var result = [Int]()
    var maxLevel = 0
    var level = 0
    for char in parenString {
        if char == "(" {
            level += 1
            if level > maxLevel {
                maxLevel = level
            }
        } else if char == ")" {
            level -= 1
        }
        result.append(maxLevel)
    }
    return result
}
```

func parseNestedParens(parenString: String) -> [Int] {
    let parenString = parenString.map { String($0) }
    var maxLevel = 0
    var maxLevels = [Int]()
    for char in parenString {
        if char == "(" {
            maxLevel += 1
            maxLevels.append(maxLevel)
        } else {
            maxLevel -= 1
        }
    }
    return maxLevels
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    let parenString = parenString.map { String($0) }
    var maxLevel = 0
    var maxLevels = [Int]()
    for char in parenString {
        if char == "(" {
            maxLevel += 1
            maxLevels.append(maxLevel)
        } else {
            maxLevel -= 1
        }
    }
    return maxLevels
}
```

func parseNestedParens(parenString: String) -> [Int] {
    var maxDepth = 0
    var result = [Int]()
    var currentDepth = 0
    for char in parenString {
        if char == "(" {
            currentDepth += 1
            if currentDepth > maxDepth {
                maxDepth = currentDepth
            }
        } else if char == ")" {
            currentDepth -= 1
        }
        result.append(maxDepth)
    }
    return result
}

class Solution {
    func maxDepthAfterSplit(_ seq: String) -> [Int] {
        var result = [Int]()
        var currentDepth = 0
        for char in seq {
            if char == "(" {
                currentDepth += 1
                result.append(currentDepth % 2)
            } else {
                result.append(currentDepth % 2)
                currentDepth -= 1
            }
        }
        return result
    }
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    var maxDepth = 0
    var result = [Int]()
    var currentDepth = 0
    for char in parenString {
        if char == "(" {
            currentDepth += 1
            if currentDepth > maxDepth {
                maxDepth = currentDepth
            }
        } else if char == ")" {
            currentDepth -= 1
        }
        result.append(maxDepth)
    }
    return result
}
```

### 解题思路

### 代码

```swift
class Solution {
    func maxDepthAfterSplit(_ seq: String) -> [Int] {
        var result = [Int]()
        var currentDepth = 0
        for char in seq {
            if char == "(" {
                currentDepth += 1
                result.append(currentDepth % 2)
            } else {
                result.append(currentDepth % 2)
                currentDepth -= 1
            }
        }
        return result
    }
}
```

func parseNestedParens(parenString: String) -> [Int] {
    let parens = parenString.map { $0 == "(" ? 1 : -1 }
    var maxDepth = 0
    var depth = 0
    var result = [Int]()
    for p in parens {
        depth += p
        if depth > maxDepth {
            maxDepth = depth
        }
        if p == 1 {
            result.append(maxDepth)
        }
    }
    return result
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    let parens = parenString.map { $0 == "(" ? 1 : -1 }
    var maxDepth = 0
    var depth = 0
    var result = [Int]()
    for p in parens {
        depth += p
        if depth > maxDepth {
            maxDepth = depth
        }
        if p == 1 {
            result.append(maxDepth)
        }
    }
    return result
}
```

func parseNestedParens(parenString: String) -> [Int] {
    var result = [Int]()
    var maxDepth = 0
    var depth = 0
    for c in parenString {
        if c == "(" {
            depth += 1
            if depth > maxDepth {
                maxDepth = depth
            }
        } else if c == ")" {
            depth -= 1
        }
        result.append(maxDepth)
    }
    return result
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    var result = [Int]()
    var maxDepth = 0
    var depth = 0
    for c in parenString {
        if c == "(" {
            depth += 1
            if depth > maxDepth {
                maxDepth = depth
            }
        } else if c == ")" {
            depth -= 1
        }
        result.append(maxDepth)
    }
    return result
}
```

func parseNestedParens(parenString: String) -> [Int] {
    let parenString = parenString.replacingOccurrences(of: " ", with: "")
    var result = [Int]()
    var maxDepth = 0
    var depth = 0
    for char in parenString {
        if char == "(" {
            depth += 1
            if depth > maxDepth {
                maxDepth = depth
            }
        } else if char == ")" {
            depth -= 1
        }
    }
    for _ in 0..<maxDepth {
        result.append(maxDepth)
    }
    return result
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    let parenString = parenString.replacingOccurrences(of: " ", with: "")
    var result = [Int]()
    var maxDepth = 0
    var depth = 0
    for char in parenString {
        if char == "(" {
            depth += 1
            if depth > maxDepth {
                maxDepth = depth
            }
        } else if char == ")" {
            depth -= 1
        }
    }
    for _ in 0..<maxDepth {
        result.append(maxDepth)
    }
    return result
}
```

func parseNestedParens(parenString: String) -> [Int] {
    var result = [Int]()
    var maxDepth = 0
    var depth = 0
    for char in parenString {
        switch char {
        case "(":
            depth += 1
            if depth > maxDepth {
                maxDepth = depth
            }
        case ")":
            depth -= 1
        default:
            break
        }
    }
    
    for _ in parenString {
        result.append(maxDepth)
    }
    return result
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    var result = [Int]()
    var maxDepth = 0
    var depth = 0
    for char in parenString {
        switch char {
        case "(":
            depth += 1
            if depth > maxDepth {
                maxDepth = depth
            }
        case ")":
            depth -= 1
        default:
            break
        }
    }
    
    for _ in parenString {
        result.append(maxDepth)
    }
    return result
}
```

func parseNestedParens(parenString: String) -> [Int] {
    let parenString = parenString.replacingOccurrences(of: " ", with: "")
    var result = [Int]()
    var maxDepth = 0
    var depth = 0
    for char in parenString {
        if char == "(" {
            depth += 1
        } else {
            depth -= 1
        }
        if depth > maxDepth {
            maxDepth = depth
        }
        if depth == 0 {
            result.append(maxDepth)
        }
    }
    return result
}

```swift
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// parseNestedParens(parenString: "(()()) ((())) () ((())()())") == [2, 3, 1, 3]
func parseNestedParens(parenString: String) -> [Int] {
    let parenString = parenString.replacingOccurrences(of: " ", with: "")
    var result = [Int]()
    var maxDepth = 0
    var depth = 0
    for char in parenString {
        if char == "(" {
            depth += 1
        } else {
            depth -= 1
        }
        if depth > maxDepth {
            maxDepth = depth
        }
        if depth == 0 {
            result.append(maxDepth)
        }
    }
    return result
}
```

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}

func mapToStrings(strings: [String]) -> [String] {
    return strings.map { String($0) }
}

func mapToStrings(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }.map { String($0) }
}

func mapToStrings(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }.reduce([], +)
}

func mapToStrings(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }.reduce([], +).map { String($0) }
}

func mapToStrings(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }.reduce([], +).map { String($0) }.filter { $0.contains(substring) }
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 2. 2-way-map

```swift
// Map an input array of strings to another array of strings
// mapToStrings(strings: [] as [String]) == [] as [String]
// mapToStrings(strings: ["abc", "bacd", "cde", "array"]) == ["abc", "bacd", "cde", "array"]
func mapToStrings(strings: [String]) -> [String] {
    return strings.map { String($0) }
}
```

### 3. 2-way-map-with-filter

```swift
// Map an input array of strings to another array of strings, only for ones that contain given substring
// mapToStrings(strings: [] as [String], substring: "a") == [] as [String]
// mapToStrings(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func mapToStrings(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }.map { String($0) }
}
```

### 4. 2-way-map-with-filter-and-reduce

```swift
// Map an input array of strings to another array of strings, only for ones that contain given substring
// mapToStrings(strings: [] as [String], substring: "a") == [] as [String]
// mapToStrings(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func mapToStrings(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }.reduce([], +)
}
```

### 5. 2-way-map-with-filter-and-reduce-and-map

```swift
// Map an input array of strings to another array of strings, only for ones that contain given substring
// mapToStrings(strings: [] as [String], substring: "a") == [] as [String]
// mapToStrings(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func mapToStrings(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }.reduce([], +).map { String($0) }
}
```

### 6. 2-way-map-with-filter-and-reduce-and-map-with-filter

```swift
// Map an input array of strings to another array of strings, only for ones that contain given substring
// mapToStrings(strings: [] as [String], substring: "a") == [] as [String]
// mapToStrings(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func mapToStrings(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }.reduce([], +).map { String($0) }.filter { $0.contains(substring) }
}
```

### 7. 2-way-map-with-filter-and-reduce-and-map-with-filter-and-map

```swift
// Map an input array of strings to another array of strings, only for ones that contain given substring
// mapToStrings(strings: [] as [String], substring: "a") == [] as [String]
// mapToStrings(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func mapToStrings(strings: [String

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}

func mapToStrings(strings: [String]) -> [String] {
    return strings.map { String($0) }
}

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { !$0.contains(substring) }
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 2. 2-way map

```swift
// Map an input array of strings to another array of strings
// mapToStrings(strings: [] as [String]) == [] as [String]
// mapToStrings(strings: ["abc", "bacd", "cde", "array"]) == ["abc", "bacd", "cde", "array"]
func mapToStrings(strings: [String]) -> [String] {
    return strings.map { String($0) }
}
```

### 3. 2-way filter

```swift
// Filter an input array of strings only for ones that don't contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["bcd", "cde", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { !$0.contains(substring) }
}
```

### 4. 2-way filter

```swift
// Filter an input array of strings only for ones that don't contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["bcd", "cde", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { !$0.contains(substring) }
}
```

### 5. 2-way map

```swift
// Map an input array of strings to another array of strings
// mapToStrings(strings: [] as [String]) == [] as [String]
// mapToStrings(strings: ["abc", "bacd", "cde", "array"]) == ["abc", "bacd", "cde", "array"]
func mapToStrings(strings: [String]) -> [String] {
    return strings.map { String($0) }
}
```

### 6. 2-way map

```swift
// Map an input array of strings to another array of strings
// mapToStrings(strings: [] as [String]) == [] as [String]
// mapToStrings(strings: ["abc", "bacd", "cde", "array"]) == ["abc", "bacd", "cde", "array"]
func mapToStrings(strings: [String]) -> [String] {
    return strings.map { String($0) }
}
```

### 7. 2-way map

```swift
// Map an input array of strings to another array of strings
// mapToStrings(strings: [] as [String]) == [] as [String]
// mapToStrings(strings: ["abc", "bacd", "cde", "array"]) == ["abc", "bacd", "cde", "array"]
func mapToStrings(strings: [String]) -> [String] {
    return strings.map { String($0) }
}
```

### 8. 2-way map

```swift
// Map an input array of strings to another array of strings
// mapToStrings(strings: [] as [String]) == [] as [String]
// mapToStrings(strings: ["abc", "bacd", "cde", "array"]) == ["abc", "bacd", "cde", "array"]
func mapToStrings(strings: [String]) -> [String] {
    return strings.map { String($0) }
}
```

### 9. 2-way map

```swift
// Map an input array of strings to another array of strings
// mapToStrings(strings: [] as [String]) ==

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 2. 过滤器

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 3. 过滤器

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 4. 过滤器

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 5. 过滤器

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 6. 过滤器

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 7. 过滤器

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 8. 过滤器

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}

func filterEmptyStrings(strings: [String]) -> [String] {
    return strings.filter { $0.isEmpty == false }
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 2.2.2. 过滤空字符串

```swift
// Filter an input array of strings only for ones that are not empty
// filterEmptyStrings(strings: [] as [String]) == [] as [String]
// filterEmptyStrings(strings: ["", "abc", "bacd", "", "cde", "array"]) == ["abc", "bacd", "cde", "array"]
func filterEmptyStrings(strings: [String]) -> [String] {
    return strings.filter { $0.isEmpty == false }
}
```

### 2.2.3. 过滤空字符串

```swift
// Filter an input array of strings only for ones that are not empty
// filterEmptyStrings(strings: [] as [String]) == [] as [String]
// filterEmptyStrings(strings: ["", "abc", "bacd", "", "cde", "array"]) == ["abc", "bacd", "cde", "array"]
func filterEmptyStrings(strings: [String]) -> [String] {
    return strings.filter { $0.isEmpty == false }
}
```

### 2.2.4. 过滤空字符串

```swift
// Filter an input array of strings only for ones that are not empty
// filterEmptyStrings(strings: [] as [String]) == [] as [String]
// filterEmptyStrings(strings: ["", "abc", "bacd", "", "cde", "array"]) == ["abc", "bacd", "cde", "array"]
func filterEmptyStrings(strings: [String]) -> [String] {
    return strings.filter { $0.isEmpty == false }
}
```

### 2.2.5. 过滤空字符串

```swift
// Filter an input array of strings only for ones that are not empty
// filterEmptyStrings(strings: [] as [String]) == [] as [String]
// filterEmptyStrings(strings: ["", "abc", "bacd", "", "cde", "array"]) == ["abc", "bacd", "cde", "array"]
func filterEmptyStrings(strings: [String]) -> [String] {
    return strings.filter { $0.isEmpty == false }
}
```

### 2.2.6. 过滤空字符串

```swift
// Filter an input array of strings only for ones that are not empty
// filterEmptyStrings(strings: [] as [String]) == [] as [String]
// filterEmptyStrings(strings: ["", "abc", "bacd", "", "cde", "array"]) == ["abc", "bacd", "cde", "array"]
func filterEmptyStrings(strings: [String]) -> [String] {
    return strings.filter { $0.isEmpty == false }
}
```

### 2.2.7. 过滤空字符串

```swift
// Filter an input array of strings only for ones that are not empty
// filterEmptyStrings(strings: [] as [String]) == [] as [String]
// filterEmptyStrings(strings: ["", "abc", "bacd", "", "cde", "array"]) == ["abc", "bacd", "cde", "array"]
func filterEmptyStrings(strings: [String]) -> [String] {
    return strings.filter { $0.isEmpty == false }
}
```

### 2.2.8. 过滤空字符串

```swift
// Filter an input array of strings only for ones that are not empty
// filterEmptyStrings(strings: [] as [String]) == [] as [String]
// filterEmptyStrings(strings: ["", "abc", "bacd", "", "cde", "array"]) == ["abc", "bacd", "cde", "array"]
func filterEmptyStrings(strings: [String]) -> [String] {
    return strings.filter { $0.isEmpty == false }
}
```

### 2.2.

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 2. 过滤器

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 3. 过滤器

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 4. 过滤器

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 5. 过滤器

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 6. 过滤器

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 7. 过滤器

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 8. 过滤器

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}

func sortByLength(strings: [String]) -> [String] {
    return strings.sorted { $0.count > $1.count }
}

func reverseStrings(strings: [String]) -> [String] {
    return strings.reversed()
}

func concatenateStrings(strings: [String]) -> String {
    return strings.joined()
}

func splitStrings(strings: [String], separator: String) -> [String] {
    return strings.split(separator: separator)
}

func replaceAllSubstrings(strings: [String], old: String, new: String) -> [String] {
    return strings.map { $0.replacingOccurrences(of: old, with: new) }
}

func containsSubstring(strings: [String], substring: String) -> Bool {
    return strings.contains(substring)
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 2. 字符串排序

```swift
// Sort an array of strings by their length
// sortByLength(strings: [] as [String]) == [] as [String]
// sortByLength(strings: ["abc", "bacd", "cde", "array"]) == ["array", "abc", "bacd", "cde"]
func sortByLength(strings: [String]) -> [String] {
    return strings.sorted { $0.count > $1.count }
}
```

### 3. 字符串反转

```swift
// Reverse an array of strings
// reverseStrings(strings: [] as [String]) == [] as [String]
// reverseStrings(strings: ["abc", "bacd", "cde", "array"]) == ["array", "cde", "bacd", "abc"]
func reverseStrings(strings: [String]) -> [String] {
    return strings.reversed()
}
```

### 4. 字符串拼接

```swift
// Concatenate an array of strings into a single string
// concatenateStrings(strings: [] as [String]) == ""
// concatenateStrings(strings: ["abc", "bacd", "cde", "array"]) == "abc bacd cde array"
func concatenateStrings(strings: [String]) -> String {
    return strings.joined()
}
```

### 5. 字符串分割

```swift
// Split an array of strings into an array of substrings by a given separator
// splitStrings(strings: [] as [String], separator: "") == [] as [String]
// splitStrings(strings: ["abc", "bacd", "cde", "array"], separator: " ") == ["abc", "bacd", "cde", "array"]
// splitStrings(strings: ["abc", "bacd", "cde", "array"], separator: "d") == ["abc", "bac", "cde", "array"]
func splitStrings(strings: [String], separator: String) -> [String] {
    return strings.split(separator: separator)
}
```

### 6. 字符串替换

```swift
// Replace all instances of a given substring in an array of strings with a new substring
// replaceAllSubstrings(strings: [] as [String], old: "", new: "") == [] as [String]
// replaceAllSubstrings(strings: ["abc", "bacd", "cde", "array"], old: "a", new: "A") == ["Abc", "Bacd", "Cde", "Array"]
func replaceAllSubstrings(strings: [String], old: String, new: String) -> [String] {
    return strings.map { $0.replacingOccurrences(of: old, with: new) }
}
```

### 7. 字符串匹配

```swift
// Check if an array of strings contains a given substring
// containsSubstring(strings: [] as [String], substring: "") == false
// containsSubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == true
func containsSubstring(strings: [String], substring: String) -> Bool {
    return strings.contains(substring)
}
```

### 8. 字符串匹配

```swift
// Check if an array of strings contains a given substring
// containsSubstring(strings: [] as [String], substring: "") == false
// containsSubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == true
func containsSubstring(strings: [String], substring: String) -> Bool {
    return strings.contains(substring)
}
```

### 9. 字符串匹配

```swift
// Check if an array of

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2.

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 3. 数组中出现次数最多的元素

```swift
// Find the most frequent element in an array
// mostFrequent(numbers: []) == nil
// mostFrequent(numbers: [1, 2, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}

func joinStrings(strings: [String]) -> String {
    return strings.joined(separator: " ")
}

func splitString(string: String) -> [Character] {
    return Array(string)
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 2. 字符串数组转成字符串

```swift
// Convert an array of strings to a single string
// joinStrings(strings: [] as [String]) == ""
// joinStrings(strings: ["abc", "bacd", "cde", "array"]) == "abc bacd cde array"
func joinStrings(strings: [String]) -> String {
    return strings.joined(separator: " ")
}
```

### 3. 字符串数组转成字符串数组

```swift
// Convert an array of strings to an array of characters
// splitString(string: "") == [] as [Character]
// splitString(string: "abc bacd cde array") == ["a", "b", "c", " ", "b", "a", "c", " ", "d", "c", "e", " ", "a", "r", "r", "a", "y"]
func splitString(string: String) -> [Character] {
    return Array(string)
}
```

### 4. 字符串数组转成字符串数组

```swift
// Convert an array of strings to an array of characters
// splitString(string: "") == [] as [Character]
// splitString(string: "abc bacd cde array") == ["a", "b", "c", " ", "b", "a", "c", " ", "d", "c", "e", " ", "a", "r", "r", "a", "y"]
func splitString(string: String) -> [Character] {
    return Array(string)
}
```

### 5. 字符串数组转成字符串数组

```swift
// Convert an array of strings to an array of characters
// splitString(string: "") == [] as [Character]
// splitString(string: "abc bacd cde array") == ["a", "b", "c", " ", "b", "a", "c", " ", "d", "c", "e", " ", "a", "r", "r", "a", "y"]
func splitString(string: String) -> [Character] {
    return Array(string)
}
```

### 6. 字符串数组转成字符串数组

```swift
// Convert an array of strings to an array of characters
// splitString(string: "") == [] as [Character]
// splitString(string: "abc bacd cde array") == ["a", "b", "c", " ", "b", "a", "c", " ", "d", "c", "e", " ", "a", "r", "r", "a", "y"]
func splitString(string: String) -> [Character] {
    return Array(string)
}
```

### 7. 字符串数组转成字符串数组

```swift
// Convert an array of strings to an array of characters
// splitString(string: "") == [] as [Character]
// splitString(string: "abc bacd cde array") == ["a", "b", "c", " ", "b", "a", "c", " ", "d", "c", "e", " ", "a", "r", "r", "a", "y"]
func splitString(string: String) -> [Character] {
    return Array(string)
}
```

### 8. 字符串数组转成字符串数组

```swift
// Convert an array of strings to an array of characters
// splitString(string: "") == [] as [Character]
// splitString(string: "abc bacd cde array") == ["a", "b", "c", " ", "b", "a", "c", " ", "d", "c", "e", " ", "a", "r", "r", "a", "y"]
func splitString(string: String) -> [Character] {
    return Array(string)
}
```

### 9. 字符串数组转成

func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}

```swift
// Filter an input array of strings only for ones that contain given substring
// filterBySubstring(strings: [] as [String], substring: "a") == [] as [String]
// filterBySubstring(strings: ["abc", "bacd", "cde", "array"], substring: "a") == ["abc", "bacd", "array"]
func filterBySubstring(strings: [String], substring: String) -> [String] {
    return strings.filter { $0.contains(substring) }
}
```

### 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2. 2.

func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for num in numbers {
        sum += num
        product *= num
    }
    return (sum, product)
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for num in numbers {
        sum += num
        product *= num
    }
    return (sum, product)
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for num in numbers {
        sum += num
        product *= num
    }
    return (sum, product)
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for num in numbers {
        sum += num
        product *= num
    }
    return (sum, product)
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for num in numbers {
        sum += num
        product *= num
    }
    return (sum, product)
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for num in numbers {
        sum += num
        product *= num
    }
    return (sum, product)
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}

class Solution {
    func sumProduct(_ nums: [Int]) -> (Int, Int) {
        var sum = 0
        var product = 1
        for number in nums {
            sum += number
            product *= number
        }
        return (sum, product)
    }
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}
```

### 解题思路

### 代码

```swift
class Solution {
    func sumProduct(_ nums: [Int]) -> (Int, Int) {
        var sum = 0
        var product = 1
        for number in nums {
            sum += number
            product *= number
        }
        return (sum, product)
    }
}
```

func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}

```swift
// For a given array of integers, return a tuple consisting of a sum and a product of all the integers in an array.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// sumProduct(numbers: [] as [Int]) == (0, 1)
// sumProduct(numbers: [1, 2, 3, 4]) == (10, 24)
func sumProduct(numbers: [Int]) -> (Int, Int) {
    var sum = 0
    var product = 1
    for number in numbers {
        sum += number
        product *= number
    }
    return (sum, product)
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 0..<numbers.count {
        result.append(max)
        if numbers[i] > max {
            max = numbers[i]
        }
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 0..<numbers.count {
        result.append(max)
        if numbers[i] > max {
            max = numbers[i]
        }
    }
    return result
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 0..<numbers.count {
        result.append(max)
        if numbers[i] > max {
            max = numbers[i]
        }
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 0..<numbers.count {
        result.append(max)
        if numbers[i] > max {
            max = numbers[i]
        }
    }
    return result
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 1..<numbers.count {
        if numbers[i] > max {
            max = numbers[i]
        }
        result.append(max)
    }
    return result
}

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var stack = [Int]()
    for i in 0..<numbers.count {
        while let top = stack.last, numbers[i] > numbers[top] {
            stack.removeLast()
        }
        stack.append(i)
        result.append(numbers[stack[0]])
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 1..<numbers.count {
        if numbers[i] > max {
            max = numbers[i]
        }
        result.append(max)
    }
    return result
}
```

### 解法二：单调栈

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var stack = [Int]()
    for i in 0..<numbers.count {
        while let top = stack.last, numbers[i] > numbers[top] {
            stack.removeLast()
        }
        stack.append(i)
        result.append(numbers[stack[0]])
    }
    return result
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 0..<numbers.count {
        result.append(max)
        if numbers[i] > max {
            max = numbers[i]
        }
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 0..<numbers.count {
        result.append(max)
        if numbers[i] > max {
            max = numbers[i]
        }
    }
    return result
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var max = numbers[0]
    var result = [Int]()
    for i in 0..<numbers.count {
        result.append(max)
        max = max > numbers[i] ? max : numbers[i]
    }
    return result
}

class Solution {
    func maxSlidingWindow(_ nums: [Int], _ k: Int) -> [Int] {
        guard k > 0, nums.count > 0 else {
            return []
        }
        var result = [Int]()
        var window = [Int]()
        for i in 0..<nums.count {
            if i >= k && window[0] <= i - k {
                window.removeFirst()
            }
            while !window.isEmpty && nums[i] >= nums[window.last!] {
                window.removeLast()
            }
            window.append(i)
            if i >= k - 1 {
                result.append(nums[window[0]])
            }
        }
        return result
    }
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var max = numbers[0]
    var result = [Int]()
    for i in 0..<numbers.count {
        result.append(max)
        max = max > numbers[i] ? max : numbers[i]
    }
    return result
}
```

### 解题思路

### 代码

```swift
class Solution {
    func maxSlidingWindow(_ nums: [Int], _ k: Int) -> [Int] {
        guard k > 0, nums.count > 0 else {
            return []
        }
        var result = [Int]()
        var window = [Int]()
        for i in 0..<nums.count {
            if i >= k && window[0] <= i - k {
                window.removeFirst()
            }
            while !window.isEmpty && nums[i] >= nums[window.last!] {
                window.removeLast()
            }
            window.append(i)
            if i >= k - 1 {
                result.append(nums[window[0]])
            }
        }
        return result
    }
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 0..<numbers.count {
        result.append(max)
        if numbers[i] > max {
            max = numbers[i]
        }
    }
    return result
}

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var stack = [Int]()
    for i in 0..<numbers.count {
        while let top = stack.last, numbers[i] > numbers[top] {
            stack.removeLast()
        }
        stack.append(i)
        result.append(numbers[stack[0]])
    }
    return result
}

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var stack = [Int]()
    stack.append(Int.max)
    for i in 0..<numbers.count {
        while let top = stack.last, numbers[i] > numbers[top] {
            stack.removeLast()
        }
        stack.append(i)
        result.append(numbers[stack[0]])
    }
    return result
}

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var stack = [Int]()
    stack.append(Int.max)
    stack.append(Int.max)
    for i in 0..<numbers.count {
        while let top = stack.last, numbers[i] > numbers[top] {
            stack.removeLast()
        }
        stack.append(i)
        result.append(numbers[stack[1]])
    }
    return result
}

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var stack = [Int]()
    stack.append(Int.max)
    stack.append(Int.max)
    stack.append(Int.max)
    for i in 0..<numbers.count {
        while let top = stack.last, numbers[i] > numbers[top] {
            stack.removeLast()
        }
        stack.append(i)
        result.append(numbers[stack[2]])
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 0..<numbers.count {
        result.append(max)
        if numbers[i] > max {
            max = numbers[i]
        }
    }
    return result
}
```

### 解法二：单调栈

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var stack = [Int]()
    for i in 0..<numbers.count {
        while let top = stack.last, numbers[i] > numbers[top] {
            stack.removeLast()
        }
        stack.append(i)
        result.append(numbers[stack[0]])
    }
    return result
}
```

### 解法三：单调栈 + 哨兵

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var stack = [Int]()
    stack.append(Int.max)
    for i in 0..<numbers.count {
        while let top = stack.last, numbers[i] > numbers[top] {
            stack.removeLast()
        }
        stack.append(i)
        result.append(numbers[stack[0]])
    }
    return result
}
```

### 解法四：单调栈 + 哨兵 + 哨兵

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var stack = [Int]()
    stack.append(Int.max)
    stack.append(Int.max)
    for i in 0..<numbers.count {
        while let top = stack.last, numbers[i] > numbers[top] {
            stack.removeLast()
        }
        stack.append(i)
        result.append(numbers[stack[1]])
    }
    return result
}
```

### 解法五：单调栈 + 哨兵 + 哨兵 + 哨兵

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var stack = [Int]()
    stack.append(Int.max)
    stack.append(Int.max)
    stack.append(Int.max)
    for i in 0..<numbers.count {
        while let top = stack.last, numbers[i] > numbers[top] {
            stack.removeLast()
        }
        stack.append(i)
        result.append(numbers[stack[2]])
    }
    return result
}
```

### 解法六：单调栈 + 哨兵 + 哨兵 + 哨兵 + 哨兵

```swift
// From a given array

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 0..<numbers.count {
        result.append(max)
        if numbers[i] > max {
            max = numbers[i]
        }
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 0..<numbers.count {
        result.append(max)
        if numbers[i] > max {
            max = numbers[i]
        }
    }
    return result
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 0..<numbers.count {
        result.append(max)
        if numbers[i] > max {
            max = numbers[i]
        }
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 0..<numbers.count {
        result.append(max)
        if numbers[i] > max {
            max = numbers[i]
        }
    }
    return result
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 1..<numbers.count {
        if numbers[i] > max {
            max = numbers[i]
        }
        result.append(max)
    }
    return result
}

class Solution {
    func maxSlidingWindow(_ nums: [Int], _ k: Int) -> [Int] {
        guard k > 0, nums.count > 0 else {
            return []
        }
        var result = [Int]()
        var max = nums[0]
        for i in 0..<nums.count - k + 1 {
            if i == 0 {
                for j in 0..<k {
                    if nums[j] > max {
                        max = nums[j]
                    }
                }
                result.append(max)
            } else {
                if nums[i + k - 1] > max {
                    max = nums[i + k - 1]
                }
                result.append(max)
            }
        }
        return result
    }
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 1..<numbers.count {
        if numbers[i] > max {
            max = numbers[i]
        }
        result.append(max)
    }
    return result
}
```

### 解题思路

### 代码

```swift
class Solution {
    func maxSlidingWindow(_ nums: [Int], _ k: Int) -> [Int] {
        guard k > 0, nums.count > 0 else {
            return []
        }
        var result = [Int]()
        var max = nums[0]
        for i in 0..<nums.count - k + 1 {
            if i == 0 {
                for j in 0..<k {
                    if nums[j] > max {
                        max = nums[j]
                    }
                }
                result.append(max)
            } else {
                if nums[i + k - 1] > max {
                    max = nums[i + k - 1]
                }
                result.append(max)
            }
        }
        return result
    }
}
```

func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 0..<numbers.count {
        if numbers[i] > max {
            max = numbers[i]
        }
        result.append(max)
    }
    return result
}

```swift
// From a given array of integers, generate an array of rolling maximum element found until given moment
// in the sequence.
// rollingMax(numbers: [1, 2, 3, 2, 3, 4, 2]) == [1, 2, 3, 3, 3, 4, 4]
func rollingMax(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var max = numbers[0]
    for i in 0..<numbers.count {
        if numbers[i] > max {
            max = numbers[i]
        }
        result.append(max)
    }
    return result
}
```

func makePalindrome(string: String) -> String {
    let s = Array(string)
    var i = s.count - 1
    while i >= 0 && !isPalindrome(s[0...i]) {
        i -= 1
    }
    let prefix = s[0...i]
    let suffix = Array(s.reversed()[0...i])
    return prefix + String(suffix.reversed())
}

func isPalindrome(_ s: [Character]) -> Bool {
    let i = s.startIndex
    let j = s.endIndex - 1
    while i < j {
        if s[i] != s[j] {
            return false
        }
        i += 1
        j -= 1
    }
    return true
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    let s = Array(string)
    var i = s.count - 1
    while i >= 0 && !isPalindrome(s[0...i]) {
        i -= 1
    }
    let prefix = s[0...i]
    let suffix = Array(s.reversed()[0...i])
    return prefix + String(suffix.reversed())
}

func isPalindrome(_ s: [Character]) -> Bool {
    let i = s.startIndex
    let j = s.endIndex - 1
    while i < j {
        if s[i] != s[j] {
            return false
        }
        i += 1
        j -= 1
    }
    return true
}
```

func makePalindrome(string: String) -> String {
    guard string.count > 0 else {
        return ""
    }
    let s = Array(string)
    var i = s.count - 1
    while i >= 0 && !isPalindrome(s[0...i]) {
        i -= 1
    }
    if i < 0 {
        return string
    }
    let prefix = s[0...i]
    let suffix = String(s.reversed()[i+1...s.count-1])
    return prefix + suffix
}

func isPalindrome(_ s: String) -> Bool {
    let s = Array(s)
    var i = 0, j = s.count - 1
    while i < j {
        if s[i] != s[j] {
            return false
        }
        i += 1
        j -= 1
    }
    return true
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    guard string.count > 0 else {
        return ""
    }
    let s = Array(string)
    var i = s.count - 1
    while i >= 0 && !isPalindrome(s[0...i]) {
        i -= 1
    }
    if i < 0 {
        return string
    }
    let prefix = s[0...i]
    let suffix = String(s.reversed()[i+1...s.count-1])
    return prefix + suffix
}

func isPalindrome(_ s: String) -> Bool {
    let s = Array(s)
    var i = 0, j = s.count - 1
    while i < j {
        if s[i] != s[j] {
            return false
        }
        i += 1
        j -= 1
    }
    return true
}
```

func makePalindrome(string: String) -> String {
    let s = Array(string)
    var i = s.count - 1
    while i >= 0 && s[i] != s[0] {
        i -= 1
    }
    let prefix = String(s[0...i])
    let suffix = String(s[i...s.count - 1].reversed())
    return prefix + suffix
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    let s = Array(string)
    var i = s.count - 1
    while i >= 0 && s[i] != s[0] {
        i -= 1
    }
    let prefix = String(s[0...i])
    let suffix = String(s[i...s.count - 1].reversed())
    return prefix + suffix
}
```

func makePalindrome(string: String) -> String {
    guard string.count > 0 else {
        return ""
    }
    
    var longestPalindrome = ""
    for i in 0..<string.count {
        let start = string.index(string.startIndex, offsetBy: i)
        let end = string.index(string.startIndex, offsetBy: string.count - i)
        let subStr = string[start..<end]
        if isPalindrome(string: subStr) {
            longestPalindrome = subStr
        }
    }
    
    let reverse = longestPalindrome.reversed()
    let prefix = string.prefix(longestPalindrome.count)
    return prefix + String(reverse)
}

func isPalindrome(string: String) -> Bool {
    let count = string.count
    for i in 0..<count / 2 {
        if string[i] != string[count - i - 1] {
            return false
        }
    }
    return true
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    guard string.count > 0 else {
        return ""
    }
    
    var longestPalindrome = ""
    for i in 0..<string.count {
        let start = string.index(string.startIndex, offsetBy: i)
        let end = string.index(string.startIndex, offsetBy: string.count - i)
        let subStr = string[start..<end]
        if isPalindrome(string: subStr) {
            longestPalindrome = subStr
        }
    }
    
    let reverse = longestPalindrome.reversed()
    let prefix = string.prefix(longestPalindrome.count)
    return prefix + String(reverse)
}

func isPalindrome(string: String) -> Bool {
    let count = string.count
    for i in 0..<count / 2 {
        if string[i] != string[count - i - 1] {
            return false
        }
    }
    return true
}
```

func makePalindrome(string: String) -> String {
    if string.isEmpty {
        return ""
    }
    let reversed = string.reversed()
    let reversedString = reversed.dropFirst(string.count % reversed.count)
    let palindrome = reversedString.compare(string) == .orderedSame ? string : string + reversedString
    return palindrome
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    if string.isEmpty {
        return ""
    }
    let reversed = string.reversed()
    let reversedString = reversed.dropFirst(string.count % reversed.count)
    let palindrome = reversedString.compare(string) == .orderedSame ? string : string + reversedString
    return palindrome
}
```

func makePalindrome(string: String) -> String {
    let reversedString = string.reversed()
    let reversedStringArray = Array(reversedString)
    let reversedStringArrayLength = reversedStringArray.count
    let stringArray = Array(string)
    let stringArrayLength = stringArray.count
    
    // Find the longest postfix of supplied string that is a palindrome.
    var longestPalindromeIndex = 0
    var longestPalindromeLength = 0
    for i in 0..<stringArrayLength {
        let startIndex = i
        let endIndex = stringArrayLength - 1 - i
        
        var startIndex = startIndex
        var endIndex = endIndex
        
        while startIndex < endIndex && stringArray[startIndex] == reversedStringArray[endIndex] {
            startIndex += 1
            endIndex -= 1
        }
        
        if startIndex >= endIndex {
            if longestPalindromeLength < endIndex - startIndex + 1 {
                longestPalindromeLength = endIndex - startIndex + 1
                longestPalindromeIndex = i
            }
        }
    }
    
    // Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    var result = string
    if longestPalindromeLength > 0 {
        let suffixStartIndex = longestPalindromeIndex + 1
        let suffixEndIndex = stringArrayLength - 1 - longestPalindromeIndex
        
        let suffix = String(stringArray[suffixStartIndex...suffixEndIndex])
        let reversedSuffix = String(reversedStringArray[suffixStartIndex...suffixEndIndex])
        
        result += reversedSuffix
    }
    
    return result
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    let reversedString = string.reversed()
    let reversedStringArray = Array(reversedString)
    let reversedStringArrayLength = reversedStringArray.count
    let stringArray = Array(string)
    let stringArrayLength = stringArray.count
    
    // Find the longest postfix of supplied string that is a palindrome.
    var longestPalindromeIndex = 0
    var longestPalindromeLength = 0
    for i in 0..<stringArrayLength {
        let startIndex = i
        let endIndex = stringArrayLength - 1 - i
        
        var startIndex = startIndex
        var endIndex = endIndex
        
        while startIndex < endIndex && stringArray[startIndex] == reversedStringArray[endIndex] {
            startIndex += 1
            endIndex -= 1
        }
        
        if startIndex >= endIndex {
            if longestPalindromeLength < endIndex - startIndex + 1 {
                longestPalindromeLength = endIndex - startIndex + 1
                longestPalindromeIndex = i
            }
        }
    }
    
    // Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
    var result = string
    if longestPalindromeLength > 0 {
        let suffixStartIndex = longestPalindromeIndex + 1
        let suffixEndIndex = stringArrayLength - 1 - longestPalindromeIndex
        
        let suffix = String(stringArray[suffixStartIndex...suffixEndIndex])
        let reversedSuffix = String(reversedStringArray[suffixStartIndex...suffixEndIndex])
        
        result += reversedSuffix
    }
    
    return result
}
```

func makePalindrome(string: String) -> String {
    let s = Array(string)
    var i = s.count - 1
    while i >= 0 && s[i] == s[0] {
        i -= 1
    }
    if i < 0 {
        return string
    }
    let prefix = Array(s[0...i])
    let suffix = Array(s[i...s.count - 1])
    let reverseSuffix = Array(suffix.reversed())
    let palindrome = Array(prefix + reverseSuffix)
    return String(palindrome)
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    let s = Array(string)
    var i = s.count - 1
    while i >= 0 && s[i] == s[0] {
        i -= 1
    }
    if i < 0 {
        return string
    }
    let prefix = Array(s[0...i])
    let suffix = Array(s[i...s.count - 1])
    let reverseSuffix = Array(suffix.reversed())
    let palindrome = Array(prefix + reverseSuffix)
    return String(palindrome)
}
```

func makePalindrome(string: String) -> String {
    if string.isEmpty {
        return ""
    }
    
    let reversed = string.reversed()
    let reversedString = reversed.dropFirst()
    let reversedPrefix = reversed.prefix(string.count - reversedString.count)
    let prefix = reversedPrefix.reversed()
    
    return string + prefix
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    if string.isEmpty {
        return ""
    }
    
    let reversed = string.reversed()
    let reversedString = reversed.dropFirst()
    let reversedPrefix = reversed.prefix(string.count - reversedString.count)
    let prefix = reversedPrefix.reversed()
    
    return string + prefix
}
```

func makePalindrome(string: String) -> String {
    let s = Array(string)
    var i = s.count - 1
    while i >= 0 && s[i] != s[0] {
        i -= 1
    }
    let prefix = String(s[0...i])
    let suffix = String(s[i...s.count - 1].reversed())
    return prefix + suffix
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    let s = Array(string)
    var i = s.count - 1
    while i >= 0 && s[i] != s[0] {
        i -= 1
    }
    let prefix = String(s[0...i])
    let suffix = String(s[i...s.count - 1].reversed())
    return prefix + suffix
}
```

func makePalindrome(string: String) -> String {
    let reversed = string.reversed()
    let reversedString = reversed.dropFirst(string.count % 2 == 0 ? 1 : 0)
    let palindrome = string + reversedString
    return palindrome
}

```swift
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// makePalindrome(string: "") == ""
// makePalindrome(string: "cat") == "catac"
// makePalindrome(string: "cata") == "catac"
func makePalindrome(string: String) -> String {
    let reversed = string.reversed()
    let reversedString = reversed.dropFirst(string.count % 2 == 0 ? 1 : 0)
    let palindrome = string + reversedString
    return palindrome
}
```

func stringXor(a: String, b: String) -> String {
    let a = a.map { $0 == "1" ? 1 : 0 }
    let b = b.map { $0 == "1" ? 1 : 0 }
    let result = a.zip(b).map { $0 ^ $1 }
    return result.map { $0 == 1 ? "1" : "0" }.joined()
}

func stringXor(a: String, b: String) -> String {
    var result = 0
    for c in a.reversed() {
        result = result << 1
        result += c == "1" ? 1 : 0
    }
    for c in b.reversed() {
        result = result << 1
        result += c == "1" ? 1 : 0
    }
    var resultStr = ""
    while result > 0 {
        resultStr.append(String(result % 2))
        result /= 2
    }
    return resultStr.reversed()
}

func stringXor(a: String, b: String) -> String {
    var result = 0
    for c in a.reversed() {
        result = result << 1
        result += c == "1" ? 1 : 0
    }
    for c in b.reversed() {
        result = result << 1
        result += c == "1" ? 1 : 0
    }
    return String(result)
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    let a = a.map { $0 == "1" ? 1 : 0 }
    let b = b.map { $0 == "1" ? 1 : 0 }
    let result = a.zip(b).map { $0 ^ $1 }
    return result.map { $0 == 1 ? "1" : "0" }.joined()
}
```

### 解法二：位运算

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = 0
    for c in a.reversed() {
        result = result << 1
        result += c == "1" ? 1 : 0
    }
    for c in b.reversed() {
        result = result << 1
        result += c == "1" ? 1 : 0
    }
    var resultStr = ""
    while result > 0 {
        resultStr.append(String(result % 2))
        result /= 2
    }
    return resultStr.reversed()
}
```

### 解法三：位运算

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = 0
    for c in a.reversed() {
        result = result << 1
        result += c == "1" ? 1 : 0
    }
    for c in b.reversed() {
        result = result << 1
        result += c == "1" ? 1 : 0
    }
    return String(result)
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<min(a.count, b.count) {
        result.append(String(a[a.index(a.startIndex, offsetBy: i)] != b[a.index(a.startIndex, offsetBy: i)] ? "1" : "0"))
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<min(a.count, b.count) {
        result.append(String(a[a.index(a.startIndex, offsetBy: i)] != b[a.index(a.startIndex, offsetBy: i)] ? "1" : "0"))
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<min(a.count, b.count) {
        result.append(String(a[a.index(a.startIndex, offsetBy: i)] != b[b.index(b.startIndex, offsetBy: i)] ? "1" : "0"))
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<min(a.count, b.count) {
        result.append(String(a[a.index(a.startIndex, offsetBy: i)] != b[b.index(b.startIndex, offsetBy: i)] ? "1" : "0"))
    }
    return result
}
```

### 解法二

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<min(a.count, b.count) {
        result.append(String(a[a.index(a.startIndex, offsetBy: i)] != b[b.index(b.startIndex, offsetBy: i)] ? "1" : "0"))
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<min(a.count, b.count) {
        result += String(a[a.index(a.startIndex, offsetBy: i)] != b[a.index(a.startIndex, offsetBy: i)])
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<min(a.count, b.count) {
        result += String(a[a.index(a.startIndex, offsetBy: i)] != b[a.index(a.startIndex, offsetBy: i)])
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<min(a.count, b.count) {
        result.append(String(a[a.index(a.startIndex, offsetBy: i)] != b[b.index(b.startIndex, offsetBy: i)] ? "1" : "0"))
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<min(a.count, b.count) {
        result.append(String(a[a.index(a.startIndex, offsetBy: i)] != b[b.index(b.startIndex, offsetBy: i)] ? "1" : "0"))
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    let a = a.map { $0 == "1" ? 1 : 0 }
    let b = b.map { $0 == "1" ? 1 : 0 }
    let result = a.zip(b).map { $0 ^ $1 }
    return result.map { $0 == 1 ? "1" : "0" }.joined()
}

func stringXor(a: String, b: String) -> String {
    var result = 0
    for (i, c) in a.enumerated() {
        result ^= (c == "1") ? 1 : 0
        result ^= (b[i] == "1") ? 1 : 0
    }
    return String(result, radix: 2)
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    let a = a.map { $0 == "1" ? 1 : 0 }
    let b = b.map { $0 == "1" ? 1 : 0 }
    let result = a.zip(b).map { $0 ^ $1 }
    return result.map { $0 == 1 ? "1" : "0" }.joined()
}
```

### 解法二：位运算

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = 0
    for (i, c) in a.enumerated() {
        result ^= (c == "1") ? 1 : 0
        result ^= (b[i] == "1") ? 1 : 0
    }
    return String(result, radix: 2)
}
```

### 解法三：位运算

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    let a = a.map { $0 == "1" ? 1 : 0 }
    let b = b.map { $0 == "1" ? 1 : 0 }
    let result = a.zip(b).map { $0 ^ $1 }
    return result.map { $0 == 1 ? "1" : "0" }.joined()
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<min(a.count, b.count) {
        result.append(String(a[a.index(a.startIndex, offsetBy: i)] != b[b.index(b.startIndex, offsetBy: i)] ? "1" : "0"))
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<min(a.count, b.count) {
        result.append(String(a[a.index(a.startIndex, offsetBy: i)] != b[b.index(b.startIndex, offsetBy: i)] ? "1" : "0"))
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for (a, b) in zip(a, b) {
        result.append(String(Int(a.asciiValue! - 48) ^ Int(b.asciiValue! - 48)))
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for (a, b) in zip(a, b) {
        result.append(String(Int(a.asciiValue! - 48) ^ Int(b.asciiValue! - 48)))
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<min(a.count, b.count) {
        result.append(String(a[a.index(a.startIndex, offsetBy: i)] != b[b.index(b.startIndex, offsetBy: i)] ? "1" : "0"))
    }
    if a.count > b.count {
        for i in b.index(b.startIndex, offsetBy: b.count)..<a.count {
            result.append(String(a[a.index(a.startIndex, offsetBy: i)] != "0" ? "1" : "0"))
        }
    } else {
        for i in a.index(a.startIndex, offsetBy: a.count)..<b.count {
            result.append(String(b[b.index(b.startIndex, offsetBy: i)] != "0" ? "1" : "0"))
        }
    }
    return result
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    var result = ""
    for i in 0..<min(a.count, b.count) {
        result.append(String(a[a.index(a.startIndex, offsetBy: i)] != b[b.index(b.startIndex, offsetBy: i)] ? "1" : "0"))
    }
    if a.count > b.count {
        for i in b.index(b.startIndex, offsetBy: b.count)..<a.count {
            result.append(String(a[a.index(a.startIndex, offsetBy: i)] != "0" ? "1" : "0"))
        }
    } else {
        for i in a.index(a.startIndex, offsetBy: a.count)..<b.count {
            result.append(String(b[b.index(b.startIndex, offsetBy: i)] != "0" ? "1" : "0"))
        }
    }
    return result
}
```

func stringXor(a: String, b: String) -> String {
    let a = Array(a), b = Array(b)
    var result = [Character]()
    for i in 0..<min(a.count, b.count) {
        result.append(a[i] ^ b[i])
    }
    if a.count > b.count {
        result.append(contentsOf: a[b.count..<a.count])
    } else {
        result.append(contentsOf: b[a.count..<b.count])
    }
    return String(result)
}

```swift
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// stringXor(a: "010", b: "110") == "100"
func stringXor(a: String, b: String) -> String {
    let a = Array(a), b = Array(b)
    var result = [Character]()
    for i in 0..<min(a.count, b.count) {
        result.append(a[i] ^ b[i])
    }
    if a.count > b.count {
        result.append(contentsOf: a[b.count..<a.count])
    } else {
        result.append(contentsOf: b[a.count..<b.count])
    }
    return String(result)
}
```

func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var maxLength = 0
    var maxString: String?
    for string in strings {
        if string.count > maxLength {
            maxLength = string.count
            maxString = string
        }
    }
    return maxString
}

func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    let n = strings.count
    var dp = Array(repeating: 0, count: n)
    var maxLength = 0
    var maxString: String?
    for i in 0..<n {
        dp[i] = strings[i].count
        if dp[i] > maxLength {
            maxLength = dp[i]
            maxString = strings[i]
        }
    }
    return maxString
}

func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    let n = strings.count
    var maxLength = 0
    var maxString: String?
    for i in 0..<n {
        if strings[i].count > maxLength {
            maxLength = strings[i].count
            maxString = strings[i]
        }
    }
    return maxString
}

func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    let n = strings.count
    var maxLength = 0
    var maxString: String?
    var dp = 0
    for i in 0..<n {
        dp = strings[i].count
        if dp > maxLength {
            maxLength = dp
            maxString = strings[i]
        }
    }
    return maxString
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var maxLength = 0
    var maxString: String?
    for string in strings {
        if string.count > maxLength {
            maxLength = string.count
            maxString = string
        }
    }
    return maxString
}
```

### 解法二：动态规划

```swift
// Dynamic programming
// Time complexity: O(n)
// Space complexity: O(n)
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    let n = strings.count
    var dp = Array(repeating: 0, count: n)
    var maxLength = 0
    var maxString: String?
    for i in 0..<n {
        dp[i] = strings[i].count
        if dp[i] > maxLength {
            maxLength = dp[i]
            maxString = strings[i]
        }
    }
    return maxString
}
```

### 解法三：动态规划

```swift
// Dynamic programming
// Time complexity: O(n)
// Space complexity: O(1)
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    let n = strings.count
    var maxLength = 0
    var maxString: String?
    for i in 0..<n {
        if strings[i].count > maxLength {
            maxLength = strings[i].count
            maxString = strings[i]
        }
    }
    return maxString
}
```

### 解法四：动态规划

```swift
// Dynamic programming
// Time complexity: O(n)
// Space complexity: O(1)
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    let n = strings.count
    var maxLength = 0
    var maxString: String?
    var dp = 0
    for i in 0..<n {
        dp = strings[i].count
        if dp > maxLength {
            maxLength = dp
            maxString = strings[i]
        }
    }
    return maxString
}
```

### 解法五：动态规划

```swift
// Dynamic programming
// Time complexity: O(n)
// Space complexity: O(1)
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    let n = strings.count
    var maxLength = 0
    var maxString: String?
    var dp = 0
    for i in 0..<n {
        dp = strings[i].count
        if dp > maxLength {
            maxLength = dp
            maxString = strings[i]
        }
    }
    return maxString
}
```

### 解法六：动态规划

```swift
// Dynamic programming
// Time complexity: O(n)
// Space complexity: O(1)
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    let n = strings.count
    var maxLength = 0
    var maxString: String?
    var dp = 0
    for i in 0..<n {
        dp = strings[i].count
        if dp > maxLength {
            maxLength = dp
            maxString = strings[i]
        }
    }
    return maxString
}
```

### 解法七：动态规划

```swift
// Dynamic programming
// Time complexity: O(n)
// Space complexity: O(1)
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    let n = strings.count
    var maxLength = 0
    var maxString: String?
    var dp = 0
    for i in 0..<n {
        dp = strings[i].count
        if dp > maxLength {
            maxLength = dp
            maxString

func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var longest = strings[0]
    for string in strings {
        if string.count > longest.count {
            longest = string
        }
    }
    return longest
}

func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    let sorted = strings.sorted { $0.count > $1.count }
    return sorted.first
}

func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var dp = [Int](repeating: 0, count: strings.count)
    var maxLen = 0
    for i in 0..<strings.count {
        dp[i] = strings[i].count
        if i == 0 {
            maxLen = dp[i]
        } else {
            if dp[i] > maxLen {
                maxLen = dp[i]
            }
        }
    }
    return strings[strings.count - maxLen]
}

func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var maxLen = 0
    var dp = [Int](repeating: 0, count: strings.count)
    for i in 0..<strings.count {
        dp[i] = strings[i].count
        if i == 0 {
            maxLen = dp[i]
        } else {
            if dp[i] > maxLen {
                maxLen = dp[i]
            }
        }
    }
    return strings[strings.count - maxLen]
}

func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var maxLen = 0
    var maxLenString = ""
    for string in strings {
        let len = string.count
        if len > maxLen {
            maxLen = len
            maxLenString = string
        }
    }
    return maxLenString
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var longest = strings[0]
    for string in strings {
        if string.count > longest.count {
            longest = string
        }
    }
    return longest
}
```

### 解法二：排序

```swift
// Sort the array of strings by length, then return the first one.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    let sorted = strings.sorted { $0.count > $1.count }
    return sorted.first
}
```

### 解法三：动态规划

```swift
// Dynamic programming
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var dp = [Int](repeating: 0, count: strings.count)
    var maxLen = 0
    for i in 0..<strings.count {
        dp[i] = strings[i].count
        if i == 0 {
            maxLen = dp[i]
        } else {
            if dp[i] > maxLen {
                maxLen = dp[i]
            }
        }
    }
    return strings[strings.count - maxLen]
}
```

### 解法四：动态规划（空间优化）

```swift
// Dynamic programming
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var maxLen = 0
    var dp = [Int](repeating: 0, count: strings.count)
    for i in 0..<strings.count {
        dp[i] = strings[i].count
        if i == 0 {
            maxLen = dp[i]
        } else {
            if dp[i] > maxLen {
                maxLen = dp[i]
            }
        }
    }
    return strings[strings.count - maxLen]
}
```

### 解法五：动态规划（空间优化）

```swift
// Dynamic programming
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var maxLen = 0
    var maxLenString = ""
    for string in strings {
        let len = string.count
        if len > maxLen {
            maxLen = len
            maxLenString = string
        }
    }
    return maxLenString
}
```

### 解法六：动态规划（空间优化）

```swift
// Dynamic programming
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var maxLen = 0
    var maxLenString = ""
    for string in strings {
        let len = string.count
        if len > maxLen {
            maxLen = len
            maxLenString = string
        }
    }
    

func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var longest = strings[0]
    for string in strings[1...] {
        if string.count > longest.count {
            longest = string
        }
    }
    return longest
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var longest = strings[0]
    for string in strings[1...] {
        if string.count > longest.count {
            longest = string
        }
    }
    return longest
}
```

func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var longest = strings[0]
    for s in strings {
        if s.count > longest.count {
            longest = s
        }
    }
    return longest
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var longest = strings[0]
    for s in strings {
        if s.count > longest.count {
            longest = s
        }
    }
    return longest
}
```

func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else {
        return nil
    }
    
    var maxLength = 0
    var maxString = ""
    
    for string in strings {
        if string.count > maxLength {
            maxLength = string.count
            maxString = string
        }
    }
    
    return maxString
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else {
        return nil
    }
    
    var maxLength = 0
    var maxString = ""
    
    for string in strings {
        if string.count > maxLength {
            maxLength = string.count
            maxString = string
        }
    }
    
    return maxString
}
```

func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var longest = strings[0]
    for string in strings {
        if string.count > longest.count {
            longest = string
        }
    }
    return longest
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var longest = strings[0]
    for string in strings {
        if string.count > longest.count {
            longest = string
        }
    }
    return longest
}
```

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var longest = strings[0]
    for string in strings {
        if string.count > longest.count {
            longest = string
        }
    }
    return longest
}
```

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var longest = strings[0]
    for string in strings {
        if string.count > longest.count {
            longest = string
        }
    }
    return longest
}
```

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var longest = strings[0]
    for string in strings {
        if string.count > longest.count {
            longest = string
        }
    }
    return longest
}
```

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var longest = strings[0]
    for string in strings {
        if string.count > longest.count {
            longest = string
        }
    }
    return longest
}
```

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else { return nil }
    var longest = strings[0]
    for string in strings {
        if string.count > longest.count {
            longest = string
        }
    }
    return longest
}
```

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "

func longest(strings: [String]) -> String? {
    guard strings.count > 0 else {
        return nil
    }
    var longest = strings[0]
    for string in strings {
        if string.count > longest.count {
            longest = string
        } else if string.count == longest.count {
            longest = min(longest, string)
        }
    }
    return longest
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard strings.count > 0 else {
        return nil
    }
    var longest = strings[0]
    for string in strings {
        if string.count > longest.count {
            longest = string
        } else if string.count == longest.count {
            longest = min(longest, string)
        }
    }
    return longest
}
```

func longest(strings: [String]) -> String? {
    if strings.isEmpty {
        return nil
    }
    
    var maxLength = 0
    var maxString: String?
    
    for string in strings {
        if string.count > maxLength {
            maxLength = string.count
            maxString = string
        }
    }
    
    return maxString
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    if strings.isEmpty {
        return nil
    }
    
    var maxLength = 0
    var maxString: String?
    
    for string in strings {
        if string.count > maxLength {
            maxLength = string.count
            maxString = string
        }
    }
    
    return maxString
}
```

func longest(strings: [String]) -> String? {
    if strings.isEmpty {
        return nil
    }
    
    var maxLength = 0
    var maxString = ""
    for string in strings {
        if string.count > maxLength {
            maxLength = string.count
            maxString = string
        }
    }
    return maxString
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    if strings.isEmpty {
        return nil
    }
    
    var maxLength = 0
    var maxString = ""
    for string in strings {
        if string.count > maxLength {
            maxLength = string.count
            maxString = string
        }
    }
    return maxString
}
```

### 解法二

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    if strings.isEmpty {
        return nil
    }
    
    var maxLength = 0
    var maxString = ""
    for string in strings {
        if string.count > maxLength {
            maxLength = string.count
            maxString = string
        }
    }
    return maxString
}
```

func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else {
        return nil
    }
    
    var longest = strings.first!
    for string in strings[1..<strings.count] {
        if string.count > longest.count {
            longest = string
        } else if string.count == longest.count {
            longest = string < longest ? string : longest
        }
    }
    return longest
}

```swift
// Out of array of strings, return the longest one. Return the first one in case of multiple
// strings of the same length. Return nil in case the input array is empty.
// longest(strings: [] as [String]) == nil
// longest(strings: ["a", "b", "c"]) == "a"
// longest(strings: ["a", "bb", "ccc"]) == "ccc"
func longest(strings: [String]) -> String? {
    guard !strings.isEmpty else {
        return nil
    }
    
    var longest = strings.first!
    for string in strings[1..<strings.count] {
        if string.count > longest.count {
            longest = string
        } else if string.count == longest.count {
            longest = string < longest ? string : longest
        }
    }
    return longest
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a - b)
}

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b & -b, b: a & -a)
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

### 解法二：辗转相除法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

### 解法三：欧几里得算法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

### 解法四：更相减损术

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a - b)
}
```

### 解法五：Stein算法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b & -b, b: a & -a)
}
```

### 解法六：更相减损术

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a - b)
}
```

### 解法七：Stein算法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b & -b, b: a & -a)
}
```

### 解法八：更相减损术

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a - b)
}
```

### 解法九：Stein算法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a < b {
        return greatestCommonDivisor(a: b, b: a)
    }
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a < b {
        return greatestCommonDivisor(a: b, b: a)
    }
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a - b)
}

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a < b {
        return greatestCommonDivisor(a: b, b: a)
    }
    if b == 0 {
        return a
    }
    if a % 2 == 0 && b % 2 == 0 {
        return 2 * greatestCommonDivisor(a: a / 2, b: b / 2)
    }
    if a % 3 == 0 && b % 3 == 0 {
        return 3 * greatestCommonDivisor(a: a / 3, b: b / 3)
    }
    return greatestCommonDivisor(a: b, b: a % b)
}

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a < b {
        return greatestCommonDivisor(a: b, b: a)
    }
    if b == 0 {
        return a
    }
    if a % 2 == 0 && b % 2 == 0 {
        return 2 * greatestCommonDivisor(a: a / 2, b: b / 2)
    }
    if a % 3 == 0 && b % 3 == 0 {
        return 3 * greatestCommonDivisor(a: a / 3, b: b / 3)
    }
    if a % 5 == 0 && b % 5 == 0 {
        return 5 * greatestCommonDivisor(a: a / 5, b: b / 5)
    }
    return greatestCommonDivisor(a: b, b: a % b)
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a < b {
        return greatestCommonDivisor(a: b, b: a)
    }
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

### 解法二：欧几里得算法

欧几里得算法又称辗转相除法，是求两个数的最大公约数的一种方法。

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a < b {
        return greatestCommonDivisor(a: b, b: a)
    }
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

### 解法三：更相减损术

更相减损术是求两个数的最大公约数的一种方法。

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a < b {
        return greatestCommonDivisor(a: b, b: a)
    }
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a - b)
}
```

### 解法四：Stein算法

Stein算法是求两个数的最大公约数的一种方法。

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a < b {
        return greatestCommonDivisor(a: b, b: a)
    }
    if b == 0 {
        return a
    }
    if a % 2 == 0 && b % 2 == 0 {
        return 2 * greatestCommonDivisor(a: a / 2, b: b / 2)
    }
    if a % 3 == 0 && b % 3 == 0 {
        return 3 * greatestCommonDivisor(a: a / 3, b: b / 3)
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

### 解法五：Legendre算法

Legendre算法是求两个数的最大公约数的一种方法。

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a < b {
        return greatestCommonDivisor(a: b, b: a)
    }
    if b == 0 {
        return a
    }
    if a % 2 == 0 && b % 2 == 0 {
        return 2 * greatestCommonDivisor(a: a / 2, b: b / 2)
    }
    if a % 3 == 0 && b % 3 == 0 {
        return 3 * greatestCommonDivisor(a: a / 3, b: b / 3)
    }
    if a % 5 == 0 && b % 5 == 0 {
        return 5 * greatestCommonDivisor(a: a / 5, b: b / 5)
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

### 解法六：欧拉算法

欧拉算法是求

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

### 解法二：辗转相除法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

### 解法三：欧几里得算法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

### 解法四：更相减损术

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

### 解法五：Stein算法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

### 解法六：更相减损术

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

### 解法七：Stein算法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

### 解法八：更相减损术

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

### 解法九：Stein算法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a < b {
        return greatestCommonDivisor(a: b, b: a)
    }
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}

class Solution {
    func isUgly(_ num: Int) -> Bool {
        if num <= 0 {
            return false
        }
        var num = num
        while num % 2 == 0 {
            num /= 2
        }
        while num % 3 == 0 {
            num /= 3
        }
        while num % 5 == 0 {
            num /= 5
        }
        return num == 1
    }
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a < b {
        return greatestCommonDivisor(a: b, b: a)
    }
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

### 代码

```swift
class Solution {
    func isUgly(_ num: Int) -> Bool {
        if num <= 0 {
            return false
        }
        var num = num
        while num % 2 == 0 {
            num /= 2
        }
        while num % 3 == 0 {
            num /= 3
        }
        while num % 5 == 0 {
            num /= 5
        }
        return num == 1
    }
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法二

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法三

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法四

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法五

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法六

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法七

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    guard a > 0, b > 0 else {
        return 1
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    guard a > 0, b > 0 else {
        return 1
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法二：辗转相除法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    guard a > 0, b > 0 else {
        return 1
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法三：欧几里得算法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    guard a > 0, b > 0 else {
        return 1
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法四：更相减损术

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    guard a > 0, b > 0 else {
        return 1
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法五：Stein's Algorithm

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    guard a > 0, b > 0 else {
        return 1
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法六：Stein's Algorithm

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    guard a > 0, b > 0 else {
        return 1
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法七：Stein's Algorithm

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法二：辗转相除法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法三：欧几里得算法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法四：更相减损术

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法五：Stein算法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法六：Stein算法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法七：Stein算法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDiv

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a < b {
        return greatestCommonDivisor(a: b, b: a)
    }
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}

class Solution {
    func isUgly(_ num: Int) -> Bool {
        if num == 0 {
            return false
        }
        var num = num
        while num % 5 == 0 {
            num /= 5
        }
        while num % 3 == 0 {
            num /= 3
        }
        while num % 2 == 0 {
            num /= 2
        }
        return num == 1
    }
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a < b {
        return greatestCommonDivisor(a: b, b: a)
    }
    if b == 0 {
        return a
    }
    return greatestCommonDivisor(a: b, b: a % b)
}
```

### 代码

```swift
class Solution {
    func isUgly(_ num: Int) -> Bool {
        if num == 0 {
            return false
        }
        var num = num
        while num % 5 == 0 {
            num /= 5
        }
        while num % 3 == 0 {
            num /= 3
        }
        while num % 2 == 0 {
            num /= 2
        }
        return num == 1
    }
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    guard a > 0, b > 0 else { return 1 }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}

class Solution {
    func isUgly(_ num: Int) -> Bool {
        guard num > 0 else { return false }
        var num = num
        while num % 5 == 0 {
            num /= 5
        }
        while num % 3 == 0 {
            num /= 3
        }
        while num % 2 == 0 {
            num /= 2
        }
        return num == 1
    }
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    guard a > 0, b > 0 else { return 1 }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 代码

```swift
class Solution {
    func isUgly(_ num: Int) -> Bool {
        guard num > 0 else { return false }
        var num = num
        while num % 5 == 0 {
            num /= 5
        }
        while num % 3 == 0 {
            num /= 3
        }
        while num % 2 == 0 {
            num /= 2
        }
        return num == 1
    }
}
```

func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法二：辗转相除法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法三：欧几里得算法

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法四：更相减损术

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法五：Stein's algorithm

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法六：Copeland's algorithm

```swift
// Return a greatest common divisor of two integers a and b
// greatestCommonDivisor(a: 3, b: 5) == 1
// greatestCommonDivisor(a: 25, b: 15) == 5
func greatestCommonDivisor(a: Int, b: Int) -> Int {
    if a == 0 {
        return b
    }
    if b == 0 {
        return a
    }
    if a > b {
        return greatestCommonDivisor(a: a - b, b: b)
    } else {
        return greatestCommonDivisor(a: b - a, b: a)
    }
}
```

### 解法七：Stein's algorithm

```swift
// Return a greatest common divisor of two integers a

func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    for char in string {
        var newPrefixes = [String]()
        for prefix in prefixes {
            newPrefixes.append(prefix + String(char))
        }
        prefixes.append(contentsOf: newPrefixes)
    }
    return prefixes
}

func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    return allPrefixesRecursive(string: string, prefixes: &prefixes)
}

func allPrefixesRecursive(string: String, prefixes: inout [String]) -> [String] {
    for char in string {
        var newPrefixes = [String]()
        for prefix in prefixes {
            newPrefixes.append(prefix + String(char))
        }
        prefixes.append(contentsOf: newPrefixes)
    }
    return prefixes
}

func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    return allPrefixesRecursive(string: string, prefixes: &prefixes, cache: [String: [String]]())
}

func allPrefixesRecursive(string: String, prefixes: inout [String], cache: inout [String: [String]]) -> [String] {
    if let cached = cache[string] {
        return cached
    }
    for char in string {
        var newPrefixes = [String]()
        for prefix in prefixes {
            newPrefixes.append(prefix + String(char))
        }
        prefixes.append(contentsOf: newPrefixes)
    }
    cache[string] = prefixes
    return prefixes
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    for char in string {
        var newPrefixes = [String]()
        for prefix in prefixes {
            newPrefixes.append(prefix + String(char))
        }
        prefixes.append(contentsOf: newPrefixes)
    }
    return prefixes
}
```

### 解法二：动态规划

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    for char in string {
        var newPrefixes = [String]()
        for prefix in prefixes {
            newPrefixes.append(prefix + String(char))
        }
        prefixes.append(contentsOf: newPrefixes)
    }
    return prefixes
}
```

### 解法三：递归

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    return allPrefixesRecursive(string: string, prefixes: &prefixes)
}

func allPrefixesRecursive(string: String, prefixes: inout [String]) -> [String] {
    for char in string {
        var newPrefixes = [String]()
        for prefix in prefixes {
            newPrefixes.append(prefix + String(char))
        }
        prefixes.append(contentsOf: newPrefixes)
    }
    return prefixes
}
```

### 解法四：递归 + 缓存

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    return allPrefixesRecursive(string: string, prefixes: &prefixes, cache: [String: [String]]())
}

func allPrefixesRecursive(string: String, prefixes: inout [String], cache: inout [String: [String]]) -> [String] {
    if let cached = cache[string] {
        return cached
    }
    for char in string {
        var newPrefixes = [String]()
        for prefix in prefixes {
            newPrefixes.append(prefix + String(char))
        }
        prefixes.append(contentsOf: newPrefixes)
    }
    cache[string] = prefixes
    return prefixes
}
```

### 解法五：递归 + 缓存 + 迭代

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    return allPrefixesRecursive(string: string, prefixes: &prefixes, cache: [String: [String]]())
}

func allPrefixesRecursive(string: String, prefixes: inout [String], cache: inout [String: [String]]) -> [String] {
    if let cached = cache[string] {
        return cached
    }
    for char in string {
        var newPrefixes = [String]()
        for prefix in prefixes {
            newPrefixes.append(prefix + String(char))
        }
        prefixes.append(contentsOf: newPrefixes)
    }
    cache[string] = prefixes
    return prefixes
}
```

### 解法六：

func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(string.prefix(i + 1))
    }
    return prefixes
}

func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    for char in string {
        var newPrefixes = [String]()
        for prefix in prefixes {
            newPrefixes.append(prefix + String(char))
        }
        prefixes.append(contentsOf: newPrefixes)
    }
    return prefixes
}

func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    for char in string {
        prefixes.append(contentsOf: prefixes.map { $0 + String(char) })
    }
    return prefixes
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(string.prefix(i + 1))
    }
    return prefixes
}
```

### 解法二：动态规划

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    for char in string {
        var newPrefixes = [String]()
        for prefix in prefixes {
            newPrefixes.append(prefix + String(char))
        }
        prefixes.append(contentsOf: newPrefixes)
    }
    return prefixes
}
```

### 解法三：递归

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    for char in string {
        prefixes.append(contentsOf: prefixes.map { $0 + String(char) })
    }
    return prefixes
}
```

func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    for char in string {
        var temp = [String]()
        for pre in prefixes {
            temp.append(pre + String(char))
        }
        prefixes.append(contentsOf: temp)
    }
    return prefixes
}

func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    for char in string {
        prefixes.append(prefixes.last! + String(char))
    }
    return prefixes
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    for char in string {
        var temp = [String]()
        for pre in prefixes {
            temp.append(pre + String(char))
        }
        prefixes.append(contentsOf: temp)
    }
    return prefixes
}
```

### 解法二

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    for char in string {
        prefixes.append(prefixes.last! + String(char))
    }
    return prefixes
}
```

### 解法三

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    for char in string {
        prefixes.append(prefixes.last! + String(char))
    }
    return prefixes
}
```

### 解法四

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    for char in string {
        prefixes.append(prefixes.last! + String(char))
    }
    return prefixes
}
```

### 解法五

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    for char in string {
        prefixes.append(prefixes.last! + String(char))
    }
    return prefixes
}
```

### 解法六

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    for char in string {
        prefixes.append(prefixes.last! + String(char))
    }
    return prefixes
}
```

### 解法七

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    for char in string {
        prefixes.append(prefixes.last! + String(char))
    }
    return prefixes
}
```

### 解法八

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append("")
    for char in string {
        prefixes.append(prefixes.last! + String(char))
    }
    return prefixes
}
```

### 解法九

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allP

func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(string.prefix(i + 1))
    }
    return prefixes
}

func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        suffixes.append(string.suffix(i + 1))
    }
    return suffixes
}

func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            substrings.append(string.substring(i, j + 1))
        }
    }
    return substrings
}

func longestSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in (0...i).reversed() {
            substrings.append(string.substring(j, i + 1))
        }
    }
    return substrings
}

func shortestSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in (0...i).reversed() {
            substrings.append(string.substring(j, i + 1))
        }
    }
    return substrings
}

func shortestSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in (0...i).reversed() {
            substrings.append(string.substring(i, j + 1))
        }
    }
    return substrings
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(string.prefix(i + 1))
    }
    return prefixes
}
```

```swift
// Return array of all suffixes from shortest to longest of the input string
// allSuffixes(string: "abc") == ["c", "bc", "ab", "abc"]
func allSuffixes(string: String) -> [String] {
    var suffixes = [String]()
    for i in 0..<string.count {
        suffixes.append(string.suffix(i + 1))
    }
    return suffixes
}
```

```swift
// Return array of all substrings from shortest to longest of the input string
// allSubstrings(string: "abc") == ["a", "b", "c", "ab", "bc", "abc"]
func allSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in 0..<string.count {
            substrings.append(string.substring(i, j + 1))
        }
    }
    return substrings
}
```

```swift
// Return array of all substrings from longest to shortest of the input string
// longestSubstrings(string: "abc") == ["abc", "bc", "ab", "c"]
func longestSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in (0...i).reversed() {
            substrings.append(string.substring(j, i + 1))
        }
    }
    return substrings
}
```

```swift
// Return array of all substrings from shortest to longest of the input string
// shortestSubstrings(string: "abc") == ["a", "ab", "abc"]
func shortestSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in (0...i).reversed() {
            substrings.append(string.substring(j, i + 1))
        }
    }
    return substrings
}
```

```swift
// Return array of all substrings from longest to shortest of the input string
// shortestSubstrings(string: "abc") == ["abc", "bc", "ab"]
func shortestSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in (0...i).reversed() {
            substrings.append(string.substring(i, j + 1))
        }
    }
    return substrings
}
```

```swift
// Return array of all substrings from shortest to longest of the input string
// shortestSubstrings(string: "abc") == ["a", "ab", "abc"]
func shortestSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in (0...i).reversed() {
            substrings.append(string.substring(j, i + 1))
        }
    }
    return substrings
}
```

```swift
// Return array of all substrings from shortest to longest of the input string
// shortestSubstrings(string: "abc") == ["a", "ab", "abc"]
func shortestSubstrings(string: String) -> [String] {
    var substrings = [String]()
    for i in 0..<string.count {
        for j in (0...i).reversed() {
            substrings.append(string.substring(j, i + 1))
        }
    }
    return substrings
}
```

```sw

func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0..<string.count {
        result.append(string.prefix(i + 1))
    }
    return result
}

class Solution {
    func longestCommonPrefix(_ strs: [String]) -> String {
        guard strs.count > 0 else {
            return ""
        }
        let shortest = strs.min()!
        let shortestLength = shortest.count
        let allPrefixes = allPrefixes(string: shortest)
        for i in 0..<allPrefixes.count {
            let prefix = allPrefixes[i]
            for str in strs {
                if !str.hasPrefix(prefix) {
                    return String(prefix.prefix(i))
                }
            }
        }
        return String(shortest)
    }

    func allPrefixes(string: String) -> [String] {
        var result = [String]()
        for i in 0..<string.count {
            result.append(string.prefix(i + 1))
        }
        return result
    }
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0..<string.count {
        result.append(string.prefix(i + 1))
    }
    return result
}
```

### 代码

```swift
class Solution {
    func longestCommonPrefix(_ strs: [String]) -> String {
        guard strs.count > 0 else {
            return ""
        }
        let shortest = strs.min()!
        let shortestLength = shortest.count
        let allPrefixes = allPrefixes(string: shortest)
        for i in 0..<allPrefixes.count {
            let prefix = allPrefixes[i]
            for str in strs {
                if !str.hasPrefix(prefix) {
                    return String(prefix.prefix(i))
                }
            }
        }
        return String(shortest)
    }

    func allPrefixes(string: String) -> [String] {
        var result = [String]()
        for i in 0..<string.count {
            result.append(string.prefix(i + 1))
        }
        return result
    }
}
```

func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0..<string.count {
        result.append(string.prefix(i + 1))
    }
    return result
}

func allPrefixes(string: String) -> [String] {
    var result = [String]()
    result.append(string)
    for i in 0..<string.count {
        result.append(string.prefix(i + 1))
    }
    return result
}

func allPrefixes(string: String) -> [String] {
    var result = [String]()
    result.append(string)
    var i = 0
    while i < string.count {
        result.append(string.prefix(i + 1))
        i += 1
    }
    return result
}

func allPrefixes(string: String) -> [String] {
    let regex = "^(.+)"
    let matches = try! regex.matches(in: string, range: Range(string.startIndex...))
    var result = [String]()
    for match in matches {
        result.append(string[match.range])
    }
    return result
}

func allPrefixes(string: String) -> [String] {
    let regex = "^(.+)"
    let matches = regex.allMatches(in: string)
    var result = [String]()
    for match in matches {
        result.append(string[match.range])
    }
    return result
}

func allPrefixes(string: String) -> [String] {
    let regex = "^(.+)"
    let matches = regex.allMatches(in: string)
    return matches.map { string[$0.range] }
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0..<string.count {
        result.append(string.prefix(i + 1))
    }
    return result
}
```

### 解法二：递归

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    result.append(string)
    for i in 0..<string.count {
        result.append(string.prefix(i + 1))
    }
    return result
}
```

### 解法三：迭代

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    result.append(string)
    var i = 0
    while i < string.count {
        result.append(string.prefix(i + 1))
        i += 1
    }
    return result
}
```

### 解法四：正则表达式

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    let regex = "^(.+)"
    let matches = try! regex.matches(in: string, range: Range(string.startIndex...))
    var result = [String]()
    for match in matches {
        result.append(string[match.range])
    }
    return result
}
```

### 解法五：正则表达式

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    let regex = "^(.+)"
    let matches = regex.allMatches(in: string)
    var result = [String]()
    for match in matches {
        result.append(string[match.range])
    }
    return result
}
```

### 解法六：正则表达式

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    let regex = "^(.+)"
    let matches = regex.allMatches(in: string)
    return matches.map { string[$0.range] }
}
```

### 解法七：正则表达式

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    let regex = "^(.+)"
    let matches = regex.allMatches(in: string)
    return matches.map { string[$0.range] }
}
```

### 解法八：正则表达式

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    let regex = "^(.+)"
    let matches = regex.allMatches(in: string)
    return matches.map { string[$0.range] }
}
```

### 解法九：正则表达式

```swift
// Return array of all prefixes from shortest to longest of the input string

func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0..<string.count {
        result.append(string.prefix(i + 1))
    }
    return result
}

func allPrefixes(string: String) -> [String] {
    var result = [String]()
    result.append(string)
    if string.count > 1 {
        result.append(contentsOf: allPrefixes(string: String(string.dropFirst())))
    }
    return result
}

func allPrefixes(string: String) -> [String] {
    var result = [String]()
    result.append(string)
    for i in 1..<string.count {
        result.append(contentsOf: allPrefixes(string: String(string.dropFirst())))
    }
    return result
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0..<string.count {
        result.append(string.prefix(i + 1))
    }
    return result
}
```

### 解法二：递归

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    result.append(string)
    if string.count > 1 {
        result.append(contentsOf: allPrefixes(string: String(string.dropFirst())))
    }
    return result
}
```

### 解法三：迭代

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    result.append(string)
    for i in 1..<string.count {
        result.append(contentsOf: allPrefixes(string: String(string.dropFirst())))
    }
    return result
}
```

### 解法四：递归 + 迭代

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    result.append(string)
    for i in 1..<string.count {
        result.append(contentsOf: allPrefixes(string: String(string.dropFirst())))
    }
    return result
}
```

### 解法五：迭代

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    result.append(string)
    for i in 1..<string.count {
        result.append(contentsOf: allPrefixes(string: String(string.dropFirst())))
    }
    return result
}
```

### 解法六：迭代

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    result.append(string)
    for i in 1..<string.count {
        result.append(contentsOf: allPrefixes(string: String(string.dropFirst())))
    }
    return result
}
```

### 解法七：迭代

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    result.append(string)
    for i in 1..<string.count {
        result.append(contentsOf: allPrefixes(string: String(string.dropFirst())))
    }
    return result
}
```

### 解法八：迭代

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    result.append(string)
    for i in 1..<string.count {
        result.append(contentsOf: allPrefixes(string: String(string.dropFirst())))
    }
    

func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(string.prefix(i + 1))
    }
    return prefixes
}

func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append(string.prefix(1))
    for i in 1..<string.count {
        prefixes.append(string.prefix(i + 1))
    }
    return prefixes
}

func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append(string.prefix(1))
    prefixes.append(contentsOf: allPrefixes(string: string.substring(from: 1, length: string.count - 1)))
    return prefixes
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(string.prefix(i + 1))
    }
    return prefixes
}
```

### 解法二：动态规划

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append(string.prefix(1))
    for i in 1..<string.count {
        prefixes.append(string.prefix(i + 1))
    }
    return prefixes
}
```

### 解法三：递归

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append(string.prefix(1))
    prefixes.append(contentsOf: allPrefixes(string: string.substring(from: 1, length: string.count - 1)))
    return prefixes
}
```

### 解法四：递归 + 缓存

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append(string.prefix(1))
    prefixes.append(contentsOf: allPrefixes(string: string.substring(from: 1, length: string.count - 1)))
    return prefixes
}

// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append(string.prefix(1))
    prefixes.append(contentsOf: allPrefixes(string: string.substring(from: 1, length: string.count - 1)))
    return prefixes
}
```

### 解法五：迭代

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append(string.prefix(1))
    for i in 1..<string.count {
        prefixes.append(string.prefix(i + 1))
    }
    return prefixes
}
```

### 解法六：迭代 + 缓存

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append(string.prefix(1))
    for i in 1..<string.count {
        prefixes.append(string.prefix(i + 1))
    }
    return prefixes
}
```

### 解法七：迭代 + 缓存 + 迭代

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    prefixes.append(string.prefix(1))
    for i in 1..<string.count {
        prefixes.append(string.prefix(i + 1))
    }

func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(string.prefix(i + 1))
    }
    return prefixes
}

class Solution {
    func longestCommonPrefix(_ strs: [String]) -> String {
        guard strs.count > 0 else {
            return ""
        }
        let first = strs[0]
        let prefixes = allPrefixes(string: first)
        for str in strs {
            for prefix in prefixes {
                if !str.hasPrefix(prefix) {
                    prefixes.remove(at: prefixes.firstIndex(of: prefix)!)
                }
            }
        }
        return prefixes.last!
    }
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var prefixes = [String]()
    for i in 0..<string.count {
        prefixes.append(string.prefix(i + 1))
    }
    return prefixes
}
```

### 解题思路

### 代码

```swift
class Solution {
    func longestCommonPrefix(_ strs: [String]) -> String {
        guard strs.count > 0 else {
            return ""
        }
        let first = strs[0]
        let prefixes = allPrefixes(string: first)
        for str in strs {
            for prefix in prefixes {
                if !str.hasPrefix(prefix) {
                    prefixes.remove(at: prefixes.firstIndex(of: prefix)!)
                }
            }
        }
        return prefixes.last!
    }
}
```

func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0..<string.count {
        result.append(string.prefix(i + 1))
    }
    return result
}

class Solution {
    func findSubstringInWraproundString(_ p: String) -> Int {
        var dic = [Character: Int]()
        var count = 0
        for i in 0..<p.count {
            let c = p[p.index(p.startIndex, offsetBy: i)]
            if i > 0, p[p.index(p.startIndex, offsetBy: i - 1)] + 1 == c {
                count += 1
            } else {
                count = 1
            }
            dic[c] = max(dic[c] ?? 0, count)
        }
        return dic.values.reduce(0, +)
    }
}

```swift
// Return array of all prefixes from shortest to longest of the input string
// allPrefixes(string: "abc") == ["a", "ab", "abc"]
func allPrefixes(string: String) -> [String] {
    var result = [String]()
    for i in 0..<string.count {
        result.append(string.prefix(i + 1))
    }
    return result
}
```

### 解题思路

### 代码

```swift
class Solution {
    func findSubstringInWraproundString(_ p: String) -> Int {
        var dic = [Character: Int]()
        var count = 0
        for i in 0..<p.count {
            let c = p[p.index(p.startIndex, offsetBy: i)]
            if i > 0, p[p.index(p.startIndex, offsetBy: i - 1)] + 1 == c {
                count += 1
            } else {
                count = 1
            }
            dic[c] = max(dic[c] ?? 0, count)
        }
        return dic.values.reduce(0, +)
    }
}
```

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}

func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n - 1) + " " + String(n)
}

func stringSequence(n: Int) -> String {
    var result = ""
    var i = 0
    while i <= n {
        result += String(i) + " "
        i += 1
    }
    return result
}

func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    var result = ""
    var i = 0
    while i <= n {
        result += String(i) + " "
        i += 1
    }
    return result
}

func stringSequence(n: Int) -> String {
    func stringSequence(_ n: Int, _ result: inout String) {
        if n == 0 {
            result += "0"
            return
        }
        stringSequence(n - 1, &result)
        result += " " + String(n)
    }
    var result = ""
    stringSequence(n, &result)
    return result
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法二：递归

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n - 1) + " " + String(n)
}
```

### 解法三：迭代

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    var i = 0
    while i <= n {
        result += String(i) + " "
        i += 1
    }
    return result
}
```

### 解法四：递归 + 迭代

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    var result = ""
    var i = 0
    while i <= n {
        result += String(i) + " "
        i += 1
    }
    return result
}
```

### 解法五：尾递归

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    func stringSequence(_ n: Int, _ result: inout String) {
        if n == 0 {
            result += "0"
            return
        }
        stringSequence(n - 1, &result)
        result += " " + String(n)
    }
    var result = ""
    stringSequence(n, &result)
    return result
}
```

### 解法六：尾递归 + 迭代

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    func stringSequence(_ n: Int, _ result: inout String) {
        if n == 0 {
            result += "0"
            return
        }
        stringSequence(n - 1, &result)
        result += " " + String(n)
    }
    var result = ""
    stringSequence(n, &result)
    return result
}
```

### 解法七：尾递归 + 迭代 + 尾递归

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    func stringSequence(_ n: Int, _ result: inout String) {
        if n == 0 {
            result += "0"
            return
        }
        stringSequence(n - 1, &result)
        result += " " + String(n)
    }
    func stringSequence(_ n: Int

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}

func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n - 1) + " " + String(n)
}

func stringSequence(n: Int) -> String {
    var result = ""
    var i = 0
    while i <= n {
        result += String(i) + " "
        i += 1
    }
    return result
}

func stringSequence(n: Int) -> String {
    var result = ""
    var i = 0
    while i <= n {
        result += String(i) + " "
        yield result
        i += 1
    }
    return result
}

func stringSequence(n: Int) -> String {
    var result = [String]()
    var i = 0
    while i <= n {
        result.append(String(i))
        i += 1
    }
    return result.joined(separator: " ")
}

func stringSequence(n: Int) -> String {
    var result = [String]()
    var i = 0
    while i <= n {
        result.append(String(i))
        yield result.joined(separator: " ")
        i += 1
    }
    return result.joined(separator: " ")
}

func stringSequence(n: Int) -> String {
    var result = [String]()
    var i = 0
    while i <= n {
        result.append(String(i))
        yield result
        i += 1
    }
    return result.joined(separator: " ")
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法二：递归

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n - 1) + " " + String(n)
}
```

### 解法三：迭代

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    var i = 0
    while i <= n {
        result += String(i) + " "
        i += 1
    }
    return result
}
```

### 解法四：生成器

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    var i = 0
    while i <= n {
        result += String(i) + " "
        yield result
        i += 1
    }
    return result
}
```

### 解法五：数组

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = [String]()
    var i = 0
    while i <= n {
        result.append(String(i))
        i += 1
    }
    return result.joined(separator: " ")
}
```

### 解法六：数组 + 生成器

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = [String]()
    var i = 0
    while i <= n {
        result.append(String(i))
        yield result.joined(separator: " ")
        i += 1
    }
    return result.joined(separator: " ")
}
```

### 解法七：数组 + 数组生成器

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = [String]()
    var i = 0
    while i <= n {
        result.append(String(i))
        yield result
        i += 1
    }
    return result.joined(separator: " ")
}
```

### 解法八：数组 + 数组生成器 + 数组

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}

func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n - 1) + " " + String(n)
}

func stringSequence(n: Int) -> String {
    var result = ""
    var i = 0
    while i <= n {
        result += String(i) + " "
        i += 1
    }
    return result
}

func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    var result = ""
    var i = 0
    while i <= n {
        result += String(i) + " "
        i += 1
    }
    return result
}

func stringSequence(n: Int) -> String {
    func stringSequence(_ n: Int, _ result: inout String) {
        if n == 0 {
            result += "0"
            return
        }
        stringSequence(n - 1, &result)
        result += " "
        stringSequence(n - 1, &result)
    }
    var result = ""
    stringSequence(n, &result)
    return result
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法二：递归

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n - 1) + " " + String(n)
}
```

### 解法三：迭代

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    var i = 0
    while i <= n {
        result += String(i) + " "
        i += 1
    }
    return result
}
```

### 解法四：递归 + 迭代

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    var result = ""
    var i = 0
    while i <= n {
        result += String(i) + " "
        i += 1
    }
    return result
}
```

### 解法五：尾递归

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    func stringSequence(_ n: Int, _ result: inout String) {
        if n == 0 {
            result += "0"
            return
        }
        stringSequence(n - 1, &result)
        result += " "
        stringSequence(n - 1, &result)
    }
    var result = ""
    stringSequence(n, &result)
    return result
}
```

### 解法六：尾递归 + 迭代

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    func stringSequence(_ n: Int, _ result: inout String) {
        if n == 0 {
            result += "0"
            return
        }
        stringSequence(n - 1, &result)
        result += " "
        stringSequence(n - 1, &result)
    }
    var result = ""
    stringSequence(n, &result)
    return result
}
```

### 解法七：尾递归 + 迭代

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    func stringSequence(_ n: Int, _ result: inout String) {
        if n == 0 {
            result += "0"
            return
        }
        stringSequence(n - 1, &result)
        result += " "
        stringSequence

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}

func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n: n - 1) + " " + "\(n)"
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}
```

### 解法二：递归

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n: n - 1) + " " + "\(n)"
}
```

### 解法三：迭代

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}
```

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}

func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    let result = stringSequence(n: n - 1)
    return result + " " + String(n)
}

func stringSequence(n: Int) -> String {
    func stringSequence(_ n: Int, _ result: inout String) {
        if n == 0 {
            result += "0"
            return
        }
        stringSequence(n - 1, &result)
        result += " " + String(n)
    }
    var result = ""
    stringSequence(n, &result)
    return result
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法二：递归

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    let result = stringSequence(n: n - 1)
    return result + " " + String(n)
}
```

### 解法三：迭代

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法四：递归 + 迭代

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法五：尾递归

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    func stringSequence(_ n: Int, _ result: inout String) {
        if n == 0 {
            result += "0"
            return
        }
        stringSequence(n - 1, &result)
        result += " " + String(n)
    }
    var result = ""
    stringSequence(n, &result)
    return result
}
```

### 解法六：尾递归 + 迭代

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    func stringSequence(_ n: Int, _ result: inout String) {
        if n == 0 {
            result += "0"
            return
        }
        stringSequence(n - 1, &result)
        result += " " + String(n)
    }
    var result = ""
    stringSequence(n, &result)
    return result
}
```

### 解法七：尾递归 + 迭代

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    func stringSequence(_ n: Int, _ result: inout String) {
        if n == 0 {
            result += "0"
            return
        }
        stringSequence(n - 1, &result)
        result += " " + String(n)
    }
    var result = ""
    stringSequence(n, &result)
    return result
}
```

### 解法八：尾递归 + 迭代

``

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}

func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n: n - 1) + " " + String(n)
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法二：递归

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n: n - 1) + " " + String(n)
}
```

### 解法三：迭代

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法四：生成器

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法五：数组

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法六：数组 + 生成器

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法七：数组 + 数组

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法八：数组 + 数组 + 数组

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法九：数组 + 数组 + 数组 + 数组

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}

func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n - 1) + " " + "\(n)"
}

func stringSequence(n: Int) -> String {
    return stringSequenceHelper(n, String())
}

func stringSequenceHelper(_ n: Int, _ result: String) -> String {
    if n == 0 {
        return result + "0"
    }
    return stringSequenceHelper(n - 1, result + "\(n) ")
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += "\(i) "
    }
    return result
}
```

### 解法二：递归

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n - 1) + " " + "\(n)"
}
```

### 解法三：尾递归

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    return stringSequenceHelper(n, String())
}

func stringSequenceHelper(_ n: Int, _ result: String) -> String {
    if n == 0 {
        return result + "0"
    }
    return stringSequenceHelper(n - 1, result + "\(n) ")
}
```

### 解法四：尾递归优化

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    return stringSequenceHelper(n, String())
}

func stringSequenceHelper(_ n: Int, _ result: String) -> String {
    if n == 0 {
        return result + "0"
    }
    return stringSequenceHelper(n - 1, result + "\(n) ")
}

// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    return stringSequenceHelper(n, String())
}

func stringSequenceHelper(_ n: Int, _ result: String) -> String {
    if n == 0 {
        return result + "0"
    }
    return stringSequenceHelper(n - 1, result + "\(n) ")
}
```

### 解法五：尾递归优化

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    return stringSequenceHelper(n, String())
}

func stringSequenceHelper(_ n: Int, _ result: String) -> String {
    if n == 0 {
        return result + "0"
    }
    return stringSequenceHelper(n - 1, result + "\(n) ")
}

// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    return stringSequenceHelper(n, String())
}

func stringSequenceHelper(_ n: Int, _ result: String) -> String {
    if n == 0 {
        return result + "0"
    }
    return stringSequenceHelper(n - 1, result + "\(n) ")
}
```

### 解法六：尾递归优化

```swift
// Return a string containing space-delimited numbers starting from 0 upto

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}

func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n - 1) + " " + String(n)
}

func stringSequence(n: Int) -> String {
    var result = ""
    var i = 0
    while i <= n {
        result += String(i) + " "
        i += 1
    }
    return result
}

func stringSequence(n: Int) -> String {
    var result = [String]()
    for i in 0...n {
        result.append(String(i))
    }
    return result.joined(separator: " ")
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法二：递归

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n - 1) + " " + String(n)
}
```

### 解法三：迭代

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    var i = 0
    while i <= n {
        result += String(i) + " "
        i += 1
    }
    return result
}
```

### 解法四：生成器

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法五：数组

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = [String]()
    for i in 0...n {
        result.append(String(i))
    }
    return result.joined(separator: " ")
}
```

### 解法六：数组 + reduce

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    return [0, 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, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}

func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n - 1) + " " + String(n)
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 方法二：递归

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n - 1) + " " + String(n)
}
```

### 方法三：迭代

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}

func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n - 1) + " " + String(n)
}

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法二：递归

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    if n == 0 {
        return "0"
    }
    return stringSequence(n - 1) + " " + String(n)
}
```

### 解法三：循环

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法四：递归 + 循环

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法五：循环 + 递归

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法六：循环 + 循环

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法七：循环 + 递归 + 循环

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法八：循环 + 循环 + 循环

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0) == "0"
// stringSequence(n: 5) == "0 1 2 3 4 5"
func stringSequence(n: Int) -> String {
    var result = ""
    for i in 0...n {
        result += String(i) + " "
    }
    return result
}
```

### 解法九：循环 + 循环 + 递归

```swift
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// stringSequence(n: 0

func countDistinctCharacters(string: String) -> Int {
    let array = Array(string)
    var set = Set<Character>()
    for c in array {
        set.insert(c)
    }
    return set.count
}

class Solution {
    func countDistinctCharacters(_ string: String) -> Int {
        let array = Array(string)
        var set = Set<Character>()
        for c in array {
            set.insert(c)
        }
        return set.count
    }
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    let array = Array(string)
    var set = Set<Character>()
    for c in array {
        set.insert(c)
    }
    return set.count
}
```

### 解题思路

### 代码

```swift
class Solution {
    func countDistinctCharacters(_ string: String) -> Int {
        let array = Array(string)
        var set = Set<Character>()
        for c in array {
            set.insert(c)
        }
        return set.count
    }
}
```

func countDistinctCharacters(string: String) -> Int {
    var map = [Character: Int]()
    for char in string {
        map[char, default: 0] += 1
    }
    return map.count
}

func countDistinctCharacters(string: String) -> Int {
    let chars = Array(string)
    chars.sort()
    var prev = chars[0]
    var count = 1
    for char in chars[1..<chars.count] {
        if char == prev {
            continue
        }
        prev = char
        count += 1
    }
    return count
}

func countDistinctCharacters(string: String) -> Int {
    var count = [Int](repeating: 0, count: 26)
    for char in string {
        count[Int(char.asciiValue!) - 97] += 1
    }
    var result = 0
    for num in count {
        result += num
    }
    return result
}

func countDistinctCharacters(string: String) -> Int {
    var mask = 0
    var count = 0
    for char in string {
        let index = Int(char.asciiValue!) - 97
        if mask & (1 << index) == 0 {
            mask |= (1 << index)
            count += 1
        }
    }
    return count
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var map = [Character: Int]()
    for char in string {
        map[char, default: 0] += 1
    }
    return map.count
}
```

### 解法二：排序

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    let chars = Array(string)
    chars.sort()
    var prev = chars[0]
    var count = 1
    for char in chars[1..<chars.count] {
        if char == prev {
            continue
        }
        prev = char
        count += 1
    }
    return count
}
```

### 解法三：计数

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var count = [Int](repeating: 0, count: 26)
    for char in string {
        count[Int(char.asciiValue!) - 97] += 1
    }
    var result = 0
    for num in count {
        result += num
    }
    return result
}
```

### 解法四：位运算

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var mask = 0
    var count = 0
    for char in string {
        let index = Int(char.asciiValue!) - 97
        if mask & (1 << index) == 0 {
            mask |= (1 << index)
            count += 1
        }
    }
    return count
}
```

### 解法五：位运算优化

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var mask = 0
    var count = 0
    for char in string {
        let index = Int(char.asciiValue!) - 97
        if mask & (1 << index) == 0 {
            mask |= (1 << index)
            count += 1
        }
    }
    return count
}
```

### 解法六：位运算优化

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var mask = 0
    var count = 0
    for char in string {
        let index = Int(char.asciiValue!) - 97
        if mask & (1 << index) == 0 {
            mask |= (1 << index)
            count += 1
        }
    }
    return count
}
```

### 解法七：位运算优化

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var mask = 0

func countDistinctCharacters(string: String) -> Int {
    let array = Array(string)
    var map = [Character: Int]()
    for char in array {
        if map[char] == nil {
            map[char] = 1
        } else {
            map[char]! += 1
        }
    }
    return map.count
}

class Solution {
    func countDistinctCharacters(_ string: String) -> Int {
        let array = Array(string)
        var map = [Character: Int]()
        for char in array {
            if map[char] == nil {
                map[char] = 1
            } else {
                map[char]! += 1
            }
        }
        return map.count
    }
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    let array = Array(string)
    var map = [Character: Int]()
    for char in array {
        if map[char] == nil {
            map[char] = 1
        } else {
            map[char]! += 1
        }
    }
    return map.count
}
```

### 解题思路

### 代码

```swift
class Solution {
    func countDistinctCharacters(_ string: String) -> Int {
        let array = Array(string)
        var map = [Character: Int]()
        for char in array {
            if map[char] == nil {
                map[char] = 1
            } else {
                map[char]! += 1
            }
        }
        return map.count
    }
}
```

func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var charSet = Set<Character>()
    for char in string {
        if !charSet.contains(char) {
            charSet.insert(char)
            count += 1
        }
    }
    return count
}

class Solution {
    func countDistinctCharacters(_ string: String) -> Int {
        var count = 0
        var charSet = Set<Character>()
        for char in string {
            if !charSet.contains(char) {
                charSet.insert(char)
                count += 1
            }
        }
        return count
    }
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var charSet = Set<Character>()
    for char in string {
        if !charSet.contains(char) {
            charSet.insert(char)
            count += 1
        }
    }
    return count
}
```

### 解题思路

### 代码

```swift
class Solution {
    func countDistinctCharacters(_ string: String) -> Int {
        var count = 0
        var charSet = Set<Character>()
        for char in string {
            if !charSet.contains(char) {
                charSet.insert(char)
                count += 1
            }
        }
        return count
    }
}
```

func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var charSet = Set<Character>()
    for char in string {
        if !charSet.contains(char) {
            charSet.insert(char)
            count += 1
        }
    }
    return count
}

class Solution {
    func countDistinctCharacters(_ s: String) -> Int {
        var count = 0
        var charSet = Set<Character>()
        for char in s {
            if !charSet.contains(char) {
                charSet.insert(char)
                count += 1
            }
        }
        return count
    }
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var charSet = Set<Character>()
    for char in string {
        if !charSet.contains(char) {
            charSet.insert(char)
            count += 1
        }
    }
    return count
}
```

### 解题思路

### 代码

```swift
class Solution {
    func countDistinctCharacters(_ s: String) -> Int {
        var count = 0
        var charSet = Set<Character>()
        for char in s {
            if !charSet.contains(char) {
                charSet.insert(char)
                count += 1
            }
        }
        return count
    }
}
```

func countDistinctCharacters(string: String) -> Int {
    var map = [Character: Int]()
    for c in string {
        map[c, default: 0] += 1
    }
    return map.count
}

func countDistinctCharacters(string: String) -> Int {
    var chars = Array(string)
    chars.sort()
    var prev = chars[0]
    var count = 1
    for c in chars[1..<chars.count] {
        if c != prev {
            count += 1
            prev = c
        }
    }
    return count
}

func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var map = [Character: Int]()
    for c in string {
        map[c, default: 0] += 1
        if map[c] == 1 {
            count += 1
        }
    }
    return count
}

func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var map = [Character: Int]()
    for c in string {
        let index = Int(c.asciiValue!) - 97
        if map[c, default: 0] == 0 {
            count += 1
        }
        map[c] = 1 << index
    }
    return count
}

func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var map = [Character: Int]()
    for c in string {
        let index = Int(c.asciiValue!) - 97
        if map[c] == nil {
            count += 1
        }
        map[c] = map[c]?.bitwiseOr(1 << index) ?? (1 << index)
    }
    return count
}

func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var map = [Character: Int]()
    for c in string {
        let index = Int(c.asciiValue!) - 97
        if map[c] == nil {
            count += 1
        } else if map[c]! & (1 << index) == 0 {
            count += 1
        }
        map[c] = map[c]?.bitwiseOr(1 << index) ?? (1 << index)
    }
    return count
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var map = [Character: Int]()
    for c in string {
        map[c, default: 0] += 1
    }
    return map.count
}
```

### 解法二：排序

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var chars = Array(string)
    chars.sort()
    var prev = chars[0]
    var count = 1
    for c in chars[1..<chars.count] {
        if c != prev {
            count += 1
            prev = c
        }
    }
    return count
}
```

### 解法三：计数

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var map = [Character: Int]()
    for c in string {
        map[c, default: 0] += 1
        if map[c] == 1 {
            count += 1
        }
    }
    return count
}
```

### 解法四：位运算

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var map = [Character: Int]()
    for c in string {
        let index = Int(c.asciiValue!) - 97
        if map[c, default: 0] == 0 {
            count += 1
        }
        map[c] = 1 << index
    }
    return count
}
```

### 解法五：位运算优化

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var map = [Character: Int]()
    for c in string {
        let index = Int(c.asciiValue!) - 97
        if map[c] == nil {
            count += 1
        }
        map[c] = map[c]?.bitwiseOr(1 << index) ?? (1 << index)
    }
    return count
}
```

### 解法六：位运算优化

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var map = [Character: Int]()
    for c in string {
        let index = Int(c.asciiValue!) - 97
        if map[c] == nil {
            count += 1
        } else if map[c]! & (1 << index) == 0 {
            count += 1
        }
        map[c] = map[c]?.bitwiseOr(1 << index) ?? (1 << index)
    }
    return count
}
```

### 解法七：位运算优化

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinct

func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var set = Set<Character>()
    for char in string {
        if !set.contains(char) {
            count += 1
            set.insert(char)
        }
    }
    return count
}

class Solution {
    func countDistinctCharacters(_ string: String) -> Int {
        let array = Array(string)
        var count = 0
        var set = Set<Character>()
        for char in array {
            if !set.contains(char) {
                count += 1
                set.insert(char)
            }
        }
        return count
    }
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var set = Set<Character>()
    for char in string {
        if !set.contains(char) {
            count += 1
            set.insert(char)
        }
    }
    return count
}
```

### 解题思路

### 代码

```swift
class Solution {
    func countDistinctCharacters(_ string: String) -> Int {
        let array = Array(string)
        var count = 0
        var set = Set<Character>()
        for char in array {
            if !set.contains(char) {
                count += 1
                set.insert(char)
            }
        }
        return count
    }
}
```

func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var map = [Character: Int]()
    for char in string {
        if map[char] == nil {
            count += 1
            map[char] = 1
        } else {
            map[char]! += 1
        }
    }
    return count
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var count = 0
    var map = [Character: Int]()
    for char in string {
        if map[char] == nil {
            count += 1
            map[char] = 1
        } else {
            map[char]! += 1
        }
    }
    return count
}
```

func countDistinctCharacters(string: String) -> Int {
    var map = [Character: Int]()
    for char in string {
        if map[char] == nil {
            map[char] = 1
        } else {
            map[char]! += 1
        }
    }
    return map.count
}

class Solution {
    func countDistinctCharacters(_ s: String) -> Int {
        var map = [Character: Int]()
        for char in s {
            if map[char] == nil {
                map[char] = 1
            } else {
                map[char]! += 1
            }
        }
        return map.count
    }
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var map = [Character: Int]()
    for char in string {
        if map[char] == nil {
            map[char] = 1
        } else {
            map[char]! += 1
        }
    }
    return map.count
}
```

### 解题思路

### 代码

```swift
class Solution {
    func countDistinctCharacters(_ s: String) -> Int {
        var map = [Character: Int]()
        for char in s {
            if map[char] == nil {
                map[char] = 1
            } else {
                map[char]! += 1
            }
        }
        return map.count
    }
}
```

func countDistinctCharacters(string: String) -> Int {
    var charSet = Set<Character>()
    for char in string {
        charSet.insert(char)
    }
    return charSet.count
}

class Solution {
    func countDistinctCharacters(_ string: String) -> Int {
        var charSet = Set<Character>()
        var result = 0
        for char in string {
            if charSet.contains(char) {
                continue
            }
            charSet.insert(char)
            result += 1
        }
        return result
    }
}

```swift
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// countDistinctCharacters(string: "xyzXYZ") == 3
// countDistinctCharacters(string: "Jerry") == 4
func countDistinctCharacters(string: String) -> Int {
    var charSet = Set<Character>()
    for char in string {
        charSet.insert(char)
    }
    return charSet.count
}
```

### 解题思路

### 代码

```swift
class Solution {
    func countDistinctCharacters(_ string: String) -> Int {
        var charSet = Set<Character>()
        var result = 0
        for char in string {
            if charSet.contains(char) {
                continue
            }
            charSet.insert(char)
            result += 1
        }
        return result
    }
}
```

func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { $0 }
    var result = [Int]()
    var currentNote = 0
    var currentDuration = 0
    for note in notes {
        switch note {
        case "o":
            currentDuration = 4
        case "o|":
            currentDuration = 2
        case ".|":
            currentDuration = 1
        default:
            break
        }
        currentNote += currentDuration
        result.append(currentNote)
    }
    return result
}

class Solution {
    func parseMusic(_ musicString: String) -> [Int] {
        var result = [Int]()
        var currentNote = 0
        var currentDuration = 0
        for note in musicString {
            switch note {
            case "o":
                currentDuration = 4
            case "o|":
                currentDuration = 2
            case ".|":
                currentDuration = 1
            default:
                break
            }
            currentNote += currentDuration
            result.append(currentNote)
        }
        return result
    }
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o| .| o| o| .| .| .| .| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { $0 }
    var result = [Int]()
    var currentNote = 0
    var currentDuration = 0
    for note in notes {
        switch note {
        case "o":
            currentDuration = 4
        case "o|":
            currentDuration = 2
        case ".|":
            currentDuration = 1
        default:
            break
        }
        currentNote += currentDuration
        result.append(currentNote)
    }
    return result
}
```

### 解题思路

### 代码

```swift
class Solution {
    func parseMusic(_ musicString: String) -> [Int] {
        var result = [Int]()
        var currentNote = 0
        var currentDuration = 0
        for note in musicString {
            switch note {
            case "o":
                currentDuration = 4
            case "o|":
                currentDuration = 2
            case ".|":
                currentDuration = 1
            default:
                break
            }
            currentNote += currentDuration
            result.append(currentNote)
        }
        return result
    }
}
```

func parseMusic(musicString: String) -> [Int] {
    var notes = [Int]()
    var note = 0
    for char in musicString {
        switch char {
        case "o":
            note = 4
        case "o|":
            note = 2
        case ".":
            note = 1
        default:
            break
        }
        notes.append(note)
    }
    return notes
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o| .| o| o| .| .| .| .| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    var notes = [Int]()
    var note = 0
    for char in musicString {
        switch char {
        case "o":
            note = 4
        case "o|":
            note = 2
        case ".":
            note = 1
        default:
            break
        }
        notes.append(note)
    }
    return notes
}
```

func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { $0 == "o" ? 4 : $0 == "o|" ? 2 : 1 }
    var result = [Int]()
    var current = 0
    for note in notes {
        current += note
        result.append(current)
    }
    return result
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o| .| o| o| .| .| .| .| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { $0 == "o" ? 4 : $0 == "o|" ? 2 : 1 }
    var result = [Int]()
    var current = 0
    for note in notes {
        current += note
        result.append(current)
    }
    return result
}
```

func parseMusic(musicString: String) -> [Int] {
    let musicArray = Array(musicString)
    var result = [Int]()
    var currentLength = 0
    for char in musicArray {
        if char == "o" {
            result.append(4)
            currentLength = 4
        } else if char == "o|" {
            result.append(2)
            currentLength = 2
        } else if char == ".|" {
            result.append(1)
            currentLength = 1
        }
        currentLength -= 1
        if currentLength == 0 {
            currentLength = 4
        }
    }
    return result
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o| .| o| o| .| .| .| .| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    let musicArray = Array(musicString)
    var result = [Int]()
    var currentLength = 0
    for char in musicArray {
        if char == "o" {
            result.append(4)
            currentLength = 4
        } else if char == "o|" {
            result.append(2)
            currentLength = 2
        } else if char == ".|" {
            result.append(1)
            currentLength = 1
        }
        currentLength -= 1
        if currentLength == 0 {
            currentLength = 4
        }
    }
    return result
}
```

func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { $0 }
    var result = [Int]()
    var currentLength = 0
    for note in notes {
        switch note {
        case "o":
            currentLength = 4
        case "o|":
            currentLength = 2
        case ".|":
            currentLength = 1
        default:
            break
        }
        result.append(currentLength)
    }
    return result
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o| .| o| o| .| .| .| .| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { $0 }
    var result = [Int]()
    var currentLength = 0
    for note in notes {
        switch note {
        case "o":
            currentLength = 4
        case "o|":
            currentLength = 2
        case ".|":
            currentLength = 1
        default:
            break
        }
        result.append(currentLength)
    }
    return result
}
```

func parseMusic(musicString: String) -> [Int] {
    let musicArray = Array(musicString)
    var notes = [Int]()
    var note = 0
    for char in musicArray {
        if char == "o" {
            note = 4
        } else if char == "o|" {
            note = 2
        } else if char == ".|" {
            note = 1
        }
        notes.append(note)
    }
    return notes
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o| .| o| o| .| .| .| .| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    let musicArray = Array(musicString)
    var notes = [Int]()
    var note = 0
    for char in musicArray {
        if char == "o" {
            note = 4
        } else if char == "o|" {
            note = 2
        } else if char == ".|" {
            note = 1
        }
        notes.append(note)
    }
    return notes
}
```

func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { $0 == "o" ? 4 : $0 == "o|" ? 2 : 1 }
    var result = [Int]()
    var count = 0
    for note in notes {
        count += note
        result.append(count)
    }
    return result
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o| .| o| o| .| .| .| .| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { $0 == "o" ? 4 : $0 == "o|" ? 2 : 1 }
    var result = [Int]()
    var count = 0
    for note in notes {
        count += note
        result.append(count)
    }
    return result
}
```

func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { String($0) }
    var result = [Int]()
    var currentNote = 0
    var currentNoteLength = 0
    for note in notes {
        if note == "o" {
            currentNoteLength = 4
        } else if note == "o|" {
            currentNoteLength = 2
        } else if note == ".|" {
            currentNoteLength = 1
        }
        currentNote += currentNoteLength
        result.append(currentNote)
    }
    return result
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o| .| o| o| .| .| .| .| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { String($0) }
    var result = [Int]()
    var currentNote = 0
    var currentNoteLength = 0
    for note in notes {
        if note == "o" {
            currentNoteLength = 4
        } else if note == "o|" {
            currentNoteLength = 2
        } else if note == ".|" {
            currentNoteLength = 1
        }
        currentNote += currentNoteLength
        result.append(currentNote)
    }
    return result
}
```

func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { $0 == "o" ? 4 : $0 == "o|" ? 2 : $0 == "." ? 1 : 0 }
    var result = [Int]()
    var current = 0
    for note in notes {
        current += note
        result.append(current)
    }
    return result
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o| .| o| o| .| .| .| .| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { $0 == "o" ? 4 : $0 == "o|" ? 2 : $0 == "." ? 1 : 0 }
    var result = [Int]()
    var current = 0
    for note in notes {
        current += note
        result.append(current)
    }
    return result
}
```

func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { $0 == "o" ? 4 : $0 == "o|" ? 2 : 1 }
    var result = [Int]()
    var current = 0
    for note in notes {
        current += note
        result.append(current)
    }
    return result
}

```swift
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return array of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// parseMusic(musicString: "o o| .| o| o| .| .| .| .| o o") == [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
func parseMusic(musicString: String) -> [Int] {
    let notes = musicString.map { $0 == "o" ? 4 : $0 == "o|" ? 2 : 1 }
    var result = [Int]()
    var current = 0
    for note in notes {
        current += note
        result.append(current)
    }
    return result
}
```

func howManyTimes(string: String, substring: String) -> Int {
    let count = string.count
    let subCount = substring.count
    if count < subCount {
        return 0
    }
    var count = 0
    for i in 0..<count {
        if string[i] == substring[0] {
            var j = i
            var k = 0
            while j < count && k < subCount && string[j] == substring[k] {
                j += 1
                k += 1
            }
            if k == subCount {
                count += 1
            }
        }
    }
    return count
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    let count = string.count
    let subCount = substring.count
    if count < subCount {
        return 0
    }
    var count = 0
    for i in 0..<count {
        if string[i] == substring[0] {
            var j = i
            var k = 0
            while j < count && k < subCount && string[j] == substring[k] {
                j += 1
                k += 1
            }
            if k == subCount {
                count += 1
            }
        }
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    guard string.count > 0, substring.count > 0 else {
        return 0
    }
    
    let count = string.count - substring.count + 1
    var result = 0
    
    for i in 0..<count {
        result += string[i..<i+substring.count].contains(substring) ? 1 : 0
    }
    
    return result
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    guard string.count > 0, substring.count > 0 else {
        return 0
    }
    
    let count = string.count - substring.count + 1
    var result = 0
    
    for i in 0..<count {
        result += string[i..<i+substring.count].contains(substring) ? 1 : 0
    }
    
    return result
}
```

func howManyTimes(string: String, substring: String) -> Int {
    if string.isEmpty || substring.isEmpty {
        return 0
    }
    let count = string.count
    let subCount = substring.count
    if count < subCount {
        return 0
    }
    var count = 0
    var start = 0
    while start < count {
        let index = string.index(string.startIndex, offsetBy: start)
        let end = string.index(index, offsetBy: subCount)
        let subString = string[index..<end]
        if subString == substring {
            count += 1
        }
        start += 1
    }
    return count
}

class Solution {
    func countSubstrings(_ s: String, _ t: String) -> Int {
        if s.isEmpty || t.isEmpty {
            return 0
        }
        let count = s.count
        let subCount = t.count
        if count < subCount {
            return 0
        }
        var count = 0
        var start = 0
        while start < count {
            let index = s.index(s.startIndex, offsetBy: start)
            let end = s.index(index, offsetBy: subCount)
            let subString = s[index..<end]
            if subString == t {
                count += 1
            }
            start += 1
        }
        return count
    }
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    if string.isEmpty || substring.isEmpty {
        return 0
    }
    let count = string.count
    let subCount = substring.count
    if count < subCount {
        return 0
    }
    var count = 0
    var start = 0
    while start < count {
        let index = string.index(string.startIndex, offsetBy: start)
        let end = string.index(index, offsetBy: subCount)
        let subString = string[index..<end]
        if subString == substring {
            count += 1
        }
        start += 1
    }
    return count
}
```

### 解题思路

### 代码

```swift
class Solution {
    func countSubstrings(_ s: String, _ t: String) -> Int {
        if s.isEmpty || t.isEmpty {
            return 0
        }
        let count = s.count
        let subCount = t.count
        if count < subCount {
            return 0
        }
        var count = 0
        var start = 0
        while start < count {
            let index = s.index(s.startIndex, offsetBy: start)
            let end = s.index(index, offsetBy: subCount)
            let subString = s[index..<end]
            if subString == t {
                count += 1
            }
            start += 1
        }
        return count
    }
}
```

func howManyTimes(string: String, substring: String) -> Int {
    guard string.count >= substring.count else {
        return 0
    }
    let count = string.count - substring.count + 1
    var result = 0
    for i in 0..<count {
        if string[i..<i + substring.count] == substring {
            result += 1
        }
    }
    return result
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    guard string.count >= substring.count else {
        return 0
    }
    let count = string.count - substring.count + 1
    var result = 0
    for i in 0..<count {
        if string[i..<i + substring.count] == substring {
            result += 1
        }
    }
    return result
}
```

func howManyTimes(string: String, substring: String) -> Int {
    guard string.count >= substring.count else { return 0 }
    let count = string.count - substring.count + 1
    var result = 0
    for i in 0..<count {
        if string[i..<i + substring.count] == substring {
            result += 1
        }
    }
    return result
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    guard string.count >= substring.count else { return 0 }
    let count = string.count - substring.count + 1
    var result = 0
    for i in 0..<count {
        if string[i..<i + substring.count] == substring {
            result += 1
        }
    }
    return result
}
```

func howManyTimes(string: String, substring: String) -> Int {
    let count = string.count
    let subCount = substring.count
    if count < subCount {
        return 0
    }
    var count = 0
    for i in 0..<count-subCount+1 {
        if string[i..<i+subCount] == substring {
            count += 1
        }
    }
    return count
}

func howManyTimes(string: String, substring: String) -> Int {
    let count = string.count
    let subCount = substring.count
    if count < subCount {
        return 0
    }
    var count = 0
    var j = 0
    let next = getNext(substring)
    for i in 0..<count {
        while j > 0 && string[i] != substring[j] {
            j = next[j-1]
        }
        if string[i] == substring[j] {
            j += 1
        }
        if j == subCount {
            count += 1
            j = next[j-1]
        }
    }
    return count
}

func getNext(_ string: String) -> [Int] {
    let count = string.count
    var next = [Int](repeating: 0, count: count)
    next[0] = 0
    var j = 0
    for i in 1..<count {
        while j > 0 && string[i] != string[j] {
            j = next[j-1]
        }
        if string[i] == string[j] {
            j += 1
        }
        next[i] = j
    }
    return next
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    let count = string.count
    let subCount = substring.count
    if count < subCount {
        return 0
    }
    var count = 0
    for i in 0..<count-subCount+1 {
        if string[i..<i+subCount] == substring {
            count += 1
        }
    }
    return count
}
```

### 解法二：滑动窗口

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    let count = string.count
    let subCount = substring.count
    if count < subCount {
        return 0
    }
    var count = 0
    for i in 0..<count-subCount+1 {
        if string[i..<i+subCount] == substring {
            count += 1
        }
    }
    return count
}
```

### 解法三：KMP

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    let count = string.count
    let subCount = substring.count
    if count < subCount {
        return 0
    }
    var count = 0
    var j = 0
    let next = getNext(substring)
    for i in 0..<count {
        while j > 0 && string[i] != substring[j] {
            j = next[j-1]
        }
        if string[i] == substring[j] {
            j += 1
        }
        if j == subCount {
            count += 1
            j = next[j-1]
        }
    }
    return count
}

func getNext(_ string: String) -> [Int] {
    let count = string.count
    var next = [Int](repeating: 0, count: count)
    next[0] = 0
    var j = 0
    for i in 1..<count {
        while j > 0 && string[i] != string[j] {
            j = next[j-1]
        }
        if string[i] == string[j] {
            j += 1
        }
        next[i] = j
    }
    return next
}
```

### 解法四：Rabin-Karp

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    let count = string.count
    let subCount = substring.count
    if count < subCount {
        return 0
    }
    let prime = 1000000007
    let base = 31
    let hashValue = getHashValue(string, subCount)
    let subHashValue = getHashValue(substring, subCount)
    var count = 0
    for i in 0..<count-subCount+1 {
        if hashValue == subHashValue && string[i..<i+subCount] == substring {
            count += 1
        }
        if i < count-subCount {
            hashValue = (hashValue * base + string[i+subCount].wholeNumber

func howManyTimes(string: String, substring: String) -> Int {
    guard string.count >= substring.count else {
        return 0
    }
    var count = 0
    for i in 0..<string.count {
        let start = string.index(string.startIndex, offsetBy: i)
        let end = string.index(string.startIndex, offsetBy: string.count - substring.count + i)
        let subStr = string[start..<end]
        if subStr == substring {
            count += 1
        }
    }
    return count
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    guard string.count >= substring.count else {
        return 0
    }
    var count = 0
    for i in 0..<string.count {
        let start = string.index(string.startIndex, offsetBy: i)
        let end = string.index(string.startIndex, offsetBy: string.count - substring.count + i)
        let subStr = string[start..<end]
        if subStr == substring {
            count += 1
        }
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    let s = Array(string)
    let sub = Array(substring)
    
    var count = 0
    var i = 0
    var j = 0
    
    while i < s.count {
        if s[i] == sub[j] {
            if j == sub.count - 1 {
                count += 1
                j = 0
            } else {
                j += 1
            }
        } else {
            j = 0
        }
        i += 1
    }
    
    return count
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    let s = Array(string)
    let sub = Array(substring)
    
    var count = 0
    var i = 0
    var j = 0
    
    while i < s.count {
        if s[i] == sub[j] {
            if j == sub.count - 1 {
                count += 1
                j = 0
            } else {
                j += 1
            }
        } else {
            j = 0
        }
        i += 1
    }
    
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    let s = Array(string)
    let sub = Array(substring)
    var count = 0
    var i = 0
    var j = 0
    while i < s.count {
        if s[i] == sub[j] {
            if j == sub.count - 1 {
                count += 1
                j = 0
            } else {
                j += 1
            }
        } else {
            j = 0
        }
        i += 1
    }
    return count
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    let s = Array(string)
    let sub = Array(substring)
    var count = 0
    var i = 0
    var j = 0
    while i < s.count {
        if s[i] == sub[j] {
            if j == sub.count - 1 {
                count += 1
                j = 0
            } else {
                j += 1
            }
        } else {
            j = 0
        }
        i += 1
    }
    return count
}
```

func howManyTimes(string: String, substring: String) -> Int {
    let s = Array(string)
    let sub = Array(substring)
    var count = 0
    var start = 0
    var end = 0
    while start < s.count {
        end = start
        while end < s.count && s[end] == sub[0] {
            end += 1
        }
        if end - start == sub.count {
            count += 1
        }
        start = end
    }
    return count
}

```swift
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// howManyTimes(string: "", substring: "a") == 0
// howManyTimes(string: "aaa", substring: "a") == 3
// howManyTimes(string: "aaaa", substring: "aa") == 3
func howManyTimes(string: String, substring: String) -> Int {
    let s = Array(string)
    let sub = Array(substring)
    var count = 0
    var start = 0
    var end = 0
    while start < s.count {
        end = start
        while end < s.count && s[end] == sub[0] {
            end += 1
        }
        if end - start == sub.count {
            count += 1
        }
        start = end
    }
    return count
}
```

func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0.unicodeScalars.first!.value) }
    return nums.sorted().joined(separator: " ")
}

func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: { $0.unicodeScalars.first!.value < $1.unicodeScalars.first!.value }).joined(separator: " ")
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0.unicodeScalars.first!.value) }
    return nums.sorted().joined(separator: " ")
}
```

### 解法二：正则表达式

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: { $0.unicodeScalars.first!.value < $1.unicodeScalars.first!.value }).joined(separator: " ")
}
```

### 解法三：自定义排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: { $0.unicodeScalars.first!.value < $1.unicodeScalars.first!.value }).joined(separator: " ")
}
```

### 解法四：自定义排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: { $0.unicodeScalars.first!.value < $1.unicodeScalars.first!.value }).joined(separator: " ")
}
```

### 解法五：自定义排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: { $0.unicodeScalars.first!.value < $1.unicodeScalars.first!.value }).joined(separator: " ")
}
```

### 解法六：自定义排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: { $0

func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted(by: { $0 < $1 }).joined()
}

func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted(by: <).joined()
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted(by: { $0 < $1 }).joined()
}
```

### 解法二：使用 Swift 标准库函数

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted(by: <).joined()
}
```

### 解法三：使用 Swift 标准库函数

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted(by: <).joined()
}
```

### 解法四：使用 Swift 标准库函数

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted(by: <).joined()
}
```

### 解法五：使用 Swift 标准库函数

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted(by: <).joined()
}
```

### 解法六：使用 Swift 标准库函数

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted(by: <).joined()
}
```

### 解法七：使用 Swift 标准库函数

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted(by: <).joined()
}

func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    var sorted = nums.sorted()
    return sorted.joined(separator: " ")
}

func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted().joined(separator: " ")
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    var sorted = nums.sorted()
    return sorted.joined(separator: " ")
}
```

### 2. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted().joined(separator: " ")
}
```

### 3. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted().joined(separator: " ")
}
```

### 4. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted().joined(separator: " ")
}
```

### 5. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted().joined(separator: " ")
}
```

### 6. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted().joined(separator: " ")
}
```

### 7. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted().joined(separator: " ")
}
```

### 8. 排序

```swift
// Input is

func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    let sorted = nums.sorted()
    return sorted.joined(separator: " ")
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    let sorted = nums.sorted()
    return sorted.joined(separator: " ")
}
```

### 2. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    let sorted = nums.sorted()
    return sorted.joined(separator: " ")
}
```

### 3. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    let sorted = nums.sorted()
    return sorted.joined(separator: " ")
}
```

### 4. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    let sorted = nums.sorted()
    return sorted.joined(separator: " ")
}
```

### 5. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    let sorted = nums.sorted()
    return sorted.joined(separator: " ")
}
```

### 6. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    let sorted = nums.sorted()
    return sorted.joined(separator: " ")
}
```

### 7. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    let sorted = nums

func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: <).joined(separator: " ")
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: <).joined(separator: " ")
}
```

### 2. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: <).joined(separator: " ")
}
```

### 3. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: <).joined(separator: " ")
}
```

### 4. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: <).joined(separator: " ")
}
```

### 5. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: <).joined(separator: " ")
}
```

### 6. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: <).joined(separator: " ")
}
```

### 7. 排序

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(

func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted(by: { $0 < $1 }).joined()
}

func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: { $0 < $1 }).joined()
}

func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: { $0.reversed() < $1.reversed() }).joined()
}

func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: { Int($0) < Int($1) }).joined()
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted(by: { $0 < $1 }).joined()
}
```

### 解法二：正则表达式

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: { $0 < $1 }).joined()
}
```

### 解法三：正则表达式

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: { $0.reversed() < $1.reversed() }).joined()
}
```

### 解法四：正则表达式

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: { Int($0) < Int($1) }).joined()
}
```

### 解法五：正则表达式

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: { Int($0) < Int($1) }).joined()
}
```

### 解法六：正则表达式

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.split(separator: " ").map { String($0) }
    return nums.sorted(by: { Int($0) < Int($1) }).joined()
}
```

### 解法七：正则表达式

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.

func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { Int(String($0))! }
    nums.sort()
    return nums.map { String($0) }.joined()
}

func sortNumbers(numbers: String) -> String {
    let regex = try! NSRegularExpression(pattern: "\\d+", options: [.caseInsensitive])
    let nums = regex.matches(in: numbers, range: NSRange(numbers.startIndex..., in: numbers)).map { Int(String($0.captures[0]))! }
    nums.sort()
    return nums.map { String($0) }.joined()
}

func sortNumbers(numbers: String) -> String {
    let regex = try! NSRegularExpression(pattern: "\\D+", options: [.caseInsensitive])
    let nums = regex.matches(in: numbers, range: NSRange(numbers.startIndex..., in: numbers)).map { Int(String($0.captures[0]))! }
    nums.sort()
    return nums.map { String($0) }.joined()
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { Int(String($0))! }
    nums.sort()
    return nums.map { String($0) }.joined()
}
```

### 解法二：正则表达式

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let regex = try! NSRegularExpression(pattern: "\\d+", options: [.caseInsensitive])
    let nums = regex.matches(in: numbers, range: NSRange(numbers.startIndex..., in: numbers)).map { Int(String($0.captures[0]))! }
    nums.sort()
    return nums.map { String($0) }.joined()
}
```

### 解法三：正则表达式

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let regex = try! NSRegularExpression(pattern: "\\D+", options: [.caseInsensitive])
    let nums = regex.matches(in: numbers, range: NSRange(numbers.startIndex..., in: numbers)).map { Int(String($0.captures[0]))! }
    nums.sort()
    return nums.map { String($0) }.joined()
}
```

### 解法四：正则表达式

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let regex = try! NSRegularExpression(pattern: "\\D+", options: [.caseInsensitive])
    let nums = regex.matches(in: numbers, range: NSRange(numbers.startIndex..., in: numbers)).map { Int(String($0.captures[0]))! }
    nums.sort()
    return nums.map { String($0) }.joined()
}
```

### 解法五：正则表达式

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let regex = try! NSRegularExpression(pattern: "\\D+", options: [.caseInsensitive])
    let nums = regex.matches(in: numbers, range: NSRange(numbers.startIndex..., in: numbers)).map { Int(String($0.captures[0]))! }
    nums.sort()
    return nums.map { String($0) }.joined()
}
```

### 解法六：正则表达式

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one

func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted { $0 < $1 }.joined()
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    return nums.sorted { $0 < $1 }.joined()
}
```

func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0.asciiValue! - 48) }
    return nums.sorted().joined(separator: " ")
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0.asciiValue! - 48) }
    return nums.sorted().joined(separator: " ")
}
```

func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    let sorted = nums.sorted { nums[$0] < nums[$1] }
    return sorted.joined()
}

func sortNumbers(numbers: String) -> String {
    let regex = "\\d+"
    let nums = numbers.split(separator: regex, omittingEmptySubsequences: false)
    let sorted = nums.sorted { nums[$0] < nums[$1] }
    return sorted.joined()
}

func sortNumbers(numbers: String) -> String {
    let regex = "\\D+"
    let nums = numbers.split(separator: regex, omittingEmptySubsequences: false)
    let sorted = nums.sorted { nums[$0] < nums[$1] }
    return sorted.joined()
}

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let nums = numbers.map { String($0) }
    let sorted = nums.sorted { nums[$0] < nums[$1] }
    return sorted.joined()
}
```

### 解法二：正则表达式

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let regex = "\\d+"
    let nums = numbers.split(separator: regex, omittingEmptySubsequences: false)
    let sorted = nums.sorted { nums[$0] < nums[$1] }
    return sorted.joined()
}
```

### 解法三：正则表达式

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let regex = "\\D+"
    let nums = numbers.split(separator: regex, omittingEmptySubsequences: false)
    let sorted = nums.sorted { nums[$0] < nums[$1] }
    return sorted.joined()
}
```

### 解法四：正则表达式

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let regex = "\\D+"
    let nums = numbers.split(separator: regex, omittingEmptySubsequences: false)
    let sorted = nums.sorted { nums[$0] < nums[$1] }
    return sorted.joined()
}
```

### 解法五：正则表达式

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let regex = "\\D+"
    let nums = numbers.split(separator: regex, omittingEmptySubsequences: false)
    let sorted = nums.sorted { nums[$0] < nums[$1] }
    return sorted.joined()
}
```

### 解法六：正则表达式

```swift
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// sortNumbers(numbers: "three one five") == "one three five"
func sortNumbers(numbers: String) -> String {
    let regex = "\\D+"
    let nums = numbers.split(separator: regex, omittingEmptySubsequences: false)
    let sorted = nums.sorted { nums[$0] < nums[$1] }

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else { fatalError("Cannot find closest elements from an array of length 1 or less") }
    let sorted = numbers.sorted()
    let closest = sorted[0..<2]
    let closestDiff = abs(closest[0] - closest[1])
    var closestIndex = 0
    for i in 1..<numbers.count {
        let diff = abs(sorted[i] - sorted[i-1])
        if diff < closestDiff {
            closestDiff = diff
            closestIndex = i
        }
    }
    return (sorted[closestIndex], sorted[closestIndex-1])
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else { fatalError("Cannot find closest elements from an array of length 1 or less") }
    let sorted = numbers.sorted()
    let closest = sorted[0..<2]
    let closestDiff = abs(closest[0] - closest[1])
    var closestIndex = 0
    for i in 1..<numbers.count {
        let diff = abs(sorted[i] - sorted[i-1])
        if diff < closestDiff {
            closestDiff = diff
            closestIndex = i
        }
    }
    return (sorted[closestIndex], sorted[closestIndex-1])
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else { fatalError("At least two numbers are required") }
    let sorted = numbers.sorted()
    let closest = sorted.first!
    let secondClosest = sorted[1]
    let diff = abs(closest - secondClosest)
    let result = (closest, secondClosest)
    return diff < 0.0000001 ? result : (secondClosest, closest)
}

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else { fatalError("At least two numbers are required") }
    let sorted = numbers.sorted()
    let closest = sorted.first!
    let secondClosest = sorted[1]
    let result = (closest, secondClosest)
    return abs(closest - secondClosest) < 0.0000001 ? result : (secondClosest, closest)
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else { fatalError("At least two numbers are required") }
    let sorted = numbers.sorted()
    let closest = sorted.first!
    let secondClosest = sorted[1]
    let diff = abs(closest - secondClosest)
    let result = (closest, secondClosest)
    return diff < 0.0000001 ? result : (secondClosest, closest)
}
```

### 解法二

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else { fatalError("At least two numbers are required") }
    let sorted = numbers.sorted()
    let closest = sorted.first!
    let secondClosest = sorted[1]
    let result = (closest, secondClosest)
    return abs(closest - secondClosest) < 0.0000001 ? result : (secondClosest, closest)
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    
    let sorted = numbers.sorted()
    let mid = sorted.count / 2
    let left = sorted[mid - 1]
    let right = sorted[mid]
    
    if abs(left - right) < 0.000000000000001 {
        return (left, right)
    }
    
    if left < right {
        return (left, sorted[mid + 1])
    } else {
        return (sorted[mid - 1], right)
    }
}

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    
    let sorted = numbers.sorted()
    let mid = sorted.count / 2
    let left = sorted[mid - 1]
    let right = sorted[mid]
    
    if abs(left - right) < 0.000000000000001 {
        return (left, right)
    }
    
    if left < right {
        return findClosestElements(numbers: sorted[0..<mid])
    } else {
        return findClosestElements(numbers: sorted[mid..<sorted.count])
    }
}

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    
    let sorted = numbers.sorted()
    let mid = sorted.count / 2
    let left = sorted[mid - 1]
    let right = sorted[mid]
    
    if abs(left - right) < 0.000000000000001 {
        return (left, right)
    }
    
    var leftIndex = 0
    var rightIndex = numbers.count - 1
    
    while leftIndex < rightIndex {
        let midIndex = leftIndex + (rightIndex - leftIndex) / 2
        let midValue = numbers[midIndex]
        
        if abs(left - midValue) < abs(right - midValue) {
            rightIndex = midIndex
        } else {
            leftIndex = midIndex + 1
        }
    }
    
    return (numbers[leftIndex], numbers[leftIndex + 1])
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    
    let sorted = numbers.sorted()
    let mid = sorted.count / 2
    let left = sorted[mid - 1]
    let right = sorted[mid]
    
    if abs(left - right) < 0.000000000000001 {
        return (left, right)
    }
    
    if left < right {
        return (left, sorted[mid + 1])
    } else {
        return (sorted[mid - 1], right)
    }
}
```

### 解法二：二分查找

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    
    let sorted = numbers.sorted()
    let mid = sorted.count / 2
    let left = sorted[mid - 1]
    let right = sorted[mid]
    
    if abs(left - right) < 0.000000000000001 {
        return (left, right)
    }
    
    if left < right {
        return findClosestElements(numbers: sorted[0..<mid])
    } else {
        return findClosestElements(numbers: sorted[mid..<sorted.count])
    }
}

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    
    let sorted = numbers.sorted()
    let mid = sorted.count / 2
    let left = sorted[mid - 1]
    let right = sorted[mid]
    
    if abs(left - right) < 0.000000000000001 {
        return (left, right)
    }
    
    var leftIndex = 0
    var rightIndex = numbers.count - 1
    
    while leftIndex < rightIndex {
        let midIndex = leftIndex + (rightIndex - leftIndex) / 2
        let midValue = numbers[midIndex]
        
        if abs(left - midValue) < abs(right - midValue) {
            rightIndex = midIndex
        } else {
            leftIndex = midIndex + 1
        }
    }
    
    return (numbers[leftIndex], numbers[leftIndex + 1])
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    
    let sorted = numbers.sorted()
    let min = sorted.first!
    let max = sorted.last!
    
    let minIndex = numbers.firstIndex(of: min)!
    let maxIndex = numbers.lastIndex(of: max)!
    
    let minDistance = abs(min - max)
    
    if minIndex == maxIndex {
        return (min, max)
    }
    
    let left = abs(min - numbers[minIndex + 1])
    let right = abs(max - numbers[maxIndex - 1])
    
    if left < right {
        return (min, numbers[minIndex + 1])
    } else {
        return (numbers[maxIndex - 1], max)
    }
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    
    let sorted = numbers.sorted()
    let min = sorted.first!
    let max = sorted.last!
    
    let minIndex = numbers.firstIndex(of: min)!
    let maxIndex = numbers.lastIndex(of: max)!
    
    let minDistance = abs(min - max)
    
    if minIndex == maxIndex {
        return (min, max)
    }
    
    let left = abs(min - numbers[minIndex + 1])
    let right = abs(max - numbers[maxIndex - 1])
    
    if left < right {
        return (min, numbers[minIndex + 1])
    } else {
        return (numbers[maxIndex - 1], max)
    }
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else { fatalError("Array must be of length at least 2") }
    
    let sorted = numbers.sorted()
    let mid = (numbers.count - 1) / 2
    let left = sorted[mid]
    let right = sorted[mid + 1]
    
    if abs(left - right) < 1e-10 {
        return (left, right)
    } else if left < right {
        return (left, sorted[mid + 1])
    } else {
        return (sorted[mid], right)
    }
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else { fatalError("Array must be of length at least 2") }
    
    let sorted = numbers.sorted()
    let mid = (numbers.count - 1) / 2
    let left = sorted[mid]
    let right = sorted[mid + 1]
    
    if abs(left - right) < 1e-10 {
        return (left, right)
    } else if left < right {
        return (left, sorted[mid + 1])
    } else {
        return (sorted[mid], right)
    }
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    
    let sorted = numbers.sorted()
    let min = sorted[0]
    let max = sorted[sorted.count - 1]
    
    let minIndex = sorted.firstIndex(of: min)!
    let maxIndex = sorted.lastIndex(of: max)!
    
    let minDistance = abs(min - max)
    
    var minIndex = minIndex
    var maxIndex = maxIndex
    
    while abs(min - max) > 0.0000001 {
        if minIndex == maxIndex {
            break
        }
        
        if abs(min - sorted[minIndex + 1]) < abs(min - sorted[maxIndex - 1]) {
            maxIndex -= 1
        } else {
            minIndex += 1
        }
    }
    
    return (sorted[minIndex], sorted[maxIndex])
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    
    let sorted = numbers.sorted()
    let min = sorted[0]
    let max = sorted[sorted.count - 1]
    
    let minIndex = sorted.firstIndex(of: min)!
    let maxIndex = sorted.lastIndex(of: max)!
    
    let minDistance = abs(min - max)
    
    var minIndex = minIndex
    var maxIndex = maxIndex
    
    while abs(min - max) > 0.0000001 {
        if minIndex == maxIndex {
            break
        }
        
        if abs(min - sorted[minIndex + 1]) < abs(min - sorted[maxIndex - 1]) {
            maxIndex -= 1
        } else {
            minIndex += 1
        }
    }
    
    return (sorted[minIndex], sorted[maxIndex])
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    
    let sorted = numbers.sorted()
    
    let min = sorted[0]
    let max = sorted[sorted.count - 1]
    
    let diff = abs(max - min)
    
    let mid = min + diff / 2
    
    let left = sorted.firstIndex(of: mid) ?? 0
    let right = left + 1
    
    let leftNum = sorted[left]
    let rightNum = sorted[right]
    
    if abs(leftNum - mid) < abs(rightNum - mid) {
        return (leftNum, rightNum)
    } else {
        return (rightNum, leftNum)
    }
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    
    let sorted = numbers.sorted()
    
    let min = sorted[0]
    let max = sorted[sorted.count - 1]
    
    let diff = abs(max - min)
    
    let mid = min + diff / 2
    
    let left = sorted.firstIndex(of: mid) ?? 0
    let right = left + 1
    
    let leftNum = sorted[left]
    let rightNum = sorted[right]
    
    if abs(leftNum - mid) < abs(rightNum - mid) {
        return (leftNum, rightNum)
    } else {
        return (rightNum, leftNum)
    }
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    
    let sorted = numbers.sorted()
    let mid = sorted.count / 2
    let left = sorted[mid - 1]
    let right = sorted[mid]
    
    return (left, right)
}

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    
    let sorted = numbers.sorted()
    let mid = sorted.count / 2
    let left = sorted[mid - 1]
    let right = sorted[mid]
    
    let diff = abs(left - right)
    let mid = (left + right) / 2
    
    let left = sorted[sorted.binarySearch(left, options: .backwards) ?? 0]
    let right = sorted[sorted.binarySearch(right, options: .backwards) ?? 0]
    
    if abs(left - mid) < diff {
        return (left, mid)
    } else {
        return (mid, right)
    }
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    
    let sorted = numbers.sorted()
    let mid = sorted.count / 2
    let left = sorted[mid - 1]
    let right = sorted[mid]
    
    return (left, right)
}
```

### 解法二

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    
    let sorted = numbers.sorted()
    let mid = sorted.count / 2
    let left = sorted[mid - 1]
    let right = sorted[mid]
    
    let diff = abs(left - right)
    let mid = (left + right) / 2
    
    let left = sorted[sorted.binarySearch(left, options: .backwards) ?? 0]
    let right = sorted[sorted.binarySearch(right, options: .backwards) ?? 0]
    
    if abs(left - mid) < diff {
        return (left, mid)
    } else {
        return (mid, right)
    }
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    let sorted = numbers.sorted()
    let mid = (numbers.count - 1) / 2
    let left = sorted[mid]
    let right = sorted[mid + 1]
    let diff = abs(left - right)
    return (left, right)
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    guard numbers.count > 1 else {
        return (numbers[0], numbers[0])
    }
    let sorted = numbers.sorted()
    let mid = (numbers.count - 1) / 2
    let left = sorted[mid]
    let right = sorted[mid + 1]
    let diff = abs(left - right)
    return (left, right)
}
```

func findClosestElements(numbers: [Double]) -> (Double, Double) {
    let sorted = numbers.sorted()
    let min = sorted.first!
    let max = sorted.last!
    let closest = min + (max - min) / 2
    let minIndex = sorted.firstIndex(of: closest)!
    let maxIndex = sorted.lastIndex(of: closest)!
    let minValue = sorted[minIndex]
    let maxValue = sorted[maxIndex]
    return (minValue, maxValue)
}

```swift
// From a supplied array of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
// findClosestElements(numbers: [1.0, 2.0, 3.0, 4.0, 5.0, 2.0]) == (2.0, 2.0)
func findClosestElements(numbers: [Double]) -> (Double, Double) {
    let sorted = numbers.sorted()
    let min = sorted.first!
    let max = sorted.last!
    let closest = min + (max - min) / 2
    let minIndex = sorted.firstIndex(of: closest)!
    let maxIndex = sorted.lastIndex(of: closest)!
    let minValue = sorted[minIndex]
    let maxValue = sorted[maxIndex]
    return (minValue, maxValue)
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 - min / range }
}

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 / range }
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 - min / range }
}
```

### 解法二

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 / range }
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 - min / range }
}

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 / range }
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 - min / range }
}
```

### 解法二

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 - min / range }
}
```

### 解法三

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 / range }
}
```

### 解法四

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 / range }
}
```

### 解法五

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 / range }
}
```

### 解法六

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 / range }
}
```

### 解法七

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let sorted = numbers.sorted()
    let min = sorted[0]
    let max = sorted.last!
    let range = max - min
    return sorted.map { (($0 - min) / range) }
}

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    let mid = numbers.count / 2
    let left = numbers[0..<mid]
    let right = numbers[mid..<numbers.count]
    let leftResult = rescaleToUnit(numbers: left)
    let rightResult = rescaleToUnit(numbers: right)
    return merge(left: leftResult, right: rightResult, min: min, range: range)
}

func merge(left: [Double], right: [Double], min: Double, range: Double) -> [Double] {
    var result = [Double]()
    var i = 0
    var j = 0
    while i < left.count && j < right.count {
        let leftValue = left[i]
        let rightValue = right[j]
        if leftValue < rightValue {
            result.append(min + (leftValue * range))
            i += 1
        } else {
            result.append(min + (rightValue * range))
            j += 1
        }
    }
    while i < left.count {
        result.append(min + (left[i] * range))
        i += 1
    }
    while j < right.count {
        result.append(min + (right[j] * range))
        j += 1
    }
    return result
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

### 解法二：排序

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let sorted = numbers.sorted()
    let min = sorted[0]
    let max = sorted.last!
    let range = max - min
    return sorted.map { (($0 - min) / range) }
}
```

### 解法三：分治

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    let mid = numbers.count / 2
    let left = numbers[0..<mid]
    let right = numbers[mid..<numbers.count]
    let leftResult = rescaleToUnit(numbers: left)
    let rightResult = rescaleToUnit(numbers: right)
    return merge(left: leftResult, right: rightResult, min: min, range: range)
}

func merge(left: [Double], right: [Double], min: Double, range: Double) -> [Double] {
    var result = [Double]()
    var i = 0
    var j = 0
    while i < left.count && j < right.count {
        let leftValue = left[i]
        let rightValue = right[j]
        if leftValue < rightValue {
            result.append(min + (leftValue * range))
            i += 1
        } else {
            result.append(min + (rightValue * range))
            j += 1
        }
    }
    while i < left.count {
        result.append(min + (left[i] * range))
        i += 1
    }
    while j < right.count {
        result.append(min + (right[j] * range))
        j += 1
    }
    return result
}
```

### 解法四：二分查找

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    let mid = numbers.count / 2
    let left = numbers[0..<mid]
    let right = numbers[mid..<numbers.count]
    let leftResult = rescaleToUnit(numbers: left)
    let rightResult = rescaleToUnit(numbers: right)
    return merge(left: leftResult, right: rightResult, min: min, range: range)
}

func merge(left: [Double], right: [Double], min: Double, range: Double) -> [Double] {
    var result = [Double]

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 - min / range }
}

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 / range }
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 - min / range }
}
```

### 解法二

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 - min / range }
}
```

### 解法三

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 / range }
}
```

### 解法四

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 / range }
}
```

### 解法五

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 / range }
}
```

### 解法六

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 / range }
}
```

### 解法七

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let sorted = numbers.sorted()
    let min = sorted[0]
    let max = sorted[sorted.count - 1]
    let range = max - min
    return sorted.map { (($0 - min) / range) }
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

### 解法二：排序

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let sorted = numbers.sorted()
    let min = sorted[0]
    let max = sorted[sorted.count - 1]
    let range = max - min
    return sorted.map { (($0 - min) / range) }
}
```

### 解法三：分治

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

### 解法四：二分查找

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

### 解法五：数学

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

### 解法六：数学

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

### 解法七：数学

```swift
// Given array of numbers (of at least two

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}

func rescaleToUnit(numbers: [Double]) -> [Double] {
    return numbers.map { $0 / Double(numbers.count) }
}

func rescaleToUnit(numbers: [Double]) -> [Double] {
    return numbers.map { $0 / numbers.max()! }
}

func rescaleToUnit(numbers: [Double]) -> [Double] {
    return numbers.map { $0 / numbers.min()! }
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

### 解法二：使用数组方法

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    return numbers.map { $0 / Double(numbers.count) }
}
```

### 解法三：使用数组方法

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    return numbers.map { $0 / numbers.max()! }
}
```

### 解法四：使用数组方法

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    return numbers.map { $0 / numbers.min()! }
}
```

### 解法五：使用数组方法

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

### 解法六：使用数组方法

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

### 解法七：使用数组方法

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.7

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

### 解法二

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

### 解法三

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

### 解法四

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

### 解法五

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

### 解法六

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

### 解法七

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

### 解法二

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { (($0 - min) / range) }
}
```

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 - min / range }
}

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let sorted = numbers.sorted()
    let min = sorted[0]
    let max = sorted[sorted.count - 1]
    let range = max - min
    return sorted.map { $0 - min / range }
}

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    let mid = min + range / 2
    let midIndex = numbers.firstIndex(of: mid) ?? 0
    let left = numbers[0...midIndex]
    let right = numbers[midIndex...]
    return left.map { $0 - min / range } + right.map { $0 - mid / range }
}

func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    let mid = min + range / 2
    let left = numbers[0...numbers.firstIndex(of: mid) ?? 0]
    let right = numbers[numbers.firstIndex(of: mid) ?? 0...]
    return left.map { $0 - min / range } + right.map { $0 - mid / range }
}

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    return numbers.map { $0 - min / range }
}
```

### 解法二：排序

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let sorted = numbers.sorted()
    let min = sorted[0]
    let max = sorted[sorted.count - 1]
    let range = max - min
    return sorted.map { $0 - min / range }
}
```

### 解法三：二分查找

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    let mid = min + range / 2
    let midIndex = numbers.firstIndex(of: mid) ?? 0
    let left = numbers[0...midIndex]
    let right = numbers[midIndex...]
    return left.map { $0 - min / range } + right.map { $0 - mid / range }
}
```

### 解法四：分治

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    let mid = min + range / 2
    let left = numbers[0...numbers.firstIndex(of: mid) ?? 0]
    let right = numbers[numbers.firstIndex(of: mid) ?? 0...]
    return left.map { $0 - min / range } + right.map { $0 - mid / range }
}
```

### 解法五：分治 + 递归

```swift
// Given array of numbers (of at least two elements), apply a linear transform to that array,
// such that the smallest number will become 0 and the largest will become 1
// rescaleToUnit(numbers: [1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
func rescaleToUnit(numbers: [Double]) -> [Double] {
    let min = numbers.min()!
    let max = numbers.max()!
    let range = max - min
    let mid = min + range / 2
    let left = numbers[0...numbers.firstIndex(of: mid) ?? 0]
    let right = numbers[numbers.firstIndex(of: mid) ?? 0...]
    return left.map { $0 - min / range } + right.map { $0 - mid / range }
}
```

### 解法六：分治 + 迭代

```swift
// Given array of numbers

func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}

func filterStrings(values: [AnyHashable]) -> [String] {
    return values.compactMap { $0 as? String }
}

func filterDictionaries(values: [AnyHashable]) -> [[AnyHashable]] {
    return values.compactMap { $0 as? [AnyHashable] }
}

func filterArrays(values: [AnyHashable]) -> [[AnyHashable]] {
    return values.compactMap { $0 as? [AnyHashable] }
}

func filterSets(values: [AnyHashable]) -> [Set<AnyHashable>] {
    return values.compactMap { $0 as? Set<AnyHashable> }
}

func filterTuples(values: [AnyHashable]) -> [(Int, Int)] {
    return values.compactMap { $0 as? (Int, Int) }
}

func filterEnums(values: [AnyHashable]) -> [MyEnum] {
    return values.compactMap { $0 as? MyEnum }
}

func filterStructs(values: [AnyHashable]) -> [MyStruct] {
    return values.compactMap { $0 as? MyStruct }
}

func filterClasses(values: [AnyHashable]) -> [MyClass] {
    return values.compactMap { $0 as? MyClass }
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}
```

### Filter out only strings

```swift
// Filter given array of any swiftthon values only for strings
// filterStrings(values: [1, 2, 3.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == ["abc"]
func filterStrings(values: [AnyHashable]) -> [String] {
    return values.compactMap { $0 as? String }
}
```

### Filter out only dictionaries

```swift
// Filter given array of any swiftthon values only for dictionaries
// filterDictionaries(values: [1, 2, 3.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [[]]
func filterDictionaries(values: [AnyHashable]) -> [[AnyHashable]] {
    return values.compactMap { $0 as? [AnyHashable] }
}
```

### Filter out only arrays

```swift
// Filter given array of any swiftthon values only for arrays
// filterArrays(values: [1, 2, 3.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [[], [:]]
func filterArrays(values: [AnyHashable]) -> [[AnyHashable]] {
    return values.compactMap { $0 as? [AnyHashable] }
}
```

### Filter out only sets

```swift
// Filter given array of any swiftthon values only for sets
// filterSets(values: [1, 2, 3.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [Set<AnyHashable>]
func filterSets(values: [AnyHashable]) -> [Set<AnyHashable>] {
    return values.compactMap { $0 as? Set<AnyHashable> }
}
```

### Filter out only tuples

```swift
// Filter given array of any swiftthon values only for tuples
// filterTuples(values: [1, 2, 3.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [(1, 2)]
func filterTuples(values: [AnyHashable]) -> [(Int, Int)] {
    return values.compactMap { $0 as? (Int, Int) }
}
```

### Filter out only enums

```swift
// Filter given array of any swiftthon values only for enums
// filterEnums(values: [1, 2, 3.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [.a]
func filterEnums(values: [AnyHashable]) -> [MyEnum] {
    return values.compactMap { $0 as? MyEnum }
}
```

### Filter out only structs

```swift
// Filter given array of any swiftthon values only for structs
// filterStructs(values: [1, 2, 3.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [MyStruct(a: 1, b: 2)]
func filterStructs(values: [AnyHashable]) -> [MyStruct] {
    return values.compactMap { $0 as? MyStruct }
}
```

### Filter out only classes

```swift
// Filter given array of any swiftthon values only for classes
// filterClasses(values: [1, 2, 3.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [MyClass(a: 1, b: 2)]
func filterClasses(values: [AnyHashable]) -> [MyClass] {
    return values.compactMap { $0 as? MyClass }
}
```

### Filter out

func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.filter { $0 is Int }.map { $0 as! Int }
}

func filterStrings(values: [AnyHashable]) -> [String] {
    return values.filter { $0 is String }.map { $0 as! String }
}

func filterFloats(values: [AnyHashable]) -> [Float] {
    return values.filter { $0 is Float }.map { $0 as! Float }
}

func filterDoubles(values: [AnyHashable]) -> [Double] {
    return values.filter { $0 is Double }.map { $0 as! Double }
}

func filterBools(values: [AnyHashable]) -> [Bool] {
    return values.filter { $0 is Bool }.map { $0 as! Bool }
}

func filterArrays(values: [AnyHashable]) -> [[AnyHashable]] {
    return values.filter { $0 is Array }.map { $0 as! [[AnyHashable]] }
}

func filterSets(values: [AnyHashable]) -> Set<AnyHashable> {
    return values.filter { $0 is Set }.map { $0 as! Set<AnyHashable> }
}

func filterDictionaries(values: [AnyHashable]) -> [Map<AnyHashable, AnyHashable>] {
    return values.filter { $0 is Map }.map { $0 as! Map<AnyHashable, AnyHashable> }
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.filter { $0 is Int }.map { $0 as! Int }
}
```

### 2.1.2. Filter only strings

```swift
// Filter given array of any swiftthon values only for strings
// filterStrings(values: [1, 2.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == ["abc"]
func filterStrings(values: [AnyHashable]) -> [String] {
    return values.filter { $0 is String }.map { $0 as! String }
}
```

### 2.1.3. Filter only floats

```swift
// Filter given array of any swiftthon values only for floats
// filterFloats(values: [1, 2.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [2.14]
func filterFloats(values: [AnyHashable]) -> [Float] {
    return values.filter { $0 is Float }.map { $0 as! Float }
}
```

### 2.1.4. Filter only doubles

```swift
// Filter given array of any swiftthon values only for doubles
// filterDoubles(values: [1, 2.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [2.14]
func filterDoubles(values: [AnyHashable]) -> [Double] {
    return values.filter { $0 is Double }.map { $0 as! Double }
}
```

### 2.1.5. Filter only booleans

```swift
// Filter given array of any swiftthon values only for booleans
// filterBools(values: [1, 2.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == []
func filterBools(values: [AnyHashable]) -> [Bool] {
    return values.filter { $0 is Bool }.map { $0 as! Bool }
}
```

### 2.1.6. Filter only arrays

```swift
// Filter given array of any swiftthon values only for arrays
// filterArrays(values: [1, 2.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == []
func filterArrays(values: [AnyHashable]) -> [[AnyHashable]] {
    return values.filter { $0 is Array }.map { $0 as! [[AnyHashable]] }
}
```

### 2.1.7. Filter only sets

```swift
// Filter given array of any swiftthon values only for sets
// filterSets(values: [1, 2.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == []
func filterSets(values: [AnyHashable]) -> Set<AnyHashable> {
    return values.filter { $0 is Set }.map { $0 as! Set<AnyHashable> }
}
```

### 2.1.8. Filter only dictionaries

```swift
// Filter given array of any swiftthon values only for dictionaries
// filterDictionaries(values: [1, 2.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == []
func filterDictionaries(values: [AnyHashable]) -> [Map<AnyHashable, AnyHashable>] {
    return values.filter { $0 is Map }.map { $0 as! Map<AnyHashable, AnyHashable> }
}
```

### 2.1.9. Filter only tuples

```swift
// Filter given array of any swiftthon values only for tuples
// filterTuples(values: [1, 2.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == []
func filterTup

func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}

func filterStrings(values: [AnyHashable]) -> [String] {
    return values.compactMap { $0 as? String }
}

func filterFloats(values: [AnyHashable]) -> [Float] {
    return values.compactMap { $0 as? Float }
}

func filterDoubles(values: [AnyHashable]) -> [Double] {
    return values.compactMap { $0 as? Double }
}

func filterBooleans(values: [AnyHashable]) -> [Bool] {
    return values.compactMap { $0 as? Bool }
}

func filterDates(values: [AnyHashable]) -> [Date] {
    return values.compactMap { $0 as? Date }
}

func filterDatetimes(values: [AnyHashable]) -> [DateTime] {
    return values.compactMap { $0 as? DateTime }
}

func filterTimestamps(values: [AnyHashable]) -> [Timestamp] {
    return values.compactMap { $0 as? Timestamp }
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}
```

### 3.1.2. Filter out strings

```swift
// Filter given array of any swiftthon values only for strings
// filterStrings(values: [1, 2, 3.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == ["abc"]
func filterStrings(values: [AnyHashable]) -> [String] {
    return values.compactMap { $0 as? String }
}
```

### 3.1.3. Filter out floats

```swift
// Filter given array of any swiftthon values only for floats
// filterFloats(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [3.14]
func filterFloats(values: [AnyHashable]) -> [Float] {
    return values.compactMap { $0 as? Float }
}
```

### 3.1.4. Filter out doubles

```swift
// Filter given array of any swiftthon values only for doubles
// filterDoubles(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [3.14]
func filterDoubles(values: [AnyHashable]) -> [Double] {
    return values.compactMap { $0 as? Double }
}
```

### 3.1.5. Filter out booleans

```swift
// Filter given array of any swiftthon values only for booleans
// filterBooleans(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [true, false]
func filterBooleans(values: [AnyHashable]) -> [Bool] {
    return values.compactMap { $0 as? Bool }
}
```

### 3.1.6. Filter out dates

```swift
// Filter given array of any swiftthon values only for dates
// filterDates(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [Date(timeIntervalSince1970: 0)]
func filterDates(values: [AnyHashable]) -> [Date] {
    return values.compactMap { $0 as? Date }
}
```

### 3.1.7. Filter out datetimes

```swift
// Filter given array of any swiftthon values only for datetimes
// filterDatetimes(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [Date(timeIntervalSince1970: 0)]
func filterDatetimes(values: [AnyHashable]) -> [DateTime] {
    return values.compactMap { $0 as? DateTime }
}
```

### 3.1.8. Filter out timestamps

```swift
// Filter given array of any swiftthon values only for timestamps
// filterTimestamps(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [Date(timeIntervalSince1970: 0)]
func filterTimestamps(values: [AnyHashable]) -> [Timestamp] {
    return values.compactMap { $0 as? Timestamp }
}
```

### 3.1.9. Filter out URLs

```swift
// Filter given array of any swiftthon values only for URLs
// filterURLs(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == ["https://github.com/krzyzanik/swift-nio"]
func filterURLs(values: [AnyHashable]) -> [URL

func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}

func filterStrings(values: [AnyHashable]) -> [String] {
    return values.compactMap { $0 as? String }
}

func filterFloats(values: [AnyHashable]) -> [Float] {
    return values.compactMap { $0 as? Float }
}

func filterDoubles(values: [AnyHashable]) -> [Double] {
    return values.compactMap { $0 as? Double }
}

func filterBools(values: [AnyHashable]) -> [Bool] {
    return values.compactMap { $0 as? Bool }
}

func filterDates(values: [AnyHashable]) -> [Date] {
    return values.compactMap { $0 as? Date }
}

func filterDatetimes(values: [AnyHashable]) -> [Date] {
    return values.compactMap { $0 as? Date }
}

func filterTimes(values: [AnyHashable]) -> [Date] {
    return values.compactMap { $0 as? Date }
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}
```

### 2.2.1. Filter out strings

```swift
// Filter given array of any swiftthon values only for strings
// filterStrings(values: [1, 2.14, 5, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == ["abc"]
func filterStrings(values: [AnyHashable]) -> [String] {
    return values.compactMap { $0 as? String }
}
```

### 2.2.2. Filter out floats

```swift
// Filter given array of any swiftthon values only for floats
// filterFloats(values: [1, 2.14, 5, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [2.14]
func filterFloats(values: [AnyHashable]) -> [Float] {
    return values.compactMap { $0 as? Float }
}
```

### 2.2.3. Filter out doubles

```swift
// Filter given array of any swiftthon values only for doubles
// filterDoubles(values: [1, 2.14, 5, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [2.14]
func filterDoubles(values: [AnyHashable]) -> [Double] {
    return values.compactMap { $0 as? Double }
}
```

### 2.2.4. Filter out bools

```swift
// Filter given array of any swiftthon values only for bools
// filterBools(values: [1, 2.14, 5, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [true]
func filterBools(values: [AnyHashable]) -> [Bool] {
    return values.compactMap { $0 as? Bool }
}
```

### 2.2.5. Filter out dates

```swift
// Filter given array of any swiftthon values only for dates
// filterDates(values: [1, 2.14, 5, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [Date(timeIntervalSince1970: 0)]
func filterDates(values: [AnyHashable]) -> [Date] {
    return values.compactMap { $0 as? Date }
}
```

### 2.2.6. Filter out datetimes

```swift
// Filter given array of any swiftthon values only for datetimes
// filterDatetimes(values: [1, 2.14, 5, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [Date(timeIntervalSince1970: 0)]
func filterDatetimes(values: [AnyHashable]) -> [Date] {
    return values.compactMap { $0 as? Date }
}
```

### 2.2.7. Filter out times

```swift
// Filter given array of any swiftthon values only for times
// filterTimes(values: [1, 2.14, 5, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [Date(timeIntervalSince1970: 0)]
func filterTimes(values: [AnyHashable]) -> [Date] {
    return values.compactMap { $0 as? Date }
}
```

### 2.2.8. Filter out timestamps

```swift
// Filter given array of any swiftthon values only for timestamps
// filterTimestamps(values: [1, 2.14, 5, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [Date(timeIntervalSince1970: 0)]
func filterTimestamps(values: [AnyHashable

func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.filter { $0 is Int }.map { $0 as! Int }
}

func filterStrings(values: [AnyHashable]) -> [String] {
    return values.filter { $0 is String }.map { $0 as! String }
}

func filterDictionaries(values: [AnyHashable]) -> [[AnyHashable]] {
    return values.filter { $0 is [AnyHashable : AnyHashable] }.map { $0 as! [[AnyHashable : AnyHashable]] }
}

func filterArrays(values: [AnyHashable]) -> [[AnyHashable]] {
    return values.filter { $0 is [AnyHashable] }.map { $0 as! [[AnyHashable]] }
}

func filterSets(values: [AnyHashable]) -> [Set<AnyHashable>] {
    return values.filter { $0 is Set<AnyHashable> }.map { $0 as! Set<AnyHashable> }
}

func filterTuples(values: [AnyHashable]) -> [(AnyHashable)] {
    return values.filter { $0 is (AnyHashable) }.map { $0 as! (AnyHashable) }
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.filter { $0 is Int }.map { $0 as! Int }
}
```

### 2.1.2. Filter out only strings

```swift
// Filter given array of any swiftthon values only for strings
// filterStrings(values: ["a", 3.14, 5]) == ["a"]
// filterStrings(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == ["abc"]
func filterStrings(values: [AnyHashable]) -> [String] {
    return values.filter { $0 is String }.map { $0 as! String }
}
```

### 2.1.3. Filter out only dictionaries

```swift
// Filter given array of any swiftthon values only for dictionaries
// filterDictionaries(values: ["a", 3.14, 5]) == []
// filterDictionaries(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [[:]]
func filterDictionaries(values: [AnyHashable]) -> [[AnyHashable]] {
    return values.filter { $0 is [AnyHashable : AnyHashable] }.map { $0 as! [[AnyHashable : AnyHashable]] }
}
```

### 2.1.4. Filter out only arrays

```swift
// Filter given array of any swiftthon values only for arrays
// filterArrays(values: ["a", 3.14, 5]) == []
// filterArrays(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]
func filterArrays(values: [AnyHashable]) -> [[AnyHashable]] {
    return values.filter { $0 is [AnyHashable] }.map { $0 as! [[AnyHashable]] }
}
```

### 2.1.5. Filter out only sets

```swift
// Filter given array of any swiftthon values only for sets
// filterSets(values: ["a", 3.14, 5]) == []
// filterSets(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]
func filterSets(values: [AnyHashable]) -> [Set<AnyHashable>] {
    return values.filter { $0 is Set<AnyHashable> }.map { $0 as! Set<AnyHashable> }
}
```

### 2.1.6. Filter out only tuples

```swift
// Filter given array of any swiftthon values only for tuples
// filterTuples(values: ["a", 3.14, 5]) == []
// filterTuples(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]
func filterTuples(values: [AnyHashable]) -> [(AnyHashable)] {
    return values.filter { $0 is (AnyHashable) }.map { $0 as! (AnyHashable) }
}
```

### 2.1.7. Filter out only enums

```swift
// Filter given array of any swiftthon values only for enums
// filterEnums(values: ["a", 3.14, 5]) == []
// filterEnums(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2

func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}
```

### 2.1.2. Filter out non-integers

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}
```

### 2.1.3. Filter out non-integers

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}
```

### 2.1.4. Filter out non-integers

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}
```

### 2.1.5. Filter out non-integers

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}
```

### 2.1.6. Filter out non-integers

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}
```

### 2.1.7. Filter out non-integers

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}
```

### 2.1.8. Filter out non-integers

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [

func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}

func filterNonIntegers(values: [AnyHashable]) -> [AnyHashable] {
    return values.compactMap { $0 as? Int == nil ? $0 : nil }
}

func filterIntegers(values: [AnyHashable]) -> [AnyHashable] {
    return values.compactMap { $0 as? Int == nil ? $0 : nil }
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}
```

### 2. Filter out all non-integers from given array of any swiftthon values

```swift
// Filter out all non-integers from given array of any swiftthon values
// filterNonIntegers(values: ["a", 3.14, 5]) == ["a"]
// filterNonIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == []
func filterNonIntegers(values: [AnyHashable]) -> [AnyHashable] {
    return values.compactMap { $0 as? Int == nil ? $0 : nil }
}
```

### 3. Filter out all integers from given array of any swiftthon values

```swift
// Filter out all integers from given array of any swiftthon values
// filterIntegers(values: ["a", 3.14, 5]) == ["a", 3.14]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == []
func filterIntegers(values: [AnyHashable]) -> [AnyHashable] {
    return values.compactMap { $0 as? Int == nil ? $0 : nil }
}
```

### 4. Filter out all non-integers from given array of any swiftthon values

```swift
// Filter out all non-integers from given array of any swiftthon values
// filterNonIntegers(values: ["a", 3.14, 5]) == ["a"]
// filterNonIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == []
func filterNonIntegers(values: [AnyHashable]) -> [AnyHashable] {
    return values.compactMap { $0 as? Int == nil ? $0 : nil }
}
```

### 5. Filter out all integers from given array of any swiftthon values

```swift
// Filter out all integers from given array of any swiftthon values
// filterIntegers(values: ["a", 3.14, 5]) == ["a", 3.14]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == []
func filterIntegers(values: [AnyHashable]) -> [AnyHashable] {
    return values.compactMap { $0 as? Int == nil ? $0 : nil }
}
```

### 6. Filter out all non-integers from given array of any swiftthon values

```swift
// Filter out all non-integers from given array of any swiftthon values
// filterNonIntegers(values: ["a", 3.14, 5]) == ["a"]
// filterNonIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == []
func filterNonIntegers(values: [AnyHashable]) -> [AnyHashable] {
    return values.compactMap { $0 as? Int == nil ? $0 : nil }
}
```

### 7. Filter out all integers from given array of any swiftthon values

```swift
// Filter out all integers from given array of any swiftthon values
// filterIntegers(values: ["a", 3.14, 5]) == ["a", 3.14]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == []
func filterIntegers(values: [AnyHashable]) -> [AnyHashable] {
    return values.compactMap { $0 as? Int == nil ? $0 : nil }
}
```

### 8. Filter out all non-integers from given array of any swiftthon values

```swift

func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.filter { $0 is Int }.map { $0 as! Int }
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.filter { $0 is Int }.map { $0 as! Int }
}
```

### 2.2.2. Filter out all non-integers

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.filter { $0 is Int }.map { $0 as! Int }
}
```

### 2.2.3. Filter out all integers

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.filter { $0 is Int }.map { $0 as! Int }
}
```

### 2.2.4. Filter out all non-integers and integers

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.filter { $0 is Int }.map { $0 as! Int }
}
```

### 2.2.5. Filter out all integers and non-integers

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.filter { $0 is Int }.map { $0 as! Int }
}
```

### 2.2.6. Filter out all integers and non-integers and integers

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.filter { $0 is Int }.map { $0 as! Int }
}
```

### 2.2.7. Filter out all integers and integers and non-integers

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.filter { $0 is Int }.map { $0 as! Int }
}
```

### 2.2.8. Filter out all integers and integers and non-integers and integers

```swift

func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.filter { $0 is Int }.map { $0 as! Int }
}

func filterStrings(values: [AnyHashable]) -> [String] {
    return values.filter { $0 is String }.map { $0 as! String }
}

func filterFloats(values: [AnyHashable]) -> [Double] {
    return values.filter { $0 is Double }.map { $0 as! Double }
}

func filterDoubles(values: [AnyHashable]) -> [Double] {
    return values.filter { $0 is Double }.map { $0 as! Double }
}

func filterBools(values: [AnyHashable]) -> [Bool] {
    return values.filter { $0 is Bool }.map { $0 as! Bool }
}

func filterDates(values: [AnyHashable]) -> [Date] {
    return values.filter { $0 is Date }.map { $0 as! Date }
}

func filterDatetimes(values: [AnyHashable]) -> [Date] {
    return values.filter { $0 is Date }.map { $0 as! Date }
}

func filterTimestamps(values: [AnyHashable]) -> [Date] {
    return values.filter { $0 is Date }.map { $0 as! Date }
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.filter { $0 is Int }.map { $0 as! Int }
}
```

### 2.1.2. Filter out strings

```swift
// Filter given array of any swiftthon values only for strings
// filterStrings(values: [1, 2.14, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == ["abc"]
func filterStrings(values: [AnyHashable]) -> [String] {
    return values.filter { $0 is String }.map { $0 as! String }
}
```

### 2.1.3. Filter out floats

```swift
// Filter given array of any swiftthon values only for floats
// filterFloats(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [2.14]
func filterFloats(values: [AnyHashable]) -> [Double] {
    return values.filter { $0 is Double }.map { $0 as! Double }
}
```

### 2.1.4. Filter out doubles

```swift
// Filter given array of any swiftthon values only for doubles
// filterDoubles(values: [1, 2.14, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [2.14]
func filterDoubles(values: [AnyHashable]) -> [Double] {
    return values.filter { $0 is Double }.map { $0 as! Double }
}
```

### 2.1.5. Filter out booleans

```swift
// Filter given array of any swiftthon values only for booleans
// filterBools(values: [1, 2.14, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [true, false]
func filterBools(values: [AnyHashable]) -> [Bool] {
    return values.filter { $0 is Bool }.map { $0 as! Bool }
}
```

### 2.1.6. Filter out dates

```swift
// Filter given array of any swiftthon values only for dates
// filterDates(values: [1, 2.14, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [Date(timeIntervalSince1970: 0)]
func filterDates(values: [AnyHashable]) -> [Date] {
    return values.filter { $0 is Date }.map { $0 as! Date }
}
```

### 2.1.7. Filter out datetimes

```swift
// Filter given array of any swiftthon values only for datetimes
// filterDatetimes(values: [1, 2.14, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [Date(timeIntervalSince1970: 0)]
func filterDatetimes(values: [AnyHashable]) -> [Date] {
    return values.filter { $0 is Date }.map { $0 as! Date }
}
```

### 2.1.8. Filter out timestamps

```swift
// Filter given array of any swiftthon values only for timestamps
// filterTimestamps(values: [1, 2.14, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [Date(timeIntervalSince1970: 0)]
func filterTimestamps(values: [AnyHashable]) -> [Date] {
    return values.filter { $0 is Date }.map { $0 as! Date }
}
```

### 2.1.9. Filter out tuples

```swift
// Filter given array of any swiftthon values only for tuples
// filterTuples(values: [1, 2.14, 3,

func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}

func filterStrings(values: [AnyHashable]) -> [String] {
    return values.compactMap { $0 as? String }
}

func filterStrings(values: [AnyHashable], length: Int) -> [String] {
    return values.compactMap { $0 as? String }.filter { $0.count > length }
}

```swift
// Filter given array of any swiftthon values only for integers
// filterIntegers(values: ["a", 3.14, 5]) == [5]
// filterIntegers(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == [1, 2, 3]
func filterIntegers(values: [AnyHashable]) -> [Int] {
    return values.compactMap { $0 as? Int }
}
```

### 1.2.1. Filter by type

```swift
// Filter given array of any swiftthon values only for strings
// filterStrings(values: ["a", 3.14, 5]) == ["a"]
// filterStrings(values: [1, 2, 3, "abc", [:] as [AnyHashable : AnyHashable], [] as [AnyHashable]]) == ["abc"]
func filterStrings(values: [AnyHashable]) -> [String] {
    return values.compactMap { $0 as? String }
}
```

### 1.2.2. Filter by type and value

```swift
// Filter given array of any swiftthon values only for strings with length > 3
// filterStrings(values: ["a", 3.14, 5], length: 3) == []
// filterStrings(values: ["abc", "def", "ghi"], length: 3) == ["abc", "def"]
func filterStrings(values: [AnyHashable], length: Int) -> [String] {
    return values.compactMap { $0 as? String }.filter { $0.count > length }
}
```

### 1.2.3. Filter by type and value

```swift
// Filter given array of any swiftthon values only for strings with length > 3
// filterStrings(values: ["a", 3.14, 5], length: 3) == []
// filterStrings(values: ["abc", "def", "ghi"], length: 3) == ["abc", "def"]
func filterStrings(values: [AnyHashable], length: Int) -> [String] {
    return values.compactMap { $0 as? String }.filter { $0.count > length }
}
```

### 1.2.4. Filter by type and value

```swift
// Filter given array of any swiftthon values only for strings with length > 3
// filterStrings(values: ["a", 3.14, 5], length: 3) == []
// filterStrings(values: ["abc", "def", "ghi"], length: 3) == ["abc", "def"]
func filterStrings(values: [AnyHashable], length: Int) -> [String] {
    return values.compactMap { $0 as? String }.filter { $0.count > length }
}
```

### 1.2.5. Filter by type and value

```swift
// Filter given array of any swiftthon values only for strings with length > 3
// filterStrings(values: ["a", 3.14, 5], length: 3) == []
// filterStrings(values: ["abc", "def", "ghi"], length: 3) == ["abc", "def"]
func filterStrings(values: [AnyHashable], length: Int) -> [String] {
    return values.compactMap { $0 as? String }.filter { $0.count > length }
}
```

### 1.2.6. Filter by type and value

```swift
// Filter given array of any swiftthon values only for strings with length > 3
// filterStrings(values: ["a", 3.14, 5], length: 3) == []
// filterStrings(values: ["abc", "def", "ghi"], length: 3) == ["abc", "def"]
func filterStrings(values: [AnyHashable], length: Int) -> [String] {
    return values.compactMap { $0 as? String }.filter { $0.count > length }
}
```

### 1.2.7. Filter by type and value

```swift
// Filter given array of any swiftthon values only for strings with length > 3
// filterStrings(values: ["a", 3.14, 5], length: 3) == []
// filterStrings(values: ["abc", "def", "ghi"], length: 3) == ["abc", "def"]
func filterStrings(values:

func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}

func strcat(string1: String, string2: String) -> String {
    return string1 + string2
}

func strcat(string1: String, string2: String, string3: String) -> String {
    return string1 + string2 + string3
}

func strcmp(string1: String, string2: String) -> Int {
    if string1 < string2 {
        return -1
    } else if string1 > string2 {
        return 1
    } else {
        return 0
    }
}

func strchr(string: String, character: Character) -> String? {
    for c in string {
        if c == character {
            return String(c)
        }
    }
    return nil
}

func strstr(string: String, character: Character) -> String? {
    for i in 0..<string.count {
        if string[i] == character {
            return String(string[i..<string.count])
        }
    }
    return nil
}

func strtok(string: String, character: Character) -> [String] {
    var tokens = [String]()
    var start = 0
    var end = 0
    while end < string.count {
        if string[end] == character {
            tokens.append(string[start..<end])
            start = end + 1
        }
        end += 1
    }
    if start < end {
        tokens.append(string[start..<end])
    }
    return tokens
}

func strtok(string: String, character: Character) -> String {
    var result = ""
    for token in strtok(string: string, character: character) {
        result += token
        result += character
    }
    return String(result.dropLast())
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}
```

### 2. 字符串拼接

```swift
// Concatenate two strings
// strcat(string1: "abc", string2: "def") == "abcdef"
// strcat(string1: "abc", string2: "def", string3: "ghi") == "abcdefghi"
func strcat(string1: String, string2: String) -> String {
    return string1 + string2
}

func strcat(string1: String, string2: String, string3: String) -> String {
    return string1 + string2 + string3
}
```

### 3. 字符串比较

```swift
// Compare two strings
// strcmp(string1: "abc", string2: "def") == -1
// strcmp(string1: "abc", string2: "abc") == 0
// strcmp(string1: "abc", string2: "def") == 1
func strcmp(string1: String, string2: String) -> Int {
    if string1 < string2 {
        return -1
    } else if string1 > string2 {
        return 1
    } else {
        return 0
    }
}
```

### 4. 字符串查找

```swift
// Find a character in a string
// strchr(string: "abc", character: "c") == "c"
// strchr(string: "abc", character: "d") == nil
func strchr(string: String, character: Character) -> String? {
    for c in string {
        if c == character {
            return String(c)
        }
    }
    return nil
}
```

### 5. 字符串替换

```swift
// Replace a character in a string
// strstr(string: "abc", character: "c") == "c"
// strstr(string: "abc", character: "d") == nil
func strstr(string: String, character: Character) -> String? {
    for i in 0..<string.count {
        if string[i] == character {
            return String(string[i..<string.count])
        }
    }
    return nil
}
```

### 6. 字符串分割

```swift
// Split a string into an array of substrings separated by a given character
// strtok(string: "abc,def,ghi", character: ",") == ["abc", "def", "ghi"]
// strtok(string: "abc,def,ghi", character: ",") == ["abcdefghi"]
func strtok(string: String, character: Character) -> [String] {
    var tokens = [String]()
    var start = 0
    var end = 0
    while end < string.count {
        if string[end] == character {
            tokens.append(string[start..<end])
            start = end + 1
        }
        end += 1
    }
    if start < end {
        tokens.append(string[start..<end])
    }
    return tokens
}
```

### 7. 字符串合并

```swift
// Merge an array of substrings into a single string separated by a given character
// strtok(string: "abcdefghi", character: ",") == "abcdefghi"
// strtok(string: "abcdefghi", character: ",") == "abcdefghi"
func strtok(string: String, character: Character) -> String {
    var result = ""
    for token in strtok(string: string, character: character) {
        result += token
        result += character
    }
    return String(result.dropLast())
}
```

### 8. 字符串转数字

```swift
// Convert a string to an integer
// atoi(string: "123") == 123
// atoi(string: "123abc") == 0

func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}

func strcat(string: String, string2: String) -> String {
    return string + string2
}

func strcmp(string: String, string2: String) -> Int {
    if string < string2 {
        return -1
    } else if string > string2 {
        return 1
    } else {
        return 0
    }
}

func strchr(string: String, character: Character) -> Int? {
    for (index, char) in string.enumerated() {
        if char == character {
            return index
        }
    }
    return nil
}

func strstr(string: String, character: Character, replacement: String) -> String {
    var result = ""
    for (index, char) in string.enumerated() {
        if char == character {
            result += replacement
        } else {
            result += String(char)
        }
    }
    return result
}

func strtok(string: String, delimiter: Character) -> [String] {
    var result = [String]()
    var buffer = ""
    for char in string {
        if char == delimiter {
            result.append(buffer)
            buffer = ""
        } else {
            buffer += String(char)
        }
    }
    result.append(buffer)
    return result
}

func strtok(string: String, delimiter: Character, joiner: Character) -> String {
    var result = ""
    var buffer = ""
    for char in string {
        if char == delimiter {
            result += buffer + joiner
            buffer = ""
        } else {
            buffer += String(char)
        }
    }
    result += buffer
    return result
}

func strtolower(string: String) -> String {
    return string.lowercased()
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}
```

### 2. 字符串拼接

```swift
// Return string concatenated with given string
// strcat(string: "", string: "") == ""
// strcat(string: "abc", string: "def") == "abcdef"
func strcat(string: String, string2: String) -> String {
    return string + string2
}
```

### 3. 字符串比较

```swift
// Return 0 if strings are equal
// Return 1 if string1 > string2
// Return -1 if string1 < string2
// strcmp(string: "abc", string: "def") == -1
// strcmp(string: "def", string: "abc") == 1
func strcmp(string: String, string2: String) -> Int {
    if string < string2 {
        return -1
    } else if string > string2 {
        return 1
    } else {
        return 0
    }
}
```

### 4. 字符串查找

```swift
// Return index of first occurrence of character in string
// strchr(string: "abc", character: "c") == 2
// strchr(string: "abc", character: "d") == nil
func strchr(string: String, character: Character) -> Int? {
    for (index, char) in string.enumerated() {
        if char == character {
            return index
        }
    }
    return nil
}
```

### 5. 字符串替换

```swift
// Return string with character replaced with given string
// strstr(string: "abc", character: "c", replacement: "d") == "abd"
// strstr(string: "abc", character: "d", replacement: "d") == "abc"
func strstr(string: String, character: Character, replacement: String) -> String {
    var result = ""
    for (index, char) in string.enumerated() {
        if char == character {
            result += replacement
        } else {
            result += String(char)
        }
    }
    return result
}
```

### 6. 字符串分割

```swift
// Return array of substrings separated by given character
// strtok(string: "abc,def", delimiter: ",") == ["abc", "def"]
// strtok(string: "abc", delimiter: ",") == ["abc"]
func strtok(string: String, delimiter: Character) -> [String] {
    var result = [String]()
    var buffer = ""
    for char in string {
        if char == delimiter {
            result.append(buffer)
            buffer = ""
        } else {
            buffer += String(char)
        }
    }
    result.append(buffer)
    return result
}
```

### 7. 字符串合并

```swift
// Return string with substrings merged by given character
// strtok(string: "abc,def", delimiter: ",", joiner: "") == "abcdef"
// strtok(string: "abc", delimiter: ",", joiner: "") == "abc"
func strtok(string: String, delimiter: Character, joiner: Character) -> String {
    var result = ""
    var buffer = ""
    for char in string {
        if char == delimiter {
            result += buffer + joiner
            buffer = ""
        } else {
            buffer += String(char)
        }
    }
    result += buffer
    return result
}
```

### 8. 字符串大小写转换

```swift
// Return string with all characters converted to lowercase
// strtolower(string: "ABC") == "abc"
// strtolower(string: "abc") == "abc"
func strtolower(string: String) -> String {
    return string.lowercased()
}
```

```swift

func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}

func count(string: String, char: Character) -> Int {
    var count = 0
    for c in string {
        if c == char {
            count += 1
        }
    }
    return count
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}

// Return the number of occurrences of the given character in the given string
// count(string: "abc", char: "a") == 1
// count(string: "abc", char: "b") == 1
// count(string: "abc", char: "c") == 1
func count(string: String, char: Character) -> Int {
    var count = 0
    for c in string {
        if c == char {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of the given character in the given string
// count(string: "abc", char: "a") == 1
// count(string: "abc", char: "b") == 1
// count(string: "abc", char: "c") == 1
func count(string: String, char: Character) -> Int {
    var count = 0
    for c in string {
        if c == char {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of the given character in the given string
// count(string: "abc", char: "a") == 1
// count(string: "abc", char: "b") == 1
// count(string: "abc", char: "c") == 1
func count(string: String, char: Character) -> Int {
    var count = 0
    for c in string {
        if c == char {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of the given character in the given string
// count(string: "abc", char: "a") == 1
// count(string: "abc", char: "b") == 1
// count(string: "abc", char: "c") == 1
func count(string: String, char: Character) -> Int {
    var count = 0
    for c in string {
        if c == char {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of the given character in the given string
// count(string: "abc", char: "a") == 1
// count(string: "abc", char: "b") == 1
// count(string: "abc", char: "c") == 1
func count(string: String, char: Character) -> Int {
    var count = 0
    for c in string {
        if c == char {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of the given character in the given string
// count(string: "abc", char: "a") == 1
// count(string: "abc", char: "b") == 1
// count(string: "abc", char: "c") == 1
func count(string: String, char: Character) -> Int {
    var count = 0
    for c in string {
        if c == char {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of the given character in the given string
// count(string: "abc", char: "a") == 1
// count(string: "abc", char: "b") == 1
// count(string: "abc", char: "c") == 1
func count(string: String, char: Character) -> Int {
    var count = 0
    for c in string {
        if c == char {
            count += 1
        }
    }
    return count
}

// Return the number of occurrences of the given character in the given string
// count(string: "abc", char: "a") == 1
// count(string: "abc", char: "b") == 1
// count(string: "abc", char: "c") == 1
func count(string: String, char: Character) -> Int {
    var count = 0
    for c in string {
        if c == char {
            count += 1
        }
    }

func strlen(string: String) -> Int {
    var length = 0
    for _ in string {
        length += 1
    }
    return length
}

func strcat(string1: String, string2: String) -> String {
    return string1 + string2
}

func strcmp(string1: String, string2: String) -> Int {
    if string1 < string2 {
        return -1
    } else if string1 > string2 {
        return 1
    } else {
        return 0
    }
}

func strchr(string: String, character: Character) -> Int {
    for (index, char) in string.enumerated() {
        if char == character {
            return index
        }
    }
    return -1
}

func strstr(string: String, character: Character, replacement: Character) -> String {
    var string = string
    for (index, char) in string.enumerated() {
        if char == character {
            string.remove(at: index)
            string.insert(replacement, at: index)
        }
    }
    return string
}

func strtok(string: String, character: Character) -> [String] {
    var string = string
    var tokens = [String]()
    while !string.isEmpty {
        let index = strchr(string: string, character: character)
        if index == -1 {
            tokens.append(string)
            break
        }
        tokens.append(string[..<index])
        string.removeSubrange(Range(uncheckedBounds: (lower: index, upper: index + 1)))
    }
    return tokens
}

func strtok(string: String, character: Character) -> String {
    var string = string
    var result = ""
    while !string.isEmpty {
        let index = strchr(string: string, character: character)
        if index == -1 {
            result += string
            break
        }
        result += string[..<index]
        string.removeSubrange(Range(uncheckedBounds: (lower: index, upper: index + 1)))
    }
    return result
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    var length = 0
    for _ in string {
        length += 1
    }
    return length
}
```

### 2. 字符串拼接

```swift
// Return concatenated string
// strcat(string1: "abc", string2: "def") == "abcdef"
// strcat(string1: "abc", string2: "def") == "abcdef"
func strcat(string1: String, string2: String) -> String {
    return string1 + string2
}
```

### 3. 字符串比较

```swift
// Return 0 if equal, -1 if string1 < string2, 1 if string1 > string2
// strcmp(string1: "abc", string2: "def") == 1
// strcmp(string1: "abc", string2: "abc") == 0
// strcmp(string1: "abc", string2: "def") == -1
func strcmp(string1: String, string2: String) -> Int {
    if string1 < string2 {
        return -1
    } else if string1 > string2 {
        return 1
    } else {
        return 0
    }
}
```

### 4. 字符串查找

```swift
// Return index of first occurrence of character in string, or -1 if not found
// strchr(string: "abc", character: "c") == 2
// strchr(string: "abc", character: "d") == -1
func strchr(string: String, character: Character) -> Int {
    for (index, char) in string.enumerated() {
        if char == character {
            return index
        }
    }
    return -1
}
```

### 5. 字符串替换

```swift
// Return string with all occurrences of character replaced by replacement
// strstr(string: "abc", character: "c", replacement: "d") == "abd"
// strstr(string: "abc", character: "d", replacement: "d") == "abc"
func strstr(string: String, character: Character, replacement: Character) -> String {
    var string = string
    for (index, char) in string.enumerated() {
        if char == character {
            string.remove(at: index)
            string.insert(replacement, at: index)
        }
    }
    return string
}
```

### 6. 字符串分割

```swift
// Return array of substrings separated by character
// strtok(string: "abc,def", character: ",") == ["abc", "def"]
// strtok(string: "abc,def", character: ",") == ["abc", "def"]
func strtok(string: String, character: Character) -> [String] {
    var string = string
    var tokens = [String]()
    while !string.isEmpty {
        let index = strchr(string: string, character: character)
        if index == -1 {
            tokens.append(string)
            break
        }
        tokens.append(string[..<index])
        string.removeSubrange(Range(uncheckedBounds: (lower: index, upper: index + 1)))
    }
    return tokens
}
```

### 7. 字符串合并

```swift
// Return string with substrings merged into one
// strtok(string: "abc,def", character: ",") == "abcdef"
// strtok(string: "abc,def", character: ",") == "abcdef"
func strtok(string: String, character: Character) -> String {
    var string = string
    var result = ""
    while !string.isEmpty {
        let index = strchr(string: string, character: character)
        if index == -1 {
            result += string
            break
        }
        result += string[..<index]
        string.removeSubrange(Range(uncheckedBounds: (lower: index, upper: index + 1)))
    }
    return result
}
```

###

func strlen(string: String) -> Int {
    var length = 0
    for _ in string {
        length += 1
    }
    return length
}

func strcat(string1: String, string2: String) -> String {
    return string1 + string2
}

func strcmp(string1: String, string2: String) -> Int {
    if string1 < string2 {
        return -1
    } else if string1 > string2 {
        return 1
    } else {
        return 0
    }
}

func strchr(string: String, character: Character) -> Character? {
    for c in string {
        if c == character {
            return c
        }
    }
    return nil
}

func strstr(string: String, character: Character) -> Character? {
    for (index, c) in string.enumerated() {
        if c == character {
            return string[index]
        }
    }
    return nil
}

func strtok(string: String, delimiter: Character) -> [String] {
    var substrings = [String]()
    var currentString = ""
    for c in string {
        if c == delimiter {
            substrings.append(currentString)
            currentString = ""
        } else {
            currentString.append(c)
        }
    }
    substrings.append(currentString)
    return substrings
}

func strcat(string: String, substrings: [String]) -> String {
    var result = string
    for s in substrings {
        result += s
    }
    return result
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    var length = 0
    for _ in string {
        length += 1
    }
    return length
}
```

### 2. 字符串拼接

```swift
// Concatenate two strings
// strcat(string1: "abc", string2: "def") == "abcdef"
// strcat(string1: "abc", string2: "def") == "abcdef"
func strcat(string1: String, string2: String) -> String {
    return string1 + string2
}
```

### 3. 字符串比较

```swift
// Compare two strings
// strcmp(string1: "abc", string2: "def") == -1
// strcmp(string1: "abc", string2: "abc") == 0
// strcmp(string1: "abc", string2: "abcd") == -1
func strcmp(string1: String, string2: String) -> Int {
    if string1 < string2 {
        return -1
    } else if string1 > string2 {
        return 1
    } else {
        return 0
    }
}
```

### 4. 字符串查找

```swift
// Find a character in a string
// strchr(string: "abc", character: "a") == "a"
// strchr(string: "abc", character: "d") == nil
func strchr(string: String, character: Character) -> Character? {
    for c in string {
        if c == character {
            return c
        }
    }
    return nil
}
```

### 5. 字符串替换

```swift
// Replace a character in a string
// strstr(string: "abc", character: "a") == "a"
// strstr(string: "abc", character: "d") == nil
func strstr(string: String, character: Character) -> Character? {
    for (index, c) in string.enumerated() {
        if c == character {
            return string[index]
        }
    }
    return nil
}
```

### 6. 字符串分割

```swift
// Split a string into substrings
// strtok(string: "abc,def", delimiter: ",") == ["abc", "def"]
// strtok(string: "abc,def", delimiter: ",") == ["abc", "def"]
func strtok(string: String, delimiter: Character) -> [String] {
    var substrings = [String]()
    var currentString = ""
    for c in string {
        if c == delimiter {
            substrings.append(currentString)
            currentString = ""
        } else {
            currentString.append(c)
        }
    }
    substrings.append(currentString)
    return substrings
}
```

### 7. 字符串合并

```swift
// Merge a list of substrings into a string
// strcat(string: "abc", substrings: ["def", "ghi"]) == "abcdefghi"
// strcat(string: "abc", substrings: ["def", "ghi"]) == "abcdefghi"
func strcat(string: String, substrings: [String]) -> String {
    var result = string
    for s in substrings {
        result += s
    }
    return result
}
```

### 8. 字符串比较

```swift
// Compare two strings
// strcmp(string1: "abc", string2: "def") == -1
// strcmp(string1: "abc", string2: "abc") == 0
// strcmp(string1: "abc", string2: "abcd") == -1
func strcmp(string1: String, string2: String) -> Int {
    if string1 < string2 {
        return -1
    } else if string1 > string2 {
        return 1
    } else {
        return 0
    }
}
```

### 9.

func strlen(string: String) -> Int {
    return string.count
}

func strlen(string: String) -> Int {
    var count = 0
    for c in string {
        count += 1
    }
    return count
}

func strcat(string: String, string2: String) -> String {
    return string + string2
}

func strcat(string: String, string2: String) -> String {
    var result = ""
    result += string
    result += string2
    return result
}

func strcmp(string: String, string2: String) -> Int {
    if string < string2 {
        return -1
    } else if string > string2 {
        return 1
    } else {
        return 0
    }
}

func strcmp(string: String, string2: String) -> Int {
    if string.compare(string2) == ComparisonResult.orderedSame {
        return 0
    } else if string.compare(string2) == ComparisonResult.orderedAscending {
        return -1
    } else {
        return 1
    }
}

func strchr(string: String, character: Character) -> Int? {
    for (index, c) in string.enumerated() {
        if c == character {
            return index
        }
    }
    return nil
}

func strstr(string: String, character: Character) -> String {
    var result = ""
    for c in string {
        if c == character {
            result += character
        } else {
            result += c
        }
    }
    return result
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    return string.count
}

// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    var count = 0
    for c in string {
        count += 1
    }
    return count
}
```

### 2. 字符串拼接

```swift
// Return concatenated string
// strcat(string: "") == ""
// strcat(string: "abc") == "abc"
func strcat(string: String, string2: String) -> String {
    return string + string2
}

// Return concatenated string
// strcat(string: "") == ""
// strcat(string: "abc") == "abc"
func strcat(string: String, string2: String) -> String {
    var result = ""
    result += string
    result += string2
    return result
}
```

### 3. 字符串比较

```swift
// Return 0 if strings are equal
// strcmp(string: "abc", string: "abc") == 0
// strcmp(string: "abc", string: "abcd") == -1
// strcmp(string: "abcd", string: "abc") == 1
func strcmp(string: String, string2: String) -> Int {
    if string < string2 {
        return -1
    } else if string > string2 {
        return 1
    } else {
        return 0
    }
}

// Return 0 if strings are equal
// strcmp(string: "abc", string: "abc") == 0
// strcmp(string: "abc", string: "abcd") == -1
// strcmp(string: "abcd", string: "abc") == 1
func strcmp(string: String, string2: String) -> Int {
    if string.compare(string2) == ComparisonResult.orderedSame {
        return 0
    } else if string.compare(string2) == ComparisonResult.orderedAscending {
        return -1
    } else {
        return 1
    }
}
```

### 4. 字符串查找

```swift
// Return index of first occurrence of character in string
// strchr(string: "abc", character: "c") == 2
// strchr(string: "abc", character: "d") == nil
func strchr(string: String, character: Character) -> Int? {
    for (index, c) in string.enumerated() {
        if c == character {
            return index
        }
    }
    return nil
}

// Return index of first occurrence of character in string
// strchr(string: "abc", character: "c") == 2
// strchr(string: "abc", character: "d") == nil
func strchr(string: String, character: Character) -> Int? {
    for (index, c) in string.enumerated() {
        if c == character {
            return index
        }
    }
    return nil
}
```

### 5. 字符串替换

```swift
// Return string with character replaced
// strstr(string: "abc", character: "c") == "abc"
// strstr(string: "abc", character: "d") == ""
func strstr(string: String, character: Character) -> String {
    var result = ""
    for c in string {
        if c == character {
            result += character
        } else {
            result += c
        }
    }
    return result
}

// Return string with character replaced
// strstr(string: "abc", character: "c") == "abc"
// strstr(string: "abc", character: "d") == ""
func strstr(string: String, character: Character) -> String {
    var result = ""
    for (index, c) in string.enumerated() {
        if c == character {
            result += character
        } else {
            result += string[index]
        }
    }

func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}

func strcat(string1: String, string2: String) -> String {
    return string1 + string2
}

func strcmp(string1: String, string2: String) -> Int {
    if string1 < string2 {
        return -1
    } else if string1 > string2 {
        return 1
    } else {
        return 0
    }
}

func strchr(string: String, character: Character) -> Int {
    for (index, char) in string.enumerated() {
        if char == character {
            return index
        }
    }
    return -1
}

func strstr(string: String, character: Character) -> String {
    var result = ""
    for (index, char) in string.enumerated() {
        if char == character {
            result += string[string.index(string.startIndex, offsetBy: index + 1) ..< string.index(string.startIndex, offsetBy: string.count)]
            break
        }
    }
    return result
}

func strtok(string: String, character: Character) -> [String] {
    var result = [String]()
    var startIndex = string.startIndex
    var endIndex = string.startIndex
    while endIndex < string.endIndex {
        endIndex = string.index(endIndex, offsetBy: 1)
        if string[endIndex] == character {
            result.append(string[startIndex..<endIndex])
            startIndex = string.index(endIndex, offsetBy: 1)
        }
    }
    result.append(string[startIndex..<endIndex])
    return result
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}
```

### 2. 字符串拼接

```swift
// Return concatenated string
// strcat(string1: "", string2: "") == ""
// strcat(string1: "abc", string2: "def") == "abcdef"
func strcat(string1: String, string2: String) -> String {
    return string1 + string2
}
```

### 3. 字符串比较

```swift
// Return 0 if strings are equal
// Return -1 if string1 is less than string2
// Return 1 if string1 is greater than string2
// strcmp(string1: "", string2: "") == 0
// strcmp(string1: "abc", string2: "def") == -1
// strcmp(string1: "def", string2: "abc") == 1
func strcmp(string1: String, string2: String) -> Int {
    if string1 < string2 {
        return -1
    } else if string1 > string2 {
        return 1
    } else {
        return 0
    }
}
```

### 4. 字符串查找

```swift
// Return index of first occurrence of character in string
// Return -1 if character is not found
// strchr(string: "", character: "") == -1
// strchr(string: "abc", character: "a") == 0
// strchr(string: "abc", character: "d") == -1
func strchr(string: String, character: Character) -> Int {
    for (index, char) in string.enumerated() {
        if char == character {
            return index
        }
    }
    return -1
}
```

### 5. 字符串替换

```swift
// Return string with character replaced
// strstr(string: "", character: "") == ""
// strstr(string: "abc", character: "a") == "bc"
// strstr(string: "abc", character: "d") == ""
func strstr(string: String, character: Character) -> String {
    var result = ""
    for (index, char) in string.enumerated() {
        if char == character {
            result += string[string.index(string.startIndex, offsetBy: index + 1) ..< string.index(string.startIndex, offsetBy: string.count)]
            break
        }
    }
    return result
}
```

### 6. 字符串分割

```swift
// Return array of substrings separated by character
// Return empty array if character is not found
// strtok(string: "", character: "") == []
// strtok(string: "abc", character: "a") == ["bc"]
// strtok(string: "abc", character: "d") == []
func strtok(string: String, character: Character) -> [String] {
    var result = [String]()
    var startIndex = string.startIndex
    var endIndex = string.startIndex
    while endIndex < string.endIndex {
        endIndex = string.index(endIndex, offsetBy: 1)
        if string[endIndex] == character {
            result.append(string[startIndex..<endIndex])
            startIndex = string.index(endIndex, offsetBy: 1)
        }
    }
    result.append(string[startIndex..<endIndex])
    return result
}
```

### 7. 字符串合并

```swift
// Return string with substrings merged
// strtok(string: "", character: "") == ""
// strtok(string: "abc", character: "a") == "bc"
// strtok(string: "abc", character: "d") == "abc"
func strtok(string: String, character: Character) -> String {
    var result = ""
    var startIndex = string.startIndex
    var endIndex = string.startIndex
    while endIndex < string.endIndex {
        endIndex = string.index(endIndex, offset

func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}

func strcat(string1: String, string2: String) -> String {
    return string1 + string2
}

func strcmp(string1: String, string2: String) -> Int {
    if string1 < string2 {
        return -1
    } else if string1 > string2 {
        return 1
    } else {
        return 0
    }
}

func strchr(string: String, character: Character) -> Character? {
    for c in string {
        if c == character {
            return c
        }
    }
    return nil
}

func strstr(string: String, character: Character, replacement: Character) -> String {
    var result = ""
    for c in string {
        if c == character {
            result.append(replacement)
        } else {
            result.append(c)
        }
    }
    return result
}

func strtok(string: String, delimiter: Character) -> [String] {
    var result = [String]()
    var start = 0
    for (index, c) in string.enumerated() {
        if c == delimiter {
            result.append(string[start..<index])
            start = index + 1
        }
    }
    result.append(string[start..<string.count])
    return result
}

func strjoin(strings: [String]) -> String {
    var result = ""
    for s in strings {
        result.append(s)
        result.append(", ")
    }
    result.removeLast()
    return result
}

func strcspn(string: String, charactersToIgnore: CharacterSet) -> Int {
    var count = 0
    for c in string {
        if !charactersToIgnore.contains(c) {
            count += 1
        }
    }
    return count
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}
```

### 2. 字符串拼接

```swift
// Concatenate two strings
// strcat(string1: "Hello", string2: "World") == "HelloWorld"
func strcat(string1: String, string2: String) -> String {
    return string1 + string2
}
```

### 3. 字符串比较

```swift
// Compare two strings
// strcmp(string1: "Hello", string2: "World") == -1
// strcmp(string1: "World", string2: "Hello") == 1
func strcmp(string1: String, string2: String) -> Int {
    if string1 < string2 {
        return -1
    } else if string1 > string2 {
        return 1
    } else {
        return 0
    }
}
```

### 4. 字符串查找

```swift
// Find a character in a string
// strchr(string: "Hello", character: "l") == "l"
// strchr(string: "Hello", character: "z") == nil
func strchr(string: String, character: Character) -> Character? {
    for c in string {
        if c == character {
            return c
        }
    }
    return nil
}
```

### 5. 字符串替换

```swift
// Replace a character in a string
// strstr(string: "Hello", character: "l", replacement: "o") == "Helloo"
func strstr(string: String, character: Character, replacement: Character) -> String {
    var result = ""
    for c in string {
        if c == character {
            result.append(replacement)
        } else {
            result.append(c)
        }
    }
    return result
}
```

### 6. 字符串分割

```swift
// Split a string into substrings
// strtok(string: "Hello, World", delimiter: ",") == ["Hello", " World"]
func strtok(string: String, delimiter: Character) -> [String] {
    var result = [String]()
    var start = 0
    for (index, c) in string.enumerated() {
        if c == delimiter {
            result.append(string[start..<index])
            start = index + 1
        }
    }
    result.append(string[start..<string.count])
    return result
}
```

### 7. 字符串合并

```swift
// Merge a list of strings into a single string
// strjoin(strings: ["Hello", "World"]) == "Hello, World"
func strjoin(strings: [String]) -> String {
    var result = ""
    for s in strings {
        result.append(s)
        result.append(", ")
    }
    result.removeLast()
    return result
}
```

### 8. 字符串编码

```swift
// Encode a string into a byte array
// strcspn(string: "Hello", charactersToIgnore: "abc") == 5
func strcspn(string: String, charactersToIgnore: CharacterSet) -> Int {
    var count = 0
    for c in string {
        if !charactersToIgnore.contains(c) {
            count += 1
        }
    }
    return count
}
```

### 9. 字符串解码

```swift
// Decode a byte array into a string
// strspn(byteArray: [0x48, 0x65, 0x6c, 0x6c, 0x6f], charactersToIgnore: "abc") == 5
func strspn(byteArray: [UInt8], charactersToIgnore: CharacterSet) -> Int {
    var count = 0
    for c in byteArray {
        if !charactersToIgnore.contains(Character(UnicodeScalar(c))) {

func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}

class Solution {
    func reverseWords(_ s: String) -> String {
        let arr = s.split(separator: " ").map { String($0) }
        var res = ""
        for i in (0..<arr.count).reversed() {
            if i == arr.count - 1 {
                res += arr[i]
            } else {
                res += arr[i] + " "
            }
        }
        return res
    }
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    var count = 0
    for _ in string {
        count += 1
    }
    return count
}
```

### 代码

```swift
class Solution {
    func reverseWords(_ s: String) -> String {
        let arr = s.split(separator: " ").map { String($0) }
        var res = ""
        for i in (0..<arr.count).reversed() {
            if i == arr.count - 1 {
                res += arr[i]
            } else {
                res += arr[i] + " "
            }
        }
        return res
    }
}
```

func strlen(string: String) -> Int {
    var count = 0
    for c in string {
        count += 1
    }
    return count
}

class Solution {
    func reverseWords(_ s: String) -> String {
        let strArr = s.split(separator: " ")
        var res = ""
        for str in strArr {
            res += String(str.reversed()) + " "
        }
        return String(res.reversed())
    }
}

```swift
// Return length of given string
// strlen(string: "") == 0
// strlen(string: "abc") == 3
func strlen(string: String) -> Int {
    var count = 0
    for c in string {
        count += 1
    }
    return count
}
```

### 代码

```swift
class Solution {
    func reverseWords(_ s: String) -> String {
        let strArr = s.split(separator: " ")
        var res = ""
        for str in strArr {
            res += String(str.reversed()) + " "
        }
        return String(res.reversed())
    }
}
```

func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 0 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}

func largestDivisor(n: Int) -> Int {
    var left = 1
    var right = n
    while left < right {
        let mid = left + (right - left) / 2
        if n % mid == 0 {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left
}

func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return n
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 0 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法二：二分查找

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var left = 1
    var right = n
    while left < right {
        let mid = left + (right - left) / 2
        if n % mid == 0 {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left
}
```

### 解法三：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return n
}
```

### 解法四：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return n
}
```

### 解法五：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return n
}
```

### 解法六：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return n
}
```

### 解法七：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return n
}
```

### 解法八：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return n
}
```

### 解法九：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return n
}
```

### 解法十：数学

```swift

func largestDivisor(n: Int) -> Int {
    var i = 1
    while i < n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return 1
}

func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 0 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}

func largestDivisor(n: Int) -> Int {
    var i = 1
    while i * i < n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return 1
}

func largestDivisor(n: Int) -> Int {
    var i = n
    while i * i > n {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 1
    while i < n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return 1
}
```

### 解法二

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 0 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法三

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 1
    while i * i < n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return 1
}
```

### 解法四

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i * i > n {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法五

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 0 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法六

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i * i > n {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法七

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 0 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法八

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i * i > n {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法九

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 0 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法十

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    

func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}

func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return n
}

func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 2
    }
    return i / 2
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法二

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return n
}
```

### 解法三

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 2
    }
    return i / 2
}
```

### 解法四

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 2
    }
    return i / 2
}
```

### 解法五

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 2
    }
    return i / 2
}
```

### 解法六

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 2
    }
    return i / 2
}
```

### 解法七

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 2
    }
    return i / 2
}
```

### 解法八

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 2
    }
    return i / 2
}
```

### 解法九

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 2
    }
    return i / 2
}
```

### 解法十

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 2
    }
    return i / 2
}
```

### 解法十一

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 

func largestDivisor(n: Int) -> Int {
    var i = 1
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return -1
}

func largestDivisor(n: Int) -> Int {
    var left = 1
    var right = n
    while left < right {
        let mid = left + (right - left) / 2
        if n % mid == 0 {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left - 1
}

func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return -1
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 1
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return -1
}
```

### 解法二：二分查找

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var left = 1
    var right = n
    while left < right {
        let mid = left + (right - left) / 2
        if n % mid == 0 {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left - 1
}
```

### 解法三：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return -1
}
```

func largestDivisor(n: Int) -> Int {
    var i = 1
    while i < n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return 1
}

func largestDivisor(n: Int) -> Int {
    if n == 1 {
        return 1
    }
    let i = n / 2
    if i * 2 == n {
        return i
    } else {
        return largestDivisor(n: i)
    }
}

func largestDivisor(n: Int) -> Int {
    var left = 1
    var right = n
    while left < right {
        let mid = left + (right - left) / 2
        if n % mid == 0 {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left - 1
}

func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return n
}

func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 2
    }
    return i / 2
}

func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 3
    }
    return i / 3
}

func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 5
    }
    return i / 5
}

func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 7
    }
    return i / 7
}

func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 11
    }
    return i / 11
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 1
    while i < n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return 1
}
```

### 解法二：递归

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    if n == 1 {
        return 1
    }
    let i = n / 2
    if i * 2 == n {
        return i
    } else {
        return largestDivisor(n: i)
    }
}
```

### 解法三：二分查找

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var left = 1
    var right = n
    while left < right {
        let mid = left + (right - left) / 2
        if n % mid == 0 {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left - 1
}
```

### 解法四：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return n
}
```

### 解法五：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 2
    }
    return i / 2
}
```

### 解法六：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 3
    }
    return i / 3
}
```

### 解法七：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 5
    }
    return i / 5
}
```

### 解法八：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 7
    }
    return i / 7
}
```

### 解法九：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 11
    }
    return i / 11
}
```

### 解法十：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n

func largestDivisor(n: Int) -> Int {
    var i = 1
    while i < n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return -1
}

func largestDivisor(n: Int) -> Int {
    var i = 1
    while i * i < n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return -1
}

func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i < n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return -1
}

func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i += 1
    }
    return i == n ? -1 : i
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 1
    while i < n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return -1
}
```

### 解法二

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 1
    while i * i < n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return -1
}
```

### 解法三

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i < n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return -1
}
```

### 解法四

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i += 1
    }
    return i == n ? -1 : i
}
```

### 解法五

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i += 1
    }
    return i == n ? -1 : i
}
```

### 解法六

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i += 1
    }
    return i == n ? -1 : i
}
```

### 解法七

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i += 1
    }
    return i == n ? -1 : i
}
```

### 解法八

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i += 1
    }
    return i == n ? -1 : i
}
```

### 解法九

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i += 1
    }
    return i == n ? -1 : i
}
```

### 解法十

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i += 1
    }
    return i == n ? -1 : i
}
```

### 解法十一

func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}

func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= largestDivisor(n: i)
    }
    return 1
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法二：

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= largestDivisor(n: i)
    }
    return 1
}
```

### 解法三：

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法四：

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法五：

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法六：

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法七：

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法八：

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法九：

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法十：

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor

func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}

func largestDivisor(n: Int) -> Int {
    if n == 1 {
        return 1
    }
    let i = n / 2
    if n % i == 0 {
        return i
    } else {
        return largestDivisor(n: i)
    }
}

func largestDivisor(n: Int) -> Int {
    var left = 1
    var right = n
    while left < right {
        let mid = left + (right - left) / 2
        if n % mid == 0 {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left
}

func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return n
}

func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 2
    }
    return i / 2
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = n
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return 1
}
```

### 解法二：递归

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    if n == 1 {
        return 1
    }
    let i = n / 2
    if n % i == 0 {
        return i
    } else {
        return largestDivisor(n: i)
    }
}
```

### 解法三：二分查找

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var left = 1
    var right = n
    while left < right {
        let mid = left + (right - left) / 2
        if n % mid == 0 {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left
}
```

### 解法四：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return n
}
```

### 解法五：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 2
    }
    return i / 2
}
```

### 解法六：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 2
    }
    return i / 2
}
```

### 解法七：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 2
    }
    return i / 2
}
```

### 解法八：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 2
    }
    return i / 2
}
```

### 解法九：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while n % i == 0 {
        i *= 2
    }
    return i / 2
}
```

### 解法十：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int

func largestDivisor(n: Int) -> Int {
    var i = 1
    while i < n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return i
}

func largestDivisor(n: Int) -> Int {
    var left = 1
    var right = n
    while left < right {
        let mid = left + (right - left) / 2
        if n % mid == 0 {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left
}

func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return n
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 1
    while i < n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return i
}
```

### 解法二：二分查找

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var left = 1
    var right = n
    while left < right {
        let mid = left + (right - left) / 2
        if n % mid == 0 {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left
}
```

### 解法三：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return n
}
```

func largestDivisor(n: Int) -> Int {
    var i = 1
    while i < n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return -1
}

func largestDivisor(n: Int) -> Int {
    var left = 1
    var right = n
    while left < right {
        let mid = left + (right - left) / 2
        if n % mid == 0 {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left - 1
}

func largestDivisor(n: Int) -> Int {
    let sqrt = Int(sqrt(Double(n)))
    var i = sqrt
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return -1
}

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var i = 1
    while i < n {
        if n % i == 0 {
            return i
        }
        i += 1
    }
    return -1
}
```

### 解法二：二分查找

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    var left = 1
    var right = n
    while left < right {
        let mid = left + (right - left) / 2
        if n % mid == 0 {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left - 1
}
```

### 解法三：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    let sqrt = Int(sqrt(Double(n)))
    var i = sqrt
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return -1
}
```

### 解法四：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    let sqrt = Int(sqrt(Double(n)))
    var i = sqrt
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return -1
}
```

### 解法五：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    let sqrt = Int(sqrt(Double(n)))
    var i = sqrt
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return -1
}
```

### 解法六：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    let sqrt = Int(sqrt(Double(n)))
    var i = sqrt
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return -1
}
```

### 解法七：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    let sqrt = Int(sqrt(Double(n)))
    var i = sqrt
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return -1
}
```

### 解法八：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 15) == 5
func largestDivisor(n: Int) -> Int {
    let sqrt = Int(sqrt(Double(n)))
    var i = sqrt
    while i > 1 {
        if n % i == 0 {
            return i
        }
        i -= 1
    }
    return -1
}
```

### 解法九：数学

```swift
// For a given number n, find the largest number that divides n evenly, smaller than n
// largestDivisor(n: 

func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    var i = 2
    while n > 1 {
        if n % i == 0 {
            factors.append(i)
            n /= i
        } else {
            i += 1
        }
    }
    return factors
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    var i = 2
    while n > 1 {
        if n % i == 0 {
            factors.append(i)
            n /= i
        } else {
            i += 1
        }
    }
    return factors
}
```

func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    var i = 2
    while n > 1 {
        if n % i == 0 {
            factors.append(i)
            n /= i
        } else {
            i += 1
        }
    }
    return factors
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    var i = 2
    while n > 1 {
        if n % i == 0 {
            factors.append(i)
            n /= i
        } else {
            i += 1
        }
    }
    return factors
}
```

func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    for i in 2...n {
        while n % i == 0 {
            factors.append(i)
            n /= i
        }
    }
    return factors
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    for i in 2...n {
        while n % i == 0 {
            factors.append(i)
            n /= i
        }
    }
    return factors
}
```

func factorize(n: Int) -> [Int] {
    var factors: [Int] = []
    var num = n
    var i = 2
    while num > 1 {
        if num % i == 0 {
            factors.append(i)
            num /= i
        } else {
            i += 1
        }
    }
    return factors
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var factors: [Int] = []
    var num = n
    var i = 2
    while num > 1 {
        if num % i == 0 {
            factors.append(i)
            num /= i
        } else {
            i += 1
        }
    }
    return factors
}
```

func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    
    for i in 2...n {
        while n % i == 0 {
            factors.append(i)
            n /= i
        }
    }
    
    return factors
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    
    for i in 2...n {
        while n % i == 0 {
            factors.append(i)
            n /= i
        }
    }
    
    return factors
}
```

func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var num = n
    for i in 2...n {
        while num % i == 0 {
            factors.append(i)
            num /= i
        }
    }
    return factors
}

class Solution {
    func primeFactors(_ n: Int) -> [Int] {
        var factors = [Int]()
        var num = n
        for i in 2...n {
            while num % i == 0 {
                factors.append(i)
                num /= i
            }
        }
        return factors
    }
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var num = n
    for i in 2...n {
        while num % i == 0 {
            factors.append(i)
            num /= i
        }
    }
    return factors
}
```

### 解题思路

### 代码

```swift
class Solution {
    func primeFactors(_ n: Int) -> [Int] {
        var factors = [Int]()
        var num = n
        for i in 2...n {
            while num % i == 0 {
                factors.append(i)
                num /= i
            }
        }
        return factors
    }
}
```

func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    for i in 2...n {
        while n % i == 0 {
            factors.append(i)
            n /= i
        }
    }
    return factors
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    for i in 2...n {
        while n % i == 0 {
            factors.append(i)
            n /= i
        }
    }
    return factors
}
```

func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    for i in 2...n {
        while n % i == 0 {
            factors.append(i)
            n /= i
        }
    }
    return factors
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    for i in 2...n {
        while n % i == 0 {
            factors.append(i)
            n /= i
        }
    }
    return factors
}
```

func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    for i in 2...n {
        while n % i == 0 {
            factors.append(i)
            n /= i
        }
    }
    return factors
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    for i in 2...n {
        while n % i == 0 {
            factors.append(i)
            n /= i
        }
    }
    return factors
}
```

func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    for i in 2...n {
        while n % i == 0 {
            factors.append(i)
            n /= i
        }
    }
    return factors
}

```swift
// Return array of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be arrayed number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// factorize(n: 8) == [2, 2, 2]
// factorize(n: 25) == [5, 5]
// factorize(n: 70) == [2, 5, 7]
func factorize(n: Int) -> [Int] {
    var factors = [Int]()
    var n = n
    for i in 2...n {
        while n % i == 0 {
            factors.append(i)
            n /= i
        }
    }
    return factors
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if result.contains(number) {
            continue
        }
        result.append(number)
    }
    return result
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        result.remove(where: { $0 == number })
    }
    return result
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        result.removeFirst()
    }
    return result
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        result.removeLast()
    }
    return result
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        result.remove(at: 0)
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if result.contains(number) {
            continue
        }
        result.append(number)
    }
    return result
}
```

### 解法二

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        result.remove(where: { $0 == number })
    }
    return result
}
```

### 解法三

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        result.removeFirst()
    }
    return result
}
```

### 解法四

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        result.removeLast()
    }
    return result
}
```

### 解法五

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        result.remove(at: 0)
    }
    return result
}
```

### 解法六

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        result.removeLast()
    }
    return result
}
```

### 解法七

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        result.append(number)
        result.removeFirst()
    }
    return result
}
```

### 解法八

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) ->

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if result.count == 0 || result.last! != number {
            result.append(number)
        }
    }
    return result
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var i = 0
    for number in numbers {
        if i == 0 || result[i - 1] != number {
            result.append(number)
        }
        i += 1
    }
    return result
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int: Int]()
    var i = 0
    for number in numbers {
        if result[number] == nil {
            result[number] = 1
            result.append(number)
        }
        i += 1
    }
    return result.keys.map { $0 }
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    let last = numbers.removeLast()
    return removeDuplicates(numbers: numbers) + [last]
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    let last = numbers.removeLast()
    var result = removeDuplicates(numbers: numbers)
    if result.count == 0 || result.last! != last {
        result.append(last)
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if result.count == 0 || result.last! != number {
            result.append(number)
        }
    }
    return result
}
```

### 解法二：双指针

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var i = 0
    for number in numbers {
        if i == 0 || result[i - 1] != number {
            result.append(number)
        }
        i += 1
    }
    return result
}
```

### 解法三：哈希表

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int: Int]()
    var i = 0
    for number in numbers {
        if result[number] == nil {
            result[number] = 1
            result.append(number)
        }
        i += 1
    }
    return result.keys.map { $0 }
}
```

### 解法四：递归

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    let last = numbers.removeLast()
    return removeDuplicates(numbers: numbers) + [last]
}
```

### 解法五：递归 + 哈希表

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    let last = numbers.removeLast()
    var result = removeDuplicates(numbers: numbers)
    if result.count == 0 || result.last! != last {
        result.append(last)
    }
    return result
}
```

### 解法六：递归 + 哈希表 + 栈

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    let last = numbers.removeLast()
    var result = removeDuplicates(numbers: numbers)
    if result.count == 0 || result.last! != last {
        result.append(last)
    }
    return result
}
```

### 解法七：递归 + 哈希表 + 栈 + 数组

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers:

func removeDuplicates(numbers: [Int]) -> [Int] {
    guard numbers.count > 0 else {
        return []
    }
    var result = [Int]()
    result.append(numbers[0])
    for i in 1..<numbers.count {
        if result.last! != numbers[i] {
            result.append(numbers[i])
        }
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    guard numbers.count > 0 else {
        return []
    }
    var result = [Int]()
    result.append(numbers[0])
    for i in 1..<numbers.count {
        if result.last! != numbers[i] {
            result.append(numbers[i])
        }
    }
    return result
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if !seen.contains(number) {
            result.append(number)
            seen.insert(number)
        }
    }
    return result
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    guard numbers.count > 0 else { return [] }
    var result = [Int]()
    result.append(numbers[0])
    var i = 0
    for j in 1..<numbers.count {
        if numbers[j] != numbers[i] {
            i += 1
            result.append(numbers[j])
        }
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var seen = Set<Int>()
    for number in numbers {
        if !seen.contains(number) {
            result.append(number)
            seen.insert(number)
        }
    }
    return result
}
```

### 解法二：双指针

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    guard numbers.count > 0 else { return [] }
    var result = [Int]()
    result.append(numbers[0])
    var i = 0
    for j in 1..<numbers.count {
        if numbers[j] != numbers[i] {
            i += 1
            result.append(numbers[j])
        }
    }
    return result
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if result.count == 0 || result.last! != number {
            result.append(number)
        }
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if result.count == 0 || result.last! != number {
            result.append(number)
        }
    }
    return result
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var dict = [Int: Int]()
    for num in numbers {
        if dict[num] == nil {
            result.append(num)
            dict[num] = 1
        }
    }
    return result
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var i = 0
    for num in numbers {
        if i < 1 || num != result[i - 1] {
            result.append(num)
            i += 1
        }
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var dict = [Int: Int]()
    for num in numbers {
        if dict[num] == nil {
            result.append(num)
            dict[num] = 1
        }
    }
    return result
}
```

### 解法二：双指针

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var i = 0
    for num in numbers {
        if i < 1 || num != result[i - 1] {
            result.append(num)
            i += 1
        }
    }
    return result
}
```

### 解法三：双指针

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var i = 0
    for num in numbers {
        if i < 1 || num != result[i - 1] {
            result.append(num)
            i += 1
        }
    }
    return result
}
```

### 解法四：双指针

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var i = 0
    for num in numbers {
        if i < 1 || num != result[i - 1] {
            result.append(num)
            i += 1
        }
    }
    return result
}
```

### 解法五：双指针

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var i = 0
    for num in numbers {
        if i < 1 || num != result[i - 1] {
            result.append(num)
            i += 1
        }
    }
    return result
}
```

### 解法六：双指针

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var i = 0
    for num in numbers {
        if i < 1 || num != result[i - 1] {
            result.append(num)
            i += 1
        }
    }
    return result
}
```

### 解法七：双指针

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1,

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if result.count == 0 || result.last! != number {
            result.append(number)
        }
    }
    return result
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    var result = [Int]()
    result.append(numbers[0])
    var i = 1
    for j in 1..<numbers.count {
        if numbers[j] != numbers[i - 1] {
            result.append(numbers[j])
            i += 1
        }
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    for number in numbers {
        if result.count == 0 || result.last! != number {
            result.append(number)
        }
    }
    return result
}
```

### 解法二：双指针

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    var result = [Int]()
    result.append(numbers[0])
    var i = 1
    for j in 1..<numbers.count {
        if numbers[j] != numbers[i - 1] {
            result.append(numbers[j])
            i += 1
        }
    }
    return result
}
```

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = numbers
    var i = 0
    while i < result.count {
        var j = i + 1
        while j < result.count {
            if result[i] == result[j] {
                result.remove(at: j)
            } else {
                j += 1
            }
        }
        i += 1
    }
    return result
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    var i = 0
    for j in 1..<numbers.count {
        if numbers[i] != numbers[j] {
            i += 1
            numbers[i] = numbers[j]
        }
    }
    return Array(numbers[0..<i + 1])
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = Set<Int>()
    for number in numbers {
        result.insert(number)
    }
    return Array(result)
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int: Int]()
    var i = 0
    for number in numbers {
        if result[number] == nil {
            result[number] = 1
            numbers[i] = number
            i += 1
        }
    }
    return Array(numbers[0..<i])
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var i = 0
    for number in numbers {
        if result.count == 0 || result[i] != number {
            result.append(number)
            i += 1
        }
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = numbers
    var i = 0
    while i < result.count {
        var j = i + 1
        while j < result.count {
            if result[i] == result[j] {
                result.remove(at: j)
            } else {
                j += 1
            }
        }
        i += 1
    }
    return result
}
```

### 解法二：双指针

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    var i = 0
    for j in 1..<numbers.count {
        if numbers[i] != numbers[j] {
            i += 1
            numbers[i] = numbers[j]
        }
    }
    return Array(numbers[0..<i + 1])
}
```

### 解法三：HashSet

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = Set<Int>()
    for number in numbers {
        result.insert(number)
    }
    return Array(result)
}
```

### 解法四：递归

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    var i = 0
    for j in 1..<numbers.count {
        if numbers[i] != numbers[j] {
            i += 1
            numbers[i] = numbers[j]
        }
    }
    return Array(numbers[0..<i + 1])
}
```

### 解法五：递归 + 哈希表

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int: Int]()
    var i = 0
    for number in numbers {
        if result[number] == nil {
            result[number] = 1
            numbers[i] = number
            i += 1
        }
    }
    return Array(numbers[0..<i])
}
```

### 解法六：递归 + 哈希表 + 数组

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = [Int]()
    var i = 0
    for number in numbers {
        if result.count == 0 || result[i] != number {
            result.append(number)
            i += 1
        }
    }
    return result
}
```

### 解法

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result: [Int] = []
    for number in numbers {
        if result.count == 0 || result.last! != number {
            result.append(number)
        }
    }
    return result
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    var slow = 0
    var fast = 1
    while fast < numbers.count {
        if numbers[slow] != numbers[fast] {
            slow += 1
            numbers[slow] = numbers[fast]
        }
        fast += 1
    }
    return Array(numbers[0..<slow + 1])
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    var set: Set<Int> = []
    for number in numbers {
        set.insert(number)
    }
    return Array(set)
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    let last = numbers.removeLast()
    return removeDuplicates(numbers: numbers) + [last]
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    var map: [Int: Int] = [:]
    var result: [Int] = []
    for number in numbers {
        if map[number] == nil {
            result.append(number)
            map[number] = 1
        }
    }
    return result
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result: [Int] = []
    for number in numbers {
        if result.count == 0 || result.last! != number {
            result.append(number)
        }
    }
    return result
}
```

### 解法二：双指针

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    var slow = 0
    var fast = 1
    while fast < numbers.count {
        if numbers[slow] != numbers[fast] {
            slow += 1
            numbers[slow] = numbers[fast]
        }
        fast += 1
    }
    return Array(numbers[0..<slow + 1])
}
```

### 解法三：Set

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var set: Set<Int> = []
    for number in numbers {
        set.insert(number)
    }
    return Array(set)
}
```

### 解法四：递归

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    if numbers.count == 0 {
        return []
    }
    let last = numbers.removeLast()
    return removeDuplicates(numbers: numbers) + [last]
}
```

### 解法五：递归 + 哈希表

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var map: [Int: Int] = [:]
    var result: [Int] = []
    for number in numbers {
        if map[number] == nil {
            result.append(number)
            map[number] = 1
        }
    }
    return result
}
```

### 解法六：递归 + 哈希表 + 数组

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var map: [Int: Int] = [:]
    var result: [Int] = []
    for number in numbers {
        if map[number] == nil {
            result.append(number)
            map[number] = 1
        }
    }
    return result
}
```

### 解法七：递归 + 哈希表 + 数组 + 数组

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4])

func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = numbers
    var i = 0
    while i < result.count {
        let j = result.index(result.startIndex, offsetBy: i + 1)
        if result[i] == result[j] {
            result.remove(at: j)
        } else {
            i += 1
        }
    }
    return result
}

func removeDuplicates(numbers: [Int]) -> [Int] {
    var i = 0
    for j in 1 ..< numbers.count {
        if numbers[i] != numbers[j] {
            i += 1
            numbers[i] = numbers[j]
        }
    }
    return Array(numbers[0 ..< i + 1])
}

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var result = numbers
    var i = 0
    while i < result.count {
        let j = result.index(result.startIndex, offsetBy: i + 1)
        if result[i] == result[j] {
            result.remove(at: j)
        } else {
            i += 1
        }
    }
    return result
}
```

### 解法二：双指针

```swift
// From an array of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// removeDuplicates(numbers: [1, 2, 3, 2, 4]) == [1, 3, 4]
func removeDuplicates(numbers: [Int]) -> [Int] {
    var i = 0
    for j in 1 ..< numbers.count {
        if numbers[i] != numbers[j] {
            i += 1
            numbers[i] = numbers[j]
        }
    }
    return Array(numbers[0 ..< i + 1])
}
```

func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        result.append(c == "a" || c == "A" ? "A" : "a")
    }
    return result
}

func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "[a-z]", with: String(c.uppercase))
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        result.append(c == "a" || c == "A" ? "A" : "a")
    }
    return result
}
```

### 解法二：使用正则表达式

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.replacingOccurrences(of: "[a-z]", with: String(c.uppercase))
}
```

### 解法三：使用字符串的遍历

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        result.append(c == "a" || c == "A" ? "A" : "a")
    }
    return result
}
```

### 解法四：使用字符串的遍历

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        result.append(c == "a" || c == "A" ? "A" : "a")
    }
    return result
}
```

### 解法五：使用字符串的遍历

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        result.append(c == "a" || c == "A" ? "A" : "a")
    }
    return result
}
```

### 解法六：使用字符串的遍历

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        result.append(c == "a" || c == "A" ? "A" : "a")
    }
    return result
}
```

### 解法七：使用字符串的遍历

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        result.append(c == "a" || c == "A" ? "A" : "a")
    }
    return result
}
```

### 解法八：使用字符串的遍历

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        result.append(c == "a" || c == "A" ? "A" : "a")
    }
    return result
}
```

### 解法九：使用字符串的遍历

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        result.append(c == "a" || c == "A" ? "A" : "a")
    }
    return result
}
```

### 解法十：使用字符串的

func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isLowercase {
            result.append(Character(UnicodeScalar(c.asciiValue! - 32)!))
        } else {
            result.append(Character(UnicodeScalar(c.asciiValue! + 32)!))
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isLowercase {
            result.append(Character(UnicodeScalar(c.asciiValue! - 32)!))
        } else {
            result.append(Character(UnicodeScalar(c.asciiValue! + 32)!))
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isLowercase {
            result.append(c.uppercased().first!)
        } else {
            result.append(c.lowercased().first!)
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isLowercase {
            result.append(c.uppercased().first!)
        } else {
            result.append(c.lowercased().first!)
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isLowercase {
            result.append(Character(UnicodeScalar(c.asciiValue! - 32)!))
        } else {
            result.append(Character(UnicodeScalar(c.asciiValue! + 32)!))
        }
    }
    return result
}

func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        result.append(c.isLowercase ? Character(UnicodeScalar(c.asciiValue! - 32)!): Character(UnicodeScalar(c.asciiValue! + 32)!))
    }
    return result
}

func flipCase(string: String) -> String {
    return string.map { $0.isLowercase ? Character(UnicodeScalar($0.asciiValue! - 32)!) : Character(UnicodeScalar($0.asciiValue! + 32)!) }
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isLowercase {
            result.append(Character(UnicodeScalar(c.asciiValue! - 32)!))
        } else {
            result.append(Character(UnicodeScalar(c.asciiValue! + 32)!))
        }
    }
    return result
}
```

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        result.append(c.isLowercase ? Character(UnicodeScalar(c.asciiValue! - 32)!): Character(UnicodeScalar(c.asciiValue! + 32)!))
    }
    return result
}
```

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        result.append(c.isLowercase ? Character(UnicodeScalar(c.asciiValue! - 32)!): Character(UnicodeScalar(c.asciiValue! + 32)!))
    }
    return result
}
```

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isLowercase ? Character(UnicodeScalar($0.asciiValue! - 32)!) : Character(UnicodeScalar($0.asciiValue! + 32)!) }
}
```

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isLowercase ? Character(UnicodeScalar($0.asciiValue! - 32)!) : Character(UnicodeScalar($0.asciiValue! + 32)!) }
}
```

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isLowercase ? Character(UnicodeScalar($0.asciiValue! - 32)!) : Character(UnicodeScalar($0.asciiValue! + 32)!) }
}
```

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isLowercase ? Character(UnicodeScalar($0.asciiValue! - 32)!) : Character(UnicodeScalar($0.asciiValue! + 32)!) }
}
```

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    return string.map { $0.isLowercase ? Character(UnicodeScalar($0.asciiValue! - 32)!) : Character(UnicodeScalar($0.asciiValue! + 32)!) }
}
```

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"

func flipCase(string: String) -> String {
    var chars = Array(string)
    for i in 0..<chars.count {
        if chars[i].isLowercase {
            chars[i] = chars[i].uppercased()
        } else {
            chars[i] = chars[i].lowercased()
        }
    }
    return String(chars)
}

func reverseString(string: String) -> String {
    var chars = Array(string)
    var left = 0
    var right = chars.count - 1
    while left < right {
        chars.swapAt(left, right)
        left += 1
        right -= 1
    }
    return String(chars)
}

func countLetters(string: String, letter: Character) -> Int {
    var count = 0
    for c in string {
        if c == letter {
            count += 1
        }
    }
    return count
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var chars = Array(string)
    for i in 0..<chars.count {
        if chars[i].isLowercase {
            chars[i] = chars[i].uppercased()
        } else {
            chars[i] = chars[i].lowercased()
        }
    }
    return String(chars)
}
```

```swift
// For a given string, reverse its characters.
// reverseString(string: "hello") == "olleh"
func reverseString(string: String) -> String {
    var chars = Array(string)
    var left = 0
    var right = chars.count - 1
    while left < right {
        chars.swapAt(left, right)
        left += 1
        right -= 1
    }
    return String(chars)
}
```

```swift
// For a given string, return the number of occurrences of a given target letter.
// countLetters(string: "tree", letter: "e") == 2
func countLetters(string: String, letter: Character) -> Int {
    var count = 0
    for c in string {
        if c == letter {
            count += 1
        }
    }
    return count
}
```

```swift
// For a given string, return the number of occurrences of a given target letter.
// countLetters(string: "tree", letter: "e") == 2
func countLetters(string: String, letter: Character) -> Int {
    var count = 0
    for c in string {
        if c == letter {
            count += 1
        }
    }
    return count
}
```

```swift
// For a given string, return the number of occurrences of a given target letter.
// countLetters(string: "tree", letter: "e") == 2
func countLetters(string: String, letter: Character) -> Int {
    var count = 0
    for c in string {
        if c == letter {
            count += 1
        }
    }
    return count
}
```

```swift
// For a given string, return the number of occurrences of a given target letter.
// countLetters(string: "tree", letter: "e") == 2
func countLetters(string: String, letter: Character) -> Int {
    var count = 0
    for c in string {
        if c == letter {
            count += 1
        }
    }
    return count
}
```

```swift
// For a given string, return the number of occurrences of a given target letter.
// countLetters(string: "tree", letter: "e") == 2
func countLetters(string: String, letter: Character) -> Int {
    var count = 0
    for c in string {
        if c == letter {
            count += 1
        }
    }
    return count
}
```

```swift
// For a given string, return the number of occurrences of a given target letter.
// countLetters(string: "tree", letter: "e") == 2
func countLetters(string: String, letter: Character) -> Int {
    var count = 0
    for c in string {
        if c == letter {
            count += 1
        }
    }
    return count
}
```

```swift
// For a given string, return the number of occurrences of a given target letter.
// countLetters(string: "tree", letter: "e") == 2
func countLetters(string: String, letter: Character) -> Int {
    var count = 0
    for c in string {
        if c == letter {
            count += 1
        }
    }
    return count
}
```

```swift
// For a given string, return the number of occurrences of a given target letter.
// countLetters(string: "tree", letter: "e") == 2
func countLetters(string: String, letter: Character) -> Int {
    var count = 0
    for c in string {
        if c == letter {
            count

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased().first!)
        } else {
            result.append(char.lowercased().first!)
        }
    }
    return result
}

func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        result.append(char.isLowercase ? char.uppercased().first! : char.lowercased().first!)
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        if char.isLowercase {
            result.append(char.uppercased().first!)
        } else {
            result.append(char.lowercased().first!)
        }
    }
    return result
}
```

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        result.append(char.isLowercase ? char.uppercased().first! : char.lowercased().first!)
    }
    return result
}
```

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        result.append(char.isLowercase ? char.uppercased().first! : char.lowercased().first!)
    }
    return result
}
```

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        result.append(char.isLowercase ? char.uppercased().first! : char.lowercased().first!)
    }
    return result
}
```

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        result.append(char.isLowercase ? char.uppercased().first! : char.lowercased().first!)
    }
    return result
}
```

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        result.append(char.isLowercase ? char.uppercased().first! : char.lowercased().first!)
    }
    return result
}
```

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        result.append(char.isLowercase ? char.uppercased().first! : char.lowercased().first!)
    }
    return result
}
```

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        result.append(char.isLowercase ? char.uppercased().first! : char.lowercased().first!)
    }
    return result
}
```

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for char in string {
        result.append(char.isLowercase ? char.uppercased().first! : char.lowercased().first!)
    }
    return result
}
```

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {

func flipCase(string: String) -> String {
    let chars = Array(string)
    var result = ""
    for char in chars {
        if char.isLowercase {
            result.append(char.uppercased().first!)
        } else {
            result.append(char.lowercased().first!)
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    let chars = Array(string)
    var result = ""
    for char in chars {
        if char.isLowercase {
            result.append(char.uppercased().first!)
        } else {
            result.append(char.lowercased().first!)
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        result.append(c == "a" || c == "A" ? "A" : "a")
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        result.append(c == "a" || c == "A" ? "A" : "a")
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isLowercase {
            result.append(c.uppercased().first!)
        } else {
            result.append(c.lowercased().first!)
        }
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        if c.isLowercase {
            result.append(c.uppercased().first!)
        } else {
            result.append(c.lowercased().first!)
        }
    }
    return result
}
```

func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        result.append(c == "a" || c == "A" ? "A" : "a")
    }
    return result
}

```swift
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// flipCase(string: "Hello") == "hELLO"
func flipCase(string: String) -> String {
    var result = ""
    for c in string {
        result.append(c == "a" || c == "A" ? "A" : "a")
    }
    return result
}
```

func concatenate(strings: [String]) -> String {
    return strings.joined()
}

func split(string: String) -> [String] {
    return Array(string)
}

func join(strings: [String]) -> String {
    return strings.joined()
}

func split(string: String) -> [Character] {
    return Array(string)
}

func join(characters: [Character]) -> String {
    return String(characters)
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 2.1.2 字符串转数组

```swift
// Split a string into an array of strings
// split("abc") == ["a", "b", "c"]
func split(string: String) -> [String] {
    return Array(string)
}
```

### 2.1.3 数组转字符串

```swift
// Join an array of strings into a single string
// join(strings: ["a", "b", "c"]) == "abc"
func join(strings: [String]) -> String {
    return strings.joined()
}
```

### 2.1.4 字符串转数组

```swift
// Split a string into an array of characters
// split(string: "abc") == ["a", "b", "c"]
func split(string: String) -> [Character] {
    return Array(string)
}
```

### 2.1.5 数组转字符串

```swift
// Join an array of characters into a single string
// join(characters: ["a", "b", "c"]) == "abc"
func join(characters: [Character]) -> String {
    return String(characters)
}
```

### 2.1.6 字符串转数组

```swift
// Split a string into an array of strings
// split(string: "abc") == ["a", "b", "c"]
func split(string: String) -> [String] {
    return Array(string)
}
```

### 2.1.7 数组转字符串

```swift
// Join an array of strings into a single string
// join(strings: ["a", "b", "c"]) == "abc"
func join(strings: [String]) -> String {
    return strings.joined()
}
```

### 2.1.8 字符串转数组

```swift
// Split a string into an array of characters
// split(string: "abc") == ["a", "b", "c"]
func split(string: String) -> [Character] {
    return Array(string)
}
```

### 2.1.9 数组转字符串

```swift
// Join an array of characters into a single string
// join(characters: ["a", "b", "c"]) == "abc"
func join(characters: [Character]) -> String {
    return String(characters)
}
```

### 2.1.10 字符串转数组

```swift
// Split a string into an array of strings
// split(string: "abc") == ["a", "b", "c"]
func split(string: String) -> [String] {
    return Array(string)
}
```

### 2.1.11 数组转字符串

```swift
// Join an array of strings into a single string
// join(strings: ["a", "b", "c"]) == "abc"
func join(strings: [String]) -> String {
    return strings.joined()
}
```

### 2.1.12 字符串转数组

```swift
// Split a string into an array of characters
// split(string: "abc") == ["a", "b", "c"]
func split(string: String) -> [Character] {
    return Array(string)
}
```

### 2.1.13 数组转字符串

```swift
// Join an array of characters into a single string
// join(characters: ["a", "b", "c"]) == "abc"
func join(characters: [Character]) -> String {
    return String(characters)
}
```

### 2.1.14 字符串转数组

```swift
// Split a string into an array of strings
// split(string: "abc") == ["a", "b", "c"]
func split(string: String) ->

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}

func concatenate(strings: [String]) -> String {
    return strings.joined()
}

func concatenate(strings: [String]) -> String {
    return strings.joined(separator: "")
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}
```

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined(separator: "")
}
```

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined(separator: "")
}
```

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined(separator: "")
}
```

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined(separator: "")
}
```

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined(separator: "")
}
```

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined(separator: "")
}
```

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined(separator: "")
}
```

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined(separator: "")
}
```

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined(separator: "")
}
```

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined(separator: "")
}
```

```swift
// Conc

func concatenate(strings: [String]) -> String {
    return strings.joined()
}

func split(string: String) -> [String] {
    return string.split(separator: " ")
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 2.3 字符串转数组

```swift
// Split a string into an array of strings
// split(string: "a b c") == ["a", "b", "c"]
func split(string: String) -> [String] {
    return string.split(separator: " ")
}
```

### 2.4 字符串转字典

```swift
// Split a string into an array of strings
// split(string: "a=b c=d") == ["a=b", "c=d"]
func split(string: String) -> [String] {
    return string.split(separator: " ")
}
```

### 2.5 字符串转数组

```swift
// Split a string into an array of strings
// split(string: "a b c") == ["a", "b", "c"]
func split(string: String) -> [String] {
    return string.split(separator: " ")
}
```

### 2.6 字符串转字典

```swift
// Split a string into an array of strings
// split(string: "a=b c=d") == ["a=b", "c=d"]
func split(string: String) -> [String] {
    return string.split(separator: " ")
}
```

### 2.7 字符串转数组

```swift
// Split a string into an array of strings
// split(string: "a b c") == ["a", "b", "c"]
func split(string: String) -> [String] {
    return string.split(separator: " ")
}
```

### 2.8 字符串转字典

```swift
// Split a string into an array of strings
// split(string: "a=b c=d") == ["a=b", "c=d"]
func split(string: String) -> [String] {
    return string.split(separator: " ")
}
```

### 2.9 字符串转数组

```swift
// Split a string into an array of strings
// split(string: "a b c") == ["a", "b", "c"]
func split(string: String) -> [String] {
    return string.split(separator: " ")
}
```

### 2.10 字符串转字典

```swift
// Split a string into an array of strings
// split(string: "a=b c=d") == ["a=b", "c=d"]
func split(string: String) -> [String] {
    return string.split(separator: " ")
}
```

### 2.11 字符串转数组

```swift
// Split a string into an array of strings
// split(string: "a b c") == ["a", "b", "c"]
func split(string: String) -> [String] {
    return string.split(separator: " ")
}
```

### 2.12 字符串转字典

```swift
// Split a string into an array of strings
// split(string: "a=b c=d") == ["a=b", "c=d"]
func split(string: String) -> [String] {
    return string.split(separator: " ")
}
```

### 2.13 字符串转数组

```swift
// Split a string into an array of strings
// split(string: "a b c") == ["a", "b", "c"]
func split(string: String) -> [String] {
    return string.split(separator: " ")
}
```

### 2.14 字符串转字典

```swift
// Split a string into an array of strings
// split(string: "a=b c=d") == ["a=b", "c=d"]
func split(string: String) -> [String] {
    return string.split(separator: " ")
}
```

###

func concatenate(strings: [String]) -> String {
    return strings.joined()
}

func sort(strings: [String]) -> [String] {
    return strings.sorted()
}

func removeDuplicates(strings: [String]) -> [String] {
    return Set(strings).sorted()
}

func intersection(strings: [String], otherStrings: [String]) -> [String] {
    return strings.filter { otherStrings.contains($0) }
}

func difference(strings: [String], otherStrings: [String]) -> [String] {
    return strings.filter { !otherStrings.contains($0) }
}

func symmetricDifference(strings: [String], otherStrings: [String]) -> [String] {
    return Set(strings).symmetricDifference(Set(otherStrings)).sorted()
}

func isSubset(strings: [String], otherStrings: [String]) -> Bool {
    return strings.allSatisfy { otherStrings.contains($0) }
}

func containsAll(strings: [String], otherStrings: [String]) -> Bool {
    return strings.contains(where: { otherStrings.contains($0) })
}

func containsAny(strings: [String], otherStrings: [String]) -> Bool {
    return strings.contains(where: { otherStrings.contains($0) })
}

func isEmpty(strings: [String]) -> Bool {
    return strings.isEmpty
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 2.2.3. 数组排序

```swift
// Sort array of strings
// sort(strings: ["c", "a", "b"]) == ["a", "b", "c"]
func sort(strings: [String]) -> [String] {
    return strings.sorted()
}
```

### 2.2.4. 数组去重

```swift
// Remove duplicates from an array of strings
// removeDuplicates(strings: ["a", "b", "a", "b", "c"]) == ["a", "b", "c"]
func removeDuplicates(strings: [String]) -> [String] {
    return Set(strings).sorted()
}
```

### 2.2.5. 数组交集

```swift
// Find the intersection of two arrays of strings
// intersection(["a", "b", "c"], ["b", "c", "d"]) == ["b", "c"]
func intersection(strings: [String], otherStrings: [String]) -> [String] {
    return strings.filter { otherStrings.contains($0) }
}
```

### 2.2.6. 数组差集

```swift
// Find the difference between two arrays of strings
// difference(["a", "b", "c"], ["b", "c", "d"]) == ["a"]
func difference(strings: [String], otherStrings: [String]) -> [String] {
    return strings.filter { !otherStrings.contains($0) }
}
```

### 2.2.7. 数组对称差集

```swift
// Find the symmetric difference of two arrays of strings
// symmetricDifference(["a", "b", "c"], ["b", "c", "d"]) == ["a", "d"]
func symmetricDifference(strings: [String], otherStrings: [String]) -> [String] {
    return Set(strings).symmetricDifference(Set(otherStrings)).sorted()
}
```

### 2.2.8. 数组是否包含另一个数组

```swift
// Check if one array of strings is a subset of another
// isSubset(["a", "b"], ["a", "b", "c"]) == true
// isSubset(["a", "b"], ["a", "c"]) == false
func isSubset(strings: [String], otherStrings: [String]) -> Bool {
    return strings.allSatisfy { otherStrings.contains($0) }
}
```

### 2.2.9. 数组是否包含另一个数组中的所有元素

```swift
// Check if one array of strings contains all elements of another
// containsAll(["a", "b", "c"], ["a", "b"]) == true
// containsAll(["a", "b", "c"], ["a", "c"]) == false
func containsAll(strings: [String], otherStrings: [String]) -> Bool {
    return strings.contains(where: { otherStrings.contains($0) })
}
```

### 2.2.10. 数组是否包含另一个数组中的任意元素

```swift
// Check if one array of strings contains any element of another
// containsAny(["a", "b", "c"], ["a", "b"]) == true
// containsAny(["a", "b", "c"], ["a", "c"]) == true
func containsAny(strings: [String], otherStrings: [String]) -> Bool {
    return strings.contains(where: { otherStrings.contains($0) })
}
```

### 2.2.11. 数组是否为空

```swift
// Check if an array of strings is empty
// isEmpty(["a", "b", "c"]) == false
// isEmpty([]) == true
func isEmpty(strings: [String]) -> Bool {
    return strings.isEmpty
}
```

### 2.2.12. 数组是否为空

```swift
// Check if an array

func concatenate(strings: [String]) -> String {
    return strings.joined()
}

func split(string: String) -> [String] {
    return Array(string)
}

func split(string: String) -> [Character] {
    return Array(string)
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 2.3.2. 字符串数组转字符串

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 2.3.3. 字符串转字符串数组

```swift
// Split string into array of strings
// split("abc") == ["a", "b", "c"]
// split("") == []
func split(string: String) -> [String] {
    return Array(string)
}
```

### 2.3.4. 字符串数组转字符串数组

```swift
// Split string into array of strings
// split("abc") == ["a", "b", "c"]
// split("") == []
func split(string: String) -> [String] {
    return Array(string)
}
```

### 2.3.5. 字符串转字符数组

```swift
// Split string into array of characters
// split("abc") == ["a", "b", "c"]
// split("") == []
func split(string: String) -> [Character] {
    return Array(string)
}
```

### 2.3.6. 字符串数组转字符数组

```swift
// Split string into array of characters
// split("abc") == ["a", "b", "c"]
// split("") == []
func split(string: String) -> [Character] {
    return Array(string)
}
```

### 2.3.7. 字符串转字符数组

```swift
// Split string into array of characters
// split("abc") == ["a", "b", "c"]
// split("") == []
func split(string: String) -> [Character] {
    return Array(string)
}
```

### 2.3.8. 字符串数组转字符数组

```swift
// Split string into array of characters
// split("abc") == ["a", "b", "c"]
// split("") == []
func split(string: String) -> [Character] {
    return Array(string)
}
```

### 2.3.9. 字符串转数组

```swift
// Split string into array of characters
// split("abc") == ["a", "b", "c"]
// split("") == []
func split(string: String) -> [Character] {
    return Array(string)
}
```

### 2.3.10. 字符串数组转数组

```swift
// Split string into array of characters
// split("abc") == ["a", "b", "c"]
// split("") == []
func split(string: String) -> [Character] {
    return Array(string)
}
```

### 2.3.11. 字符串转数组

```swift
// Split string into array of characters
// split("abc") == ["a", "b", "c"]
// split("") == []
func split(string: String) -> [Character] {
    return Array(string)
}
```

### 2.3.12. 字符串数组转数组

```swift
// Split string into array of characters
// split("abc") == ["a", "b", "c"]
// split("") == []
func split(string: String) -> [Character] {
    return Array(string)
}
```

### 2.3.13. 字符串转数组

```swift
// Split string into array of characters
// split("abc") == ["a", "b", "c"]
// split("") == []
func split(string: String) -> [Character] {
    return Array(string)

func concatenate(strings: [String]) -> String {
    return strings.joined()
}

class Solution {
    func reverseWords(_ s: String) -> String {
        return s.split(separator: " ").reversed().joined(separator: " ")
    }
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 代码

```swift
class Solution {
    func reverseWords(_ s: String) -> String {
        return s.split(separator: " ").reversed().joined(separator: " ")
    }
}
```

func concatenate(strings: [String]) -> String {
    return strings.joined()
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 2. 字符串拼接

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 3. 字符串拼接

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 4. 字符串拼接

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 5. 字符串拼接

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 6. 字符串拼接

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 7. 字符串拼接

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 8. 字符串拼接

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 9. 字符串拼接

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 10. 字符串拼接

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 11. 字符串拼接

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 12. 字符串拼接

```swift
// Concatenate array of strings into a single string
// concatenate(strings

func concatenate(strings: [String]) -> String {
    return strings.joined()
}

func join(strings: [String]) -> String {
    return strings.joined(separator: " ")
}

func characters(string: String) -> [Character] {
    return Array(string)
}

func join(characters: [Character]) -> String {
    return String(characters)
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 2.2.2. 字符串数组转字符串

```swift
// Convert array of strings into a single string
// join(strings: [] as [String]) == ""
// join(strings: ["a", "b", "c"]) == "a b c"
func join(strings: [String]) -> String {
    return strings.joined(separator: " ")
}
```

### 2.2.3. 字符串转数组

```swift
// Convert string into an array of characters
// characters(string: "") == []
// characters(string: "abc") == ["a", "b", "c"]
func characters(string: String) -> [Character] {
    return Array(string)
}
```

### 2.2.4. 字符串转数组

```swift
// Convert string into an array of characters
// characters(string: "") == []
// characters(string: "abc") == ["a", "b", "c"]
func characters(string: String) -> [Character] {
    return Array(string)
}
```

### 2.2.5. 数组转字符串

```swift
// Convert array of characters into a string
// join(characters: [] as [Character]) == ""
// join(characters: ["a", "b", "c"]) == "abc"
func join(characters: [Character]) -> String {
    return String(characters)
}
```

### 2.2.6. 数组转字符串

```swift
// Convert array of characters into a string
// join(characters: [] as [Character]) == ""
// join(characters: ["a", "b", "c"]) == "abc"
func join(characters: [Character]) -> String {
    return String(characters)
}
```

### 2.2.7. 字符串转数组

```swift
// Convert string into an array of characters
// characters(string: "") == []
// characters(string: "abc") == ["a", "b", "c"]
func characters(string: String) -> [Character] {
    return Array(string)
}
```

### 2.2.8. 字符串转数组

```swift
// Convert string into an array of characters
// characters(string: "") == []
// characters(string: "abc") == ["a", "b", "c"]
func characters(string: String) -> [Character] {
    return Array(string)
}
```

### 2.2.9. 数组转字符串

```swift
// Convert array of characters into a string
// join(characters: [] as [Character]) == ""
// join(characters: ["a", "b", "c"]) == "abc"
func join(characters: [Character]) -> String {
    return String(characters)
}
```

### 2.2.10. 数组转字符串

```swift
// Convert array of characters into a string
// join(characters: [] as [Character]) == ""
// join(characters: ["a", "b", "c"]) == "abc"
func join(characters: [Character]) -> String {
    return String(characters)
}
```

### 2.2.11. 字符串转数组

```swift
// Convert string into an array of characters
// characters(string: "") == []
// characters(string: "abc") == ["a", "b", "c"]
func characters(string: String) -> [Character] {
    return Array(string)
}
```

### 2.2.12. 字符串转数组

```swift
// Convert string into an array of characters
// characters(string: "") == []
// characters(string: "abc") == ["a", "b", "c"]
func characters(string: String) -> [Character] {
    return Array(string)
}

func concatenate(strings: [String]) -> String {
    return strings.joined()
}

class Solution {
    func reverseWords(_ s: String) -> String {
        let words = s.split(separator: " ")
        var res = ""
        for word in words.reversed() {
            if word.count > 0 {
                res += word + " "
            }
        }
        return String(res.dropLast())
    }
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    return strings.joined()
}
```

### 代码

```swift
class Solution {
    func reverseWords(_ s: String) -> String {
        let words = s.split(separator: " ")
        var res = ""
        for word in words.reversed() {
            if word.count > 0 {
                res += word + " "
            }
        }
        return String(res.dropLast())
    }
}
```

func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}

class Solution {
    func reverseWords(_ s: String) -> String {
        let words = s.split(separator: " ")
        let reverseWords = words.reversed()
        return reverseWords.joined(separator: " ")
    }
}

```swift
// Concatenate array of strings into a single string
// concatenate(strings: [] as [String]) == ""
// concatenate(strings: ["a", "b", "c"]) == "abc"
func concatenate(strings: [String]) -> String {
    var result = ""
    for string in strings {
        result += string
    }
    return result
}
```

### 代码

```swift
class Solution {
    func reverseWords(_ s: String) -> String {
        let words = s.split(separator: " ")
        let reverseWords = words.reversed()
        return reverseWords.joined(separator: " ")
    }
}
```

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { !$0.hasPrefix(prefix) }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

### 2.2.2. 过滤器

```swift
// Filter an input array of strings only for ones that don't start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["bcd", "cde"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { !$0.hasPrefix(prefix) }
}
```

### 2.2.3. 过滤器

```swift
// Filter an input array of strings only for ones that don't start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["bcd", "cde"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { !$0.hasPrefix(prefix) }
}
```

### 2.2.4. 过滤器

```swift
// Filter an input array of strings only for ones that don't start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["bcd", "cde"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { !$0.hasPrefix(prefix) }
}
```

### 2.2.5. 过滤器

```swift
// Filter an input array of strings only for ones that don't start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["bcd", "cde"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { !$0.hasPrefix(prefix) }
}
```

### 2.2.6. 过滤器

```swift
// Filter an input array of strings only for ones that don't start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["bcd", "cde"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { !$0.hasPrefix(prefix) }
}
```

### 2.2.7. 过滤器

```swift
// Filter an input array of strings only for ones that don't start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["bcd", "cde"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { !$0.hasPrefix(prefix) }
}
```

### 2.2.8. 过滤器

```swift
// Filter an input array of strings only for ones that don't start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

func joinStrings(strings: [String]) -> String {
    return strings.joined(separator: ",")
}

func splitStrings(strings: [String], separator: String) -> [String] {
    return strings.split(separator: separator)
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

### 2. 字符串数组转成字符串

```swift
// Convert an array of strings to a single string, separated by commas.
// joinStrings(strings: [] as [String]) == ""
// joinStrings(strings: ["abc", "bcd", "cde", "array"]) == "abc,bcd,cde,array"
func joinStrings(strings: [String]) -> String {
    return strings.joined(separator: ",")
}
```

### 3. 字符串数组转成字符串数组

```swift
// Convert an array of strings to an array of substrings, split on a given separator.
// splitStrings(strings: [] as [String], separator: "") == [] as [String]
// splitStrings(strings: ["abc", "bcd", "cde", "array"], separator: ",") == ["abc", "bcd", "cde", "array"]
func splitStrings(strings: [String], separator: String) -> [String] {
    return strings.split(separator: separator)
}
```

### 4. 字符串数组转成字符串数组

```swift
// Convert an array of strings to an array of substrings, split on a given separator.
// splitStrings(strings: [] as [String], separator: "") == [] as [String]
// splitStrings(strings: ["abc", "bcd", "cde", "array"], separator: ",") == ["abc", "bcd", "cde", "array"]
func splitStrings(strings: [String], separator: String) -> [String] {
    return strings.split(separator: separator)
}
```

### 5. 字符串数组转成字符串数组

```swift
// Convert an array of strings to an array of substrings, split on a given separator.
// splitStrings(strings: [] as [String], separator: "") == [] as [String]
// splitStrings(strings: ["abc", "bcd", "cde", "array"], separator: ",") == ["abc", "bcd", "cde", "array"]
func splitStrings(strings: [String], separator: String) -> [String] {
    return strings.split(separator: separator)
}
```

### 6. 字符串数组转成字符串数组

```swift
// Convert an array of strings to an array of substrings, split on a given separator.
// splitStrings(strings: [] as [String], separator: "") == [] as [String]
// splitStrings(strings: ["abc", "bcd", "cde", "array"], separator: ",") == ["abc", "bcd", "cde", "array"]
func splitStrings(strings: [String], separator: String) -> [String] {
    return strings.split(separator: separator)
}
```

### 7. 字符串数组转成字符串数组

```swift
// Convert an array of strings to an array of substrings, split on a given separator.
// splitStrings(strings: [] as [String], separator: "") == [] as [String]
// splitStrings(strings: ["abc", "bcd", "cde", "array"], separator: ",") == ["abc", "bcd", "cde", "array"]
func splitStrings(strings: [String], separator: String) -> [String] {
    return strings.split(separator: separator)
}
```

### 8. 字符串数组转成字符串数组

```swift
// Convert an array of strings to an array of substrings, split on a given separator.
// splitStrings(strings: [] as [String], separator: "") == [] as [String]
// splitStrings(strings: ["abc", "bcd", "cde", "array"], separator

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

func joinStrings(strings: [String]) -> String {
    return strings.joined(separator: ",")
}

func splitStrings(strings: [String]) -> [Character] {
    return strings.joined().map { String($0) }
}

func splitAndTrimStrings(strings: [String]) -> [Character] {
    return strings.map { String($0.first!) }
}

func splitAndTrimLastStrings(strings: [String]) -> [Character] {
    return strings.map { String($0.last!) }
}

func splitAndTrimFirstLastStrings(strings: [String]) -> [Character] {
    return strings.map { String($0.dropFirst!.dropLast!) }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

### 2. 字符串数组转成字符串

```swift
// Convert an array of strings into a single string, with each string separated by a comma.
// joinStrings(strings: [] as [String]) == ""
// joinStrings(strings: ["abc", "bcd", "cde", "array"]) == "abc,bcd,cde,array"
func joinStrings(strings: [String]) -> String {
    return strings.joined(separator: ",")
}
```

### 3. 字符串数组转成字符串数组

```swift
// Convert an array of strings into an array of characters.
// splitStrings(strings: [] as [String]) == [] as [Character]
// splitStrings(strings: ["abc", "bcd", "cde", "array"]) == ["a", "b", "c", "d", "e", "a", "r", "r", "a", "r", "y"]
func splitStrings(strings: [String]) -> [Character] {
    return strings.joined().map { String($0) }
}
```

### 4. 字符串数组转成字符串数组

```swift
// Convert an array of strings into an array of characters, with each character in the array being the first character of each string in the array.
// splitAndTrimStrings(strings: [] as [String]) == [] as [Character]
// splitAndTrimStrings(strings: ["abc", "bcd", "cde", "array"]) == ["a", "b", "c", "d", "e", "a", "r", "r", "a", "r", "y"]
func splitAndTrimStrings(strings: [String]) -> [Character] {
    return strings.map { String($0.first!) }
}
```

### 5. 字符串数组转成字符串数组

```swift
// Convert an array of strings into an array of characters, with each character in the array being the last character of each string in the array.
// splitAndTrimLastStrings(strings: [] as [String]) == [] as [Character]
// splitAndTrimLastStrings(strings: ["abc", "bcd", "cde", "array"]) == ["a", "b", "c", "d", "e", "a", "r", "r", "a", "r", "y"]
func splitAndTrimLastStrings(strings: [String]) -> [Character] {
    return strings.map { String($0.last!) }
}
```

### 6. 字符串数组转成字符串数组

```swift
// Convert an array of strings into an array of characters, with each character in the array being the first character of each string in the array, with the first character of the first string in the array being the last character of the last string in the array.
// splitAndTrimFirstLastStrings(strings: [] as [String]) == [] as [Character]
// splitAndTrimFirstLastStrings(strings: ["abc", "bcd", "cde", "array"]) == ["a", "b", "c", "d", "e", "a", "r", "r", "a", "r", "y"]
func splitAndTrimFirstLastStrings(strings: [String]) -> [Character] {
    return strings.map { String($0.dropFirst!.dropLast!) }
}
```

### 7. 字符串数组转成字符串数组

```swift
// Convert an array of strings into an array of characters, with each character in the array being the last character of each string in the array, with the last character of the first string in the array being the first character of the last string in the array.
// splitAndTrimFirstLastStrings(strings: [] as [String]) == [] as [Character]
// splitAndTrimFirstLastStrings(strings: ["abc", "bcd", "cde", "array"]) == ["a", "b", "c", "d

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

func joinStrings(strings: [String]) -> String {
    return strings.joined(separator: ",")
}

func joinStringsWithPrefix(strings: [String], prefix: String) -> String {
    return strings.joined(separator: ",").prefix(prefix.count)
}

func joinStringsWithSuffix(strings: [String], suffix: String) -> String {
    return strings.joined(separator: ",").suffix(suffix.count)
}

func joinStringsWithPrefixAndSuffix(strings: [String], prefix: String, suffix: String) -> String {
    return strings.joined(separator: ",").prefix(prefix.count).suffix(suffix.count)
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

### 2. 字符串数组转成字符串

```swift
// Convert an array of strings to a single string, with each string separated by a comma.
// joinStrings(strings: [] as [String]) == ""
// joinStrings(strings: ["abc", "bcd", "cde", "array"]) == "abc,bcd,cde,array"
func joinStrings(strings: [String]) -> String {
    return strings.joined(separator: ",")
}
```

### 3. 字符串数组转成字符串，并加上前缀

```swift
// Convert an array of strings to a single string, with each string separated by a comma and prefixed with a given prefix.
// joinStringsWithPrefix(strings: [] as [String], prefix: "a") == ""
// joinStringsWithPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == "aabc,abcd,acde,aarray"
func joinStringsWithPrefix(strings: [String], prefix: String) -> String {
    return strings.joined(separator: ",").prefix(prefix.count)
}
```

### 4. 字符串数组转成字符串，并加上后缀

```swift
// Convert an array of strings to a single string, with each string separated by a comma and suffixed with a given suffix.
// joinStringsWithSuffix(strings: [] as [String], suffix: "a") == ""
// joinStringsWithSuffix(strings: ["abc", "bcd", "cde", "array"], suffix: "a") == "abca,bcda,cdea,arraya"
func joinStringsWithSuffix(strings: [String], suffix: String) -> String {
    return strings.joined(separator: ",").suffix(suffix.count)
}
```

### 5. 字符串数组转成字符串，并加上前后缀

```swift
// Convert an array of strings to a single string, with each string separated by a comma and prefixed and suffixed by given prefix and suffix.
// joinStringsWithPrefixAndSuffix(strings: [] as [String], prefix: "a", suffix: "a") == ""
// joinStringsWithPrefixAndSuffix(strings: ["abc", "bcd", "cde", "array"], prefix: "a", suffix: "a") == "aabca,abcda,acdea,aarraya"
func joinStringsWithPrefixAndSuffix(strings: [String], prefix: String, suffix: String) -> String {
    return strings.joined(separator: ",").prefix(prefix.count).suffix(suffix.count)
}
```

### 6. 字符串数组转成字符串，并加上前缀和后缀

```swift
// Convert an array of strings to a single string, with each string separated by a comma and prefixed and suffixed by given prefix and suffix.
// joinStringsWithPrefixAndSuffix(strings: [] as [String], prefix: "a", suffix: "a") == ""
// joinStringsWithPrefixAndSuffix(strings: ["abc", "bcd", "cde", "array"], prefix: "a", suffix: "a") == "aabca,abcda,acdea,aarraya"
func joinStringsWithPrefixAndSuffix(strings: [String], prefix: String, suffix: String) -> String {
    return strings.joined(separator: ",").prefix(prefix.count).suffix(suffix.count)
}
```

### 7. 字符串数组转成字符串，并加上前缀和后缀，并加上分隔符

```swift
// Convert an array of strings to a single string, with each string separated by a given separator and prefixed and suffixed by given prefix and suffix.

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

func characters(of string: String) -> [Character] {
    return Array(string)
}

func string(of array: [Character]) -> String {
    return String(array)
}

func dictionary(of array: [String], key: String) -> [String: String] {
    return array.reduce([String: String]()) {
        $0[$1] = key
        return $0
    }
}

func pairs(of dictionary: [String: String]) -> [(String, String)] {
    return dictionary.map { (key, value) in
        (key, value)
    }
}

func tuple(of array: [String]) -> (String, String, String) {
    return (array[0], array[1], array[2])
}

func set(of array: [String]) -> Set<String> {
    return Set(array)
}

func array(of array: [String]) -> [String] {
    return array
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

### 2. 字符串转数组

```swift
// Convert a string to an array of characters.
// characters(of: "abc") == ["a", "b", "c"]
// characters(of: "") == []
func characters(of string: String) -> [Character] {
    return Array(string)
}
```

### 3. 数组转字符串

```swift
// Convert an array of characters to a string.
// string(of: ["a", "b", "c"]) == "abc"
// string(of: []) == ""
func string(of array: [Character]) -> String {
    return String(array)
}
```

### 4. 数组转字典

```swift
// Convert an array to a dictionary with a given key and value.
// dictionary(of: ["a": 1, "b": 2, "c": 3], key: "a") == [1: "a", 2: "b", 3: "c"]
// dictionary(of: [], key: "a") == []
func dictionary(of array: [String], key: String) -> [String: String] {
    return array.reduce([String: String]()) {
        $0[$1] = key
        return $0
    }
}
```

### 5. 字典转数组

```swift
// Convert a dictionary to an array of key-value pairs.
// pairs(of: [1: "a", 2: "b", 3: "c"]) == [(1, "a"), (2, "b"), (3, "c")]
// pairs(of: []) == []
func pairs(of dictionary: [String: String]) -> [(String, String)] {
    return dictionary.map { (key, value) in
        (key, value)
    }
}
```

### 6. 数组转元组

```swift
// Convert an array to a tuple.
// tuple(of: ["a", "b", "c"]) == ("a", "b", "c")
// tuple(of: []) == ()
func tuple(of array: [String]) -> (String, String, String) {
    return (array[0], array[1], array[2])
}
```

### 7. 数组转集合

```swift
// Convert an array to a set.
// set(of: ["a", "b", "c"]) == ["a", "b", "c"]
// set(of: []) == []
func set(of array: [String]) -> Set<String> {
    return Set(array)
}
```

### 8. 数组转数组

```swift
// Convert an array to another array.
// array(of: [1, 2, 3]) == [1, 2, 3]
// array(of: []) == []
func array(of array: [String]) -> [String] {
    return array
}
```

### 9. 数组转数组

```swift
// Convert an array to another array.
// array(of: [1, 2, 3]) == [1, 2, 3]
// array(of: []) == []
func array(of array: [String]) -> [String] {
    return array
}
```

### 10. 数组转数组

```swift
// Convert an array to another array.
// array(of: [1, 2, 3]) == [1, 2, 3]
// array(of: []) == []
func array(of array: [String]) -> [String] {
    return array
}
```

### 11. 数组转数组

```swift
// Convert an array to another array.
// array(of: [1, 2, 3]) == [1, 2, 3]
// array(of: []) == []
func array(of array: [String]) -> [String] {
    return array

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.enumerated().filter { $0.element.hasPrefix(prefix) }.map { $0.element }
}

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.enumerated().filter { $0.element.hasPrefix(prefix) }.map { $0.offset }.map { strings[$0] }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

### 2. 利用数组下标

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.enumerated().filter { $0.element.hasPrefix(prefix) }.map { $0.element }
}
```

### 3. 利用数组下标

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.enumerated().filter { $0.element.hasPrefix(prefix) }.map { $0.offset }.map { strings[$0] }
}
```

### 4. 利用数组下标

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.enumerated().filter { $0.element.hasPrefix(prefix) }.map { $0.offset }.map { strings[$0] }
}
```

### 5. 利用数组下标

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.enumerated().filter { $0.element.hasPrefix(prefix) }.map { $0.offset }.map { strings[$0] }
}
```

### 6. 利用数组下标

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.enumerated().filter { $0.element.hasPrefix(prefix) }.map { $0.offset }.map { strings[$0] }
}
```

### 7. 利用数组下标

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.enumerated().filter { $0.element.hasPrefix(prefix) }.map { $0.offset }.map { strings[$0] }
}
```

### 8. 

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

func characters(in string: String) -> [Character] {
    return Array(string)
}

func String(of array: [Character]) -> String {
    return String(array)
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

### 2. 字符串转数组

```swift
// Convert a string to an array of characters.
// characters(in: "abc") == ["a", "b", "c"]
// characters(in: "") == []
func characters(in string: String) -> [Character] {
    return Array(string)
}
```

### 3. 数组转字符串

```swift
// Convert an array of characters to a string.
// String(of: [Character]()) == ""
// String(of: ["a", "b", "c"]) == "abc"
func String(of array: [Character]) -> String {
    return String(array)
}
```

### 4. 字符串转数组

```swift
// Convert a string to an array of characters.
// characters(in: "abc") == ["a", "b", "c"]
// characters(in: "") == []
func characters(in string: String) -> [Character] {
    return Array(string)
}
```

### 5. 数组转字符串

```swift
// Convert an array of characters to a string.
// String(of: [Character]()) == ""
// String(of: ["a", "b", "c"]) == "abc"
func String(of array: [Character]) -> String {
    return String(array)
}
```

### 6. 字符串转数组

```swift
// Convert a string to an array of characters.
// characters(in: "abc") == ["a", "b", "c"]
// characters(in: "") == []
func characters(in string: String) -> [Character] {
    return Array(string)
}
```

### 7. 数组转字符串

```swift
// Convert an array of characters to a string.
// String(of: [Character]()) == ""
// String(of: ["a", "b", "c"]) == "abc"
func String(of array: [Character]) -> String {
    return String(array)
}
```

### 8. 字符串转数组

```swift
// Convert a string to an array of characters.
// characters(in: "abc") == ["a", "b", "c"]
// characters(in: "") == []
func characters(in string: String) -> [Character] {
    return Array(string)
}
```

### 9. 数组转字符串

```swift
// Convert an array of characters to a string.
// String(of: [Character]()) == ""
// String(of: ["a", "b", "c"]) == "abc"
func String(of array: [Character]) -> String {
    return String(array)
}
```

### 10. 字符串转数组

```swift
// Convert a string to an array of characters.
// characters(in: "abc") == ["a", "b", "c"]
// characters(in: "") == []
func characters(in string: String) -> [Character] {
    return Array(string)
}
```

### 11. 数组转字符串

```swift
// Convert an array of characters to a string.
// String(of: [Character]()) == ""
// String(of: ["a", "b", "c"]) == "abc"
func String(of array: [Character]) -> String {
    return String(array)
}
```

### 12. 字符串转数组

```swift
// Convert a string to an array of characters.
// characters(in: "abc") == ["a", "b", "c"]
// characters(in: "") == []
func characters(in string: String) -> [Character] {
    return Array(string)
}
```

### 13. 数组转字符串

```swift
// Convert an array of characters to a string.

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

### 2. 判断字符串是否以指定字符串开头

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

### 3. 判断字符串是否以指定字符串开头

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

### 4. 判断字符串是否以指定字符串开头

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

### 5. 判断字符串是否以指定字符串开头

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

### 6. 判断字符串是否以指定字符串开头

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

### 7. 判断字符串是否以指定字符串开头

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

### 8. 判断字符串是否以指定字符串开头

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filter

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

func charactersInString(string: String) -> [Character] {
    return Array(string)
}

func stringFromCharacters(characters: [Character]) -> String {
    return String(characters)
}

func asInt(string: String) -> Int {
    return Int(string) ?? 0
}

func asString(integer: Int) -> String {
    return "\(integer)"
}

func asBool(string: String) -> Bool {
    return string == "true"
}

func asString(boolean: Bool) -> String {
    return "\(boolean)"
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

### 2. 字符串转数组

```swift
// Convert a string to an array of characters.
// charactersInString(string: "abc") == ["a", "b", "c"]
func charactersInString(string: String) -> [Character] {
    return Array(string)
}
```

### 3. 数组转字符串

```swift
// Convert an array of characters to a string.
// stringFromCharacters(characters: ["a", "b", "c"]) == "abc"
func stringFromCharacters(characters: [Character]) -> String {
    return String(characters)
}
```

### 4. 字符串转数字

```swift
// Convert a string to an integer.
// asInt(string: "123") == 123
func asInt(string: String) -> Int {
    return Int(string) ?? 0
}
```

### 5. 数字转字符串

```swift
// Convert an integer to a string.
// asString(integer: 123) == "123"
func asString(integer: Int) -> String {
    return "\(integer)"
}
```

### 6. 字符串转布尔值

```swift
// Convert a string to a boolean.
// asBool(string: "true") == true
func asBool(string: String) -> Bool {
    return string == "true"
}
```

### 7. 布尔值转字符串

```swift
// Convert a boolean to a string.
// asString(boolean: true) == "true"
func asString(boolean: Bool) -> String {
    return "\(boolean)"
}
```

### 8. 字符串转数组

```swift
// Convert a string to an array of characters.
// charactersInString(string: "abc") == ["a", "b", "c"]
func charactersInString(string: String) -> [Character] {
    return Array(string)
}
```

### 9. 数组转字符串

```swift
// Convert an array of characters to a string.
// stringFromCharacters(characters: ["a", "b", "c"]) == "abc"
func stringFromCharacters(characters: [Character]) -> String {
    return String(characters)
}
```

### 10. 字符串转数字

```swift
// Convert a string to an integer.
// asInt(string: "123") == 123
func asInt(string: String) -> Int {
    return Int(string) ?? 0
}
```

### 11. 数字转字符串

```swift
// Convert an integer to a string.
// asString(integer: 123) == "123"
func asString(integer: Int) -> String {
    return "\(integer)"
}
```

### 12. 字符串转布尔值

```swift
// Convert a string to a boolean.
// asBool(string: "true") == true
func asBool(string: String) -> Bool {
    return string == "true"
}
```

### 13. 布尔值转字符串

```swift
// Convert a boolean to a string.
// asString(boolean: true) == "true"
func asString(boolean: Bool) -> String {
    return "\(boolean)"
}
```

### 14. 字符串转数组

```swift
// Convert a string to an array of characters.
// charactersInString(string: "abc") == ["a", "b", "c"]
func charactersInString(string: String) -> [Character] {
    return Array(string)
}
```

### 15. 数组转字符串

```swift
// Convert an array of characters to a string.
// stringFrom

func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}

func joinStrings(strings: [String]) -> String {
    return strings.joined(separator: ",")
}

func splitStrings(strings: [String]) -> [Character] {
    return strings.joined().map { String($0) }
}

func splitAndTrimStrings(strings: [String]) -> [Character] {
    return strings.joined().filter { !$0.isWhitespace }.map { String($0) }
}

func splitAndTrimAndLowercaseStrings(strings: [String]) -> [Character] {
    return strings.joined().filter { !$0.isWhitespace }.map { String($0).lowercased() }
}

```swift
// Filter an input array of strings only for ones that start with a given prefix.
// filterByPrefix(strings: [] as [String], prefix: "a") == [] as [String]
// filterByPrefix(strings: ["abc", "bcd", "cde", "array"], prefix: "a") == ["abc", "array"]
func filterByPrefix(strings: [String], prefix: String) -> [String] {
    return strings.filter { $0.hasPrefix(prefix) }
}
```

### 2. 字符串数组转成字符串

```swift
// Convert an array of strings to a single string, with each string separated by a comma.
// joinStrings(strings: [] as [String]) == ""
// joinStrings(strings: ["abc", "bcd", "cde", "array"]) == "abc,bcd,cde,array"
func joinStrings(strings: [String]) -> String {
    return strings.joined(separator: ",")
}
```

### 3. 字符串数组转成字符串数组

```swift
// Convert an array of strings to an array of characters.
// splitStrings(strings: [] as [String]) == [] as [Character]
// splitStrings(strings: ["abc", "bcd", "cde", "array"]) == ["a", "b", "c", "d", "e", "a", "r", "r", "a", "r", "y"]
func splitStrings(strings: [String]) -> [Character] {
    return strings.joined().map { String($0) }
}
```

### 4. 字符串数组转成字符串数组

```swift
// Convert an array of strings to an array of characters, removing all whitespace characters.
// splitAndTrimStrings(strings: [] as [String]) == [] as [Character]
// splitAndTrimStrings(strings: ["abc", " bcd ", "cde ", "array"]) == ["a", "b", "c", "d", "e", "a", "r", "r", "a", "r", "y"]
func splitAndTrimStrings(strings: [String]) -> [Character] {
    return strings.joined().filter { !$0.isWhitespace }.map { String($0) }
}
```

### 5. 字符串数组转成字符串数组

```swift
// Convert an array of strings to an array of characters, removing all whitespace characters and case-insensitive.
// splitAndTrimAndLowercaseStrings(strings: [] as [String]) == [] as [Character]
// splitAndTrimAndLowercaseStrings(strings: ["abc", " bcd ", "cde ", "array"]) == ["a", "b", "c", "d", "e", "a", "r", "r", "a", "r", "y"]
func splitAndTrimAndLowercaseStrings(strings: [String]) -> [Character] {
    return strings.joined().filter { !$0.isWhitespace }.map { String($0).lowercased() }
}
```

### 6. 字符串数组转成字符串数组

```swift
// Convert an array of strings to an array of characters, removing all whitespace characters and case-insensitive.
// splitAndTrimAndLowercaseStrings(strings: [] as [String]) == [] as [Character]
// splitAndTrimAndLowercaseStrings(strings: ["abc", " bcd ", "cde ", "array"]) == ["a", "b", "c", "d", "e", "a", "r", "r", "a", "r", "y"]
func splitAndTrimAndLowercaseStrings(strings: [String]) -> [Character] {
    return strings.joined().filter { !$0.isWhitespace }.map { String($0).lowercased() }
}
```

### 7. 字符串数组转成字符串数组

```swift
// Convert an array of strings to an array of characters, removing all whitespace characters and case-insensitive.
// splitAndTrimAndLowercaseStrings(strings: [] as [String]) == [] as [Character]
// splitAndTrimAndLowercaseStrings(strings: ["abc", " bcd ", "cde ", "array"]) == ["a", "b", "c", "d", "e",

func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}

func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}
```

### 解法二：

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法三：

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法四：

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法五：

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法六：

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法七：

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法八：

func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}

func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}

func getPositive(l: [Int]) -> [Int] {
    return l.reduce([Int]()) { (result, i) in
        if i > 0 {
            result.append(i)
        }
        return result
    }
}

func getPositive(l: [Int]) -> [Int] {
    return l.reduce([Int]()) { (result, i) in
        result.append(contentsOf: filter(i))
        return result
    }
}

func filter(_ i: Int) -> [Int] {
    return i > 0 ? [i] : []
}

func getPositive(l: [Int]) -> [Int] {
    return l.reduce([Int]()) { (result, i) in
        result.append(contentsOf: filter(i).map { $0 })
        return result
    }
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}
```

### 方法二：使用filter

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 方法三：使用reduce

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.reduce([Int]()) { (result, i) in
        if i > 0 {
            result.append(i)
        }
        return result
    }
}
```

### 方法四：使用reduce + filter

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.reduce([Int]()) { (result, i) in
        result.append(contentsOf: filter(i))
        return result
    }
}

func filter(_ i: Int) -> [Int] {
    return i > 0 ? [i] : []
}
```

### 方法五：使用reduce + filter + map

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.reduce([Int]()) { (result, i) in
        result.append(contentsOf: filter(i).map { $0 })
        return result
    }
}

func filter(_ i: Int) -> [Int] {
    return i > 0 ? [i] : []
}
```

### 方法六：使用reduce + filter + map + filter

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.reduce([Int]()) { (result, i) in
        result.append

func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}

func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}
```

### 解法二

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法三

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}
```

### 解法四

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法五

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法六

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法七

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter

func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}

func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    var left = 0
    var right = l.count - 1
    while left <= right {
        if l[left] > 0 {
            result.append(l[left])
            left += 1
        } else {
            left += 1
        }
        if l[right] > 0 {
            result.append(l[right])
            right -= 1
        } else {
            right -= 1
        }
    }
    return result
}

func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        } else if i == 0 {
            continue
        } else {
            let subResult = getPositive(l: Array(i...))
            for j in subResult {
                result.append(j)
            }
        }
    }
    return result
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}
```

### 方法二：双指针

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    var left = 0
    var right = l.count - 1
    while left <= right {
        if l[left] > 0 {
            result.append(l[left])
            left += 1
        } else {
            left += 1
        }
        if l[right] > 0 {
            result.append(l[right])
            right -= 1
        } else {
            right -= 1
        }
    }
    return result
}
```

### 方法三：递归

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        } else if i == 0 {
            continue
        } else {
            let subResult = getPositive(l: Array(i...))
            for j in subResult {
                result.append(j)
            }
        }
    }
    return result
}
```

func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}

func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}
```

### 解法二：

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法三：

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法四：

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法五：

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法六：

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法七：

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法八：

func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}

func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}
```

### 解题思路2

使用filter过滤器

### 代码

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}

func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}
```

### 解法二

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法三

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}
```

### 解法四

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法五

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法六

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法七

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter

func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}

class Solution {
    func plusOne(_ digits: [Int]) -> [Int] {
        var digits = digits
        var carry = 1
        for i in stride(from: digits.count - 1, through: 0, by: -1) {
            let sum = digits[i] + carry
            digits[i] = sum % 10
            carry = sum / 10
        }
        if carry > 0 {
            digits.insert(carry, at: 0)
        }
        return digits
    }
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}
```

### 解题思路

### 代码

```swift
class Solution {
    func plusOne(_ digits: [Int]) -> [Int] {
        var digits = digits
        var carry = 1
        for i in stride(from: digits.count - 1, through: 0, by: -1) {
            let sum = digits[i] + carry
            digits[i] = sum % 10
            carry = sum / 10
        }
        if carry > 0 {
            digits.insert(carry, at: 0)
        }
        return digits
    }
}
```

func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}

func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}
```

### 解法二

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法三

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}
```

### 解法四

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法五

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法六

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter { $0 > 0 }
}
```

### 解法七

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    return l.filter

func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}

```swift
// Return only positive numbers in the array.
// getPositive(l: [-1, 2, -4, 5, 6]) == [2, 5, 6]
// getPositive(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 9, 123, 1]
func getPositive(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if i > 0 {
            result.append(i)
        }
    }
    return result
}
```

func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    
    return true
}

func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    
    for i in 2..<Int(sqrt(Double(n))) {
        if n % i == 0 {
            return false
        }
    }
    
    return true
}

func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    
    let sqrt = Int(sqrt(Double(n)))
    for i in 2..<sqrt {
        if n % i == 0 {
            return false
        }
    }
    
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    
    return true
}
```

### 解法二：

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    
    for i in 2..<Int(sqrt(Double(n))) {
        if n % i == 0 {
            return false
        }
    }
    
    return true
}
```

### 解法三：

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    
    let sqrt = Int(sqrt(Double(n)))
    for i in 2..<sqrt {
        if n % i == 0 {
            return false
        }
    }
    
    return true
}
```

### 解法四：

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    
    let sqrt = Int(sqrt(Double(n)))
    for i in 2..<sqrt {
        if n % i == 0 {
            return false
        }
    }
    
    return true
}
```

### 解法五：

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    
    let sqrt = Int(sqrt(Double(n)))
    for i in 2..<sqrt {
        if n % i == 0 {
            return false
        }
    }
    
    return true
}
```

### 解法六：

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime

func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    return true
}

func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    var i = 3
    var arr = Array(repeating: true, count: n)
    while i * i <= n {
        if arr[i] == true {
            var j = i * i
            while j <= n {
                arr[j] = false
                j += i
            }
        }
        i += 2
    }
    return arr[n]
}

func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    var i = 3
    var arr = Array(repeating: true, count: n)
    arr[0] = false
    arr[1] = false
    while i * i <= n {
        if arr[i] == true {
            var j = i * i
            while j <= n {
                arr[j] = false
                j += i
            }
        }
        i += 2
    }
    return arr[n]
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    return true
}
```

### 解法二：埃拉托斯特尼筛法

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    var i = 3
    var arr = Array(repeating: true, count: n)
    while i * i <= n {
        if arr[i] == true {
            var j = i * i
            while j <= n {
                arr[j] = false
                j += i
            }
        }
        i += 2
    }
    return arr[n]
}
```

### 解法三：线性筛

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    var i = 3
    var arr = Array(repeating: true, count: n)
    arr[0] = false
    arr[1] = false
    while i * i <= n {
        if arr[i] == true {
            var j = i * i
            while j <= n {
                arr[j] = false
                j += i
            }
        }
        i += 2
    }
    return arr[n]
}
```

func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 || n == 3 {
        return true
    }
    if n % 2 == 0 || n % 3 == 0 {
        return false
    }
    var i = 5
    while i * i <= n {
        if n % i == 0 || n % (i + 2) == 0 {
            return false
        }
        i += 6
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 || n == 3 {
        return true
    }
    if n % 2 == 0 || n % 3 == 0 {
        return false
    }
    var i = 5
    while i * i <= n {
        if n % i == 0 || n % (i + 2) == 0 {
            return false
        }
        i += 6
    }
    return true
}
```

func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    
    return true
}

func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    
    if n == 2 {
        return true
    }
    
    if n % 2 == 0 {
        return false
    }
    
    for i in 3..<Int(sqrt(Double(n))) {
        if n % i == 0 {
            return false
        }
    }
    
    return true
}

func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    
    if n == 2 {
        return true
    }
    
    if n % 2 == 0 {
        return false
    }
    
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    
    for i in 2..<n {
        if n % i == 0 {
            return false
        }
    }
    
    return true
}
```

### 解法二：

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    
    if n == 2 {
        return true
    }
    
    if n % 2 == 0 {
        return false
    }
    
    for i in 3..<Int(sqrt(Double(n))) {
        if n % i == 0 {
            return false
        }
    }
    
    return true
}
```

### 解法三：

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    
    if n == 2 {
        return true
    }
    
    if n % 2 == 0 {
        return false
    }
    
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    
    return true
}
```

### 解法四：

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    
    if n == 2 {
        return true
    }
    
    if n % 2 == 0 {
        return false
    }
    
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    
    return true
}
```

### 解法五：

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    
    if n == 2 {
        return true
    }
    
    if n % 2 == 0 {
        return false
    }
    
    var i = 3
    while i * i <= n {
        if n % i

func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    return true
}
```

### 解法二

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    return true
}
```

func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    for i in 3..<Int(sqrt(Double(n))) {
        if n % i == 0 {
            return false
        }
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    for i in 3..<Int(sqrt(Double(n))) {
        if n % i == 0 {
            return false
        }
    }
    return true
}
```

func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    return true
}
```

func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    return true
}
```

func isPrime(n: Int) -> Bool {
    if n <= 1 {
        return false
    }
    
    if n == 2 {
        return true
    }
    
    if n % 2 == 0 {
        return false
    }
    
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n <= 1 {
        return false
    }
    
    if n == 2 {
        return true
    }
    
    if n % 2 == 0 {
        return false
    }
    
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    
    return true
}
```

### 解法二：

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n <= 1 {
        return false
    }
    
    if n == 2 {
        return true
    }
    
    if n % 2 == 0 {
        return false
    }
    
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    
    return true
}
```

### 解法三：

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n <= 1 {
        return false
    }
    
    if n == 2 {
        return true
    }
    
    if n % 2 == 0 {
        return false
    }
    
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    
    return true
}
```

### 解法四：

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n <= 1 {
        return false
    }
    
    if n == 2 {
        return true
    }
    
    if n % 2 == 0 {
        return false
    }
    
    var i = 3
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 2
    }
    
    return true
}
```

### 解法五：

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n <= 1 {
        return false
    }
    
    if n == 2

func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 || n == 3 {
        return true
    }
    if n % 2 == 0 || n % 3 == 0 {
        return false
    }
    var i = 5
    while i * i <= n {
        if n % i == 0 || n % (i + 2) == 0 {
            return false
        }
        i += 6
    }
    return true
}

```swift
// Return true if a given number is prime, and false otherwise.
// isPrime(n: 6) == false
// isPrime(n: 101) == true
// isPrime(n: 11) == true
// isPrime(n: 13441) == true
// isPrime(n: 61) == true
// isPrime(n: 4) == false
// isPrime(n: 1) == false
func isPrime(n: Int) -> Bool {
    if n < 2 {
        return false
    }
    if n == 2 || n == 3 {
        return true
    }
    if n % 2 == 0 || n % 3 == 0 {
        return false
    }
    var i = 5
    while i * i <= n {
        if n % i == 0 || n % (i + 2) == 0 {
            return false
        }
        i += 6
    }
    return true
}
```

func sortThird(l: [Int]) -> [Int] {
    var l = l
    l.removeSubrange(l.indices.filter { $0 % 3 == 0 }.map { $0 })
    l.insert(contentsOf: l.indices.filter { $0 % 3 == 0 }.map { $0 }, at: 0)
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    l.removeSubrange(l.indices.filter { $0 % 3 == 0 }.map { $0 })
    l.insert(contentsOf: l.indices.filter { $0 % 3 == 0 }.map { $0 }, at: 0)
    return l
}
```

func sortThird(l: [Int]) -> [Int] {
    var l = l
    let third = l.count / 3
    let first = l.filter { $0 % 3 == 0 }
    let second = l.filter { $0 % 3 == 1 }
    let third = l.filter { $0 % 3 == 2 }
    l = first + second + third
    return l
}

func sortThird(l: [Int]) -> [Int] {
    var l = l
    let third = l.count / 3
    let first = l.filter { $0 % 3 == 0 }
    let second = l.filter { $0 % 3 == 1 }
    let third = l.filter { $0 % 3 == 2 }
    l = first + second + third
    l.sort()
    return l
}

func sortThird(l: [Int]) -> [Int] {
    var l = l
    let third = l.count / 3
    let first = l.filter { $0 % 3 == 0 }
    let second = l.filter { $0 % 3 == 1 }
    let third = l.filter { $0 % 3 == 2 }
    l = first + second + third
    l.sort { $0 < $1 }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    let third = l.count / 3
    let first = l.filter { $0 % 3 == 0 }
    let second = l.filter { $0 % 3 == 1 }
    let third = l.filter { $0 % 3 == 2 }
    l = first + second + third
    return l
}
```

### 解法二

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    let third = l.count / 3
    let first = l.filter { $0 % 3 == 0 }
    let second = l.filter { $0 % 3 == 1 }
    let third = l.filter { $0 % 3 == 2 }
    l = first + second + third
    l.sort()
    return l
}
```

### 解法三

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    let third = l.count / 3
    let first = l.filter { $0 % 3 == 0 }
    let second = l.filter { $0 % 3 == 1 }
    let third = l.filter { $0 % 3 == 2 }
    l = first + second + third
    l.sort { $0 < $1 }
    return l
}
```

func sortThird(l: [Int]) -> [Int] {
    var l = l
    l.removeSubrange(l.indices.filter { $0 % 3 == 0 }.map { $0 })
    l.insert(contentsOf: l.indices.filter { $0 % 3 == 0 }.map { $0 }, at: 0)
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    l.removeSubrange(l.indices.filter { $0 % 3 == 0 }.map { $0 })
    l.insert(contentsOf: l.indices.filter { $0 % 3 == 0 }.map { $0 }, at: 0)
    return l
}
```

### 解法二

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    l.removeSubrange(l.indices.filter { $0 % 3 == 0 }.map { $0 })
    l.insert(contentsOf: l.indices.filter { $0 % 3 == 0 }.map { $0 }, at: 0)
    return l
}
```

func sortThird(l: [Int]) -> [Int] {
    var l = l
    l.removeSubrange(0...2)
    l.insert(l.remove(at: 0), at: 2)
    return l
}

func sortThird(l: [Int]) -> [Int] {
    let l = l.sorted { (a, b) -> Bool in
        return a % 3 == b % 3
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    l.removeSubrange(0...2)
    l.insert(l.remove(at: 0), at: 2)
    return l
}
```

### 解法二

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    let l = l.sorted { (a, b) -> Bool in
        return a % 3 == b % 3
    }
    return l
}
```

func sortThird(l: [Int]) -> [Int] {
    let l = l.sorted()
    var l1 = [Int]()
    var l2 = [Int]()
    for i in 0..<l.count {
        if i % 3 == 0 {
            l1.append(l[i])
        } else {
            l2.append(l[i])
        }
    }
    return l1 + l2
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    let l = l.sorted()
    var l1 = [Int]()
    var l2 = [Int]()
    for i in 0..<l.count {
        if i % 3 == 0 {
            l1.append(l[i])
        } else {
            l2.append(l[i])
        }
    }
    return l1 + l2
}
```

func sortThird(l: [Int]) -> [Int] {
    var l = l
    let mid = l.count / 3
    l.removeSubrange(0..<mid)
    l.removeSubrange(l.count - mid..<l.count)
    l.append(contentsOf: l)
    l.removeSubrange(l.count - mid..<l.count)
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    let mid = l.count / 3
    l.removeSubrange(0..<mid)
    l.removeSubrange(l.count - mid..<l.count)
    l.append(contentsOf: l)
    l.removeSubrange(l.count - mid..<l.count)
    return l
}
```

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var l1 = l
    var l2 = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l1.remove(at: i)
            l1.insert(l[i], at: i)
        }
    }
    for i in 0..<l.count {
        if i % 3 == 0 {
            l2.remove(at: i)
            l2.insert(l[i], at: i)
        }
    }
    return l1
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var l1 = l
    var l2 = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l1.remove(at: i)
            l1.insert(l[i], at: i)
        }
    }
    for i in 0..<l.count {
        if i % 3 == 0 {
            l2.remove(at: i)
            l2.insert(l[i], at: i)
        }
    }
    return l1
}
```

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var l1 = l
    var l2 = l
    
    for i in 0..<l.count {
        if i % 3 == 0 {
            l1.remove(at: i)
            l1.insert(l[i], at: i)
        }
    }
    
    for i in 0..<l.count {
        if i % 3 == 0 {
            l2.remove(at: i)
            l2.insert(l[i], at: i)
        }
    }
    
    return l1
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var l1 = l
    var l2 = l
    
    for i in 0..<l.count {
        if i % 3 == 0 {
            l1.remove(at: i)
            l1.insert(l[i], at: i)
        }
    }
    
    for i in 0..<l.count {
        if i % 3 == 0 {
            l2.remove(at: i)
            l2.insert(l[i], at: i)
        }
    }
    
    return l1
}
```

func sortThird(l: [Int]) -> [Int] {
    let sorted = l.sorted { $0 % 3 == $1 % 3 }
    var result = [Int]()
    for i in 0..<l.count {
        if sorted[i] % 3 == 0 {
            result.append(l[i])
        }
    }
    for i in 0..<l.count {
        if sorted[i] % 3 != 0 {
            result.append(l[i])
        }
    }
    return result
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    let sorted = l.sorted { $0 % 3 == $1 % 3 }
    var result = [Int]()
    for i in 0..<l.count {
        if sorted[i] % 3 == 0 {
            result.append(l[i])
        }
    }
    for i in 0..<l.count {
        if sorted[i] % 3 != 0 {
            result.append(l[i])
        }
    }
    return result
}
```

func sortThird(l: [Int]) -> [Int] {
    var l = l
    var l1 = l
    var l2 = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l1.remove(at: i)
            l1.insert(l[i], at: i)
        }
    }
    for i in 0..<l.count {
        if i % 3 == 0 {
            l2.remove(at: i)
            l2.insert(l[i], at: i)
        }
    }
    return l1
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// sortThird(l: [1, 2, 3]) == [1, 2, 3]
// sortThird(l: [5, 6, 3, 4, 8, 9, 2]) == [2, 6, 3, 4, 8, 9, 5]
func sortThird(l: [Int]) -> [Int] {
    var l = l
    var l1 = l
    var l2 = l
    for i in 0..<l.count {
        if i % 3 == 0 {
            l1.remove(at: i)
            l1.insert(l[i], at: i)
        }
    }
    for i in 0..<l.count {
        if i % 3 == 0 {
            l2.remove(at: i)
            l2.insert(l[i], at: i)
        }
    }
    return l1
}
```

func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    var result = [Int]()
    for i in l {
        if dict[i] == nil {
            dict[i] = 1
            result.append(i)
        }
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    return l.sorted { (a, b) -> Bool in
        return a < b
    }.reduce([], { (result, i) -> [Int] in
        if result.contains(i) {
            return result
        } else {
            result.append(i)
            return result
        }
    })
}

func unique(l: [Int]) -> [Int] {
    return Set(l).sorted()
}

func unique(l: [Int]) -> [Int] {
    return l.reduce(into: [Int]()) { (result, i) -> Void in
        if !result.contains(i) {
            result.append(i)
        }
    }.sorted()
}

func unique(l: [Int]) -> [Int] {
    return l.reduce(into: Set<Int>()) { (result, i) -> Void in
        result.insert(i)
    }.sorted()
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    var result = [Int]()
    for i in l {
        if dict[i] == nil {
            dict[i] = 1
            result.append(i)
        }
    }
    return result
}
```

### 解法二：排序

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.sorted { (a, b) -> Bool in
        return a < b
    }.reduce([], { (result, i) -> [Int] in
        if result.contains(i) {
            return result
        } else {
            result.append(i)
            return result
        }
    })
}
```

### 解法三：Set

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return Set(l).sorted()
}
```

### 解法四：Set

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.reduce(into: [Int]()) { (result, i) -> Void in
        if !result.contains(i) {
            result.append(i)
        }
    }.sorted()
}
```

### 解法五：Set

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.reduce(into: Set<Int>()) { (result, i) -> Void in
        result.insert(i)
    }.sorted()
}
```

### 解法六：Set

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.reduce(into: Set<Int>()) { (result, i) -> Void in
        result.insert(i)
    }.sorted()
}
```

### 解法七：Set

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.reduce(into: Set<Int>()) { (result, i) -> Void in
        result.insert(i)
    }.sorted()
}
```

### 解法八：Set

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return

func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if !result.contains(i) {
            result.append(i)
        }
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    var result = Set<Int>()
    for i in l {
        result.insert(i)
    }
    return Array(result)
}

func unique(l: [Int]) -> [Int] {
    var result = [Int: Int]()
    for i in l {
        result[i] = 1
    }
    return Array(result.keys)
}

func unique(l: [Int]) -> [Int] {
    return l.sorted { (i, j) -> Bool in
        return i < j
    }.reduce([Int]()) { (result, i) -> [Int] in
        if !result.contains(i) {
            result.append(i)
        }
        return result
    }
}

func unique(l: [Int]) -> [Int] {
    return l.sorted().reduce(into: Set<Int>()) { (result, i) in
        result.insert(i)
    }
}

func unique(l: [Int]) -> [Int] {
    return l.sorted().reduce(into: [Int: Int]()) { (result, i) in
        result[i] = 1
    }
}

func unique(l: [Int]) -> [Int] {
    return l.sorted().reduce([Int]()) { (result, i) in
        if !result.contains(i) {
            result.append(i)
        }
        return result
    }
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if !result.contains(i) {
            result.append(i)
        }
    }
    return result
}
```

### 解法二：Set

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = Set<Int>()
    for i in l {
        result.insert(i)
    }
    return Array(result)
}
```

### 解法三：Hash Table

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int: Int]()
    for i in l {
        result[i] = 1
    }
    return Array(result.keys)
}
```

### 解法四：Sort

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.sorted { (i, j) -> Bool in
        return i < j
    }.reduce([Int]()) { (result, i) -> [Int] in
        if !result.contains(i) {
            result.append(i)
        }
        return result
    }
}
```

### 解法五：Sort + Set

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.sorted().reduce(into: Set<Int>()) { (result, i) in
        result.insert(i)
    }
}
```

### 解法六：Sort + Hash Table

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.sorted().reduce(into: [Int: Int]()) { (result, i) in
        result[i] = 1
    }
}
```

### 解法七：Sort + Array

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.sorted().reduce([Int]()) { (result, i) in
        if !result.contains(i) {
            result.append(i)
        }
        return result
    }
}
```

### 解法八：Sort + Array + Set

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l:

func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if !result.contains(i) {
            result.append(i)
        }
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    return Array(Set(l))
}

func unique(l: [Int]) -> [Int] {
    return l.sorted { $0 < $1 }.reduce([], +)
}

func unique(l: [Int]) -> [Int] {
    return l.reduce(into: [Int]()) { $0.append($1) }.sorted()
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if !result.contains(i) {
            result.append(i)
        }
    }
    return result
}
```

### 解法二

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return Array(Set(l))
}
```

### 解法三

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.sorted { $0 < $1 }.reduce([], +)
}
```

### 解法四

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.reduce(into: [Int]()) { $0.append($1) }.sorted()
}
```

### 解法五

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.reduce(into: [Int]()) { $0.append($1) }.sorted()
}
```

### 解法六

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.reduce(into: [Int]()) { $0.append($1) }.sorted()
}
```

### 解法七

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.reduce(into: [Int]()) { $0.append($1) }.sorted()
}
```

### 解法八

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.reduce(into: [Int]()) { $0.append($1) }.sorted()
}
```

### 解法九

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.reduce(into: [Int]()) { $0.append($1) }.sorted()
}

func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    var result = [Int]()
    for i in l {
        if dict[i] == nil {
            dict[i] = 1
            result.append(i)
        }
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    var result = [Int]()
    for i in l {
        if !set.contains(i) {
            set.insert(i)
            result.append(i)
        }
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var l = l
    l.sort()
    for i in l {
        if result.count == 0 || i != result.last! {
            result.append(i)
        }
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var count = [Int: Int]()
    for i in l {
        if count[i] == nil {
            count[i] = 1
            result.append(i)
        }
    }
    return result
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    var result = [Int]()
    for i in l {
        if dict[i] == nil {
            dict[i] = 1
            result.append(i)
        }
    }
    return result
}
```

### 解法二：Set

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    var result = [Int]()
    for i in l {
        if !set.contains(i) {
            set.insert(i)
            result.append(i)
        }
    }
    return result
}
```

### 解法三：排序

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var l = l
    l.sort()
    for i in l {
        if result.count == 0 || i != result.last! {
            result.append(i)
        }
    }
    return result
}
```

### 解法四：计数

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var count = [Int: Int]()
    for i in l {
        if count[i] == nil {
            count[i] = 1
            result.append(i)
        }
    }
    return result
}
```

### 解法五：计数

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var count = [Int: Int]()
    for i in l {
        if count[i] == nil {
            count[i] = 1
            result.append(i)
        }
    }
    return result
}
```

### 解法六：计数

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var count = [Int: Int]()
    for i in l {
        if count[i] == nil {
            count[i] = 1
            result.append(i)
        }
    }
    return result
}
```

### 解法七：计数

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var count = [Int: Int]()
    for i in l {
        if count[i] == nil {

func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    for i in l {
        dict[i] = 1
    }
    var result = [Int]()
    for i in l {
        result.append(i)
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    var result = [Int]()
    for i in l {
        if !set.contains(i) {
            result.append(i)
            set.insert(i)
        }
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var dict = [Int: Int]()
    for i in l {
        if dict[i] == nil {
            result.append(i)
            dict[i] = 1
        }
    }
    return result
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    for i in l {
        dict[i] = 1
    }
    var result = [Int]()
    for i in l {
        result.append(i)
    }
    return result
}
```

### 解法二：使用集合

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    var result = [Int]()
    for i in l {
        if !set.contains(i) {
            result.append(i)
            set.insert(i)
        }
    }
    return result
}
```

### 解法三：使用数组

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var dict = [Int: Int]()
    for i in l {
        if dict[i] == nil {
            result.append(i)
            dict[i] = 1
        }
    }
    return result
}
```

### 解法四：使用数组

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var dict = [Int: Int]()
    for i in l {
        if dict[i] == nil {
            result.append(i)
            dict[i] = 1
        }
    }
    return result
}
```

### 解法五：使用数组

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var dict = [Int: Int]()
    for i in l {
        if dict[i] == nil {
            result.append(i)
            dict[i] = 1
        }
    }
    return result
}
```

### 解法六：使用数组

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var dict = [Int: Int]()
    for i in l {
        if dict[i] == nil {
            result.append(i)
            dict[i] = 1
        }
    }
    return result
}
```

### 解法七：使用数组

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    var dict = [Int: Int]()
    for i in l {
        if dict[i

func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    for i in l {
        dict[i] = 1
    }
    return dict.keys.sorted()
}

func unique(l: [Int]) -> [Int] {
    let sorted = l.sorted()
    var result = [Int]()
    for i in 0..<sorted.count {
        if i == 0 || sorted[i] != sorted[i - 1] {
            result.append(sorted[i])
        }
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    for i in l {
        set.insert(i)
    }
    return set.sorted()
}

func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    for i in l {
        dict[i] = (dict[i] ?? 0) + 1
    }
    var result = [Int]()
    for i in l {
        if dict[i] == 1 {
            result.append(i)
        }
    }
    return result
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    for i in l {
        dict[i] = 1
    }
    return dict.keys.sorted()
}
```

### 解法二：排序

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    let sorted = l.sorted()
    var result = [Int]()
    for i in 0..<sorted.count {
        if i == 0 || sorted[i] != sorted[i - 1] {
            result.append(sorted[i])
        }
    }
    return result
}
```

### 解法三：Set

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    for i in l {
        set.insert(i)
    }
    return set.sorted()
}
```

### 解法四：计数

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    for i in l {
        dict[i] = (dict[i] ?? 0) + 1
    }
    var result = [Int]()
    for i in l {
        if dict[i] == 1 {
            result.append(i)
        }
    }
    return result
}
```

### 解法五：计数优化

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    for i in l {
        dict[i] = (dict[i] ?? 0) + 1
    }
    var result = [Int]()
    for i in l {
        if dict[i] == 1 {
            result.append(i)
        }
    }
    return result
}
```

### 解法六：计数优化

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    for i in l {
        dict[i] = (dict[i] ?? 0) + 1
    }
    var result = [Int]()
    for i in l {
        if dict[i] == 1 {
            result.append(i)
        }
    }
    return result
}
```

### 解法七：计数优化

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()

func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    var result = [Int]()
    for i in l {
        if dict[i] == nil {
            dict[i] = 1
            result.append(i)
        }
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    var result = [Int]()
    for i in l {
        if !set.contains(i) {
            set.insert(i)
            result.append(i)
        }
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    var result = [Int]()
    for i in l {
        if set.insert(i).success {
            result.append(i)
        }
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    var result = [Int]()
    for i in l {
        if set.insert(i).0 {
            result.append(i)
        }
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    var result = [Int]()
    for i in l {
        result.append(i)
        set.insert(i)
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    var result = [Int]()
    for i in l {
        result.append(i)
        set.insert(i).0
    }
    return result
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    var result = [Int]()
    for i in l {
        if dict[i] == nil {
            dict[i] = 1
            result.append(i)
        }
    }
    return result
}
```

### 解法二：Set

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    var result = [Int]()
    for i in l {
        if !set.contains(i) {
            set.insert(i)
            result.append(i)
        }
    }
    return result
}
```

### 解法三：Set

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    var result = [Int]()
    for i in l {
        if set.insert(i).success {
            result.append(i)
        }
    }
    return result
}
```

### 解法四：Set

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    var result = [Int]()
    for i in l {
        if set.insert(i).0 {
            result.append(i)
        }
    }
    return result
}
```

### 解法五：Set

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    var result = [Int]()
    for i in l {
        result.append(i)
        set.insert(i)
    }
    return result
}
```

### 解法六：Set

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    var result = [Int]()
    for i in l {
        result.append(i)
        set.insert(i).0
    }
    return result
}
```

### 解法七：Set

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    var result = [Int]()
    for i in l {
        result.append(i)
        set.insert(i)
    }
    return result
}
```

### 解法八：Set

```swift
// Return sorted unique elements in an array
// unique(l: [5,

func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    var result = [Int]()
    for i in l {
        if dict[i] == nil {
            result.append(i)
            dict[i] = 1
        }
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if !result.contains(i) {
            result.append(i)
        }
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i)
        result.sort()
        result.removeDuplicates()
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i)
        result.sort()
        result.removeDuplicates(in: result)
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i)
        result.sort()
        result.removeDuplicates(using: {$0 == $1})
    }
    return result
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    var result = [Int]()
    for i in l {
        if dict[i] == nil {
            result.append(i)
            dict[i] = 1
        }
    }
    return result
}
```

### 解法二

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        if !result.contains(i) {
            result.append(i)
        }
    }
    return result
}
```

### 解法三

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i)
        result.sort()
        result.removeDuplicates()
    }
    return result
}
```

### 解法四

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i)
        result.sort()
        result.removeDuplicates(in: result)
    }
    return result
}
```

### 解法五

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i)
        result.sort()
        result.removeDuplicates(using: {$0 == $1})
    }
    return result
}
```

### 解法六

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i)
        result.sort()
        result.removeDuplicates(using: {$0 == $1})
    }
    return result
}
```

### 解法七

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in l {
        result.append(i)
        result.sort()
        result.removeDuplicates(using: {$0 == $1})
    }
    return result
}
```

### 解法八

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 12

func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    var result = [Int]()
    for i in l {
        if dict[i] == nil {
            dict[i] = 1
            result.append(i)
        }
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    return l.sorted { $0 < $1 }.reduce(into: [Int]()) {
        if !$1.contains($2) {
            $1.append($2)
        }
    }
}

func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    return l.reduce(into: [Int]()) {
        if !set.contains($2) {
            set.insert($2)
            $1.append($2)
        }
    }
}

func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    return l.sorted { $0 < $1 }.reduce(into: [Int]()) {
        if !dict[$2]!.contains($1) {
            dict[$2]!.append($1)
            $1.append($2)
        }
    }
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    var result = [Int]()
    for i in l {
        if dict[i] == nil {
            dict[i] = 1
            result.append(i)
        }
    }
    return result
}
```

### 解法二：排序

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.sorted { $0 < $1 }.reduce(into: [Int]()) {
        if !$1.contains($2) {
            $1.append($2)
        }
    }
}
```

### 解法三：集合

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    return l.reduce(into: [Int]()) {
        if !set.contains($2) {
            set.insert($2)
            $1.append($2)
        }
    }
}
```

### 解法四：哈希表

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    var result = [Int]()
    for i in l {
        if dict[i] == nil {
            dict[i] = 1
            result.append(i)
        }
    }
    return result
}
```

### 解法五：排序 + 哈希表

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var dict = [Int: Int]()
    return l.sorted { $0 < $1 }.reduce(into: [Int]()) {
        if !dict[$2]!.contains($1) {
            dict[$2]!.append($1)
            $1.append($2)
        }
    }
}
```

### 解法六：集合 + 哈希表

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var set = Set<Int>()
    return l.reduce(into: [Int]()) {
        if !set.contains($2) {
            set.insert($2)
            $1.append($2)
        }
    }
}
```

### 解法七：排序 + 集合

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.sorted { $0 < $1 }.reduce(into: Set<Int>()) {
        if !$1

func unique(l: [Int]) -> [Int] {
    var dict: [Int: Int] = [:]
    var result: [Int] = []
    for i in l {
        if dict[i] == nil {
            dict[i] = 1
            result.append(i)
        }
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    var result: [Int] = []
    for i in l {
        if !result.contains(i) {
            result.append(i)
        }
    }
    return result
}

func unique(l: [Int]) -> [Int] {
    return l.sorted { $0 < $1 }.reduce(into: []) { $0[$1] = $1 }.map { $0 }
}

func unique(l: [Int]) -> [Int] {
    return l.reduce(into: [Int]()) { $0[$1] = $1 }.filter { $0.count == 1 }
}

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var dict: [Int: Int] = [:]
    var result: [Int] = []
    for i in l {
        if dict[i] == nil {
            dict[i] = 1
            result.append(i)
        }
    }
    return result
}
```

### 解法二

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    var result: [Int] = []
    for i in l {
        if !result.contains(i) {
            result.append(i)
        }
    }
    return result
}
```

### 解法三

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.sorted { $0 < $1 }.reduce(into: []) { $0[$1] = $1 }.map { $0 }
}
```

### 解法四

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.reduce(into: [Int]()) { $0[$1] = $1 }.filter { $0.count == 1 }
}
```

### 解法五

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.reduce(into: [Int]()) { $0[$1] = $1 }.filter { $0.count == 1 }
}
```

### 解法六

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.reduce(into: [Int]()) { $0[$1] = $1 }.filter { $0.count == 1 }
}
```

### 解法七

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.reduce(into: [Int]()) { $0[$1] = $1 }.filter { $0.count == 1 }
}
```

### 解法八

```swift
// Return sorted unique elements in an array
// unique(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
func unique(l: [Int]) -> [Int] {
    return l.reduce(into: [Int]()) { $0[$1] = $1 }.filter { $0.count == 1 }
}
```

### 解

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in l {
        if i > max {
            max = i
        }
    }
    return max
}

func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}

func maxElement(l: [Int]) -> Int {
    var dp = Array(repeating: 0, count: l.count)
    dp[0] = l[0]
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}

func maxElement(l: [Int]) -> Int {
    return quickSelect(l: l, k: l.count - 1)
}

func quickSelect(l: [Int], k: Int) -> Int {
    let pivot = l[0]
    var left = [Int]()
    var right = [Int]()
    for i in l {
        if i < pivot {
            left.append(i)
        } else if i > pivot {
            right.append(i)
        }
    }
    if k < left.count {
        return quickSelect(l: left, k: k)
    } else if k > left.count {
        return quickSelect(l: right, k: k - left.count - 1)
    } else {
        return pivot
    }
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in l {
        if i > max {
            max = i
        }
    }
    return max
}
```

### 解法二：递归

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}
```

### 解法三：动态规划

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var dp = Array(repeating: 0, count: l.count)
    dp[0] = l[0]
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}
```

### 解法四：分治

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}
```

### 解法五：快速选择

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    return quickSelect(l: l, k: l.count - 1)
}

func quickSelect(l: [Int], k: Int) -> Int {
    let pivot = l[0]
    var left = [Int]()
    var right = [Int]()
    for i in l {
        if i < pivot {
            left.append(i)
        } else if i > pivot {
            right.append(i)
        }
    }
    if k < left.count {
        return quickSelect(l: left, k: k)
    } else if k > left.count {
        return quickSelect(l: right, k: k - left.count - 1)
    } else {
        return pivot
    }
}
```

### 解法六：堆

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var heap = Heap<Int>(

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}

func maxElement(l: [Int]) -> Int {
    return maxElement(l: l, start: 0, end: l.count - 1)
}

func maxElement(l: [Int], start: Int, end: Int) -> Int {
    if start == end {
        return l[start]
    }
    let mid = (start + end) / 2
    let left = maxElement(l: Array(l[start..<mid]), start: start, end: mid)
    let right = maxElement(l: Array(l[mid + 1..<end]), start: mid + 1, end: end)
    return max(left, right)
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}
```

### 解法二：递归

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}
```

### 解法三：分治

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    return maxElement(l: l, start: 0, end: l.count - 1)
}

func maxElement(l: [Int], start: Int, end: Int) -> Int {
    if start == end {
        return l[start]
    }
    let mid = (start + end) / 2
    let left = maxElement(l: Array(l[start..<mid]), start: start, end: mid)
    let right = maxElement(l: Array(l[mid + 1..<end]), start: mid + 1, end: end)
    return max(left, right)
}
```

### 解法四：分治 + 递归

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    return maxElement(l: l, start: 0, end: l.count - 1)
}

func maxElement(l: [Int], start: Int, end: Int) -> Int {
    if start == end {
        return l[start]
    }
    let mid = (start + end) / 2
    let left = maxElement(l: Array(l[start..<mid]), start: start, end: mid)
    let right = maxElement(l: Array(l[mid + 1..<end]), start: mid + 1, end: end)
    return max(left, right)
}

func maxElement(l: [Int], start: Int, end: Int) -> Int {
    if start == end {
        return l[start]
    }
    let mid = (start + end) / 2
    let left = maxElement(l: Array(l[start..<mid]), start: start, end: mid)
    let right = maxElement(l: Array(l[mid + 1..<end]), start: mid + 1, end: end)
    return max(left, right)
}
```

### 解法五：分治 + 迭代

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var start = 0
    var end = l.count - 1
    return maxElement(l:

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in l {
        if i > max {
            max = i
        }
    }
    return max
}

func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}

func maxElement(l: [Int]) -> Int {
    var dp = Array(repeating: 0, count: l.count)
    dp[0] = l[0]
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}

func maxElement(l: [Int]) -> Int {
    var stack = [Int]()
    stack.append(l[0])
    for i in 1..<l.count {
        if l[i] > stack.last! {
            stack.append(l[i])
        } else {
            stack.popLast()
            stack.append(l[i])
        }
    }
    return stack.last!
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in l {
        if i > max {
            max = i
        }
    }
    return max
}
```

### 解法二：递归

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}
```

### 解法三：分治

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}
```

### 解法四：动态规划

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var dp = Array(repeating: 0, count: l.count)
    dp[0] = l[0]
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}
```

### 解法五：单调栈

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var stack = [Int]()
    stack.append(l[0])
    for i in 1..<l.count {
        if l[i] > stack.last! {
            stack.append(l[i])
        } else {
            stack.popLast()
            stack.append(l[i])
        }
    }
    return stack.last!
}
```

### 解法六：BFPRT

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    let n = l.count
    if n == 1 {
        return l[0]
    }
    let k = n / 5
    let ls = Array(l[0..<k])
    let rs = Array(l[k..<n])
    let lmax = maxElement(l: ls)
    let rmax = maxElement(l: rs)
    if lmax >

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in l {
        if i > max {
            max = i
        }
    }
    return max
}

func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}

func maxElement(l: [Int]) -> Int {
    var dp = Array(l[0..<l.count])
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in l {
        if i > max {
            max = i
        }
    }
    return max
}
```

### 解法二：递归

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}
```

### 解法三：分治

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}
```

### 解法四：动态规划

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var dp = Array(l[0..<l.count])
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}
```

### 解法五：动态规划优化

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var dp = Array(l[0..<l.count])
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}
```

### 解法六：动态规划优化

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var dp = Array(l[0..<l.count])
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}
```

### 解法七：动态规划优化

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}

func maxElement(l: [Int]) -> Int {
    var dp = [Int](repeating: 0, count: l.count)
    dp[0] = l[0]
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}

func maxElement(l: [Int]) -> Int {
    var left = 0
    var right = l.count - 1
    while left < right {
        let mid = left + (right - left) / 2
        if l[mid] < l[right] {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return l[left]
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}
```

### 解法二：递归

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}
```

### 解法三：分治

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}
```

### 解法四：动态规划

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var dp = [Int](repeating: 0, count: l.count)
    dp[0] = l[0]
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}
```

### 解法五：二分查找

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var left = 0
    var right = l.count - 1
    while left < right {
        let mid = left + (right - left) / 2
        if l[mid] < l[right] {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return l[left]
}
```

### 解法六：分治 + 动态规划

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var dp = [Int](repeating: 0, count: l.count)
    dp[0] = l[0]
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    var left = 0
    var right = l.count - 1
    while

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}

func maxElement(l: [Int]) -> Int {
    var dp = [Int](repeating: 0, count: l.count)
    dp[0] = l[0]
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}

func maxElement(l: [Int]) -> Int {
    var stack = [Int]()
    for i in 0..<l.count {
        while let top = stack.last, l[top] < l[i] {
            stack.removeLast()
        }
        stack.append(i)
    }
    return l[stack[0]]
}

func maxElement(l: [Int]) -> Int {
    var queue = PriorityQueue<Int> { (a, b) in a > b }
    for i in l {
        queue.push(i)
    }
    return queue.peek()!
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}
```

### 解法二：递归

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}
```

### 解法三：分治

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}
```

### 解法四：动态规划

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var dp = [Int](repeating: 0, count: l.count)
    dp[0] = l[0]
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}
```

### 解法五：单调栈

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var stack = [Int]()
    for i in 0..<l.count {
        while let top = stack.last, l[top] < l[i] {
            stack.removeLast()
        }
        stack.append(i)
    }
    return l[stack[0]]
}
```

### 解法六：优先队列

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var queue = PriorityQueue<Int> { (a, b) in a > b }
    for i in l {
        queue.push(i)
    }
    return queue.peek()!
}
```

### 解法七：快速选择

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l:

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in l {
        if i > max {
            max = i
        }
    }
    return max
}

func maxElement(l: [Int]) -> Int {
    if l.count == 0 {
        return 0
    }
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = l[0..<mid]
    let right = l[mid..<l.count]
    return max(maxElement(l: left), maxElement(l: right))
}

func maxElement(l: [Int]) -> Int {
    if l.count == 0 {
        return 0
    }
    if l.count == 1 {
        return l[0]
    }
    var dp = [Int](repeating: 0, count: l.count)
    dp[0] = l[0]
    dp[1] = max(l[0], l[1])
    for i in 2..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in l {
        if i > max {
            max = i
        }
    }
    return max
}
```

### 解法二：递归

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 0 {
        return 0
    }
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = l[0..<mid]
    let right = l[mid..<l.count]
    return max(maxElement(l: left), maxElement(l: right))
}
```

### 解法三：分治

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 0 {
        return 0
    }
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = l[0..<mid]
    let right = l[mid..<l.count]
    return max(maxElement(l: left), maxElement(l: right))
}
```

### 解法四：动态规划

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 0 {
        return 0
    }
    if l.count == 1 {
        return l[0]
    }
    var dp = [Int](repeating: 0, count: l.count)
    dp[0] = l[0]
    dp[1] = max(l[0], l[1])
    for i in 2..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}
```

### 解法五：动态规划优化

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 0 {
        return 0
    }
    if l.count == 1 {
        return l[0]
    }
    var dp = [Int](repeating: 0, count: l.count)
    dp[0] = l[0]
    dp[1] = max(l[0], l[1])
    for i in 2..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}
```

### 解法六：分治优化

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}

func maxElement(l: [Int]) -> Int {
    var dp = Array(repeating: 0, count: l.count)
    dp[0] = l[0]
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}
```

### 解法二：递归

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}
```

### 解法三：分治

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}
```

### 解法四：动态规划

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var dp = Array(repeating: 0, count: l.count)
    dp[0] = l[0]
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}
```

### 解法五：动态规划优化

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var dp = Array(repeating: 0, count: l.count)
    dp[0] = l[0]
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}
```

### 解法六：动态规划优化

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var dp = Array(repeating: 0, count: l.count)
    dp[0] = l[0]
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}
```

### 解法七：动态规划优化

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in l {
        if i > max {
            max = i
        }
    }
    return max
}

func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}

func maxElement(l: [Int]) -> Int {
    return maxElement(l: l, start: 0, end: l.count - 1)
}

func maxElement(l: [Int], start: Int, end: Int) -> Int {
    if start == end {
        return l[start]
    }
    let mid = (start + end) / 2
    let left = maxElement(l: Array(l[start..<mid]), start: start, end: mid)
    let right = maxElement(l: Array(l[mid + 1..<end]), start: mid + 1, end: end)
    return max(left, right)
}

func maxElement(l: [Int]) -> Int {
    var dp = Array(repeating: 0, count: l.count)
    dp[0] = l[0]
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}

func maxElement(l: [Int]) -> Int {
    var dp = Array(repeating: 0, count: l.count)
    dp[0] = l[0]
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    var max = dp[l.count - 1]
    for i in 0..<l.count {
        if dp[i] > max {
            max = dp[i]
        }
    }
    return max
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in l {
        if i > max {
            max = i
        }
    }
    return max
}
```

### 解法二：递归

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    if l.count == 1 {
        return l[0]
    }
    let mid = l.count / 2
    let left = maxElement(l: Array(l[0..<mid]))
    let right = maxElement(l: Array(l[mid..<l.count]))
    return max(left, right)
}
```

### 解法三：分治

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    return maxElement(l: l, start: 0, end: l.count - 1)
}

func maxElement(l: [Int], start: Int, end: Int) -> Int {
    if start == end {
        return l[start]
    }
    let mid = (start + end) / 2
    let left = maxElement(l: Array(l[start..<mid]), start: start, end: mid)
    let right = maxElement(l: Array(l[mid + 1..<end]), start: mid + 1, end: end)
    return max(left, right)
}
```

### 解法四：动态规划

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var dp = Array(repeating: 0, count: l.count)
    dp[0] = l[0]
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    return dp[l.count - 1]
}
```

### 解法五：动态规划优化

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var dp = Array(repeating: 0, count: l.count)
    dp[0] = l[0]
    for i in 1..<l.count {
        dp[i] = max(dp[i - 1], l[i])
    }
    var max = dp[l.count - 1]
    for i in 0..<l.count {
        if dp[i] > max {
            max = dp[i]
        }
    }
    return max
}
```

### 解法六：分治优化

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int])

func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}

class Solution {
    func maxSubArray(_ nums: [Int]) -> Int {
        var max = nums[0]
        var sum = 0
        for i in 0..<nums.count {
            if sum > 0 {
                sum += nums[i]
            } else {
                sum = nums[i]
            }
            max = max > sum ? max : sum
        }
        return max
    }
}

```swift
// Return maximum element in the array.
// maxElement(l: [1, 2, 3]) == 3
// maxElement(l: [5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]) == 123
func maxElement(l: [Int]) -> Int {
    var max = l[0]
    for i in 1..<l.count {
        if l[i] > max {
            max = l[i]
        }
    }
    return max
}
```

### 解题思路

### 代码

```swift
class Solution {
    func maxSubArray(_ nums: [Int]) -> Int {
        var max = nums[0]
        var sum = 0
        for i in 0..<nums.count {
            if sum > 0 {
                sum += nums[i]
            } else {
                sum = nums[i]
            }
            max = max > sum ? max : sum
        }
        return max
    }
}
```

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

func fizzBuzz(n: Int) -> Int {
    if n < 1 {
        return 0
    }
    if n == 1 {
        return 0
    }
    if n % 11 == 0 || n % 13 == 0 {
        return 1 + fizzBuzz(n: n - 1)
    } else {
        return fizzBuzz(n: n - 1)
    }
}

func fizzBuzz(n: Int) -> Int {
    var memo = [Int: Int]()
    func helper(n: Int) -> Int {
        if n < 1 {
            return 0
        }
        if n == 1 {
            return 0
        }
        if let count = memo[n] {
            return count
        }
        if n % 11 == 0 || n % 13 == 0 {
            return 1 + helper(n: n - 1)
        } else {
            return helper(n: n - 1)
        }
    }
    return helper(n: n)
}

func fizzBuzz(n: Int) -> Int {
    var memo = [Int: Int]()
    for i in 1...n {
        if let count = memo[i] {
            continue
        }
        if i % 11 == 0 || i % 13 == 0 {
            memo[i] = 1
        } else {
            memo[i] = 0
        }
    }
    var count = 0
    for i in 1...n {
        if memo[i] == 1 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

### 解法二：递归

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    if n < 1 {
        return 0
    }
    if n == 1 {
        return 0
    }
    if n % 11 == 0 || n % 13 == 0 {
        return 1 + fizzBuzz(n: n - 1)
    } else {
        return fizzBuzz(n: n - 1)
    }
}
```

### 解法三：递归 + 记忆化

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var memo = [Int: Int]()
    func helper(n: Int) -> Int {
        if n < 1 {
            return 0
        }
        if n == 1 {
            return 0
        }
        if let count = memo[n] {
            return count
        }
        if n % 11 == 0 || n % 13 == 0 {
            return 1 + helper(n: n - 1)
        } else {
            return helper(n: n - 1)
        }
    }
    return helper(n: n)
}
```

### 解法四：循环

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

### 解法五：循环 + 记忆化

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var memo = [Int: Int]()
    for i in 1...n {
        if let count = memo[i] {
            continue
        }
        if i % 11 == 0 || i % 13 == 0 {
            memo[i] = 1
        } else {
            memo[i] = 0
        }
    }
    var count = 0
    for i in 1...n {
        if memo[i] == 1 {
            count += 1
        }
    }
    return count
}
```

### 解法六：循环 + 状态机

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBu

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            if i % 11 == 0 && i % 13 == 0 {
                count += 1
            } else if i % 11 == 0 {
                count += 1
            } else if i % 13 == 0 {
                count += 1
            }
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

### 解法二：数学

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            if i % 11 == 0 && i % 13 == 0 {
                count += 1
            } else if i % 11 == 0 {
                count += 1
            } else if i % 13 == 0 {
                count += 1
            }
        }
    }
    return count
}
```

### 解法三：数学

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

### 解法四：数学

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

### 解法五：数学

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

### 解法六：数学

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

### 解法七：数学

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) ==

func fizzBuzz(n: Int) -> Int {
    var result = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            result += 1
        }
    }
    return result
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var result = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            result += 1
        }
    }
    return result
}
```

func fizzBuzz(n: Int) -> Int {
    var result = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            result += 1
        }
    }
    return result
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var result = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            result += 1
        }
    }
    return result
}
```

### 解法二：数学

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var result = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            result += 1
        }
    }
    return result
}
```

### 解法三：数学

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var result = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            result += 1
        }
    }
    return result
}
```

### 解法四：数学

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var result = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            result += 1
        }
    }
    return result
}
```

### 解法五：数学

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var result = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            result += 1
        }
    }
    return result
}
```

### 解法六：数学

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var result = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            result += 1
        }
    }
    return result
}
```

### 解法七：数学

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var result = 0
    for i in 1...n

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
        if i % 10 == 7 {
            count += 1
        }
    }
    return count
}

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 || i % 7 == 0 {
            count += 1
        }
    }
    return count
}

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 || i % 7 == 0 {
            count += 1
        }
        if i % 10 == 7 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

### 解法二

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
        if i % 10 == 7 {
            count += 1
        }
    }
    return count
}
```

### 解法三

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 || i % 7 == 0 {
            count += 1
        }
    }
    return count
}
```

### 解法四

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 || i % 7 == 0 {
            count += 1
        }
        if i % 10 == 7 {
            count += 1
        }
    }
    return count
}
```

### 解法五

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 || i % 7 == 0 {
            count += 1
        }
        if i % 10 == 7 {
            count += 1
        }
    }
    return count
}
```

### 解法六

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 || i % 7 == 0 {
            count += 1
        }
        if i % 10 == 7 {
            count += 1
        }
    }
    return count
}
```

### 解法七

```swift
// Return the number

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

func fizzBuzz(n: Int) -> Int {
    var result = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            result += 1
        }
    }
    return result
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var result = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            result += 1
        }
    }
    return result
}
```

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// fizzBuzz(n: 50) == 0
// fizzBuzz(n: 78) == 2
// fizzBuzz(n: 79) == 3
func fizzBuzz(n: Int) -> Int {
    var count = 0
    for i in 1...n {
        if i % 11 == 0 || i % 13 == 0 {
            count += 1
        }
    }
    return count
}
```

func sortEven(l: [Int]) -> [Int] {
    let even = l.filter { $0 % 2 == 0 }
    let odd = l.filter { $0 % 2 == 1 }
    return even + odd.sorted()
}

func sortEven(l: [Int]) -> [Int] {
    var even = l.filter { $0 % 2 == 0 }
    var odd = l.filter { $0 % 2 == 1 }
    var i = 0
    var j = 0
    var result = [Int]()
    while i < even.count && j < odd.count {
        result.append(even[i])
        result.append(odd[j])
        i += 1
        j += 1
    }
    if i < even.count {
        result.append(contentsOf: even[i..<even.count])
    }
    if j < odd.count {
        result.append(contentsOf: odd[j..<odd.count])
    }
    return result
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    let even = l.filter { $0 % 2 == 0 }
    let odd = l.filter { $0 % 2 == 1 }
    return even + odd.sorted()
}
```

### 方法二：双指针

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var even = l.filter { $0 % 2 == 0 }
    var odd = l.filter { $0 % 2 == 1 }
    var i = 0
    var j = 0
    var result = [Int]()
    while i < even.count && j < odd.count {
        result.append(even[i])
        result.append(odd[j])
        i += 1
        j += 1
    }
    if i < even.count {
        result.append(contentsOf: even[i..<even.count])
    }
    if j < odd.count {
        result.append(contentsOf: odd[j..<odd.count])
    }
    return result
}
```

### 方法三：递归

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    let even = l.filter { $0 % 2 == 0 }
    let odd = l.filter { $0 % 2 == 1 }
    return even + odd.sorted()
}
```

func sortEven(l: [Int]) -> [Int] {
    var l = l
    var even = l.filter { $0 % 2 == 0 }
    var odd = l.filter { $0 % 2 != 0 }
    
    odd.append(contentsOf: even)
    return odd
}

func sortEven(l: [Int]) -> [Int] {
    var l = l
    var even = l.filter { $0 % 2 == 0 }
    var odd = l.filter { $0 % 2 != 0 }
    
    odd.append(contentsOf: even.sorted())
    return odd
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    var even = l.filter { $0 % 2 == 0 }
    var odd = l.filter { $0 % 2 != 0 }
    
    odd.append(contentsOf: even)
    return odd
}
```

### 解法二

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    var even = l.filter { $0 % 2 == 0 }
    var odd = l.filter { $0 % 2 != 0 }
    
    odd.append(contentsOf: even.sorted())
    return odd
}
```

### 解法三

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    var even = l.filter { $0 % 2 == 0 }
    var odd = l.filter { $0 % 2 != 0 }
    
    odd.append(contentsOf: even.sorted())
    return odd
}
```

### 解法四

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    var even = l.filter { $0 % 2 == 0 }
    var odd = l.filter { $0 % 2 != 0 }
    
    odd.append(contentsOf: even.sorted())
    return odd
}
```

### 解法五

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    var even = l.filter { $0 % 2 == 0 }
    var odd = l.filter { $0 % 2 != 0 }
    
    odd.append(contentsOf: even.sorted())
    return odd
}
```

### 解法六

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4])

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l.remove(at: i+1)
        }
    }
    l.sort()
    return l
}

func sortEven(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    var j = l.count - 1
    while i < j {
        if l[i] % 2 == 0 {
            i += 1
        } else if l[j] % 2 == 1 {
            j -= 1
        } else {
            l.swapAt(i, j)
            i += 1
            j -= 1
        }
    }
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l.remove(at: i+1)
        }
    }
    l.sort()
    return l
}
```

### 解法二：双指针

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    var i = 0
    var j = l.count - 1
    while i < j {
        if l[i] % 2 == 0 {
            i += 1
        } else if l[j] % 2 == 1 {
            j -= 1
        } else {
            l.swapAt(i, j)
            i += 1
            j -= 1
        }
    }
    return l
}
```

func sortEven(l: [Int]) -> [Int] {
    var l = l
    var odd = l[0...(l.count - 1)].filter { $0 % 2 != 0 }
    var even = l[0...(l.count - 1)].filter { $0 % 2 == 0 }
    odd.sort()
    even.sort()
    var result = [Int]()
    for i in 0...(l.count - 1) {
        if i % 2 == 0 {
            result.append(even[i / 2])
        } else {
            result.append(odd[i / 2])
        }
    }
    return result
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    var odd = l[0...(l.count - 1)].filter { $0 % 2 != 0 }
    var even = l[0...(l.count - 1)].filter { $0 % 2 == 0 }
    odd.sort()
    even.sort()
    var result = [Int]()
    for i in 0...(l.count - 1) {
        if i % 2 == 0 {
            result.append(even[i / 2])
        } else {
            result.append(odd[i / 2])
        }
    }
    return result
}
```

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l.remove(at: i+1)
        }
    }
    l.sort()
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l.remove(at: i+1)
        }
    }
    l.sort()
    return l
}
```

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l.remove(at: i+1)
        }
    }
    l.sort()
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l.remove(at: i+1)
        }
    }
    l.sort()
    return l
}
```

func sortEven(l: [Int]) -> [Int] {
    var l = l
    var even = l.filter { $0 % 2 == 0 }
    var odd = l.filter { $0 % 2 == 1 }
    odd.reverse()
    return even + odd
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    var even = l.filter { $0 % 2 == 0 }
    var odd = l.filter { $0 % 2 == 1 }
    odd.reverse()
    return even + odd
}
```

### 解法二

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    var even = l.filter { $0 % 2 == 0 }
    var odd = l.filter { $0 % 2 == 1 }
    odd.reverse()
    return even + odd
}
```

### 解法三

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    var even = l.filter { $0 % 2 == 0 }
    var odd = l.filter { $0 % 2 == 1 }
    odd.reverse()
    return even + odd
}
```

### 解法四

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    var even = l.filter { $0 % 2 == 0 }
    var odd = l.filter { $0 % 2 == 1 }
    odd.reverse()
    return even + odd
}
```

### 解法五

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    var even = l.filter { $0 % 2 == 0 }
    var odd = l.filter { $0 % 2 == 1 }
    odd.reverse()
    return even + odd
}
```

### 解法六

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    var

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i + 1]
            l.remove(at: i + 1)
        }
    }
    l.sort()
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i + 1]
            l.remove(at: i + 1)
        }
    }
    l.sort()
    return l
}
```

### 解法二

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i + 1]
            l.remove(at: i + 1)
        }
    }
    l.sort()
    return l
}
```

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l.remove(at: i+1)
        }
    }
    l.sort()
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l.remove(at: i+1)
        }
    }
    l.sort()
    return l
}
```

func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l.remove(at: i+1)
        }
    }
    l.sort()
    return l
}

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l.remove(at: i+1)
        }
    }
    l.sort()
    return l
}
```

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l.remove(at: i+1)
        }
    }
    l.sort()
    return l
}
```

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l.remove(at: i+1)
        }
    }
    l.sort()
    return l
}
```

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l.remove(at: i+1)
        }
    }
    l.sort()
    return l
}
```

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) == [1, 2, 3]
// sortEven(l: [5, 6, 3, 4]) == [3, 6, 5, 4]
func sortEven(l: [Int]) -> [Int] {
    var l = l
    for i in 0..<l.count {
        if i % 2 == 0 {
            l[i] = l[i] + l[i+1]
            l.remove(at: i+1)
        }
    }
    l.sort()
    return l
}
```

```swift
// This function takes an array l and returns an array l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// sortEven(l: [1, 2, 3]) ==

func primeFib(n: Int) -> Int {
    var fib = 1
    var fibPrev = 1
    var fibPrevPrev = 1
    var n = 1
    while n < n {
        fibPrevPrev = fibPrev
        fibPrev = fib
        fib = fibPrev + fibPrevPrev
        if isPrime(fib) {
            n += 1
        }
    }
    return fib
}

func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    for i in 2...Int(sqrt(Double(n))) {
        if n % i == 0 {
            return false
        }
    }
    return true
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = 1
    var fibPrev = 1
    var fibPrevPrev = 1
    var n = 1
    while n < n {
        fibPrevPrev = fibPrev
        fibPrev = fib
        fib = fibPrev + fibPrevPrev
        if isPrime(fib) {
            n += 1
        }
    }
    return fib
}

func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    for i in 2...Int(sqrt(Double(n))) {
        if n % i == 0 {
            return false
        }
    }
    return true
}
```

func primeFib(n: Int) -> Int {
    var a = 1, b = 2, c = 0
    for _ in 1...n {
        c = a + b
        a = b
        b = c
        if isPrime(c) {
            return c
        }
    }
    return -1
}

func isPrime(n: Int) -> Bool {
    if n <= 1 {
        return false
    }
    for i in 2...Int(sqrt(Double(n))) {
        if n % i == 0 {
            return false
        }
    }
    return true
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var a = 1, b = 2, c = 0
    for _ in 1...n {
        c = a + b
        a = b
        b = c
        if isPrime(c) {
            return c
        }
    }
    return -1
}

func isPrime(n: Int) -> Bool {
    if n <= 1 {
        return false
    }
    for i in 2...Int(sqrt(Double(n))) {
        if n % i == 0 {
            return false
        }
    }
    return true
}
```

func primeFib(n: Int) -> Int {
    var fib = [Int]()
    fib.append(1)
    fib.append(2)
    var i = 2
    while fib[i] < n {
        fib.append(fib[i] + fib[i - 1])
        i += 1
    }
    var j = 0
    while fib[j] < n {
        j += 1
    }
    return fib[j]
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [Int]()
    fib.append(1)
    fib.append(2)
    var i = 2
    while fib[i] < n {
        fib.append(fib[i] + fib[i - 1])
        i += 1
    }
    var j = 0
    while fib[j] < n {
        j += 1
    }
    return fib[j]
}
```

func primeFib(n: Int) -> Int {
    var fib = [Int]()
    fib.append(2)
    fib.append(3)
    var i = 2
    while fib[i] < n {
        fib.append(fib[i] + fib[i - 1])
        i += 1
    }
    return fib[i - 1]
}

func primeFib(n: Int) -> Int {
    var fib = [Int]()
    fib.append(2)
    fib.append(3)
    var i = 2
    while fib[i] < n {
        fib.append(fib[i] + fib[i - 1])
        i += 1
    }
    var j = 1
    while fib[i - 1] % j != 0 {
        j += 1
    }
    return fib[i - 1]
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [Int]()
    fib.append(2)
    fib.append(3)
    var i = 2
    while fib[i] < n {
        fib.append(fib[i] + fib[i - 1])
        i += 1
    }
    return fib[i - 1]
}
```

### 解法二：动态规划

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [Int]()
    fib.append(2)
    fib.append(3)
    var i = 2
    while fib[i] < n {
        fib.append(fib[i] + fib[i - 1])
        i += 1
    }
    var j = 1
    while fib[i - 1] % j != 0 {
        j += 1
    }
    return fib[i - 1]
}
```

func primeFib(n: Int) -> Int {
    var fibonacci = [Int]()
    fibonacci.append(1)
    fibonacci.append(2)
    var i = 2
    while fibonacci[i] < n {
        fibonacci.append(fibonacci[i] + fibonacci[i - 1])
        i += 1
    }
    return fibonacci[i - 1]
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fibonacci = [Int]()
    fibonacci.append(1)
    fibonacci.append(2)
    var i = 2
    while fibonacci[i] < n {
        fibonacci.append(fibonacci[i] + fibonacci[i - 1])
        i += 1
    }
    return fibonacci[i - 1]
}
```

func primeFib(n: Int) -> Int {
    var a = 1
    var b = 2
    var c = 0
    var i = 0
    while i < n {
        c = a + b
        if isPrime(c) {
            i += 1
            a = b
            b = c
        }
    }
    return c
}

func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 1
    }
    return true
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var a = 1
    var b = 2
    var c = 0
    var i = 0
    while i < n {
        c = a + b
        if isPrime(c) {
            i += 1
            a = b
            b = c
        }
    }
    return c
}

func isPrime(n: Int) -> Bool {
    if n == 1 {
        return false
    }
    var i = 2
    while i * i <= n {
        if n % i == 0 {
            return false
        }
        i += 1
    }
    return true
}
```

func primeFib(n: Int) -> Int {
    var fib = [Int]()
    fib.append(2)
    fib.append(3)
    var i = 2
    while fib[i] < n {
        let fib_i = fib[i]
        let fib_i_1 = fib[i - 1]
        let fib_i_2 = fib[i - 2]
        if fib_i % 2 == 0 {
            fib.append(fib_i)
        } else if fib_i % 3 == 0 {
            fib.append(fib_i)
        } else if fib_i_1 % 2 == 0 {
            fib.append(fib_i_1)
        } else if fib_i_1 % 3 == 0 {
            fib.append(fib_i_1)
        } else if fib_i_2 % 2 == 0 {
            fib.append(fib_i_2)
        } else if fib_i_2 % 3 == 0 {
            fib.append(fib_i_2)
        } else {
            fib.append(fib_i)
        }
        i += 1
    }
    return fib[n - 1]
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [Int]()
    fib.append(2)
    fib.append(3)
    var i = 2
    while fib[i] < n {
        let fib_i = fib[i]
        let fib_i_1 = fib[i - 1]
        let fib_i_2 = fib[i - 2]
        if fib_i % 2 == 0 {
            fib.append(fib_i)
        } else if fib_i % 3 == 0 {
            fib.append(fib_i)
        } else if fib_i_1 % 2 == 0 {
            fib.append(fib_i_1)
        } else if fib_i_1 % 3 == 0 {
            fib.append(fib_i_1)
        } else if fib_i_2 % 2 == 0 {
            fib.append(fib_i_2)
        } else if fib_i_2 % 3 == 0 {
            fib.append(fib_i_2)
        } else {
            fib.append(fib_i)
        }
        i += 1
    }
    return fib[n - 1]
}
```

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = 2
    var fibPrev = 1
    var fibPrevPrev = 1
    var i = 2
    while i < n {
        fib = fibPrev + fibPrevPrev
        fibPrevPrev = fibPrev
        fibPrev = fib
        if fib % 2 == 0 {
            fibPrev = fibPrev / 2
        }
        if fib % 3 == 0 {
            fibPrev = fibPrev / 3
        }
        if fib % 5 == 0 {
            fibPrev = fibPrev / 5
        }
        if fib % 7 == 0 {
            fibPrev = fibPrev / 7
        }
        if fib % 11 == 0 {
            fibPrev = fibPrev / 11
        }
        if fib % 13 == 0 {
            fibPrev = fibPrev / 13
        }
        if fib % 17 == 0 {
            fibPrev = fibPrev / 17
        }
        if fib % 19 == 0 {
            fibPrev = fibPrev / 19
        }
        if fib % 23 == 0 {
            fibPrev = fibPrev / 23
        }
        if fib % 29 == 0 {
            fibPrev = fibPrev / 29
        }
        if fib % 31 == 0 {
            fibPrev = fibPrev / 31
        }
        if fib % 37 == 0 {
            fibPrev = fibPrev / 37
        }
        if fib % 41 == 0 {
            fibPrev = fibPrev / 41
        }
        if fib % 43 == 0 {
            fibPrev = fibPrev / 43
        }
        if fib % 47 == 0 {
            fibPrev = fibPrev / 47
        }
        if fib % 53 == 0 {
            fibPrev = fibPrev / 53
        }
        if fib % 59 == 0 {
            fibPrev = fibPrev / 59
        }
        if fib % 61 == 0 {
            fibPrev = fibPrev / 61
        }
        if fib % 67 == 0 {
            fibPrev = fibPrev / 67
        }
        if fib % 71 == 0 {
            fibPrev = fibPrev / 71
        }
        if fib % 73 == 0 {
            fibPrev = fibPrev / 73
        }
        if fib % 79 == 0 {
            fibPrev = fibPrev / 79
        }
        if fib % 83 == 0 {
            fibPrev = fibPrev / 83
        }
        if fib % 89 == 0 {
            fibPrev = fibPrev / 89
        }
        if fib % 97 == 0 {
            fibPrev = fibPrev / 97
        }
        if fib % 101 == 0 {
            fibPrev = fibPrev / 101
        }
        if fib % 103 == 0 {
            fibPrev = fibPrev / 103
        }
        if fib % 107 == 0 {
            fibPrev = fibPrev / 107
        }
        if fib % 109 == 0 {
            fibPrev = fibPrev / 109
        }
        if fib % 113 == 0 {
            fibPrev = fibPrev / 113
        }
        if fib % 127 == 0 {
            fibPrev = fibPrev / 127
        }
        if fib % 131 == 0 {
            fibPrev = fibPrev / 131
        }
        if fib % 137 == 0 {
            

func primeFib(n: Int) -> Int {
    var fib = [Int]()
    fib.append(1)
    fib.append(2)
    var i = 2
    while fib[i] < n {
        fib.append(fib[i] + fib[i - 1])
        i += 1
    }
    return fib[i - 1]
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fib = [Int]()
    fib.append(1)
    fib.append(2)
    var i = 2
    while fib[i] < n {
        fib.append(fib[i] + fib[i - 1])
        i += 1
    }
    return fib[i - 1]
}
```

func primeFib(n: Int) -> Int {
    var fibs = [2, 3]
    var i = 2
    while fibs.count < n {
        let last = fibs[fibs.count - 1]
        let next = last + fibs[fibs.count - 2]
        if isPrime(num: next) {
            fibs.append(next)
        }
        i += 1
    }
    return fibs[n - 1]
}

func isPrime(num: Int) -> Bool {
    if num == 1 {
        return false
    }
    for i in 2...Int(sqrt(Double(num))) {
        if num % i == 0 {
            return false
        }
    }
    return true
}

```swift
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// primeFib(n: 1) == 2
// primeFib(n: 2) == 3
// primeFib(n: 3) == 5
// primeFib(n: 4) == 13
// primeFib(n: 5) == 89
func primeFib(n: Int) -> Int {
    var fibs = [2, 3]
    var i = 2
    while fibs.count < n {
        let last = fibs[fibs.count - 1]
        let next = last + fibs[fibs.count - 2]
        if isPrime(num: next) {
            fibs.append(next)
        }
        i += 1
    }
    return fibs[n - 1]
}

func isPrime(num: Int) -> Bool {
    if num == 1 {
        return false
    }
    for i in 2...Int(sqrt(Double(num))) {
        if num % i == 0 {
            return false
        }
    }
    return true
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    let set = Set<Int>(l)
    for i in set {
        let complement = -i
        if set.contains(complement) {
            return true
        }
    }
    return false
}

func triplesSumToZero(l: [Int]) -> Bool {
    var map = [Int: Int]()
    for i in l {
        if map[i] == nil {
            map[i] = 1
        } else {
            map[i]! += 1
        }
    }
    for i in l {
        let complement = -i
        if map[complement] != nil {
            if map[complement]! == 1 {
                map[complement] = nil
            } else {
                map[complement]! -= 1
            }
            if map[complement] == nil {
                return true
            }
        }
    }
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let set = Set<Int>(l)
    for i in set {
        let complement = -i
        if set.contains(complement) {
            return true
        }
    }
    return false
}
```

### 解法二

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var map = [Int: Int]()
    for i in l {
        if map[i] == nil {
            map[i] = 1
        } else {
            map[i]! += 1
        }
    }
    for i in l {
        let complement = -i
        if map[complement] != nil {
            if map[complement]! == 1 {
                map[complement] = nil
            } else {
                map[complement]! -= 1
            }
            if map[complement] == nil {
                return true
            }
        }
    }
    return false
}
```

### 解法三

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var map = [Int: Int]()
    for i in l {
        if map[i] == nil {
            map[i] = 1
        } else {
            map[i]! += 1
        }
    }
    for i in l {
        let complement = -i
        if map[complement] != nil {
            if map[complement]! == 1 {
                map[complement] = nil
            } else {
                map[complement]! -= 1
            }
            if map[complement] == nil {
                return true
            }
        }
    }
    return false
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    var dict = [Int: Int]()
    for i in 0..<l.count {
        if dict[l[i]] != nil {
            return true
        }
        dict[0 - l[i]] = i
    }
    return false
}

func triplesSumToZero(l: [Int]) -> Bool {
    let sorted = l.sorted()
    var i = 0
    var j = sorted.count - 1
    while i < j {
        let sum = sorted[i] + sorted[j]
        if sum == 0 {
            return true
        } else if sum > 0 {
            j -= 1
        } else {
            i += 1
        }
    }
    return false
}

func triplesSumToZero(l: [Int]) -> Bool {
    let sorted = l.sorted()
    for i in 0..<sorted.count {
        let target = 0 - sorted[i]
        var left = i + 1
        var right = sorted.count - 1
        while left < right {
            let mid = left + (right - left) / 2
            if sorted[mid] > target {
                right = mid
            } else {
                left = mid + 1
            }
        }
        if sorted[left] == target {
            return true
        }
    }
    return false
}

func triplesSumToZero(l: [Int]) -> Bool {
    let sorted = l.sorted()
    var dict = [Int: Int]()
    for i in 0..<sorted.count {
        if dict[sorted[i]] != nil {
            return true
        }
        dict[0 - sorted[i]] = i
    }
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var dict = [Int: Int]()
    for i in 0..<l.count {
        if dict[l[i]] != nil {
            return true
        }
        dict[0 - l[i]] = i
    }
    return false
}
```

### 解法二：排序 + 双指针

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let sorted = l.sorted()
    var i = 0
    var j = sorted.count - 1
    while i < j {
        let sum = sorted[i] + sorted[j]
        if sum == 0 {
            return true
        } else if sum > 0 {
            j -= 1
        } else {
            i += 1
        }
    }
    return false
}
```

### 解法三：排序 + 二分查找

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let sorted = l.sorted()
    for i in 0..<sorted.count {
        let target = 0 - sorted[i]
        var left = i + 1
        var right = sorted.count - 1
        while left < right {
            let mid = left + (right - left) / 2
            if sorted[mid] > target {
                right = mid
            } else {
                left = mid + 1
            }
        }
        if sorted[left] == target {
            return true
        }
    }
    return false
}
```

### 解法四：排序 + 哈希表

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let sorted = l.sorted()
    var dict = [Int: Int]()
    for i in 0..<sorted.count {
        if dict[sorted[i]] != nil {
            return true
        }
        dict[0 - sorted[i]] = i
    }
    return false
}
```

### 解法五：排序 + 哈希表 + 计

func triplesSumToZero(l: [Int]) -> Bool {
    let set = Set(l)
    for i in 0..<l.count {
        for j in i + 1..<l.count {
            for k in j + 1..<l.count {
                if l[i] + l[j] + l[k] == 0 {
                    return true
                }
            }
        }
    }
    return false
}

func triplesSumToZero(l: [Int]) -> Bool {
    let set = Set(l)
    for i in 0..<l.count {
        let complement = -l[i]
        if set.contains(complement) {
            return true
        }
    }
    return false
}

func triplesSumToZero(l: [Int]) -> Bool {
    let set = Set(l)
    for i in 0..<l.count {
        let complement = -l[i]
        if set.contains(complement) && set.count == l.count {
            return true
        }
    }
    return false
}

func triplesSumToZero(l: [Int]) -> Bool {
    let set = Set(l)
    for i in 0..<l.count {
        let complement = -l[i]
        if set.contains(complement) && set.count == l.count - 1 {
            return true
        }
    }
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let set = Set(l)
    for i in 0..<l.count {
        for j in i + 1..<l.count {
            for k in j + 1..<l.count {
                if l[i] + l[j] + l[k] == 0 {
                    return true
                }
            }
        }
    }
    return false
}
```

### 解法二

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let set = Set(l)
    for i in 0..<l.count {
        let complement = -l[i]
        if set.contains(complement) {
            return true
        }
    }
    return false
}
```

### 解法三

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let set = Set(l)
    for i in 0..<l.count {
        let complement = -l[i]
        if set.contains(complement) && set.count == l.count {
            return true
        }
    }
    return false
}
```

### 解法四

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let set = Set(l)
    for i in 0..<l.count {
        let complement = -l[i]
        if set.contains(complement) && set.count == l.count - 1 {
            return true
        }
    }
    return false
}
```

### 解法五

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1,

func triplesSumToZero(l: [Int]) -> Bool {
    let set = Set(l)
    for i in set {
        for j in set {
            let k = i + j
            if k == 0 && set.contains(k) {
                return true
            }
        }
    }
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let set = Set(l)
    for i in set {
        for j in set {
            let k = i + j
            if k == 0 && set.contains(k) {
                return true
            }
        }
    }
    return false
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    let n = l.count
    for i in 0..<n {
        for j in i+1..<n {
            for k in j+1..<n {
                if l[i] + l[j] + l[k] == 0 {
                    return true
                }
            }
        }
    }
    return false
}

func triplesSumToZero(l: [Int]) -> Bool {
    let n = l.count
    let l = l.sorted()
    for i in 0..<n {
        var j = i + 1
        var k = n - 1
        while j < k {
            if l[i] + l[j] + l[k] == 0 {
                return true
            } else if l[i] + l[j] + l[k] < 0 {
                j += 1
            } else {
                k -= 1
            }
        }
    }
    return false
}

func triplesSumToZero(l: [Int]) -> Bool {
    let n = l.count
    var dict = [Int: Int]()
    for i in 0..<n {
        if dict[l[i]] != nil {
            return true
        }
        dict[l[i]] = i
    }
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let n = l.count
    for i in 0..<n {
        for j in i+1..<n {
            for k in j+1..<n {
                if l[i] + l[j] + l[k] == 0 {
                    return true
                }
            }
        }
    }
    return false
}
```

### 解法二：排序 + 双指针

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let n = l.count
    let l = l.sorted()
    for i in 0..<n {
        var j = i + 1
        var k = n - 1
        while j < k {
            if l[i] + l[j] + l[k] == 0 {
                return true
            } else if l[i] + l[j] + l[k] < 0 {
                j += 1
            } else {
                k -= 1
            }
        }
    }
    return false
}
```

### 解法三：哈希表

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let n = l.count
    var dict = [Int: Int]()
    for i in 0..<n {
        if dict[l[i]] != nil {
            return true
        }
        dict[l[i]] = i
    }
    return false
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    var dict = [Int: Int]()
    for i in 0..<l.count {
        if dict[l[i]] != nil {
            return true
        }
        dict[0 - l[i]] = i
    }
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var dict = [Int: Int]()
    for i in 0..<l.count {
        if dict[l[i]] != nil {
            return true
        }
        dict[0 - l[i]] = i
    }
    return false
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    let set = Set<Int>(l)
    for i in set {
        let complement = -i
        if set.contains(complement) {
            return true
        }
    }
    return false
}

func triplesSumToZero(l: [Int]) -> Bool {
    let sorted = l.sorted()
    let n = sorted.count
    for i in 0..<n {
        let j = n - 1
        let k = i + 1
        while j > k {
            let sum = sorted[i] + sorted[j] + sorted[k]
            if sum == 0 {
                return true
            } else if sum > 0 {
                j -= 1
            } else {
                k += 1
            }
        }
    }
    return false
}

func triplesSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}

func triplesSumToZero(l: [Int]) -> Bool {
    let sum = l.reduce(0, +)
    if sum % 3 != 0 {
        return false
    }
    let target = sum / 3
    var set = Set<Int>()
    for i in l {
        if set.contains(target - i) {
            return true
        }
        set.insert(i)
    }
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let set = Set<Int>(l)
    for i in set {
        let complement = -i
        if set.contains(complement) {
            return true
        }
    }
    return false
}
```

### 解法二：排序+双指针

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let sorted = l.sorted()
    let n = sorted.count
    for i in 0..<n {
        let j = n - 1
        let k = i + 1
        while j > k {
            let sum = sorted[i] + sorted[j] + sorted[k]
            if sum == 0 {
                return true
            } else if sum > 0 {
                j -= 1
            } else {
                k += 1
            }
        }
    }
    return false
}
```

### 解法三：哈希表

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var set = Set<Int>()
    for i in l {
        if set.contains(-i) {
            return true
        }
        set.insert(i)
    }
    return false
}
```

### 解法四：数学

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let sum = l.reduce(0, +)
    if sum % 3 != 0 {
        return false
    }
    let target = sum / 3
    var set = Set<Int>()
    for i in l {
        if set.contains(target - i) {
            return true
        }
        set.insert(i)
    }
    return false
}
```

func triplesSumToZero(l: [Int]) -> Bool {
    let n = l.count
    var dp = Array(repeating: Array(repeating: Array(repeating: false, count: n), count: n), count: n)
    for i in 0..<n {
        for j in 0..<n {
            dp[i][j][0] = true
        }
    }
    for i in 1..<n {
        for j in 1..<n {
            for k in 1..<n {
                dp[i][j][k] = l[i] + l[j] + l[k] == 0 && dp[i - 1][j - 1][k - 1]
            }
        }
    }
    return dp[n - 1][n - 1][n - 1]
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let n = l.count
    var dp = Array(repeating: Array(repeating: Array(repeating: false, count: n), count: n), count: n)
    for i in 0..<n {
        for j in 0..<n {
            dp[i][j][0] = true
        }
    }
    for i in 1..<n {
        for j in 1..<n {
            for k in 1..<n {
                dp[i][j][k] = l[i] + l[j] + l[k] == 0 && dp[i - 1][j - 1][k - 1]
            }
        }
    }
    return dp[n - 1][n - 1][n - 1]
}
```

### 解法二：动态规划

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let n = l.count
    var dp = Array(repeating: Array(repeating: Array(repeating: false, count: n), count: n), count: n)
    for i in 0..<n {
        for j in 0..<n {
            dp[i][j][0] = true
        }
    }
    for i in 1..<n {
        for j in 1..<n {
            for k in 1..<n {
                dp[i][j][k] = l[i] + l[j] + l[k] == 0 && dp[i - 1][j - 1][k - 1]
            }
        }
    }
    return dp[n - 1][n - 1][n - 1]
}
```

### 解法三：动态规划

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    let n = l.count
    var dp = Array(repeating: Array(repeating: Array(repeating: false, count: n), count: n), count: n)
    for i in 0..<n {
        for j in 0..<n {
            dp[i][j][0] = true
        }
    }
    for i in 1..<n {
        for j in 1..<n {
            for k in 1..<n {
                dp[i][j][k] = l[i] + l[j] + l[k] == 0 && dp[i - 1][j - 1][k - 1]
            }
        }
    }
    return dp[n - 1][n - 1][n - 1]
}
```

### 解法四：动态规划

```swift
// triples_sum_to_

func triplesSumToZero(l: [Int]) -> Bool {
    var map = [Int: Int]()
    for i in 0..<l.count {
        let num = l[i]
        if map[num] != nil {
            return true
        }
        map[num] = i
    }
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var map = [Int: Int]()
    for i in 0..<l.count {
        let num = l[i]
        if map[num] != nil {
            return true
        }
        map[num] = i
    }
    return false
}
```

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var map = [Int: Int]()
    for i in 0..<l.count {
        let num = l[i]
        if map[num] != nil {
            return true
        }
        map[num] = i
    }
    return false
}
```

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var map = [Int: Int]()
    for i in 0..<l.count {
        let num = l[i]
        if map[num] != nil {
            return true
        }
        map[num] = i
    }
    return false
}
```

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var map = [Int: Int]()
    for i in 0..<l.count {
        let num = l[i]
        if map[num] != nil {
            return true
        }
        map[num] = i
    }
    return false
}
```

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1])

func triplesSumToZero(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in 0..<l.count {
        if seen.contains(-l[i]) {
            return true
        }
        seen.insert(l[i])
    }
    return false
}

```swift
// triples_sum_to_zero takes an array of integers as an input.
// it returns true if there are three distinct elements in the array that
// sum to zero, and false otherwise.
// triplesSumToZero(l: [1, 3, 5, 0]) == false
// triplesSumToZero(l: [1, 3, -2, 1]) == true
// triplesSumToZero(l: [1, 2, 3, 7]) == false
// triplesSumToZero(l: [2, 4, -5, 3, 9, 7]) == true
// triplesSumToZero(l: [1]) == false
func triplesSumToZero(l: [Int]) -> Bool {
    var seen = Set<Int>()
    for i in 0..<l.count {
        if seen.contains(-l[i]) {
            return true
        }
        seen.insert(l[i])
    }
    return false
}
```

func carRaceCollision(n: Int) -> Int {
    var cars = [Int]()
    for i in 0..<n {
        cars.append(i)
    }
    var ans = 0
    for i in 0..<n {
        var j = i
        while j < n {
            if cars[j] < cars[i] {
                ans += 1
            }
            j += n
        }
    }
    return ans
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var cars = [Int]()
    for i in 0..<n {
        cars.append(i)
    }
    var ans = 0
    for i in 0..<n {
        var j = i
        while j < n {
            if cars[j] < cars[i] {
                ans += 1
            }
            j += n
        }
    }
    return ans
}
```

func carRaceCollision(n: Int) -> Int {
    var cars = Array(repeating: 0, count: n)
    var result = 0
    for i in 0..<n {
        cars[i] = i
    }
    while true {
        var temp = Array(repeating: 0, count: n)
        for i in 0..<n {
            if cars[i] == 0 {
                continue
            }
            let j = (cars[i] + 1) % n
            temp[j] = temp[j] + 1
        }
        if temp.contains(0) {
            break
        }
        for i in 0..<n {
            if cars[i] == 0 {
                continue
            }
            let j = (cars[i] + 1) % n
            if temp[j] > 0 {
                result += 1
                cars[i] = 0
                temp[j] -= 1
            }
        }
    }
    return result
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var cars = Array(repeating: 0, count: n)
    var result = 0
    for i in 0..<n {
        cars[i] = i
    }
    while true {
        var temp = Array(repeating: 0, count: n)
        for i in 0..<n {
            if cars[i] == 0 {
                continue
            }
            let j = (cars[i] + 1) % n
            temp[j] = temp[j] + 1
        }
        if temp.contains(0) {
            break
        }
        for i in 0..<n {
            if cars[i] == 0 {
                continue
            }
            let j = (cars[i] + 1) % n
            if temp[j] > 0 {
                result += 1
                cars[i] = 0
                temp[j] -= 1
            }
        }
    }
    return result
}
```

func carRaceCollision(n: Int) -> Int {
    var cars = Array(repeating: 0, count: n)
    var result = 0
    for i in 0..<n {
        if cars[i] == 0 {
            cars[i] = 1
            for j in i + 1..<n {
                if cars[j] == 1 {
                    cars[j] = 0
                    result += 1
                }
            }
        }
    }
    return result
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var cars = Array(repeating: 0, count: n)
    var result = 0
    for i in 0..<n {
        if cars[i] == 0 {
            cars[i] = 1
            for j in i + 1..<n {
                if cars[j] == 1 {
                    cars[j] = 0
                    result += 1
                }
            }
        }
    }
    return result
}
```

func carRaceCollision(n: Int) -> Int {
    let n = n
    var count = 0
    for i in 0..<n {
        if i % 2 == 0 {
            count += 1
        }
    }
    return count
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    let n = n
    var count = 0
    for i in 0..<n {
        if i % 2 == 0 {
            count += 1
        }
    }
    return count
}
```

func carRaceCollision(n: Int) -> Int {
    let mod = 1000000007
    var ans = 0
    var left = 0
    var right = 1
    for _ in 0..<n {
        let temp = left
        left = (left + right) % mod
        right = (temp + right) % mod
        ans = (ans + left) % mod
    }
    return ans
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    let mod = 1000000007
    var ans = 0
    var left = 0
    var right = 1
    for _ in 0..<n {
        let temp = left
        left = (left + right) % mod
        right = (temp + right) % mod
        ans = (ans + left) % mod
    }
    return ans
}
```

func carRaceCollision(n: Int) -> Int {
    let n = n
    var cars = Array(repeating: 0, count: n)
    var result = 0
    
    while true {
        let left = cars.reversed()
        let right = cars
        
        var i = 0
        while i < n {
            if left[i] > right[i] {
                result += 1
                cars[i] = 0
            } else {
                cars[i] += 1
            }
            i += 1
        }
        
        if cars == left {
            break
        }
    }
    
    return result
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    let n = n
    var cars = Array(repeating: 0, count: n)
    var result = 0
    
    while true {
        let left = cars.reversed()
        let right = cars
        
        var i = 0
        while i < n {
            if left[i] > right[i] {
                result += 1
                cars[i] = 0
            } else {
                cars[i] += 1
            }
            i += 1
        }
        
        if cars == left {
            break
        }
    }
    
    return result
}
```

func carRaceCollision(n: Int) -> Int {
    var cars = [Int]()
    for i in 0..<n {
        cars.append(i)
    }
    var result = 0
    var left = 0
    var right = n - 1
    while left < right {
        if cars[left] < cars[right] {
            result += 1
            left += 1
        } else {
            result += 1
            right -= 1
        }
    }
    return result
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var cars = [Int]()
    for i in 0..<n {
        cars.append(i)
    }
    var result = 0
    var left = 0
    var right = n - 1
    while left < right {
        if cars[left] < cars[right] {
            result += 1
            left += 1
        } else {
            result += 1
            right -= 1
        }
    }
    return result
}
```

func carRaceCollision(n: Int) -> Int {
    let n = n
    var cars = [Int]()
    for i in 0..<n {
        cars.append(i)
    }
    var result = 0
    while !cars.isEmpty {
        let car1 = cars.removeFirst()
        let car2 = cars.removeFirst()
        if car1 < car2 {
            result += 1
        }
    }
    return result
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    let n = n
    var cars = [Int]()
    for i in 0..<n {
        cars.append(i)
    }
    var result = 0
    while !cars.isEmpty {
        let car1 = cars.removeFirst()
        let car2 = cars.removeFirst()
        if car1 < car2 {
            result += 1
        }
    }
    return result
}
```

func carRaceCollision(n: Int) -> Int {
    var cars = Array(repeating: 0, count: n)
    var result = 0
    for i in 0..<n {
        cars[i] = i
    }
    while true {
        var temp = Array(repeating: 0, count: n)
        for i in 0..<n {
            if cars[i] == 0 {
                temp[i] = 1
            } else {
                temp[i] = cars[i]
            }
        }
        for i in 0..<n {
            if temp[i] == 0 {
                continue
            }
            for j in 0..<n {
                if temp[j] == 0 {
                    continue
                }
                if temp[i] < temp[j] {
                    result += 1
                    break
                }
            }
        }
        cars = temp
        if cars.contains(0) {
            break
        }
    }
    return result
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var cars = Array(repeating: 0, count: n)
    var result = 0
    for i in 0..<n {
        cars[i] = i
    }
    while true {
        var temp = Array(repeating: 0, count: n)
        for i in 0..<n {
            if cars[i] == 0 {
                temp[i] = 1
            } else {
                temp[i] = cars[i]
            }
        }
        for i in 0..<n {
            if temp[i] == 0 {
                continue
            }
            for j in 0..<n {
                if temp[j] == 0 {
                    continue
                }
                if temp[i] < temp[j] {
                    result += 1
                    break
                }
            }
        }
        cars = temp
        if cars.contains(0) {
            break
        }
    }
    return result
}
```

func carRaceCollision(n: Int) -> Int {
    var cars = Array(repeating: 0, count: n)
    var result = 0
    
    for i in 0..<n {
        cars[i] = i
    }
    
    while true {
        let next = cars.map { (i) -> Int in
            if i == 0 {
                return n - 1
            } else {
                return i - 1
            }
        }
        
        if next.elementsEqual(cars) {
            break
        }
        
        cars = next
        result += 1
    }
    
    return result
}

```swift
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
func carRaceCollision(n: Int) -> Int {
    var cars = Array(repeating: 0, count: n)
    var result = 0
    
    for i in 0..<n {
        cars[i] = i
    }
    
    while true {
        let next = cars.map { (i) -> Int in
            if i == 0 {
                return n - 1
            } else {
                return i - 1
            }
        }
        
        if next.elementsEqual(cars) {
            break
        }
        
        cars = next
        result += 1
    }
    
    return result
}
```

func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}

func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(l[i] + 1)
    }
    return result
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 2. 数组遍历

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(l[i] + 1)
    }
    return result
}
```

### 3. 数组遍历 + 数组下标

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(l[i] + 1)
    }
    return result
}
```

### 4. 数组遍历 + 数组下标 + 数组元素

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(l[i] + 1)
    }
    return result
}
```

### 5. 数组遍历 + 数组下标 + 数组元素 + 数组下标

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(l[i] + 1)
    }
    return result
}
```

### 6. 数组遍历 + 数组下标 + 数组元素 + 数组下标 + 数组元素

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(l[i

func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(l[i] + 1)
    }
    return result
}

func incrList(l: [Int]) -> [Int] {
    if l.count == 0 {
        return [Int]()
    }
    var result = [Int]()
    result.append(l[0] + 1)
    result += incrList(l: Array(l[1...]))
    return result
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(l[i] + 1)
    }
    return result
}
```

### 方法二：使用递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    if l.count == 0 {
        return [Int]()
    }
    var result = [Int]()
    result.append(l[0] + 1)
    result += incrList(l: Array(l[1...]))
    return result
}
```

### 方法三：使用递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    if l.count == 0 {
        return [Int]()
    }
    var result = [Int]()
    result.append(l[0] + 1)
    result += incrList(l: Array(l[1...]))
    return result
}
```

### 方法四：使用递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    if l.count == 0 {
        return [Int]()
    }
    var result = [Int]()
    result.append(l[0] + 1)
    result += incrList(l: Array(l[1...]))
    return result
}
```

### 方法五：使用递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    if l.count == 0 {
        return [Int]()
    }
    var result = [Int]()
    result.append(l[0] + 1)
    result += incrList(l: Array(l[1...]))
    return result
}
```

### 方法六：使用递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {

func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(l[i] + 1)
    }
    return result
}

func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(incr(l[i]))
    }
    return result
}

func incr(i: Int) -> Int {
    return i + 1
}

func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(incr(i: i))
    }
    return result
}

func incrList(l: [Int]) -> [Int] {
    return incrListHelper(l: l, i: 0)
}

func incrListHelper(l: [Int], i: Int) -> [Int] {
    if i == l.count {
        return []
    }
    return [incr(i: i)] + incrListHelper(l: l, i: i + 1)
}

func incrListHelper(l: [Int], i: Int) -> [Int] {
    return i == l.count ? [] : [incr(i: i)] + incrListHelper(l: l, i: i + 1)
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(l[i] + 1)
    }
    return result
}
```

### 解法二：递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(incr(l[i]))
    }
    return result
}

func incr(i: Int) -> Int {
    return i + 1
}
```

### 解法三：递归 + 闭包

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(incr(i: i))
    }
    return result
}

func incr(i: Int) -> Int {
    return i + 1
}
```

### 解法四：递归 + 闭包 + 尾递归优化

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    return incrListHelper(l: l, i: 0)
}

func incrListHelper(l: [Int], i: Int) -> [Int] {
    if i == l.count {
        return []
    }
    return [incr(i: i)] + incrListHelper(l: l, i: i + 1)
}

func incr(i: Int) -> Int {
    return i + 1
}
```

### 解法五：递归 + 尾递归优化

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    return incrListHelper(l: l, i: 0)
}

func incrListHelper(l: [Int], i: Int) -> [Int] {
    return i == l.count ? [] : [incr(i: i)] + incrListHelper(l: l, i: i + 1)
}

func incr(i: Int) -> Int {
    return i + 1
}
```

### 解法六：递归 + 尾递归优化 + 闭包

```swift
// Return array with elements incremented by 1.
// inc

func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 2. 递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 3. 递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 4. 递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 5. 递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 6. 递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 7. 递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 1

func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(l[i] + 1)
    }
    return result
}

func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(incr(l[i]))
    }
    return result
}

func incr(i: Int) -> Int {
    return i + 1
}

func incrList(l: [Int]) -> [Int] {
    return incrListHelper(l, 0, l.count)
}

func incrListHelper(l: [Int], _ i: Int, _ n: Int) -> [Int] {
    if i == n {
        return []
    }
    return [l[i]] + incrListHelper(l, i + 1, n)
}

func incrListHelper(l: [Int], _ i: Int, _ n: Int) -> [Int] {
    return i == n ? [] : [l[i]] + incrListHelper(l, i + 1, n)
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(l[i] + 1)
    }
    return result
}
```

### 解法二：递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = [Int]()
    for i in 0..<l.count {
        result.append(incr(l[i]))
    }
    return result
}

func incr(i: Int) -> Int {
    return i + 1
}
```

### 解法三：递归 + 尾递归优化

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    return incrListHelper(l, 0, l.count)
}

func incrListHelper(l: [Int], _ i: Int, _ n: Int) -> [Int] {
    if i == n {
        return []
    }
    return [l[i]] + incrListHelper(l, i + 1, n)
}
```

### 解法四：递归 + 尾递归优化 + 闭包

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    return incrListHelper(l, 0, l.count)
}

func incrListHelper(l: [Int], _ i: Int, _ n: Int) -> [Int] {
    return i == n ? [] : [l[i]] + incrListHelper(l, i + 1, n)
}
```

### 解法五：递归 + 尾递归优化 + 闭包 + 尾递归优化

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    return incrListHelper(l, 0, l.count)
}

func incrListHelper(l: [Int], _ i: Int, _ n: Int) -> [Int] {
    return i == n ? [] : [l[i]] + incrListHelper(l, i + 1, n)
}
```

### 解法六：尾递归优化 + 闭包 + 尾递归优化

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3

func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 解法二：递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 解法三：递归 + 数组

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 解法四：递归 + 数组 + 数组

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 解法五：递归 + 数组 + 数组 + 数组

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 解法六：递归 + 数组 + 数组 + 数组 + 数组

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 解法七：递归 + 数组 + 数组 + 数组 + 数组 + 数组

```swift
// Return array with elements incre

func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 2. 递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 3. 迭代

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 4. 递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 5. 迭代

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 6. 递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 7. 迭代

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123])

func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 解法二：递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 解法三：递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 解法四：递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 解法五：递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 解法六：递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 解法七：递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9

func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 2. 递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 3. 递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 4. 递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 5. 递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 6. 递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 123]) == [6, 4, 6, 3, 4, 4, 10, 1, 124]
func incrList(l: [Int]) -> [Int] {
    var result = l
    for i in 0..<l.count {
        result[i] += 1
    }
    return result
}
```

### 7. 递归

```swift
// Return array with elements incremented by 1.
// incrList(l: [1, 2, 3]) == [2, 3, 4]
// incrList(l: [5, 3, 5, 2, 3, 3, 9, 0, 1

func pairsSumToZero(l: [Int]) -> Bool {
    // 1. create a dictionary to store the elements and their indexes
    var dict: [Int: Int] = [:]
    for (index, element) in l.enumerated() {
        dict[element] = index
    }
    // 2. iterate through the array
    for (index, element) in l.enumerated() {
        // 3. check if the element is in the dictionary
        let complement = -element
        if dict[complement] != nil && dict[complement] != index {
            return true
        }
    }
    return false
}

func pairsSumToZero(l: [Int]) -> Bool {
    // 1. sort the array
    let sorted = l.sorted()
    // 2. create two pointers
    var left = 0
    var right = sorted.count - 1
    // 3. iterate through the array
    while left < right {
        // 4. check if the sum is zero
        let sum = sorted[left] + sorted[right]
        if sum == 0 {
            return true
        } else if sum > 0 {
            // 5. if the sum is greater than zero, move the right pointer to the left
            right -= 1
        } else {
            // 6. if the sum is less than zero, move the left pointer to the right
            left += 1
        }
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    // 1. create a dictionary to store the elements and their indexes
    var dict: [Int: Int] = [:]
    for (index, element) in l.enumerated() {
        dict[element] = index
    }
    // 2. iterate through the array
    for (index, element) in l.enumerated() {
        // 3. check if the element is in the dictionary
        let complement = -element
        if dict[complement] != nil && dict[complement] != index {
            return true
        }
    }
    return false
}
```

### 解法二：双指针

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    // 1. sort the array
    let sorted = l.sorted()
    // 2. create two pointers
    var left = 0
    var right = sorted.count - 1
    // 3. iterate through the array
    while left < right {
        // 4. check if the sum is zero
        let sum = sorted[left] + sorted[right]
        if sum == 0 {
            return true
        } else if sum > 0 {
            // 5. if the sum is greater than zero, move the right pointer to the left
            right -= 1
        } else {
            // 6. if the sum is less than zero, move the left pointer to the right
            left += 1
        }
    }
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    // 1. create a dictionary to store the elements and their indexes
    var dict = [Int: Int]()
    for (index, element) in l.enumerated() {
        if dict.keys.contains(element) {
            return true
        }
        dict[element] = index
    }
    return false
}

func pairsSumToZero(l: [Int]) -> Bool {
    // 1. sort the array
    let sorted = l.sorted()
    // 2. create two pointers
    var left = 0
    var right = sorted.count - 1
    // 3. while the pointers are not equal, check if the sum is zero
    while left < right {
        let sum = sorted[left] + sorted[right]
        if sum == 0 {
            return true
        } else if sum > 0 {
            right -= 1
        } else {
            left += 1
        }
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    // 1. create a dictionary to store the elements and their indexes
    var dict = [Int: Int]()
    for (index, element) in l.enumerated() {
        if dict.keys.contains(element) {
            return true
        }
        dict[element] = index
    }
    return false
}
```

### 解法二：双指针

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    // 1. sort the array
    let sorted = l.sorted()
    // 2. create two pointers
    var left = 0
    var right = sorted.count - 1
    // 3. while the pointers are not equal, check if the sum is zero
    while left < right {
        let sum = sorted[left] + sorted[right]
        if sum == 0 {
            return true
        } else if sum > 0 {
            right -= 1
        } else {
            left += 1
        }
    }
    return false
}
```

### 解法三：双指针优化

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    // 1. sort the array
    let sorted = l.sorted()
    // 2. create two pointers
    var left = 0
    var right = sorted.count - 1
    // 3. while the pointers are not equal, check if the sum is zero
    while left < right {
        let sum = sorted[left] + sorted[right]
        if sum == 0 {
            return true
        } else if sum > 0 {
            right -= 1
        } else {
            left += 1
        }
    }
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    var dict = [Int: Int]()
    for i in l {
        if dict[i] != nil {
            return true
        }
        dict[i * -1] = 1
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var dict = [Int: Int]()
    for i in l {
        if dict[i] != nil {
            return true
        }
        dict[i * -1] = 1
    }
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    var dict = [Int: Int]()
    for i in 0..<l.count {
        let num = l[i]
        if dict[num] != nil {
            return true
        }
        dict[(-1 * num)] = i
    }
    return false
}

func pairsSumToZero(l: [Int]) -> Bool {
    let l = l.sorted()
    var left = 0
    var right = l.count - 1
    while left < right {
        let sum = l[left] + l[right]
        if sum == 0 {
            return true
        } else if sum > 0 {
            right -= 1
        } else {
            left += 1
        }
    }
    return false
}

func pairsSumToZero(l: [Int]) -> Bool {
    var bitmap = 0
    for num in l {
        if num < 0 {
            num = -1 * num
        }
        if bitmap & (1 << num) != 0 {
            return true
        }
        bitmap |= 1 << num
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var dict = [Int: Int]()
    for i in 0..<l.count {
        let num = l[i]
        if dict[num] != nil {
            return true
        }
        dict[(-1 * num)] = i
    }
    return false
}
```

### 解法二：排序+双指针

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    let l = l.sorted()
    var left = 0
    var right = l.count - 1
    while left < right {
        let sum = l[left] + l[right]
        if sum == 0 {
            return true
        } else if sum > 0 {
            right -= 1
        } else {
            left += 1
        }
    }
    return false
}
```

### 解法三：哈希表

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var dict = [Int: Int]()
    for i in 0..<l.count {
        let num = l[i]
        if dict[num] != nil {
            return true
        }
        dict[(-1 * num)] = i
    }
    return false
}
```

### 解法四：位运算

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var bitmap = 0
    for num in l {
        if num < 0 {
            num = -1 * num
        }
        if bitmap & (1 << num) != 0 {
            return true
        }
        bitmap |= 1 << num
    }
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    var dict = [Int: Int]()
    for i in 0..<l.count {
        if dict[l[i]] != nil {
            return true
        }
        dict[l[i] * -1] = i
    }
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    var dict = [Int: Int]()
    for i in 0..<l.count {
        if dict[l[i]] != nil {
            return true
        }
        dict[l[i] * -1] = i
    }
    return false
}
```

func pairsSumToZero(l: [Int]) -> Bool {
    // 1. create a dictionary with key-value pairs
    //    where the key is the number and the value is the number's index
    var dict = [Int: Int]()
    for (index, value) in l.enumerated() {
        dict[value] = index
    }
    
    // 2. iterate through the array
    for (index, value) in l.enumerated() {
        let complement = -value
        if dict.keys.contains(complement) && dict[complement] != index {
            return true
        }
    }
    
    return false
}

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    // 1. create a dictionary with key-value pairs
    //    where the key is the number and the value is the number's index
    var dict = [Int: Int]()
    for (index, value) in l.enumerated() {
        dict[value] = index
    }
    
    // 2. iterate through the array
    for (index, value) in l.enumerated() {
        let complement = -value
        if dict.keys.contains(complement) && dict[complement] != index {
            return true
        }
    }
    
    return false
}
```

### 解法二

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    // 1. create a dictionary with key-value pairs
    //    where the key is the number and the value is the number's index
    var dict = [Int: Int]()
    for (index, value) in l.enumerated() {
        dict[value] = index
    }
    
    // 2. iterate through the array
    for (index, value) in l.enumerated() {
        let complement = -value
        if dict.keys.contains(complement) && dict[complement] != index {
            return true
        }
    }
    
    return false
}
```

### 解法三

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {
    // 1. create a dictionary with key-value pairs
    //    where the key is the number and the value is the number's index
    var dict = [Int: Int]()
    for (index, value) in l.enumerated() {
        dict[value] = index
    }
    
    // 2. iterate through the array
    for (index, value) in l.enumerated() {
        let complement = -value
        if dict.keys.contains(complement) && dict[complement] != index {
            return true
        }
    }
    
    return false
}
```

### 解法四

```swift
// pairs_sum_to_zero takes an array of integers as an input.
// it returns true if there are two distinct elements in the array that
// sum to zero, and false otherwise.
// pairsSumToZero(l: [1, 3, 5, 0]) == false
// pairsSumToZero(l: [1, 3, -2, 1]) == false
// pairsSumToZero(l: [1, 2, 3, 7]) == false
// pairsSumToZero(l: [2, 4, -5, 3, 5, 7]) == true
// pairsSumToZero(l: [1]) == false
func pairsSumToZero(l: [Int]) -> Bool {