c++ 摩尔斯电码

2024-01-13 10:36
文章标签 c++ 摩尔 电码

本文主要是介绍c++ 摩尔斯电码，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

        摩尔斯电码是一种字符编码方式，使用不同长度的信号来表示不同的字母、数字和标点符号。它由美国发明家塞缪尔·摩尔斯和阿尔弗雷德·维尔斯利于1836年设计。

        摩尔斯电码使用两种信号表示，一种是点（.），代表短信号，另一种是线（-），代表长信号。字母和数字由若干个点和线的组合表示，不同的字符之间用空格隔开。

摩尔斯电码的编码规则如下：

1、字母A-Z和数字0-9分别对应不同的摩尔斯电码序列。
2、信号之间的间隔用空格表示。
3、单词之间用空格或斜杠表示。
下面是一些常见字符的摩尔斯电码编码示例：

  • 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: ----.

        通过解码摩尔斯电码，可以将摩尔斯电码转换回原始文本，以实现信息的传输和交流。 

示例一：

/**
 * @file
 * @author [Deep Raval](https://github.com/imdeep2905)
 *
 * @brief Implementation of [Morse Code]
 * (https://en.wikipedia.org/wiki/Morse_code).
 *
 * @details
 * Morse code is a method used in telecommunication to encode text characters
 * as standardized sequences of two different signal durations, called dots
 * and dashes or dits and dahs. Morse code is named after Samuel Morse, an
 * inventor of the telegraph.
 */
#include <cassert>
#include <iostream>
#include <string>
#include <vector>

/** \namespace ciphers
 * \brief Algorithms for encryption and decryption
 */
namespace ciphers {
/** \namespace morse
 * \brief Functions for [Morse Code]
 * (https://en.wikipedia.org/wiki/Morse_code).
 */
namespace morse {
/**
 * Get the morse representation for given character.
 * @param c Character
 * @returns morse representation string of character
 */
std::string char_to_morse(const char &c) {
    // return corresponding morse code
    switch (c) {
        case 'a':
            return ".-";
        case 'b':
            return "-...";
        case 'c':
            return "-.-.";
        case 'd':
            return "-..";
        case 'e':
            return ".";
        case 'f':
            return "..-.";
        case 'g':
            return "--.";
        case 'h':
            return "....";
        case 'i':
            return "..";
        case 'j':
            return ".---";
        case 'k':
            return "-.-";
        case 'l':
            return ".-..";
        case 'm':
            return "--";
        case 'n':
            return "-.";
        case 'o':
            return "---";
        case 'p':
            return ".--.";
        case 'q':
            return "--.-";
        case 'r':
            return ".-.";
        case 's':
            return "...";
        case 't':
            return "-";
        case 'u':
            return "..-";
        case 'v':
            return "...-";
        case 'w':
            return ".--";
        case 'x':
            return "-..-";
        case 'y':
            return "-.--";
        case 'z':
            return "--..";
        case '1':
            return ".----";
        case '2':
            return "..---";
        case '3':
            return "...--";
        case '4':
            return "....-";
        case '5':
            return ".....";
        case '6':
            return "-....";
        case '7':
            return "--...";
        case '8':
            return "---..";
        case '9':
            return "----.";
        case '0':
            return "-----";
        default:
            std::cerr << "Found invalid character: " << c << ' ' << std::endl;
            std::exit(0);
    }
}
/**
 * Get character from the morse representation.
 * @param s Morse representation
 * @returns corresponding character
 */
char morse_to_char(const std::string &s) {
    // return corresponding character
    if (s == ".-") {
        return 'a';
    } else if (s == "-...") {
        return 'b';
    } else if (s == "-.-.") {
        return 'c';
    } else if (s == "-..") {
        return 'd';
    } else if (s == ".") {
        return 'e';
    } else if (s == "..-.") {
        return 'f';
    } else if (s == "--.") {
        return 'g';
    } else if (s == "....") {
        return 'h';
    } else if (s == "..") {
        return 'i';
    } else if (s == ".---") {
        return 'j';
    } else if (s == "-.-") {
        return 'k';
    } else if (s == ".-..") {
        return 'l';
    } else if (s == "--") {
        return 'm';
    } else if (s == "-.") {
        return 'n';
    } else if (s == "---") {
        return 'o';
    } else if (s == ".--.") {
        return 'p';
    } else if (s == "--.-") {
        return 'q';
    } else if (s == ".-.") {
        return 'r';
    } else if (s == "...") {
        return 's';
    } else if (s == "-") {
        return 't';
    } else if (s == "..-") {
        return 'u';
    } else if (s == "...-") {
        return 'v';
    } else if (s == ".--") {
        return 'w';
    } else if (s == "-..-") {
        return 'x';
    } else if (s == "-.--") {
        return 'y';
    } else if (s == "--..") {
        return 'z';
    } else if (s == ".----") {
        return '1';
    } else if (s == "..---") {
        return '2';
    } else if (s == "...--") {
        return '3';
    } else if (s == "....-") {
        return '4';
    } else if (s == ".....") {
        return '5';
    } else if (s == "-....") {
        return '6';
    } else if (s == "--...") {
        return '7';
    } else if (s == "---..") {
        return '8';
    } else if (s == "----.") {
        return '9';
    } else if (s == "-----") {
        return '0';
    } else {
        std::cerr << "Found invalid Morse code: " << s << ' ' << std::endl;
        std::exit(0);
    }
}
/**
 * Encrypt given text using morse code.
 * @param text text to be encrypted
 * @returns new encrypted text
 */
std::string encrypt(const std::string &text) {
    std::string encrypted_text = "";  // Empty string to store encrypted text
    // Going through each character of text and converting it
    // to morse representation
    for (const char &c : text) {
        encrypted_text += ciphers::morse::char_to_morse(c) + " ";
    }
    return encrypted_text;  // Returning encrypted text
}
/**
 * Decrypt given morse coded text.
 * @param text text to be decrypted
 * @returns new decrypted text
 */
std::string decrypt(const std::string &text) {
    // Going through each character of text and converting it
    // back to normal representation.
    std::string decrypted_text = "";  // Empty string to store decrypted text
    // Spliting string (with delimiter = " ") and storing it
    // in vector
    std::size_t pos_start = 0, pos_end = 0, delim_len = 1;
    std::vector<std::string> splits;
    while ((pos_end = text.find(' ', pos_start)) != std::string::npos) {
        std::string token = text.substr(pos_start, pos_end - pos_start);
        pos_start = pos_end + delim_len;
        splits.push_back(token);
    }

    // Traversing through each morse code string
    for (const std::string &s : splits) {
        // Add corresponding character
        decrypted_text += ciphers::morse::morse_to_char(s);
    }

    return decrypted_text;  // Returning decrypted text
}
}  // namespace morse
}  // namespace ciphers

/**
 * @brief Function to test above algorithm
 * @returns void
 */
static void test() {
    // Test 1
    std::string text1 = "01234567890";
    std::string encrypted1 = ciphers::morse::encrypt(text1);
    std::string decrypted1 = ciphers::morse::decrypt(encrypted1);
    assert(text1 == decrypted1);
    std::cout << "Original text : " << text1 << std::endl;
    std::cout << "Encrypted text : " << encrypted1 << std::endl;
    std::cout << "Decrypted text : " << decrypted1 << std::endl;
    // Test 2
    std::string text2 = "abcdefghijklmnopqrstuvwxyz";
    std::string encrypted2 = ciphers::morse::encrypt(text2);
    std::string decrypted2 = ciphers::morse::decrypt(encrypted2);
    assert(text2 == decrypted2);
    std::cout << "Original text : " << text2 << std::endl;
    std::cout << "Encrypted text : " << encrypted2 << std::endl;
    std::cout << "Decrypted text : " << decrypted2 << std::endl;
}

/**
 * @brief Main function
 * @returns 0 on exit
 */
int main() {
    // Testing
    test();
    return 0;
}

示例二：

实现摩尔斯电码编码和解码的C++示例：

#include <iostream>
#include <map>
#include <string>
#include <sstream>
#include <algorithm>

std::map<char, std::string> morseCode = {
  {'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 encodeToMorseCode(const std::string& text) {
  std::stringstream encodedText;
  for (char c : text) {
    if (morseCode.count(std::toupper(c)) > 0) {
      encodedText << morseCode[std::toupper(c)] << " ";
    }
  }
  return encodedText.str();
}

std::string decodeFromMorseCode(const std::string& morse) {
  std::stringstream decodedText;
  std::stringstream morseStream(morse);
  std::string code;
  while (morseStream >> code) {
    auto it = std::find_if(morseCode.begin(), morseCode.end(), [&](const auto& pair) {
      return pair.second == code;
    });
    if (it != morseCode.end()) {
      decodedText << it->first;
    }
  }
  return decodedText.str();
}

int main() {
  std::string text = "HELLO WORLD";
  std::string morse = encodeToMorseCode(text);
  std::cout << "Morse code: " << morse << std::endl;
  std::string decodedText = decodeFromMorseCode(morse);
  std::cout << "Decoded text: " << decodedText << std::endl;
  return 0;
}
        在上述示例中，`encodeToMorseCode`函数接受一个字符串作为输入，并将其转换为摩尔斯电码。`decodeFromMorseCode`函数接受一个摩尔斯电码字符串，并将其解码为原始文本。

        在主函数中，我们将字符串"HELLO WORLD"编码为摩尔斯电码，并将其解码回原始文本。最后，我们输出编码后的摩尔斯电码和解码后的文本。

这篇关于c++ 摩尔斯电码的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/601164。

相关文章

【C++ Primer Plus习题】13.4

【C++ Primer Plus习题】13.4

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: main.cpp #include <iostream>#include "port.h"int main() {Port p1;Port p2("Abc", "Bcc", 30);std::cout <<
阅读更多...
C++包装器

C++包装器

包装器 在 C++ 中，“包装器”通常指的是一种设计模式或编程技巧，用于封装其他代码或对象，使其更易于使用、管理或扩展。包装器的概念在编程中非常普遍，可以用于函数、类、库等多个方面。下面是几个常见的 “包装器” 类型： 1. 函数包装器 函数包装器用于封装一个或多个函数，使其接口更统一或更便于调用。例如，std::function 是一个通用的函数包装器，它可以存储任意可调用对象（函数、函数
阅读更多...
C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页： 南桥几晴秋 🌈C++专栏： 南桥谈C++ 🌈C语言专栏： C语言学习系列 🌈Linux学习专栏： 南桥谈Linux 🌈数据结构学习专栏： 数据结构杂谈 🌈数据库学习专栏： 南桥谈MySQL 🌈Qt学习专栏： 南桥谈Qt 🌈菜鸡代码练习： 练习随想记录 🌈git学习： 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�
阅读更多...
【C++】_list常用方法解析及模拟实现

【C++】_list常用方法解析及模拟实现

相信自己的力量，只要对自己始终保持信心，尽自己最大努力去完成任何事，就算事情最终结果是失败了，努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一：什么是list？ •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二：list常用接口 •🌰1.默认成员函数 🔥构造函数（⭐） 🔥析构函数 •🌰2.list对象
阅读更多...
06 C++Lambda表达式

06 C++Lambda表达式

lambda表达式的定义 没有显式模版形参的lambda表达式 [捕获] 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 有显式模版形参的lambda表达式 [捕获] <模版形参> 模版约束 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 含义 捕获：包含零个或者多个捕获符的逗号分隔列表 模板形参：用于泛型lambda提供个模板形参的名
阅读更多...
6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

上篇：6.1.数据结构-c/c++模拟实现堆上篇（向下，上调整算法，建堆，增删数据）-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小)： 2.2 C语言代码（手写堆） 2.3 C++代码（使用优先级队列 priority_queue）
阅读更多...
【C++高阶】C++类型转换全攻略：深入理解并高效应用

【C++高阶】C++类型转换全攻略：深入理解并高效应用

📝个人主页🌹：Eternity._ ⏩收录专栏⏪：C++ “ 登神长阶 ” 🤡往期回顾🤡：C++ 智能指针 🌹🌹期待您的关注 🌹🌹 ❀C++的类型转换 📒1. C语言中的类型转换📚2. C++强制类型转换⛰️static_cast🌞reinterpret_cast⭐const_cast🍁dynamic_cast 📜3. C++强制类型转换的原因📝
阅读更多...
C++——stack、queue的实现及deque的介绍

C++——stack、queue的实现及deque的介绍

目录 1.stack与queue的实现 1.1stack的实现  1.2 queue的实现 2.重温vector、list、stack、queue的介绍 2.1 STL标准库中stack和queue的底层结构  3.deque的简单介绍 3.1为什么选择deque作为stack和queue的底层默认容器  3.2 STL中对stack与queue的模拟实现 ①stack模拟实现
阅读更多...
c++的初始化列表与const成员

c++的初始化列表与const成员

初始化列表与const成员 const成员 使用const修饰的类、结构、联合的成员变量，在类对象创建完成前一定要初始化。 不能在构造函数中初始化const成员，因为执行构造函数时，类对象已经创建完成，只有类对象创建完成才能调用成员函数，构造函数虽然特殊但也是成员函数。 在定义const成员时进行初始化，该语法只有在C11语法标准下才支持。 初始化列表 在构造函数小括号后面，主要用于给
阅读更多...
2024/9/8 c++ smart

2024/9/8 c++ smart

1.通过自己编写的class来实现unique_ptr指针的功能 #include <iostream> using namespace std; template<class T> class unique_ptr { public:         //无参构造函数         unique_ptr();         //有参构造函数         unique_ptr(
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2