// Нужно найти минимальный элемент в массиве.
// Сейчас всегда выдает очень большое число

func min(_ array: [Int]) -> Int {
    var minElement = Int.max

    for i in 0 ..< array.count {
        if (array[i] > minElement) {
            minElement = array[i]
        }
    }

    return minElement
}

// Степень тройки

func isPowerOfThree(_ n: Int) -> Bool {
    if n <= 0 {
        return false
    }

    var m = n

    while m % 3 == 0  {
        m /= 3
    }

    return n == 1
}

// Метод должен сортировать строку по возрастанию( abcde...z )
// Сейчас сортирует по убыванию

- (NSString *)sortedString:(NSString *)inputString {
   NSMutableArray *charArray = [NSMutableArray new];

   for (int i = 0; i < inputString.length; ++i) {
       [charArray addObject:[NSString stringWithFormat:@"%c", [inputString characterAtIndex:i]]];
   }

   NSString *resultString = [[charArray sortedArrayUsingComparator:^NSComparisonResult(id  _Nonnull obj2, id  _Nonnull obj1) {
       return [obj1 compare:obj2];
   }] componentsJoinedByString:@""];

   return resultString;
}

// Ищем, содержит ли массив повторяющиеся значения
// Сейчас не работает

func containsDuplicate(_ nums: [Int]) -> Bool {
    var set = Set<Int>()

    for num in nums {
        if (set.insert(num).inserted == false) {
            return false
        }
    }
    return true
}

// Нужно развернуть строку. 
// Сейчас из строки abcd получается строка dccd.

func reverseString(_ s: String) -> String {
    var helperString = Array(s.characters)
    let length = s.characters.count

    for i in 0 ..< (length / 2) {
        let rightIndex = length - i - 1
        let tmp = helperString[rightIndex]

        helperString[i] = tmp
        helperString[rightIndex] = helperString[i]
    }

    return String(helperString)
}

// Найти длину самой длинной увеличивающейся подпоследовательности.

func lengthOfLIS(_ nums: [Int]) -> Int {
    var lengths = [Int](repeatElement(1, count: nums.count))
    var maxLength = 0

    for i in 0 ..< nums.count {
        for j in 0 ..< i {
            if (nums[j] < nums[i]) {
                lengths[i] = max(lengths[i] + 1, lengths[j])
            }
        }
        maxLength = max(maxLength, lengths[i])
    }

    return maxLength
}

// Найти длину самой длинной подстроки без повторяющихся символов.

func lengthOfLongestSubstring(_ s: String) -> Int {
    let n = s.characters.count
    let charsString = s.utf8CString

    var set = Set<String>()
    var i = 0
    var j = 0
    var answer = 0

    while i < n && j < n {
        let currentCharRight = String(charsString[j])
        let currentCharLeft = String(charsString[i])

        if (set.contains(currentCharRight) == false) {
            set.insert(currentCharRight)
            answer = max(answer, j - i + 1)
            i += 1
        } else {
            set.remove(currentCharLeft)
            j += 1
        }
    }

    return answer
}