¿Cómo ciclo por todo el alfabeto con Swift al asignar valores?

swift2 uitextfield

Question

Estoy intentando recorrer todo el alfabeto con Swift. El único problema es que me gustaría asignar valores a cada letra.

Por ejemplo: a = 1, b = 2, c = 3 y así sucesivamente hasta que llegue a z, que sería = 26.

¿Cómo reviso cada letra en el campo de texto que el usuario tipeó al usar los valores previamente asignados a las letras del alfabeto?

Una vez hecho esto, ¿cómo puedo sumar todos los valores de las letras para obtener una suma para toda la palabra? Estoy buscando la forma más simple posible para lograr esto, pero funciona de la manera que me gustaría.

¿Alguna sugerencia?

Gracias por adelantado.

Answer 1

Acabo de armar la siguiente función en swiftstub.com y parece funcionar como se esperaba.

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 :)

La función recorre cada carácter en la cadena que le pasa, y usa la función find para verificar si el carácter (valor) existe en la secuencia (alphabetArray), y si lo hace, devuelve el índice de la secuencia. El índice se agrega al recuento y cuando se han verificado todos los caracteres, se devuelve el recuento.

Answer 2

Asigne las letras iterando sobre ellas y construyendo un diccionario con letras correspondientes a sus valores respectivos:

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
}

Utilice la función de reduce matriz incorporada de Swift para resumir las letras devueltas desde su 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 3

Crearía una función como esta ...

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
}

Entonces puedes repetir la palabra ...

let word = "hello"
var score = 0

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

Answer 4

Tal vez estás buscando algo como esto:

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

La secuencia text.lowercaseString.unicodeScalars (texto en minúsculas como unicode escalar) se filtra filter manteniendo solo los escalares que coinciden con ~= con el rango lowerCase la lowerCase . reduce sumas todos los valores escalares filtrados desplazados por -96 (de forma que ''a'' da 1, etc.). reduce comienza desde un valor de acumulador ( acc ) de 0 . En esta solución, el operador de coincidencia de patrones simplemente comprobará que el valor escalar se encuentre entre lowerCase.start (a) y lowerCase.end (z), por lo que no hay búsqueda o bucle en una matriz de caracteres.

Answer 5

editar / actualizar: Xcode 7.2.1 • Swift 2.1.1

import UIKit

class ViewController: UIViewController {

    @IBOutlet weak var strWordValue: UILabel!
    @IBOutlet weak var strInputField: UITextField!


    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }

    @IBAction func sumLettersAction(sender: AnyObject) {
        strWordValue.text = strInputField.text?.wordValue.description

    }

}

Extensiones

extension String {
    var letterValue: Int {
        return Array("abcdefghijklmnopqrstuvwxyz".characters).indexOf(Character(lowercaseString))?.successor() ?? 0
    }
    var wordValue: Int {
        var result = 0
        characters.forEach { result += String($0).letterValue }
        return result
    }
}

func letterValue(letter: String) -> Int {
    return Array("abcdefghijklmnopqrstuvwxyz".characters).indexOf(Character(letter.lowercaseString))?.successor() ?? 0
}

func wordValue(word: String) -> Int {
    var result = 0
    word.characters.forEach { result += letterValue(String($0)) }
    return result
}


let aValue = letterValue("a")  // 1
let bValue = letterValue("b")  // 2
let cValue = letterValue("c")  // 3
let zValue = letterValue("Z")  // 26

let busterWordValue = wordValue("Buster") // 85
let busterWordValueString = wordValue("Buster").description // "85"

//

extension Character {
    var lowercase: Character { return Character(String(self).lowercaseString) }
    var value: Int { return Array("abcdefghijklmnopqrstuvwxyz".characters).indexOf(lowercase)?.successor() ?? 0 }
}
extension String {
    var wordValue: Int { return Array(characters).map{ $0.value }.reduce(0){ $0 + $1 } }
}

"Abcde".wordValue    // 15