Why is the optimum space complexity of the answer O(n), when we are only storing all possible alphabets?

I have written a solution to the question: “You are given a non-empty string, and a key, k which is a positive integer value. You are asked to shift each character in string by k values across according to the alphabet.”

For example, if k=2 and string = "abcd" -> "cdef". And we need to **wrap around the alphabet ** for any order greater than ‘z’. i.e. if string= "zzz" and k=2 then the output should be "bbb".

My solution uses a dictionary to store the ord() of all characters in the alphabet, then for each character in string simply adds k to the order and returns the corresponding character from the dictionary:

def caesarCipherEncryptor(string, key):
    my_dict = dict()
    for i in range(97, 123):
        my_dict[ord(chr(i)) - ord("a")] = chr(i)

    res = ""
    for i in range(len(string)):
        finder = (ord(string[i]) - ord("a")) + key
        while finder > 25:
            finder = finder % 26
        res += my_dict[finder]

    return res

The code above passes all test cases presented, so that is no issue. However,I am told that the optimum space complexity for this problem is O(n), however by the way I have solved it in the above, is it not O(1)? Since I am simple storing all characters in the alphabet (max 26) in my dictionary?


The space complexity is O(n) because if there were more letters to the alphabet, or you were trying to extend this program you would have to insert all those letters too. Thus, for a problem space of n letters, you are using n bytes of space which means the space complexity is O(n)