How do I cycle through the entire alphabet with Swift while assigning values?

Question

I am trying to cycle through the entire alphabet using Swift. The only problem is that I would like to assign values to each letter.

For Example: a = 1, b = 2, c = 3 and so on until I get to z which would = 26.

How do I go through each letter in the text field that the user typed while using the values previously assigned to the letters in the alphabet?

After this is done, how would I add up all the letters values to get a sum for the entire word. I am looking for the simplest possible way to accomplish this but works the way I would like it to.

Answer 1

edit/update: Xcode 12.5 • Swift 5.4

---

extension Character {
    static let alphabetValue = zip("abcdefghijklmnopqrstuvwxyz", 1...26).reduce(into: [:]) { $0[$1.0] = $1.1 }
    var lowercased: Character { .init(lowercased()) }
    var letterValue: Int? { Self.alphabetValue[lowercased] }
}

---

extension String {
    var wordValue: Int { compactMap(\.letterValue).reduce(0, +) }
}

---

Character("A").letterValue    // 1
Character("b").letterValue    // 2
Character("c").letterValue    // 3
Character("d").letterValue    // 4
Character("e").letterValue    // 5
Character("Z").letterValue    // 26
"Abcde".wordValue    // 15

Answer 2

I'd create a function something like this...

func valueOfLetter(inputLetter: String) -> Int {
    let alphabet = ["a", "b", "c", "d", ... , "y", "z"] // finish the array properly

    for (index, letter) in alphabet {
        if letter = inputLetter.lowercaseString {
            return index + 1
        }
    }

    return 0
}

Then you can iterate the word...

let word = "hello"
var score = 0

for character in word {
    score += valueOfLetter(character)
}

Answer 3

Assign the letters by iterating over them and building a dictionary with letters corresponding to their respective values:

let alphabet: [String] = [
    "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"
]

var alphaDictionary = [String: Int]()
var i: Int = 0

for a in alphabet {
    alphaDictionary[a] = ++i
}

Use Swift's built-in Array reduce function to sum up the letters returned from your UITextViewDelegate:

func textViewDidEndEditing(textView: UITextView) {
    let sum = Array(textView.text.unicodeScalars).reduce(0) { a, b in
        var sum = a

        if let d = alphaDictionary[String(b).lowercaseString] {
            sum += d
        }

        return sum
    }
}

Answer 4

Maybe you are looking for something like this:

func alphabetSum(text: String) -> Int {
    let lowerCase = UnicodeScalar("a")..."z"
    return reduce(filter(text.lowercaseString.unicodeScalars, { lowerCase ~= $0}), 0) { acc, x in
        acc + Int((x.value - 96))
    }
}


alphabetSum("Az") // 27 case insensitive
alphabetSum("Hello World!") // 124 excludes non a...z characters

The sequence text.lowercaseString.unicodeScalars ( lower case text as unicode scalar ) is filtered filter keeping only the scalars that pattern match ~= with the lowerCase range. reduce sums all the filtered scalar values shifted by -96 (such that 'a' gives 1 etc.). reduce starts from an accumulator (acc) value of 0. In this solution the pattern match operator will just check for the scalar value to be between lowerCase.start (a) and lowerCase.end (z), thus there is no lookup or looping into an array of characters.

Answer 5

I've just put together the following function in swiftstub.com and it seems to work as expected.

func getCount(word: String) -> Int {
    let alphabetArray = Array(" abcdefghijklmnopqrstuvwxyz")
    var count = 0

    // enumerate through each character in the word (as lowercase)
    for (index, value) in enumerate(word.lowercaseString) {
        // get the index from the alphabetArray and add it to the count
        if let alphabetIndex = find(alphabetArray, value) {
            count += alphabetIndex
        }
    }

    return count
}

let word = "Hello World"
let expected = 8+5+12+12+15+23+15+18+12+4

println("'\(word)' should equal \(expected), it is \(getCount(word))")

// 'Hello World' should equal 124 :)

The function loops through each character in the string you pass into it, and uses the find function to check if the character (value) exists in the sequence (alphabetArray), and if it does it returns the index from the sequence. The index is then added to the count and when all characters have been checked the count is returned.