OpenEuphoria

2. Re: Morse

• Posted by ghaberek (admin) Sep 05, 2014
• 1663 views

Well, it's not smaller, but it is probably more efficient and more Euphoria-like. Storing the codes in a table indexed by ASCII character should be more efficient than using vslice() and lookup(). I'm a bit rusty on my time complexity theory, but I believe it's the difference of O(1) vs O(n) or O(log n). I haven't examined the underlying code, so I don't know if lookup() uses a binary search or linear search. I would imagine it's binary, which is O(log n) complex.

-- morse.e 
 
public constant 
    STARTING_SIGNAL         =  1, 
    END_OF_MESSAGE          =  4, 
    INVITATION_TO_TRANSMIT  =  5, 
    UNDERSTOOD              =  6, 
    ERROR                   = 21, 
    WAIT                    = 22, 
    END_OF_WORK             = 23, 
$ 
 
public sequence MORSE = repeat( "", 127 ) 
 
MORSE[ERROR]                    = "........" 
MORSE[END_OF_MESSAGE]           = ".-.-." 
MORSE[END_OF_WORK]              = "...-.-" 
MORSE[INVITATION_TO_TRANSMIT]   = "-.-" 
MORSE[STARTING_SIGNAL]          = "-.-.-" 
MORSE[UNDERSTOOD]               = "...-." 
MORSE[WAIT]                     = ".-..." 
MORSE['!']  = "-.-.--" 
MORSE['\"'] = ".-..-." 
MORSE['$']  = "...-..-" 
MORSE['&']  = ".-..." 
MORSE['\''] = ".----." 
MORSE['(']  = "-.--." 
MORSE[')']  = "-.--.-" 
MORSE['+']  = ".-.-." 
MORSE[',']  = "--..--" 
MORSE['-']  = "-....-" 
MORSE['.']  = ".-.-.-" 
MORSE['/']  = "-..-." 
MORSE['0']  = "-----" 
MORSE['1']  = ".----" 
MORSE['2']  = "..---" 
MORSE['3']  = "...--" 
MORSE['4']  = "....-" 
MORSE['5']  = "....." 
MORSE['6']  = "-...." 
MORSE['7']  = "--..." 
MORSE['8']  = "---.." 
MORSE['9']  = "----." 
MORSE[':']  = "---..." 
MORSE[';']  = "-.-.-." 
MORSE['=']  = "-...-" 
MORSE['?']  = "..--.." 
MORSE['@']  = ".--.-." 
MORSE['A']  = ".-" 
MORSE['B']  = "-..." 
MORSE['C']  = "-.-." 
MORSE['D']  = "-.." 
MORSE['E']  = "." 
MORSE['F']  = "..-." 
MORSE['G']  = "--." 
MORSE['H']  = "...." 
MORSE['I']  = ".." 
MORSE['J']  = ".---" 
MORSE['K']  = "-.-" 
MORSE['L']  = ".-.." 
MORSE['M']  = "--" 
MORSE['N']  = "-." 
MORSE['O']  = "---" 
MORSE['P']  = ".--." 
MORSE['Q']  = "--.-" 
MORSE['R']  = ".-." 
MORSE['S']  = "..." 
MORSE['T']  = "-" 
MORSE['U']  = "..-" 
MORSE['V']  = "...-" 
MORSE['W']  = ".--" 
MORSE['X']  = "-..-" 
MORSE['Y']  = "-.--" 
MORSE['Z']  = "--.." 
MORSE['_']  = "..--.-" 
MORSE['a']  = ".-" 
MORSE['b']  = "-..." 
MORSE['c']  = "-.-." 
MORSE['d']  = "-.." 
MORSE['e']  = "." 
MORSE['f']  = "..-." 
MORSE['g']  = "--." 
MORSE['h']  = "...." 
MORSE['i']  = ".." 
MORSE['j']  = ".---" 
MORSE['k']  = "-.-" 
MORSE['l']  = ".-.." 
MORSE['m']  = "--" 
MORSE['n']  = "-." 
MORSE['o']  = "---" 
MORSE['p']  = ".--." 
MORSE['q']  = "--.-" 
MORSE['r']  = ".-." 
MORSE['s']  = "..." 
MORSE['t']  = "-" 
MORSE['u']  = "..-" 
MORSE['v']  = "...-" 
MORSE['w']  = ".--" 
MORSE['x']  = "-..-" 
MORSE['y']  = "-.--" 
MORSE['z']  = "--.." 
 
public function morse( object s ) -- s = string 
     
    if atom( s ) then 
         
        s = and_bits( s, #FF ) 
        return MORSE[s] 
         
    end if 
     
    sequence m = "" -- m = message 
     
    for i = 1 to length( s ) do 
         
        sequence c = morse( s[i] ) -- c = code 
         
        if length( c ) > 0 and length( m ) > 0 then 
            m &= " " 
        end if 
         
        m &= c 
         
    end for 
     
    return m 
end function 

-- morse.ex 
 
include std/console.e 
include morse.e 
 
sequence cmd = command_line() 
 
for i = 3 to length( cmd ) do 
    sequence code = morse( cmd[i] & END_OF_MESSAGE ) 
    printf( 1, "%s\n", {code} ) 
end for 

> eui morse.ex "Hello, world!" 
.... . .-.. .-.. --- --..-- .-- --- .-. .-.. -.. -.-.-- .-.-. 
 
> eui morse.ex "The quick brown fox jumps over the lazy dog." 
- .... . --.- ..- .. -.-. -.- -... .-. --- .-- -. ..-. --- -..- .--- ..- -- .--. ... --- ...- . .-. - .... . .-.. .- --.. -.-- -.. --- --. .-.-.- .-.-. 

-Greg

4. Re: Morse

• Posted by ghaberek (admin) Sep 06, 2014
• 1548 views

You're right, it's not case-sensitive. I am sacrificing the extra few bytes of memory for the sake of speed. Passing everything through lower() takes time. Indexing everything directly is faster. If we simply "copy" the values from A-Z to a-z, it should use less memory (due to Euphoria's copy-on-write sequence management). Although if we add it all up, we're probably only saving about 400 bytes of memory.

MORSE['a']  = MORSE['A'] 
MORSE['b']  = MORSE['B'] 
MORSE['c']  = MORSE['C'] 
MORSE['d']  = MORSE['D'] 
MORSE['e']  = MORSE['E'] 
MORSE['f']  = MORSE['F'] 
MORSE['g']  = MORSE['G'] 
MORSE['h']  = MORSE['H'] 
MORSE['i']  = MORSE['I'] 
MORSE['j']  = MORSE['J'] 
MORSE['k']  = MORSE['K'] 
MORSE['l']  = MORSE['L'] 
MORSE['m']  = MORSE['M'] 
MORSE['n']  = MORSE['N'] 
MORSE['o']  = MORSE['O'] 
MORSE['p']  = MORSE['P'] 
MORSE['q']  = MORSE['Q'] 
MORSE['r']  = MORSE['R'] 
MORSE['s']  = MORSE['S'] 
MORSE['t']  = MORSE['T'] 
MORSE['u']  = MORSE['U'] 
MORSE['v']  = MORSE['V'] 
MORSE['w']  = MORSE['W'] 
MORSE['x']  = MORSE['X'] 
MORSE['y']  = MORSE['Y'] 
MORSE['z']  = MORSE['Z'] 

Wikipedia has a pretty comprehensive list of Letters, numbers, punctuation, prosigns and non-English variants for Morse code, which is what I used as a reference.

-Greg

6. Re: Morse

• Posted by petelomax Sep 08, 2014
• 1415 views

I thought it might be "fun" to encode that tree picture thing, see what it turned out like.

sequence morse = repeat(0,255) 
 
    morse[' '] = "    " 
 
procedure ext(string root, object data) 
object dot, dash 
    if sequence(data) then 
        {data,dot,dash} = data 
        ext(root,data) 
        ext(root&'.',dot) 
        ext(root&'-',dash) 
    elsif data!=0 then 
        morse[data] = root 
--      printf(1,"morse['%c']:=%s\n",{data,root}) 
    end if 
end procedure 
 
      ext("",{0,{'E',{'I',{'S',{'H','5','4'}, 
                               {'V',{0,{0,0,'$'},0},'3'}}, 
                          {'U','F',{0,{0,'?','_'},'2'}}}, 
                     {'A',{'R',{'L','&',{0,'"',0}}, 
                               {0,{'+',0,'.'},0}}, 
                          {'W',{'P',0,{0,'@',0}}, 
                               {'J',0,{'1','\'',0}}}}}, 
                {'T',{'N',{'D',{'B',{'6',0,'-'},'='}, 
                               {'X','/',0}}, 
                          {'K',{'C',0,{0,';','!'}}, 
                               {'Y',{'(',0,')'},0}}}, 
                     {'M',{'G',{'Z','7',{0,0,','}}, 
                               'Q'}, 
                          {'O',{0,{'8',':',0},0}, 
                               {0,'9','0'}}}}}) 

Amazingly it works. (Obviously I use Phix so you might need to change that {data,dot,dash} = data to dash = data[3] dot = data[2] data = data[1], not tested on OpenEu.)

I think the word you're looking for is "ugly".

Pete