Programming Challenge - Morse Code Cipher

Code:

#include <iostream>
#include <Windows.h>
#include <string>
#include <sstream>
#include <iterator>
#include <algorithm>
#include <map>

namespace morse_code {

  typedef std::map<char, const char *> MorseCodeMap; // Contains substitution mappings

  // Reference table for substitutions
  const char _plaintext[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,?'!/()&:;=+-_\"$@";
  const char _morsetext[][8] = {
    // Letters
    ".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..",
    ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.",
    "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--..",

    // Digits
    "-----", ".----", "..---", "...--", "....-",
    ".....", "-....", "--...", "---..", "----.",

    // Special
    ".-.-.-", "--..--", "..--..", ".----.", "-.-.--", "-..-.", "-.--.",
    "-.--.-", ".-...", "---...", "-.-.-.", "-...-", ".-.-.", "-....-",
    "..--.-", ".-..-.", "...-..-", ".--.-."
  };

  // Translates input text from or to morse code.
  class MorseCode {
  public:
    MorseCode(std::string &inputstring) : _inputstring(inputstring) {}
    ~MorseCode() {}

    // Translates the plaintext input into morse code and returns the result.
    std::string TranslateToMorse()
    {
      // Create and initialize morse code map used for substitutions.
      MorseCodeMap morse_code_map; InitMorseMap(morse_code_map);

      // Transform all input text to uppercase for easy indexing via the
      // morse code table and parse words from the full text to be placed in
      // a vector for easy iterator access.
      std::vector<std::string> parts;
      std::transform(_inputstring.begin(), _inputstring.end(), _inputstring.begin(), ::toupper);
      GetWords(_inputstring, parts);

      // The constant gap/units between each word by international
      // morse code standard is 7.
      const unsigned kWordGap = 7;
      std::string morse; // Morse code string to be returned.

      // Iterate through each word appending each character in morse code,
      // separated by spaces, following a constant gap of 7 spaces after
      // each word.
      for (auto &it : parts) {
        std::for_each(it.begin(), it.end(), [&morse, &morse_code_map](char c) {
          morse.append(morse_code_map.find(c) == morse_code_map.end()
                       ? " " : morse_code_map[c]).append(1, ' ');
        });
        morse.append(kWordGap - 1, ' ');
      }
      return morse.substr(0, morse.length() - kWordGap);
    }

    // Translates the morse code input into morse code and returns the result.
    std::string TranslateFromMorse()
    {
      // TODO
      std::string morse;
      return morse;
    }

    // Plays the morse code string through a series of beeps.
    static void PlayMorseString(std::string &morse, int lowfreq, int highfreq, int delay)
    {
      // Use a const iterator for each char in the morse code string to check
      // whether a high or low beep is produced. A minimal frequency is used for
      // all parts that are not morse code.
      for (const auto &it : morse) {
        if (it == ' ') { Beep(37, delay); continue; }
        Beep(it == '.' ? lowfreq : highfreq, delay);
      }
    }
  private:
    std::string _inputstring; // Input string initialized by the constructor.

    // Populates the referenced (STL) vector container with the words
    // from the input string.
    void GetWords(std::string &s, std::vector<std::string> &words)
    {
      std::istringstream isstrm(s);
      std::copy(
        std::istream_iterator<std::string>(isstrm),
        std::istream_iterator<std::string>(),
        std::back_inserter<std::vector<std::string>>(words)
      );
    }

    // Initializes the referenced morese code map container with the
    // morse code translation table.
    void InitMorseMap(MorseCodeMap &morse_code_map)
    {
      // The total number of stored substitution values for morse code.
      int max = sizeof(_morsetext) / sizeof(_morsetext[0]);
      for (int i = 0; i < max; ++i) morse_code_map[_plaintext[i]] = _morsetext[i];
    }
  }; // MorseCode Class

} // morse_code Namespace

// ----------------------------------------------------------------------------------------------------

int main()
{
  std::string original("Test by 0xDEAD10CC.");
  morse_code::MorseCode morse(original);
  std::string morse_string = morse.TranslateToMorse();
  std::cout << morse_string << std::endl;
  // morse::MorseCode::PlayMorseString(morse_string, 750, 1025, 200);
}

Code:

Dictionary<char, string> morseMap = new Dictionary<char, 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', "--.."},
  {'0', "-----"},
  {'1', ".----"},
  {'2', "..---"},
  {'3', "...--"},
  {'4', "....-"},
  {'5', "....."},
  {'6', "-...."},
  {'7', "--..."},
  {'8', "---.."},
  {'9', "----."}
};

string plainText = "This is a simple test by 0xDEAD10CC";
StringBuilder sb = new StringBuilder();
foreach (var c in plainText)
{
  if (c == ' ') {
    sb.Append(' ', 6); // minus 1 space because all other chars are padded with a space anyways
    continue;
  }
  // You can do whatever for a value which can't be mapped to morse code
  char upperChar = char.ToUpper(c);
  sb.AppendFormat("{0} ", morseMap.ContainsKey(upperChar) ? morseMap[upperChar] : "?????");
}
Console.WriteLine(sb);

Code:

string plainText = "This is a simple test by 0xDEAD10CC";
Console.WriteLine(string.Join(
                    new string(' ', 7),
                    plainText.Split(' ').Select(w => string.Join(" ", w.Select(c => morseMap.ContainsKey(char.ToUpper(c)) ? morseMap[char.ToUpper(c)] : "????")))
                  )
                 );

Code:

class MorseCodeConverter {
  Dictionary<char, string> morseMap = new Dictionary<char, 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', "--.."},
    {'0', "-----"},
    {'1', ".----"},
    {'2', "..---"},
    {'3', "...--"},
    {'4', "....-"},
    {'5', "....."},
    {'6', "-...."},
    {'7', "--..."},
    {'8', "---.."},
    {'9', "----."}
  };

  public string this[char key]
  {
    get {
      char c = char.ToUpper(key);
      if (morseMap.ContainsKey(c)) return morseMap[c];
      return "????";
    }
  }
  public char this[string val]
  {
    get {
      if (morseMap.ContainsValue(val))
        return morseMap.First(kv => kv.Value.Equals(val, StringComparison.OrdinalIgnoreCase)).Key;
      return '?';
    }
  }
}