js расшифровка азбуки Морзе

Вот метод, который использует .map(), .split() и .join().

function decodeMorse(morseCode) {
  var ref = { 
    '.-':     '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',
    '.----':  '1',
    '..---':  '2',
    '...--':  '3',
    '....-':  '4',
    '.....':  '5',
    '-....':  '6',
    '--...':  '7',
    '---..':  '8',
    '----.':  '9',
    '-----':  '0',
  };

  return morseCode
    .split('   ')
    .map(
      a => a
        .split(' ')
        .map(
          b => ref[b]
        ).join('')
    ).join(' ');
}

var decoded = decodeMorse(".-- --- .-. -..   .-- --- .-. -..");
console.log(decoded);

Возможно, вместо этого есть две вложенные петли. Внешний цикл разбивает азбуку Морзе на три пробела, а внутренний цикл разбивает слово на один пробел. Это проанализирует букву, затем вы сможете сопоставить буквенно-цифровой символ, используя перечисление букв кода Морзе.

// message = Halp! Morse code is driving me nuts!
var message = ".... .- .-.. .--. -·-·--     -- --- .-. ... .     -.-. --- -.. .     .. ...     -.. .-. .. ...- .. -. --.     -- .     -. ..- - ... -·-·--"; 
var alphabet = {  
   "-----":"0",
   ".----":"1",
   "..---":"2",
   "...--":"3",
   "....-":"4",
   ".....":"5",
   "-....":"6",
   "--...":"7",
   "---..":"8",
   "----.":"9",
   ".-":"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 messageConverted = [];

message.split("   ").map(function (word) {
    word.split(" ").map(function (letter) {
        messageConverted.push(alphabet[letter]);
    });
    messageConverted.push(" ");
});
 
console.log(messageConverted.join(""));

Или что-то вроде того. Это перечисление не полное (заглавные буквы, знаки препинания), но вы поняли.

decodeMorse = function( morseCode ) {
    return morseCode
             .split("   ") // get word code 3 spaces apart
             .map(word => word
                           .split(" ") // get character code 1 spaces apart
                           .map(character => MORSE_CODE[character]) // decode Morse code character
                           .join('')
              )
              .join(' ') // add spaces between words 
              .trim()
}

decodeMorse('.... . -.--   .--- ..- -.. .') // "HEY JUDE"
decodeMorse(' . ') // "E"

Он отлично работает на codewars.com. Если не codewars.com, вам необходимо определить символы Морзе:

    var MORSE_CODE = {  
        "-----":"0",
        ".----":"1",
        "..---":"2",
        "...--":"3",
        "....-":"4",
        ".....":"5",
        "-....":"6",
        "--...":"7",
        "---..":"8",
        "----.":"9",
        ".-":"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 message = ".... .- .-.. .--. -.-.--     -- --- .-. ... .     -.-. --- -.. .     .. ...     -.. .-. .. ...- .. -. --.     -- .     -. ..- - ... -.-.--"; 

Словарь Морзе:

var dictionary= {  
   "-----":"0",
   ".----":"1",
   "..---":"2",
   "...--":"3",
   "....-":"4",
   ".....":"5",
   "-....":"6",
   "--...":"7",
   "---..":"8",
   "----.":"9",
   ".-":"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 representation = message.replace(/([.-]+[-.]*)/g, (_, x) =>dictionary [x]);
console.log(representation);

Другое решение, основанное на 2 циклах. Разделение слов в азбуке Морзе осуществляется с помощью split(" ") - (с 3 знаками разделения) - который разбивает азбуку Морзе на слова, когда он распознает 3 знака разделения. Теперь у вас есть массив x строк. Чтобы получить доступ к каждому элементу (букве) в азбуке Морзе, вы должны сделать еще одно разделение, зациклившись на массиве строк (вы можете использовать «карту»), но теперь с разделением («») - (с 1 разделением знаки). теперь у вас есть массив, содержащий вложенные массивы, каждый из которых представляет слово (конечно, в коде Морзе). Чтобы перебрать словарь азбуки Морзе (объект), вы можете преобразовать его в массив с помощью Object.keys и т. д., а затем найти конкретную букву (в Морзе) в преобразованном массиве (искать конкретный ключ).

пример азбуки Морзе:

 decodeMorse('.... . -.--   .--- ..- -.. .');
 //should return:"HEY JUDE"

функция:

decodeMorse = function(morseCode){ 
  var ind=0;
  var answer = [];
  const TOT_MORSE_CODE = {
  ".-": "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", ".---- 
  ":"1", "..---":"2", "...--":"3", "....-":"4", ".....":"5", 
  "-....":"6", "--...":"7", "---..":"8", "----.":"9", "----- 
  ":"0", "|":" "
  };

  const moerse_keys = Object.keys(TOT_MORSE_CODE);/*converting 
  the object into an array*/
  const moerse_values = Object.values(TOT_MORSE_CODE);
  var words_in_morse = morseCode.split ('   ');
  /*sperating the morse code by words*/
  var letters_in_morse = 
       words_in_morse.map(word => word.split(' '));
  /*sperating the morse code by letters for each word*/


  for (i=0 ; i<letters_in_morse.length ; i++) {
    for (j=0 ; j<letters_in_morse[i].length ; j++) {
       if ( moerse_keys.includes(letters_in_morse[i][j]) ) {
         ind = moerse_keys.indexOf( letters_in_morse[i][j] );
         answer.push(moerse_values[ind]);
       }
       if (j===letters_in_morse[i].length-1 ) { /*for seperate 
          words by ' '*/
          answer.push(' ');
       }
    }
  }

  answer.pop(); /*to remove the last ' ' (avoiding getting 
  "HEY JUDE ")*/
  return answer.join('').toUpperCase();
}

let STR = "hello".split("");
// % = space
let morse = ".-%-...%-.-.%-..%.%..-%--.%....%..%.---%-.-%.-..%--%-.%---%.--.%--.-%.-.%...%-%..-%...-%.--%-..-%-.--%--..".split("%");
let alphabet = "abcdefghijklmnopqrstuvwxyz".split("")

let output = [];

for(let i = 0; i < STR.length; i++){
    output.push(morse[alphabet.indexOf(STR[i])])
}

console.log(output.join(" "));

Это сделано для одного слова в нижнем регистре, как видите, оно преобразует текст в азбуку Морзе, вместо преобразования морзе в текст

Вот метод, который использует .map(), .split(), .join() и .trim(). Он отлично работает для меня на codewars. Таблица азбуки Морзе предварительно загружена для вас как словарь на MORSE_CODE.. поэтому нет необходимости писать весь словарь, как я сделал в этом примере.

function decodeMorse(morseCode) {
  var letter = { 
    '.-':     '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',
    '.----':  '1',
    '..---':  '2',
    '...--':  '3',
    '....-':  '4',
    '.....':  '5',
    '-....':  '6',
    '--...':  '7',
    '---..':  '8',
    '----.':  '9',
    '-----':  '0',
  };

  return morseCode
    .split('   ')
    .map(
      a => a
        .split(' ')
        .map(
          b => letters[b]
        ).join('')
    ).join(' ')
    .trim() ;
}
var decoded = decodeMorse("   .-- --- .-. -..   .-- --- .-. -..");
console.log(decoded);

Простой пример C# можно найти по адресу https://github.com/zizwiz/Convert-Text-to-Morse-and-Play-it Позволяет преобразовывать текст в азбуку Морзе, а азбуку Морзе преобразовывать в текст, а также воспроизводить азбуку Морзе.

Использует интервалы следующим образом

<summary>
Dot = 1 unit
Dash = 3 units

Between dots and dashes in letter = 1 unit
Between Chars = 3 units
Between words = 7 units
</summary>