Morse Code

[48T7M4Gy]

Yes VR this is a prime example where an STL container, in this case a <map> cuts out at least 50% of the code simply because the map does all the work.

( It also depends on how the base data is stored, hard-coded or as a separate file or as structs as you can see. But it doesn't need to be complicated due to the nature of maps. )

[DirtyDan]

Well I updated my code to use maps, I chose not to go the external data file route because I used cpp.sh to write all the code since I am playing around with this at work (shhhhhhh).

So, here is the updated code...

#include <iostream>
#include <map>
#include <string>
#include <iomanip>
#include <vector>

using namespace std;

std::map <char, std::string> morseList;
std::map <std::string, char> asciiList;

//function prototypes
void displaymorse();
void load_morse();
void load_ascii_from_morse();
void englishtomorse();
void morsetoenglish();
std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems);
std::vector<std::string> split(const std::string &s, char delim);

int main()
{
    int choice=1;

    load_morse();
    load_ascii_from_morse ();
    
    std::cout << "This programm will convert a letter, number, word or phrase\n";
    std::cout << "from english to morse code, or from morse code to english.\n";
    std::cout << "Only letters and numbers are converted, others are ignored,\n";
    std::cout << "all letters are converted to lowercase automatically.\n";
    std::cout << "\n";
    
    while (choice != 0)
    {
        std::cout << "What would you like to do?\n";
        std::cout << "Enter 0 to exit...\n";
        std::cout << "Enter 1 to display the morse code table...\n";
        std::cout << "Enter 2 for english to morse code...\n";
        std::cout << "Enter 3 for morse code to english...\n";
        std::cout << "Enter your choice: ";

        std::cin >> choice;

        //if user entered something besides a number we handle it here
        //after clearing the error we set choice to 4 to inform the user
        //of an invalid entry and ask them to try again
        if(!std::cin)
        {
            std::cin.clear();
            std::cin.ignore(999,'\n');
            choice = 4;
        }
            
        std::cout << "\n";

        switch (choice)
        {
            case 0:
                std::cout << "\nGood bye\n\n\n";
                exit(0);
                break;
            case 1:
                displaymorse();
                break;
            case 2:
                englishtomorse();
                break;
            case 3:
                displaymorse();
                morsetoenglish();
                break;
            default:
                std::cout << "\nInvalid choice, please try again.\n\n\n";
                break;
        }
    }

    return 0;
}

void load_morse ()
{
    morseList[' '] = " ";
    morseList['0'] = "-----";
    morseList['1'] = ".----";
    morseList['2'] = "..---";
    morseList['3'] = "...--";
    morseList['4'] = "....-";
    morseList['5'] = ".....";
    morseList['6'] = "-....";
    morseList['7'] = "--...";
    morseList['8'] = "---..";
    morseList['9'] = "----.";
    morseList['a'] = ".-";
    morseList['b'] = "-...";
    morseList['c'] = "-.-.";
    morseList['d'] = "-..";
    morseList['e'] = ".";
    morseList['f'] = "..-.";
    morseList['g'] = "--.";
    morseList['h'] = "....";
    morseList['i'] = "..";
    morseList['j'] = ".---";
    morseList['k'] = "-.-";
    morseList['l'] = ".-..";
    morseList['m'] = "--";
    morseList['n'] = "-.";
    morseList['o'] = "---";
    morseList['p'] = ".--.";
    morseList['q'] = "--.-";
    morseList['r'] = ".-.";
    morseList['s'] = "...";
    morseList['t'] = "-";
    morseList['u'] = "..-";
    morseList['v'] = "...-";
    morseList['w'] = ".--";
    morseList['x'] = "-..-";
    morseList['y'] = "-.--";
    morseList['z'] = "--..";
}
    
void load_ascii_from_morse ()
{
    for (auto& x: morseList)
    {
        std::pair<std::string,char> pr (x.second, x.first);
        asciiList.insert (pr);
    }
}

void displaymorse()
{
    int counter = 1;
    const int width = 8;
    for (auto& x: morseList)
    {
        if (x.first != ' ')  //skip the space
        {
            std::cout << x.first << " = " << setw(width) << left << x.second;
            ++counter;
            if (counter > 6)
            {
                cout << endl;
                counter = 1;
            }
        }
    }
    cout << endl << endl;
}

void englishtomorse()
{
    std::string input = "";
    std::vector<char> notFoundItems;
    
    std::cout << "Enter a letter, number, word, or phrase to convert to morse code: ";
    std::cin.ignore();//clear any newlines cin may have left behind
    getline(std::cin, input, '\n');

    std::cout << "Desired input for translation: \"" << input << "\"\n";
    std::cout << "Morse code output: ";

    for(std::string::iterator it=input.begin(); it!=input.end(); ++it)
    {
        if (morseList.find(*it) == morseList.end())
        {
            //item was not found in the list
            //store it in a vector to report back to user
            notFoundItems.push_back(*it);
        } else {
            cout << morseList.find(*it)->second;
        }
    }

    if(notFoundItems.size() != 0)
    {
        std::cout << "\nThe following items were ignored: ";
        for(unsigned int i = 0; i<notFoundItems.size(); i++)
        {
            std::cout << "\"" << notFoundItems[i] << "\" ";
        }
    }
    std::cout << "\n\n\n";
}

void morsetoenglish()
{
    std::string input = "";
    std::vector<std::string> morse;
    std::vector<std::string> notFoundItems;

    
    std::cout << "Enter a letter, number, word, or phrase to convert to morse code: ";
    std::cin.ignore();//clear any newlines cin may have left behind
    getline(std::cin, input, '\n');

    std::cout << "User input for translation: \"" << input << "\"\n";
    std::cout << "Morse code output: ";

    morse = split(input, ' ');
    for(unsigned int i = 0; i<morse.size(); i++)
    {
        if(morse[i] == "")
        {
            std::cout << " ";
        }
        input = morse[i];

        if (asciiList.find(morse[i]) == asciiList.end())
        {
            //item was not found in the list
            //store it in a vector to report back to user
            if (morse[i] != "") {notFoundItems.push_back(morse[i]);}
        } else {
            cout << asciiList.find(morse[i])->second;
        }
    }

    if(notFoundItems.size() != 0)
    {
        std::cout << "\nThe following items were ignored: ";
        for(unsigned int i = 0; i<notFoundItems.size(); i++)
        {
            std::cout << "\"" << notFoundItems[i] << "\" ";
        }
    }

    std::cout << "\n\n\n";
}

std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems)
{
    std::stringstream ss(s);
    std::string item;
    while (std::getline(ss, item, delim))
    {
        elems.push_back(item);
    }
    return elems;
}

std::vector<std::string> split(const std::string &s, char delim)
{
    std::vector<std::string> elems;
    split(s, delim, elems);
    return elems;
}

[48T7M4Gy]

#include <iostream>
#include <map>
#include <string>

void display_menu();

int main()
{
    char aKey[] =
    {
        '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'
    };
    
    std::string mKey[] =
    {
        ".-","-...","-.-.","-..",".","..-.","--.","....","..",".---",
        "-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-",
        "..-","...-",".--","-..-","-.--","--..","-----",".----",
        "..---","...--","....-",".....","-....","--...","---..","----."
    };
    
    int key_sizeA = sizeof(aKey)/sizeof(char);
    
    std::map<char, std::string> alpha_to_morse;
    std::map<char, std::string>::iterator it_a_m;
    char alpha_input;
    
    std::map< std::string, char> morse_to_alpha;
    std::map< std::string, char>::iterator it_m_a;
    std::string morse_input;
    
    display_menu();
    char option = 'x';
    
    for(int i = 0; i < key_sizeA; i++)
    {
        alpha_to_morse.insert(std::pair<char, std::string>(aKey[i],mKey[i]) );
        morse_to_alpha.insert(std::pair<std::string,char>(mKey[i],aKey[i]) );
    }
    
    while ( std::cin >> option && tolower(option) != 'q')
    {
        switch(option)
        {
            case '1':
                std::cout << "Please enter alpha characters, / to end:\n";
                while( std::cin.get(alpha_input) && alpha_input != '/' )
                {
                    if(alpha_input == ' ')
                        std::cout << '|'; // vertical bar to separate words
                    
                    it_a_m = alpha_to_morse.find(alpha_input);
                    std::cout << it_a_m -> second << ' ';
                }
                break;
                
            case '2':
                std::cout << "Please enter morse string:\n";
                while( std::cin >> morse_input && morse_input != "/" )
                {
                    if(morse_input == "|")
                        std::cout << " ";
                    else
                    {
                        it_m_a = morse_to_alpha.find(morse_input);
                        std::cout << it_m_a -> second;
                    }
                }
                break;
                
            default:
                std::cout << "Invalid choice\n";
        }
        display_menu();
    }
    
    return 0;
}

void display_menu()
{
    std::cout << "*********************\n";
    std::cout << "* 1. alpha -> morse *\n";
    std::cout << "* 2. morse -> alpha *\n";
    std::cout << "* q  Quit program   *\n";
    std::cout << "*********************\n";
}