Reading unknown length line - regex

Question

I have an unknown length line that is in this format
bobaboao dsaas : 5->2 2->3 4->6 7->2 1->4 5->1 8->1 222->1 23->13 ...
I need to read each
"X->Y"
and send to function
Dist(X,Y)
until the end of the line
How can I do this in MATLAB?

Answer 1

I'd use regexp with 'tokens', which pulls out the bits of the match in between parentheses (()):
>> C = regexp(s,'(\d*)->(\d*)','tokens')
C =
{1x2 cell} {1x2 cell} {1x2 cell} {1x2 cell} {1x2 cell} ...
{1x2 cell} {1x2 cell} {1x2 cell} {1x2 cell}
>> xy = str2double(vertcat(C{:})).'
xy =
5 2 4 7 1 5 8 222 23
2 3 6 2 4 1 1 1 13
Then you have X = xy(1,:); and Y = xy(2,:);.
Explained: \d is a digit ([0-9]), \d* means any number of digits. Wrapping them in () makes them tokens. The whole pattern defines a match, but the tokens are extracted into a cell array of cell arrays, one cell array for each match, containing cell arrays for the tokens. It's easy to make a single matrix with vertcat and convert it with str2double.

Answer 2

One suggestion I have is to use regular expressions so that you search for substrings within that string in your example that specifically have one ID, followed by -> followed by another ID. Once we find these exact patterns in your string, we simply extract those out and place them into a cell array. In other words, supposing that our string was stored in s (I'm actually going to use your example), do this:
s = 'bobaboao dsaas : 5->2 2->3 4->6 7->2 1->4 5->1 8->1 222->1 23->13';
g = regexp(s, '[0-9]+->[0-9]+', 'match');
Let's go through this code slowly. s stores the string that you're analyzing, then the next line finds substrings in your string s that finds a sequence of at least one digit, followed by a ->, followed by at least one digit. The 'match' flag extracts out the strings that match this pattern we are finding in s. g is the output of this line, and each string is stored in a cell array. We thus get:
g =
Columns 1 through 7
'5->2' '2->3' '4->6' '7->2' '1->4' '5->1' '8->1'
Columns 8 through 9
'222->1' '23->13'
Note that storing into a cell array is important, because the length of each substring may be different.
Once we extract these substrings, what we can do is extract the numbers before and after the ->. We simply apply two more regular expression calls to get the numbers before and after:
X = regexp(g, '^[0-9]+', 'match');
Y = regexp(g, '[0-9]+$', 'match');
The first call looks for substrings at the beginning of each string in g that starts with a number, while the second call looks for substrings at the end of each string in g that ends with a number. What will be returned are the numbers contained in cell arrays. Also, the numbers themselves are strings. Because each element in the cell is a string, we should convert these back into actual numbers. We should also place these into a numeric vector for you to use with your code:
X = cellfun(#str2double, X);
Y = cellfun(#str2double, Y);
cellfun is a function that allows you to apply a particular function to each cell in a cell array. In this case, we want to convert each number in the cell array as it's a string into double. Therefore, use str2double to facilitate this conversion. Once we're done, we will get numeric vectors that give you the numbers before the -> and after the ->.
We finally get:
X =
5 2 4 7 1 5 8 222 23
Y =
2 3 6 2 4 1 1 1 13

Answer 3

I found a tricky way:
0)delete the alphabetical sequence by writing the following line:
str(1:strfind(str,':'))=''
1)concatenate this string in the following way:
newStr=['[',str,']']
, so that now your new string will be: '[5->2 2->3 4->6 7->2 1->4 5->1 8->1 222->1 23->13]'
2)delete all the '>' , you can do it by the command:
newStr(newStr=='>')=''
,so that now you will have '[5-2 2-3 4-6 7-2 1-4 5-1 8-1 222-1 23-13]',
pay attention that this is actually a string that represents a vector that contains the distances between the numbers, and that leads us to step 3...
3)evaluate the string we get:
distances=eval(newStr);
if you want the distances without + an - , just use abs() function.