O código Morse sem espaços é exclusivamente decifrável?

Todas as seqüências de código Morse são decifráveis ​​de maneira única? Sem os espaços,

......-...-..---.-----.-..-..-..

poderia ser, Hello Worldmas talvez a primeira letra seja uma 5- na verdade, parece muito improvável que uma sequência arbitrária de pontos e traços deva ter uma tradução única.

Pode-se usar a desigualdade de Kraft, mas isso só se aplica aos códigos de prefixo .

Código morse com espaços é o código de prefixo no qual as mensagens sempre podem ser decodificadas exclusivamente. Depois que removemos os espaços, isso não é mais verdade.

Caso eu esteja certo, e todas as mensagens do código Morse não possam ser decodificadas exclusivamente, existe uma maneira de listar todas as mensagens possíveis? Aqui estão alguns exercícios relacionados que encontrei no codegolf.SE

• https://codegolf.stackexchange.com/questions/36735/morse-decode-golf
• https://codegolf.stackexchange.com/questions/131/morse-code-translator

A seguir, são duas mensagens plausíveis, mas com um significado completamente diferente:

SOS HELP      = ...---...  .... . .-.. .--.        => ...---.........-...--.
I AM HIS DATE = ..  .- --  .... .. ...  -.. .- - . => ...---.........-...--.

Citando David Richerby dos comentários:

$\{E,T\}^*$

$\{A,I,M,N\}^*\{E,T\}?$

Aqui está um JavaScript que mostra todas as interpretações possíveis de uma sequência de caracteres de .e -. Seqüências de caracteres de até 22 caracteres são executadas em menos de um segundo, mas qualquer coisa maior do que isso começa a ficar bem lenta - eu não tentaria, por exemplo, decodificar HELLO WORLD com ela. Você pode abrir um console JavaScript no navegador, colá-lo e chamar, por exemplo decode('......-...-..---'),. (Neste exemplo, a entrada # 2446 é a sequência pretendida "HELLO".)

var decode = function(code) {
  var cache = {
    '0': ['']
  };
  for(var start = 0;start < code.length;start++) {
    for(var len = 1;len < 6;len++) {
      if(start + len > code.length) continue;
      if(!cache[start + len]) cache[start + len] = [];
      var curCode = code.slice(start, start + len);
      if(dict[curCode]) {
        for(var i_start = 0;i_start < cache[start].length;i_start++) {
          cache[start + len].push(cache[start][i_start] + dict[curCode]);
        }
      }
    }
  }
  return cache[code.length];
};

var dict = {
  '.-': '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'
};

O código para removê-lo apenas para seqüências de palavras reais é um pouco mais longo, então eu o coloco aqui . Ele é executado em node.js e espera um arquivo em /usr/share/dict/words-2500. O dicionário que estou usando pode ser encontrado aqui . Não é ingênuo - corta como vai, por isso corre muito mais rápido em entradas maiores.

O dicionário consiste em uma lista das 2.500 palavras que encontrei na Internet em algum lugar, menos algumas combinações de 1, 2 e 3 letras que não considerava palavras. Esse algoritmo é sensível a ter muitas palavras curtas para escolher e diminui drasticamente se você permitir, digamos, cada letra individual como uma palavra (estou olhando para você /usr/share/dict/words).

O algoritmo termina classificando com base no número de palavras, portanto, as "interessantes" devem estar no topo. Isso funciona muito bem HELLO WORLD, rodando em menos de um segundo e retornando a frase esperada como o primeiro hit. Com isso, também aprendi que DATA SCIENTIST(a única outra frase que tentei) os códigos morse são iguais a NEW REAL INDIA.

Edit: Eu procurei por mais interessantes por alguns minutos. As palavras SPACESe SWITCHsão morsagramas. Até agora, eles são o par mais longo de uma palavra que encontrei.

Basta observar que certas combinações curtas de letras produzem decodificações ambíguas. Uma única sequência ambígua é suficiente, mas posso ver o seguinte:

ATE ~ P
EA ~ IT
MO ~ OM

etc. Como David Richerby observa nos comentários, qualquer letra é equivalente a uma sequência de Es e Ts, o que torna o Código Morse ambíguo como uma maneira de codificar seqüências arbitrárias de letras; as combinações acima mostram que isso é verdade mesmo em combinações plausíveis de letras em inglês (por exemplo, MEAT~ MITT). Talvez um exercício de codificação interessante seja encontrar todas as seqüências de cinco ou menos letras que possam ser confundidas com outra coisa, restringindo as combinações de letras que podem ser encontradas no texto em inglês (usando uma ou mais palavras), agrupadas por classe de equivalência.

Usando seu exemplo original, também acontece que

HELLO WORLD ~ HAS TEAM NO MAID TOE

e, embora o lado direito seja talvez irreal, mesmo como uma mensagem parcial, é certamente uma sequência de palavras em inglês, que pode ser encontrada em menos de 15 minutos sem a ajuda do computador. Isso pode ser tomado como evidência de que muitas frases em inglês podem ser interpretadas incorretamente como uma sequência diferente (possivelmente sem sentido) de palavras em inglês.

O Código Morse é na verdade um código ternário, não um código binário, portanto os espaços são necessários. Se os espaços não existissem, haveria muita ambiguidade, não tanto com a mensagem inteira, mas com letras individuais.

Por exemplo, 2 pontos é um I, mas 3 pontos é um S. Se você está transcrevendo e ouve dois pontos, escreve imediatamente "I" ou espera até ouvir outro ponto (ou traço)?

A resposta é que cada valor é separado por espaço, para que sejam agrupados. Quando os operadores digitam mensagens em Morse, eles fazem uma pausa do mesmo tamanho que um hífen após cada sequência de código de letras para indicar o fim da sequência.

Mesmo se você escrevesse um programa de IA para analisar uma frase completa de cada vez e descobrir qual era a interpretação lógica da mensagem, ainda haveria muitas ambiguidades e erros de ortografia que

algumas notas não abordadas em outras (boas) respostas, mas que geralmente não pesquisam conhecimentos prévios e citam qualquer coisa (para mim uma parte intrínseca da ciência da computação ).

• essa teoria geral do CS se enquadra na categoria de segmentação de texto e também de "divisão de palavras" / "desambiguação", embora a teoria seja um pouco diferente, trata-se de dividir seqüências de símbolos em palavras (com letras variáveis), etc., onde os símbolos são unidades. aqui as strings são divididas em letras em que as letras têm comprimento variável, mas a teoria é análoga, embora não seja exatamente 1-1. ou seja, mapeamento entre sentenças em palavras, comprimento variável da palavra-letra e sentenças em palavras, comprimento variável da palavra / letra.

• como outros já apontaram, isso pode ser estudado empiricamente. e alguém fez isso de um ângulo (existem várias maneiras de estudar isso) e "publicou" os resultados em uma página da web com um grande diretório / tabela de resultados.

  Encontrei 25.787 palavras ambíguas do código Morse. Isso é feito de 10.330 seqüências Morse distintas. A palavra Morse ambígua de maior frequência possui 13 palavras possíveis de doadores. Os resultados estão agrupados abaixo em tabelas com base na frequência de palavras que compartilham a mesma representação Morse.

• uau, "o contexto importa" ... uma pergunta quase idêntica "traduzindo código morse sem espaços" no stackoverflow de 3 anos atrás atualmente tem 0 votos.

Em geral, existem exponencialmente muitas decodificações possíveis, mas se você realmente quiser, pode listar todas elas. Você também pode listá-los de maneira sucinta, ou seja, fornecer uma representação sucinta de todos eles. Como isso não passa de um exercício de programação, eu desafio você a fazer isso sozinho.

Dito isto, o fato de haver ambiguidade não impede a capacidade de decifrar a mensagem, ou pelo menos grandes partes da mensagem. Assumindo um modelo probabilístico para o texto representado pelo código Morse - por definição, podemos assumir que é inglês e usar propriedades estatísticas do inglês - pode ser possível decodificar essencialmente a mensagem, embora algumas ambiguidades locais possam ser inevitáveis. A razão é que a maioria das decodificações corresponde a texto sem sentido. A maneira de fazer isso é estender o algoritmo de programação dinâmica do parágrafo anterior para estimar a probabilidade de cada decodificação e, em seguida, escolher a decodificação de probabilidade máxima. Essa abordagem tem mais chances de ter sucesso à medida que a mensagem fica mais longa.

Como definir / reconhecer / gerar o idioma de todas as decodificações possíveis.

Claramente, sem espaços, o código morse não é mais decifrável exclusivamente.

No entanto, é possível fornecer de forma condensada todas as formas possíveis de decodificá-lo. Na verdade, isso é semelhante ao que é feito no processamento de fala: a partir de um fluxo único de sons (ou de fonemas), você precisa encontrar todas as maneiras pelas quais ele pode ser decomposto em uma sequência de palavras. Os algoritmos para fazer isso produzem o que é chamado de treliça de palavras. Você encontrará um exemplo na seção "ambiguidade lexical" desta resposta .

No caso do código Morse binário (sem espaços), você tem apenas pontos e traços, mas o problema é o mesmo.

A maneira como você pode obter todas as traduções é a seguinte.

$T$

$w$$n$$W$$n+1$$0$$n$$L=\{w\}=\mathcal L(W)$$T(L)$$T(L)$

$T$$W$$T$$W$

Os detalhes são facilmente resolvidos. Mas pergunte se você precisa de mais.

Algum pseudo-código para um solucionador que dará todas as interpretações possíveis. Isso se baseia em algumas reflexões rápidas, portanto contribuições adicionais serão bem-vindas. O método aceita duas entradas, uma do texto traduzido até agora e a segunda do código morse.

MorseSolver (string textSoFar, string codeRemaining)
{
    if(codeRemaining length == 0) output textSoFar
    else
    {
        codeLength = length of code remaining
        read 1 through (min of 5 or codeLength) characters from codeRemaining
        for each set of characters
        {
            call an IsMorseCode method that checks if the characters 
              input are valid morse code
            if they are valid add the translated character to textSoFar 
              and remove the characters from codeRemaining, then call 
              the MorseSolver again with the new strings)
        }

}

Isso produzirá todas as combinações possíveis de letras e números sem espaços entre as "palavras". Se você quisesse provar a ambiguidade, isso certamente o faria. Se você deseja receber algumas mensagens significativas, tente procurar um código destinado a traduzir hashtags em linguagem legível.

Usando o acima, eu escrevi um programa em C # que faz o acima. Eu parei de rodar em 22 milhões de possibilidades para a string acima que pode ser traduzida para olá mundo. O equivalente do código Morse a "Hello" resultou em 20.569 resultados possíveis. Eu também não incluí os números. Isso seria maior se eu permitisse.