Function 'contains' did not work

The background is CODY problem 95

The purpose is to confirm whether the vector s1 contains the vector s2. (or s2 cover s1)

The problem is that when the size of the vector is very large, the function ’contains‘ cannot be judged correctly.

case 1

clear

s1 = 1:100;
s2 = [50 51];


s1str=num2str(s1);
s2str=num2str(s2);
tf1=contains(s1str,s2str)

tf1 = logical
   0

tf2=contains(s2str,s1str)

tf2 = logical
   0

tf1 SHOULD be 1, since [50 51] is part of s1. but the result is not correct.

case 2

s1 = 40:60;
s2 = [50 51];


s1str=num2str(s1);
s2str=num2str(s2);
tf1=contains(s1str,s2str)

tf1 = logical
   1

tf2=contains(s2str,s1str)

tf2 = logical
   0

When the size of the vector S1 decreases, the function works normally.

[Stephen23]

"tf1 SHOULD be 1, since [50 51] is part of s1."

No, it shoud not be. In your first case, neither TF1 nor TF2 are contained in the other one.

"but the result is not correct."

The result is correct. The NUM2STR documentation very clearly states that "The output format depends on the magnitudes of the original values". For aesthetic reasons by default NUM2STR uses the highest magnitute to determine the spacing for the entire text. This is the expected and documented behavior (and is why reading the documentation is strongly recommended).

Note that you can easily override the default beavior by setting the format (and hence spacing) yourself, e.g.:

s1 = 1:100;
s2 = [50,51];
s1str=num2str(s1,'%7d')

s1str = '1      2      3      4      5      6      7      8      9     10     11     12     13     14     15     16     17     18     19     20     21     22     23     24     25     26     27     28     29     30     31     32     33     34     35     36     37     38     39     40     41     42     43     44     45     46     47     48     49     50     51     52     53     54     55     56     57     58     59     60     61     62     63     64     65     66     67     68     69     70     71     72     73     74     75     76     77     78     79     80     81     82     83     84     85     86     87     88     89     90     91     92     93     94     95     96     97     98     99    100'

s2str=num2str(s2,'%7d')

s2str = '50     51'

tf1=contains(s1str,s2str)

tf1 = logical
   1

tf2=contains(s2str,s1str)

tf2 = logical
   0

[Dyuman Joshi]

"The background is CODY problem 95

The purpose is to confirm whether the vector s1 contains the vector s2. (or s2 cover s1)"

If you are talking about this problem - https://in.mathworks.com/matlabcentral/cody/problems/95, then you have misunderstood what is being asked. I suggest you go through the question and the test cases once again.

Also, if you want to check whether elements of a numeric array are present or not in another, you should use ismember or ismembertol, instead of converting to a char array and using contains().

[Alex]

@Stephen23 thank you so much for your support.

overriding the default beavior is really a good way!

Answer 1

[Dinesh]

Hi Alex,

The issue arises from the default behavior of "num2str" when converting arrays to strings. When "s1" is converted to a string, each element in the array is separated by a set number of spaces, regardless of the number of digits in each number. This means '50' and '51' in "s1str" are separated by more spaces than they are in "s2str", where only two spaces are used between '50' and '51'.

The "contains" function checks for exact substrings, and since the spacing differs, it does not consider '50 51' (with two spaces) to be present in "s1str" (where there are 3 spaces between '50' and '51'). To reliably check for the presence of the sequence of numbers, you would need to account for the variable spacing introduced by "num2str".

To consistently check if a vector contains another, regardless of size, use numerical operations like "ismember":

s1 = 1:100;
s2 = [50 51];
tf1 = all(ismember(s2, s1));

This code will return a logical "1" because "s2" is contained within "s1", which is the correct behavior for your case. When using numerical arrays, it's more reliable to use numerical comparisons rather than string functions. For the CODY problem 95, this method should give you the correct result even for very large vectors.

[Alex]

Thank you very much for your reply.

Unfortunately, the reply didn't solve my problem.

First of all, this reply doesn't explain why the judgment function was restored after the S1's size was reduced. For details, please refer to case2.

Also, the background of this program fragment is CODY problem 95. What we need is that we can extract another vector from the vector, including elements and order. So you can't use the function 'ismember'.

For example, [1 2 3 4 5] does not cover [4 3], but only cover [3 4].

[Dinesh]

@Alex, The judgement function was restored because the space between 50 and 51 for case 2 in s1str are just 2 spaces which is same as the number of spaces between 50 and 51 in s1str. That is why it returns 1. But for case 1, in s1str, there are 3 spaces between 50 and 51. Therefore, string matching in case 1 didn't give the expected result.

The inconsistency arises because the string representation of numerical vectors with "num2str" does not maintain a consistent number of spaces between numbers, particularly when the numbers vary in length (single-digit versus double-digit). This spacing issue is less pronounced in smaller vectors or vectors with numbers of similar lengths, hence the different outcomes in Case 1 and Case 2.

Thanks for pointing out the critical requirement of preserving the order of elements in the vectors. To meet your requirements, we should implement a custom solution that checks for "s2" as a contiguous subsequence within "s1". Here's an adjusted MATLAB function:

function isSubsequence = checkSubsequence(s1, s2)
    isSubsequence = false;
    for i = 1:(length(s1) - length(s2) + 1)
        if isequal(s1(i:i+length(s2)-1), s2)
            isSubsequence = true;
            break;
        end
    end
end

s1 = 1:100;
s2 = [50 51];
tf1 = checkSubsequence(s1, s2);

Hope this helps!

[Alex]

thank you so much for your support~

this function really helps!

Answer 2

[VBBV]

if you use compose function nstead of num2str then contains works correctly,

clear

s1 = 1:100;
s2 = [50 51];

s1str=compose('%d',(s1));  % converts array elements into discrete array elements
s2str=compose('%d',(s2));
tf1=contains(s1str,s2str)

tf1 = 1×100 logical array
  Columns 1 through 49

   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0

  Columns 50 through 98

   1   1   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0

  Columns 99 through 100

   0   0

tf2=contains(s2str,s1str)

tf2 = 1×2 logical array
   1   1

% case 2
s1 = 40:60;
s2 = [50 51];

s1str=compose('%d',(s1));
s2str=compose('%d',(s2));

tf1=contains(s1str,s2str)

tf1 = 1×21 logical array
   0   0   0   0   0   0   0   0   0   0   1   1   0   0   0   0   0   0   0   0   0

tf2=contains(s2str,s1str)

tf2 = 1×2 logical array
   1   1

num2str converts entire array into one continous string, so when comparing commonalitiy of elements in two different arrays, its better to avoid num2str

[Stephen23]

"if you use compose function nstead of num2str then contains works correctly, "

CONTAINS worked correctly in all of the OP's examples.

[VBBV]

Yes, i meant contains function works correctly as expected by OP