Runtime: 8 ms, faster than 100.00% of Swift online submissions for Decode String. Memory Usage: 20.1 MB, less than 100.00% of Swift online submissions for Decode String.

use "abcdefghiepoiuq" to test, print 9. but 10 Actually.

My code prints correctly:

    func lengthOfLongestSubstring(_ string: String) -> Int {
        var flags = Array(repeating: -1, count: 128)
        var maxLength = 0
        var startIndex = -1
        
        for (index, char) in string.enumerated() {
            let asciiValue = Int(char.asciiValue ?? 0)
            if flags[asciiValue] > startIndex {
                if index - startIndex > maxLength {
                    maxLength = index - startIndex
                }
                startIndex = flags[asciiValue] + 1
                flags[asciiValue] = index
                continue
            }
            flags[asciiValue] = index
        }
        
        if string.count - startIndex > maxLength {
            maxLength = string.count - startIndex
        }
        return maxLength
    }

The current algorithm will always return the last integer to displace the major as the new majority element. Take var array = [1,1,1,2,2,3] for example. The answer should be 1 but the algorithm returns 3.

Also, majority element must appear more than number of elements/2 times. The algorithm doesn't take this in to account.

Thanks for all your hard work!

Slight Correction..

`func isPalindrome(_ s: String) -> Bool { // Make String into an array of lowercase Characters let characters = s.lowercased()

// Only keep alphanumeric characters.
let cleanedCharacter = characters.filter { character in
    return character.description.rangeOfCharacter(from: CharacterSet.alphanumerics) != nil
}

// Making array of cleaned characters let cleaned = Array(cleanedCharacter)

// Compare values at mirroring indices.
let total = cleaned.count
for i in 0 ..< total/2 {
    if cleaned[i] != cleaned[total - 1 - i] {
        return false
    }
}
return true

} `

For this hunk:

if i - maxIdx.first! + 1 == k {
      maxIdx.removeFirst()
}

Same as:

if maxIdx.last! - maxIdx.first! + 1 == k {
      maxIdx.removeFirst()
}

As maxIdx.last! - maxIdx.first! + 1 is always less than or equal to maxIdx.count, and will poll the first element when it reachesk. Such that : maxIdx.count is always less than or equal to k.

=> The space complexity is O(k), rather than O(n).

When I cloned this project I had to individually select each playground file to view the implementation. I took all your LeetCode_Swift .swift files and neatly put them in one Xcode project folder so it will be easier for anyone cloning it to have it in one place. I also added .playground files to each one. Is that something thats you are willing to consider pulling?

The old version of the solution to 304. Range Sum Query 2D - Immutable didn't cover the case that the input matrix is empty. When the input matrix is empty, the result will be "Fatal error: Index out of range".

Runtime: 52 ms, faster than 97.77% of Swift online submissions for Add Two Numbers. Memory Usage: 18.9 MB, less than 28.75% of Swift online submissions for Add Two Numbers.

I think it would be cool if there was an option for each contributor to be able to explain in a REAME file their thought process and how they came up with their solutions. I think it would help people understand someone else's logic. It will also help it read better on github. I can add additional changes to the Architect branch. What do you think?

Great solution! Although I think the time complexity is more like O(lgn), as n being num? Not that important anyways, since num is guaranteed to be <= 3999.

as Apple API Reference say:

Swift Standard Library - AnyBidirectiona - lCollection

reversed()

Instance Method reversed() Returns a view presenting the elements of the collection in reverse order. ... ... If you need a reversed collection of the same type, you may be able to use the collection’s sequence-based or collection-based initializer. For example, to get the reversed version of a string, reverse its characters and initialize a new String instance from the result.

let reversedWord = String(word.characters.reversed())
print(reversedWord)
// Prints "sdrawkcaB"

Complexity: O(1)

/**

• Question Link: https://leetcode.com/problems/range-sum-query-immutable/
• Primary idea: Calculate the sum of the elements of nums between indices left and right
• Time Complexity: O(n), Space Complexity: O(1)

*/

class NumArray {
	var sums: [Int] = []

	init(_ nums: [Int]) {
		var currentSum = 0

		for num in nums {
			currentSum += num
			sums.append(currentSum)
		}
		print(sums)
	}

	func sumRange(_ left: Int, _ right: Int) -> Int {
		if left == 0 {
			return sums[right]
		}
		return sums[right] - sums[left-1]
	}
}