Konvertieren Zeichenfolge durch Hash

Question

Ich versuche, eine Zeichenfolge von Morse-Code in Wörter zu konvertieren. Ich habe die Zeichenfolge in Wörter aufgeteilt. Dann spalte ich jedes Wort in eine zweite Reihe von Buchstaben und Zahlen.

def self.decode(str) 
    decoded = "" 
    arr = [] 
    p arr = str.split(' ') 
    p arr.map! { |i| i.split(' ') } 

    arr.each do |r| 
     r.each do |i| 
      decoded += @morse.invert[i].to_s[-1] 
     end 
    end 

    p decoded 
end 

In meinem hash verwende ich Nummern. Sie beginnen mit N. In , die -1 ist die N fallenlassen.

ich diesen Fehler:

`+': no implicit conversion of nil into String 

ich herausfinden kann, wie in der Vergangenheit es aber bekommen, weil ich in dem Array keinen nil Wert sehen.

class Morse 

    @morse = { 
     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: '--..', 
     ' ': ' ' , 
     N1: '.----', 
     N2: '..---', 
     N3: '...--', 
     N4: '....-', 
     N5: '.....', 
     N6: '-....', 
     N7: '--...', 
     N8: '---..', 
     N9: '----.', 
     N0: '-----' 
    } 

def self.encode(str) 
    encoded = "" 
    sym_temp = "" 
    str = str.upcase! 
    str.each_char do |c| 
     ascii_check = c.ord 
     if ascii_check.between?(65,90) 
      temp = str[c].to_sym 
      encoded += "#{@morse[temp]}" + " " 
     elsif ascii_check.between?(48,57) 
      temp = "N".concat(str[c]).to_sym 
      encoded += "#{@morse[temp]}" + " " 
     elsif ascii_check ===(32) 
      temp = str[c].to_sym 
      encoded += "#{@morse[temp]}" 
     end 
    end 
    p encoded 
end 

def self.decode(str) 
    decoded = "" 
    arr = [] 
    # str.split(' ').map do |i| 
    p arr = str.split(' ') 
    p arr.map! { |i| i.split(' ') } 

    arr.each do |r| 
     r.each do |i| 
     p decoded += @morse.invert[i].to_s[-1].to_s 
     end 
    end    

    p decoded 
end 

# def self.read_file 
    # # @Temp = File.read("preamble_encode.txt").chomp 
     # # File.open('hiscore.txt'){|f| f.lines.map{|l| l.chomp!.split(',')}} 
    # # @Temp = File.foreach("preamble_encode.txt", 'r') {|f| f.lines.map{|l| l.chomp}} 

# end 

# def self.write_file 
    # # Temp2 = File.open('preamble_decode.txt', 'w') do |f| 
     # # f.puts Temp2 
    # # end 
# end 

end 


test = "Abc 1oL!" 
test2 = ".-- . - .... . .--. . --- .--. .-.. ." 
Morse.encode(test) 
Morse.decode(test2) 

Answer 1

Ihr Problem ist hier:

 :P => :'.--.', 

Ihr Doppelpunkt auf der rechten Seite der Hash-Rakete macht, dass ein Symbol, kein String. Wie es passiert, enthält Ihr Testfall für die Dekodierung ein P. Wenn Sie versuchen, die String '.--.', Es findet es nicht und gibt Null zurück.

Answer 2

Da Ihre Frage beantwortet wurde, möchte ich vorschlagen, wie Sie Methoden zum Kodieren und Dekodieren schreiben können.

Erstens, die Schlüssel Ihres Hash sollten Zeichenketten anstelle von Symbolen sein, da der Hash zum Codieren von Zeichenketten verwendet wird, die aus Zeichenketten bestehen. Wir brauchen auch die Ziffern '0' bis '9' statt 'N0' bis 'N9'. Leerzeichen werden durch Zeitverzögerungen dargestellt, die sieben Punkten entsprechen, anstatt Kombinationen von Punkten und Bindestrichen. Daher habe ich Leerzeichen durch die Zeichenfolge '<delay>' dargestellt. Siehe die Morse Wiki.

Da sich der Hashwert nicht ändert, habe ich ihn zu einer Konstante gemacht und nicht zum Wert einer Instanzvariablen.

CharactersToMorse = { 
    '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' => '--..' , ' ' => '<delay>', '0' => '-----', '1' => '.----', 
    '2' => '..---', '3' => '...--', '4' => '....-', '5' => '.....', '6' => '-....', 
    '7' => '--...', '8' => '---..', '9' => '----.' 
} 

Wir müssen entschlüsseln, also werde ich auch den invertierten Hash einer Konstante zuweisen.

MorseToCharacters = CharactersToMorse.invert 
    #=> {".-"=>"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", "<delay>"=>" ", "-----"=>"0", ".----"=>"1", "..---"=>"2", 
    # "...--"=>"3", "....-"=>"4", "....."=>"5", "-...."=>"6", "--..."=>"7", 
    # "---.."=>"8", "----."=>"9"} 

Unsere Verfahren zur Codierung und Decodierung sind jetzt sehr einfach.

def code(text) 
    text.each_char.map { |c| CharactersToMorse[c] } 
end 

def decode(morse) 
    morse.map { |m| MorseToCharacters[m] }.join(' ') 
end 

Lassen Sie uns es versuchen.

def code(text) 
    text.each_char.map { |c| CharactersToMorse[c.to_sym] } 
end 

def decode(morse) 
    morse.map { |m| MorseToCharacters[m].to_s }.join(' ') 
end