Il codice Morse senza spazi è decifrabile in modo univoco?

Tutte le stringhe di codice Morse sono decifrabili in modo univoco? Senza gli spazi,

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

potrebbe essere, Hello Worldma forse la prima lettera è un 5: in effetti sembra molto improbabile che una sequenza arbitraria di punti e trattini debba avere una traduzione unica.

Si potrebbe eventualmente usare la disuguaglianza di Kraft ma ciò vale solo per i codici prefisso .

Il codice Morse con spazi è il prefisso in cui i messaggi possono sempre essere decodificati in modo univoco. Una volta rimossi gli spazi, questo non è più vero.

Nel caso in cui abbia ragione, e tutti i messaggi in codice Morse non possano essere decodificati in modo univoco, c'è un modo per elencare tutti i messaggi possibili? Ecco alcuni esercizi correlati che ho trovato su codegolf.SE

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

I seguenti sono entrambi messaggi plausibili, ma hanno un significato completamente diverso:

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

Citando David Richerby dai commenti:

Poiché ⋅ rappresenta E e - rappresenta T, qualsiasi messaggio Morse senza spazi può essere interpretato come una stringa in $\{E,T\}^*$

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

Ecco alcuni JavaScript che ti diranno tutte le possibili interpretazioni di una stringa di .e -. Stringhe fino alla lunghezza 22 arrivano in meno di un secondo, ma qualsiasi cosa più alta di questa inizia a diventare piuttosto lenta - ad esempio, non proverei a decodificare HELLO WORLD con esso. Puoi aprire una console JavaScript nel tuo browser, incollarla e quindi chiamare, ad esempio decode('......-...-..---'),. (In questo esempio, la voce # 2446 è la stringa desiderata "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'
};

Il codice per potarlo a sole stringhe di parole reali è un po 'più lungo, quindi l'ho messo qui . Funziona con node.js e si aspetta un file su /usr/share/dict/words-2500. Il dizionario che sto usando può essere trovato qui . Non è ingenuo: pota mentre procede, quindi corre molto più velocemente su input più grandi.

Il dizionario è costituito da un elenco di 2500 parole che ho trovato su Internet da qualche parte, meno alcune combinazioni di 1, 2 e 3 lettere che non ho considerato parole. Questo algoritmo è sensibile al fatto di avere troppe parole brevi tra cui scegliere e rallenta drasticamente se permetti, diciamo, ogni singola lettera come parola (ti sto guardando /usr/share/dict/words).

L'algoritmo termina ordinando in base al numero di parole, quindi si spera che quelli "interessanti" siano in cima. Funziona alla grande HELLO WORLD, correndo in meno di un secondo e restituendo la frase prevista come primo colpo. Da ciò ho anche imparato che DATA SCIENTIST(l'unica altra frase che ho provato) i codici morse sono gli stessi di NEW REAL INDIA.

Modifica: ho cercato quelli più interessanti per alcuni minuti. Le parole SPACESe SWITCHsono morsagrammi. Finora sono la coppia di parole singole più lunga che abbia mai trovato.

Basta osservare che alcune brevi combinazioni di lettere danno decodificazioni ambigue. È sufficiente un'unica sequenza ambigua, ma posso vedere quanto segue:

ATE ~ P
EA ~ IT
MO ~ OM

ecc. Come osserva David Richerby nei commenti, qualsiasi lettera equivale a una serie di Es e Ts, il che rende ambiguo il Codice Morse come un modo per codificare sequenze arbitrarie di lettere; le combinazioni precedenti mostrano che ciò è vero anche per combinazioni di lettere plausibili in inglese (ad esempio, MEAT~ MITT). Forse un interessante esercizio di codifica sarebbe quello di trovare tutte le stringhe di cinque o meno lettere che potrebbero essere scambiate per qualcos'altro, limitandosi alle combinazioni di lettere che possono essere effettivamente trovate nel testo inglese (usando una o più parole), raggruppate per classe di equivalenza.

Usando il tuo esempio originale, capita anche che sia così

HELLO WORLD ~ HAS TEAM NO MAID TOE

e mentre il lato destro è forse irrealistico anche come messaggio parziale, è certamente una sequenza di parole inglesi, e quella che potrebbe essere trovata in meno di 15 minuti senza l'assistenza del computer. Questo potrebbe essere preso come prova del fatto che molte frasi in inglese potrebbero essere interpretate erroneamente come una diversa sequenza (forse senza senso) di parole inglesi.

Il codice Morse è in realtà un codice ternario, non un codice binario, quindi gli spazi sono necessari. Se gli spazi non fossero presenti, si otterrebbe molta ambiguità, non tanto con l'intero messaggio, ma con singole lettere.

Ad esempio, 2 punti sono una I, ma 3 punti sono una S. Se stai trascrivendo e senti due punti, scrivi immediatamente "I" o aspetti fino a quando senti un altro punto (o trattino)?

La risposta è che ogni valore è separato dallo spazio, quindi sono raggruppati insieme. Quando gli operatori digitano i messaggi in Morse, fanno una pausa della stessa lunghezza di un trattino dopo ogni sequenza di codici di lettere per indicare la fine della sequenza.

Anche se hai scritto un programma di intelligenza artificiale per guardare una frase completa alla volta e capire quale fosse l'interpretazione logica del messaggio, ci sarebbero ancora molte piccole ambiguità e errori di ortografia che

alcune note non trattate in altre (buone) risposte ma che generalmente non ricercano conoscenze precedenti e citano qualsiasi cosa (per me una parte intrinseca dell'informatica ).

• questa teoria generale del CS rientra nella categoria della segmentazione del testo e anche "suddivisione delle parole" / "chiarimento delle ambiguità" sebbene lì la teoria sia un po 'diversa, si tratta di dividere sequenze di simboli in parole (con lettere variabili), ecc., dove i simboli sono unità. qui le stringhe sono divise in lettere in cui le lettere hanno una lunghezza variabile, ma la teoria è analoga anche se non esattamente 1-1. cioè mappatura tra frasi in parole, lunghezze di parole variabili, e frasi in parole, lunghezze variabili / lettere.

• come altri hanno sottolineato, questo può essere studiato empiricamente. e qualcuno lo ha fatto da un punto di vista (ci sono molti modi per studiarlo) e ha "pubblicato" i risultati su una pagina web con una grande directory / tabella dei risultati.

  Ho trovato 25.787 parole in codice Morse ambigue. Questo è composto da 10.330 stringhe Morse distinte. La parola Morse ambigua più alta frequenza ha 13 parole donatore possibili. I risultati sono raggruppati di seguito in tabelle basate sulla frequenza delle parole che condividono la stessa rappresentazione Morse.

• wow, "il contesto conta" ... una domanda quasi identica "tradurre il codice morse senza spazi" su stackoverflow da 3 anni fa attualmente ha 0 voti.

In generale ci sono in modo esponenziale molte possibili decodifiche, ma se proprio lo desideri puoi elencarle tutte. Puoi anche elencarli in modo sintetico, cioè dare una rappresentazione succinta per tutti loro. Dal momento che questo non è altro che un esercizio di programmazione, ti sfido a farlo da solo.

Detto questo, il fatto che vi sia ambiguità non preclude la capacità di decifrare il messaggio, o almeno gran parte del messaggio. Supponendo un modello probabilistico per il testo rappresentato dal codice Morse - per sicurezza, possiamo presumere che sia l'inglese e utilizzare le proprietà statistiche dell'inglese - potrebbe essere possibile decodificare essenzialmente il messaggio, anche se alcune ambiguità locali potrebbero essere inevitabili. Il motivo è che la maggior parte delle decodifiche corrispondono al testo in chiaro senza senso. Il modo per farlo è estendere l'algoritmo di programmazione dinamica dal paragrafo precedente per stimare la probabilità di ciascuna decodifica e quindi scegliere la decodifica della massima probabilità. Questo approccio ha maggiori possibilità di successo man mano che il messaggio si allunga.

Come definire / riconoscere / generare la lingua di tutte le possibili decodifiche.

Chiaramente, senza spazi, il codice morse non è più unicamente decifrabile.

È comunque possibile dare in forma condensata tutti i modi possibili per decodificarlo. Questo è in realtà simile a quello che viene fatto nell'elaborazione del parlato: da un flusso unico di suoni (o di fonemi), devi trovare tutti i modi in cui può essere decomposto in una sequenza di parole. Gli algoritmi per farlo producono ciò che viene chiamato reticolo di parole. Troverai un esempio nella sezione "ambiguità lessicale" di questa risposta .

Nel caso del codice binario Morse (senza spazi), hai solo punti e trattini, ma il problema è lo stesso.

Il modo in cui puoi ottenere tutte le traduzioni è il seguente.

$T$

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

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

I dettagli sono facilmente elaborabili. Ma chiedi se hai bisogno di più.

Alcuni pseudo-codici per un risolutore che forniranno tutte le possibili interpretazioni. Questo si basa su alcune considerazioni rapide, quindi input aggiuntivi sarebbero i benvenuti. Il metodo accetta due input uno del testo finora tradotto e il secondo del codice 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)
        }

}

Questo produrrà tutte le possibili combinazioni di lettere e numeri senza spazi tra "parole". Se volessi dimostrare l'ambiguità, questo lo farebbe sicuramente. Se desideri ottenere alcuni messaggi significativi, prova a cercare il codice per tradurre gli hashtag in un linguaggio leggibile.

Usando quanto sopra, ho scritto un programma in C # che fa quanto sopra. Ho interrotto l'esecuzione di 22 milioni di possibilità per la stringa sopra che può tradursi in ciao mondo. L'equivalente del codice Morse di "Hello" ha prodotto 20.569 risultati possibili. Inoltre non ho incluso i numeri. Sarebbe più alto se glielo consentissi.