Erlang code split String without delimiter and put into list

Question

I am very new to programming in Erlang. I am making a program to decode braille but I am having a problem trying to split a string every 2 characters with the absence of a delimiter, and putting them into a list.

First I read in the braille alphabet like this:

inKey(Key1) -> Key1.
inKey2(Key2) -> Key2.
inKey3(Key3) -> Key3.

Key 1-3 are strings and look like this:"x.x.xxxxx.xxxxx..x.xx.x.xxxxx.xxxxx..x.xx.x..xxxxxx." these 3 keys form the braille information that I will later use to transform braille into normal characters.

Now I need to split this string and place them in a list so that it would look like this: ["x.","x.","xx","xx",x.","xx","xx","x.",".x and so on.

If the string is split I want to insert them into my coding list like shown in Tuplet for the character A

 Code=[#row{name="R1",alfabet=[#codes{letter="A",braille="X."},#codes{letter="B",braille=""}

Can someone helpe me out?

`

7stud · Accepted Answer

In Erlang, you need to remember that a string is equivalent to a list of numbers, where the numbers are the ascii codes for each character. The confusing thing is that sometimes the shell displays a list of numbers as a string, and sometimes it displays a list of numbers as a list of numbers. That is a TERRIBLE feature of the erlang shell.

Despite what the shell displays, just remember that a string is a list of numbers. The problem then becomes, what if you want to output a list of numbers and not a string? The answer is: you can't do anything about that; the shell may display your list of numbers as a string...unless you take further action:

45> Grades = [97,98,99].
"abc"

Wtf??!

46> io:format("~w~n", [Grades]).
[97,98,99]
ok

Another way of thinking about it is this: the erlang string syntax "abc" is just a shortcut for creating the list of numbers [97,98,99].

Next, you can deconstruct a list with a pattern like this:

[Head|Tail] = [1,2,3]

In the shell:

8> [Head|Tail] = [1, 2, 3, 4].
[1,2,3,4]

9> Head.                      
1

10> Tail.
[2,3,4]

But, the cons operator | is more flexible than that, and it allows you to do this:

13> [N1,N2 | T] = [1, 2, 3, 4].   
[1,2,3,4]

14> N1.
1

15> N2.
2

16> T.
[3,4]

Therefore, you can do this:

-module(my).
-compile(export_all).

string() ->
    "x.x.xxxxx.xxxxx..x.xx.x.xxxxx.xxxxx..x.xx.x..xxxxxx.".

chunk2([]) -> [];
chunk2([N1, N2| Tail]) ->
    [[N1,N2] | chunk2(Tail) ].

In the shell:

2> c(my).
my.erl:2: Warning: export_all flag enabled - all functions will be exported
{ok,my}

3> my:chunk2(my:string()).  
["x.","x.","xx","xx","x.","xx","xx","x.",".x",".x","x.",
 "x.","xx","xx","x.","xx","xx","x.",".x",".x","x.","x.",".x",
 "xx","xx","x."]

4>

Finally, to construct a list of #code{} records, you can do this:

-module(my).
-compile(export_all).
-record(codes, {letter, braille}).

string() ->
    "x.x.xxxxx.xxxxx..x.xx.x.xxxxx.xxxxx..x.xx.x..xxxxxx.".

chunk2([]) -> [];
chunk2([N1, N2| Tail]) ->
    [[N1,N2] | chunk2(Tail) ].

make_record_list(Letters, Chunks) ->
    lists:zipwith(
        fun(Letter, Chunk) -> #codes{letter=[Letter], braille=Chunk} end,
        Letters,
        Chunks
    ).

In the shell:

31> c(my).             
my.erl:2: Warning: export_all flag enabled - all functions will be exported
{ok,my}

32> ListOfCapLetters = lists:seq($A, $Z).
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"

33> BrailleChunks = my:chunk2(my:string()).
["x.","x.","xx","xx","x.","xx","xx","x.",".x",".x","x.",
 "x.","xx","xx","x.","xx","xx","x.",".x",".x","x.","x.",".x",
 "xx","xx","x."]

34> Records = my:make_record_list(ListOfCapLetters, BrailleChunks).
[{codes,"A","x."},
 {codes,"B","x."},
 {codes,"C","xx"},
 {codes,"D","xx"},
 {codes,"E","x."},
 {codes,"F","xx"},
 {codes,"G","xx"},
 {codes,"H","x."},
 {codes,"I",".x"},
 {codes,"J",".x"},
 {codes,"K","x."},
 {codes,"L","x."},
 {codes,"M","xx"},
 {codes,"N","xx"},
 {codes,"O","x."},
 {codes,"P","xx"},
 {codes,"Q","xx"},
 {codes,"R","x."},
 {codes,"S",".x"},
 {codes,"T",".x"},
 {codes,"U","x."},
 {codes,"V","x."},
 {codes,"W",".x"},
 {codes,"X","xx"},
 {codes,"Y","xx"},
 {codes,"Z",[...]}]

It looks like there may be a problem with the last record, so let's check:

37> tl(Records).  
[{codes,"B","x."},
 {codes,"C","xx"},
 {codes,"D","xx"},
 {codes,"E","x."},
 {codes,"F","xx"},
 {codes,"G","xx"},
 {codes,"H","x."},
 {codes,"I",".x"},
 {codes,"J",".x"},
 {codes,"K","x."},
 {codes,"L","x."},
 {codes,"M","xx"},
 {codes,"N","xx"},
 {codes,"O","x."},
 {codes,"P","xx"},
 {codes,"Q","xx"},
 {codes,"R","x."},
 {codes,"S",".x"},
 {codes,"T",".x"},
 {codes,"U","x."},
 {codes,"V","x."},
 {codes,"W",".x"},
 {codes,"X","xx"},
 {codes,"Y","xx"},
 {codes,"Z","x."}]

Nope, the first output just reached the limit of what the shell was willing to display.

Note that each element of ListOfCapLetters is a number, and a number is not a list, so each element of ListOfCapLetters is not a string itself. To create a string from a number, you need to put it inside a list, hence [Letter]. It's the same difference between: String = [97,98,99] and ListOfStrings = [[97], [98], [99]]:

40> String = [97,98,99].
"abc"

41> hd(String).
97

42> ListOfStrings = [[97], [98], [99]].
["a","b","c"]

43> hd(ListOfStrings).
"a"

lists:seq() returns the equivalent of String.

Response to comment:

See lists:keyfind/3:

20> TargetRecord = lists:keyfind("xx", 3, Records).                
#codes{letter = "C",braille = "xx"}

21> rr(my).  %Read record definition contained in my.erl into the shell.                                                     
[codes]

22> TargetRecord#codes.letter.
"C"

The string "C" is actually the list [67], which the shell has decided to display as "C". You need to be able to look up an ascii table to discover what a string really represents in Erlang. Or, you can get the ascii code of a character like this:

24> $C.
67

25> $a.
97

So, "C" is actually the list [67], and "a" is actually the list [97].

Erlang code split String without delimiter and put into list

Answers (2)

Related Questions