Hello, when testing both cases within switch via .append(" @") I could see that both cases do the same work - create space between words. So I decided to comment out the 2nd case. Morse to text still seems to work. I would like to ask you:
- why the cases are set up the way they are and what this
switchstatement accomplishes. When you can help me to clarify more compared to my current comments below. Especially the purpose of case 2 and reseting morseSign via assigning “” to it.
// 1.1. first figure out how to translate englishText into Morse code
var englishText: String
englishText = "this is a secret message"
englishText = "a b c"
// 1.2. then we’ll finish the project off with deciphering secretMessage
var secretMessage: String
secretMessage = ".... --- .-- -.. -.-- .--. .- .-. - -. . .-."
secretMessage = ".... .. --- .... --- .-- .- .-. . -.-- --- ..- --- ..--.."
// secretMessage = ".... ...."
// 2. stores individual letters of the alphabet as String type keys and their morse counterpart as String type values.
var letterToMorse: [String: String] = [:]
letterToMorse = [
"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": "--..",
".": ".-.-.-",
"!": "-.-.--",
"?": "..--..",
",": "--..--"
]
// 3. morseText to store the encrypted message
var morseText = ""
// 4. loop to iterate through each character in englishText, name the placeholder element
for element in englishText {
// 5. if-let statement that assigns a variable called morseChar to the value of a key in the dictionary letterToMorse. ~ check if value does exist in the dictionary
if let morseChar = letterToMorse["\(element)"] { // 6. change element type from 'Character' to 'String'
// 7. append letter and space to morseText
morseText += morseChar + " "
} else {
// 8. append three spaces " " to the end of the value to represent the space between new words.
morseText += " "
}
}
// 9. Great job! Now that we’ve finished populating morseText, let’s take a look at our encoded message. Outside of the for-in loop, use print() to output morseText.
print("English text to morse: \(morseText)")
// 10. to store the decoded version of secretMessage
var decodedMessage = ""
// 11. array to store individual Morse code letter/s represented as String/s
var arrayOfmorseSigns: [String] = []
// 12. individual Morse code letter represented as String composed of dots . and dashes - characters (char)
var morseSign = ""
// 13. iterate through each character of secretMessage. Rule of Morse, each letter is separated by single space, each word by three spaces. We use this information to figure out when we hit a new letter or new word in secretMessage loop.
for dotDash in secretMessage {
// if no space in code, append dot/dash to morseSign string
if dotDash != " " {
morseSign.append(dotDash)
// else space in code means new morseSign String, that can be: 1. empty, 2. ???, 3. by default append morseSign to arrayOfMorseSigns, then reset value of morseSign
} else {
switch morseSign {
case "":
// empty morseSign, creates single space between words
morseSign.append(" ")
/*case " ": // can skip, above case creates one space/empty morseSign and morseSignString is already appended to arrayOfmorseSigns by default
arrayOfmorseSigns.append(" ")
morseSign = ""*/
default:
// by default append morseSign to arrayOfMorseSigns
arrayOfmorseSigns.append(morseSign)
// reset the value of morseSign, so that dot/Dash/" " can be appended
morseSign = "" // if "@", @ is added to the begginin of each morseSign
}
}
}
// 17. Outside loop, finish populating arrayOfmorseSigns by appending morseSign. Othwerise would be missing the last morseSign.
arrayOfmorseSigns.append(morseSign)
print(arrayOfmorseSigns)
// 18. Create an empty dictionary. This will hold morse code values as Keys and their english counter parts as Values
var morseToLetter: [String: String] = [:]
// 19. Create a for-in loop that iterates through the keys and the values of the letterToMorse dictionary. Name the key placeholder letter and the values placeholder morseChar.
// 20. We are going to populate morseToLetter. In the body of the loop, add a key-value pair to morseToLetter with morseChar as the key and letter as the value. Outside of the loop, output the value of morseToLetter to check if all the values look correct. If everything looks okay, feel free to delete this print() statement.
for (letter, morseChar) in letterToMorse {
// we do reverse key with value because from letterToMorse we make morseToLetter
morseToLetter[morseChar] = letter
}
// print(morseToLetter) // just for check
// 21. Go through each element in morseCodeArray and find the text value via the morseToLetter dictionary
for morseValue in arrayOfmorseSigns {
// 22. Check if the value exists in the morseToLetter dictionary
if let letterChar = morseToLetter[morseValue] {
// 23. Append the values to decodedMessage
decodedMessage += letterChar
} else {
// 24. If morseValue does not exist as a key within morseToLetter, then the value of morseValue is a space.
decodedMessage += " "
}
}
// 25. Print decodedMessage to find out what the secret message is!
print("Morse secret message to text: \(decodedMessage)")
// print(arrayOfmorseSigns)