swift - मूल्यों को निर्दिष्ट करते हुए मैं स्विफ्ट के साथ पूरे वर्णमाला के माध्यम से कैसे चक्र कर सकता हूं?




swift2 uitextfield (4)

उन पर पुनरावृत्त करके और उनके संबंधित मूल्यों के अनुरूप अक्षरों के साथ एक शब्दकोश बनाने के द्वारा पत्रों को असाइन करें:

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
}

स्विफ्ट के अंतर्निर्मित ऐरे का उपयोग करें अपने UITextViewDelegate से लौटाए गए अक्षरों को योग करने के reduce कार्य को reduce करें:

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
    }
}

मैं स्विफ्ट का उपयोग करके पूरे वर्णमाला के माध्यम से चक्र की कोशिश कर रहा हूं। केवल एक समस्या यह है कि मैं प्रत्येक अक्षर के लिए मान असाइन करना चाहूंगा।

उदाहरण के लिए: a = 1, b = 2, c = 3 और इतने पर जब तक मैं z तक नहीं होता जो = 26 होता है

मैं पाठ फ़ील्ड में प्रत्येक अक्षर के माध्यम से कैसे जाना चाहूँगा जो पहले वर्णों के वर्णों को असाइन किए गए मानों का उपयोग करते समय टाइप किया था?

ऐसा करने के बाद, मैं पूरे शब्द के लिए एक राशि प्राप्त करने के लिए सभी अक्षरों के मूल्यों को कैसे जोड़ूँ? मैं इसे पूरा करने के लिए सबसे सरल तरीके से तलाश कर रहा हूं, लेकिन जिस तरीके से मैं इसे पसंद करूंगा, वह काम करता है

कोई सुझाव?

अग्रिम में धन्यवाद।


मैं इस तरह से एक समारोह बनाऊँगा ...

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
}

फिर आप शब्द को दोहरा सकते हैं ...

let word = "hello"
var score = 0

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

शायद आप ऐसा कुछ ढूंढ रहे हैं:

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

अनुक्रम text.lowercaseString.unicodeScalarstext.lowercaseString.unicodeScalars (यूनिकोड स्केलर के रूप में निचला केस पाठ) filter को फ़िल्टर्ड किया जाता है, जो केवल स्केलर को बनाए जाते हैं, जो कि ~= साथ कम lowerCase श्रेणी से मेल खाते हैंreduce सभी फ़िल्टर किए गए स्केलर मूल्यों को -96 द्वारा स्थानांतरित कर दिया जाता है (जैसे 'ए' 1 देता है आदि)। reduce के लिए 0 एक संचायक ( acc ) मूल्य से शुरू होता है इस समाधान में पैटर्न मिलान ऑपरेटर केवल lowerCase.start (a) और lowerCase.end (z) के बीच होने वाले स्केलर मान की जांच करेगा, इस प्रकार वर्णों के सरणी में कोई लुकअप या पाशन नहीं है।


संपादित करें / अपडेट: Xcode 7.2.1 • स्विफ्ट 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

    }

}

एक्सटेंशन

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






alphabet