Is there a SAS function to flag a word that repeats in order across columns?

Is there a way to flag rows where the word 'Add' is in sequence without any other word or missing in between?

I tried the array statement with the find function, but no luck!

This code will find all sequences of Add where there are at least two Adds in a row and save all of the sequences to a single comma-separated variable.

Sample data:

data have;
    input t1$ t2$ t3$ t4$ t5$ t6$ t7$ t8$ t9$ t10$;
    datalines;
Add Add No Add No Add . No Add .
Add No Add Add Add Add . . No .
Add Add Add No Add Add Add Add . .
;
run;

Code:

data want;
    set have;

    array t[*] t:;
    array col[10] $;
    length sequences $50.;

    /* Check if the current and previous value is 'Add' */
    do i = 1 to dim(t);
        if(i > 1 AND t[i] = 'Add' AND t[i-1] = 'Add') then do;
            col[i]   = vname(t[i]);
            col[i-1] = vname(t[i-1]);
        end;
    end;

    /* Create a comma-separated list for each sequence. For example:
       t1-t3,t3-t5
       t1-t4
       etc.
    */
    flag_start = 0;

    do i = 1 to dim(col);
        
        /* Find the start of the sequence */
        if(col[i] NE ' ' AND NOT flag_start) then do;
            seq_start  = col[i];
            flag_start = 1;
        end;

        /* Find the end of the sequence */
        if(col[i] = ' ' AND flag_start) then do;
            seq_end    = col[i-1];
            flag_start = 0;
        end;

        /* If we are between sequences, calculate the sequence range and save it */
        if(i > 1 AND col[i] = ' ' AND col[i-1] NE ' ') then do;
            seq_range = cats(seq_start, '-', seq_end);
            sequences = catx(',', sequences, seq_range);
        end;
    end;

    drop i flag_start seq_start seq_end seq_range col:;
run;

Output:

t1	t2	t3	t4	t5	t6	t7	t8	t9	t10	sequences
Add	Add	No	Add	No	Add		No	Add		t1-t2
Add	No	Add	Add	Add	Add			No		t3-t6
Add	Add	Add	No	Add	Add	Add	Add			t1-t3,t5-t8

The presence of a target word at a T<index> column can be flagged using a binary value, setting the bits appropriately.

Example:

Flag up to 32 columns. For more than 32 columns you would need additional flag variables and some extra bookkeeping when calculating the flag value.

data have;
    input (t1-t10) ($);
    datalines;
Add Add No Add No Add . No Add .
Add No Add Add Add Add . . No .
Add Add Add No Add Add Add Add . .
;


data want;
  set have;
  array ts t1-t10;
  flag = 0;
  do over ts;
    flag = BOR (flag, BLSHIFT(ts='Add', _i_-1));
  end;

  format flag binary32.;
run;

I have a few solutions depending on when and how many sequences are allowed.

First, a sequence is defined as 2 or more consecutive time periods with 'Add'. For my solutions I used Richard's sample data.

Solution 1: Valid sequences begin at T1 until a break

* valid sequence begins at t1 until a break;
data want1;
set have;
length sequence $20;
if t1 = 'Add' and t2 = 'Add';  * if either T1 or T2 <> 'Add' then move on to next obs;

array t(*) t1-t10;  

do i = 3 to dim(t);  * start loop at t3 since we know t1 & t2 = 'Add';
    if t[i] ne 'Add' then do;
        sequence = cats('T1-T', put(i-1, 2.));
        output;
        leave;  * exit loop. move to next obs;
    end;
end;
drop i;
run;

Result:

t1	t2	t3	t4	t5	t6	t7	t8	t9	t10	sequence
Add	Add	No	Add	No	Add		No	Add		T1-T2
Add	Add	Add	No	Add	Add	Add	Add			T1-T3

Solution 2: The next solution still detects valid sequences beginning at T1, but allows breaks and other sequences beyond the first one.

* sequence begins at t1 with a break and another sequence occurs on same row;
data want2;
set have;
length sequence $20;
if t1 = 'Add' and t2 = 'Add';  * if either T1 or T2 <> 'Add' then move to next obs;

array t(*) t1-t10;

seq_strt = 1;  * start of sequence. start at 1 because of subsetting if;
break = 0;     * flag for break in sequence. start at 0 because of subsetting if;
sequence = '';

do i = 3 to dim(t);  * start loop at t3 since we know t1 & t2 = 'Add';
    * start of sequence - 2 consecutive 'Add' during break;
    if break = 1 and t{i] = 'Add' and t[i-1] = 'Add' then do;  * start of new sequence;
        break = 0;
        seq_strt = i-1;
    end;
    * end of sequence;
    else if break = 0 and t[i] ne 'Add' then do;
        break = 1;  * flag a break;
        sequence = catx(',', sequence, cats('T', put(seq_strt, 2.), '-T', put(i-1, 2.)));
    end;
end;
drop i seq_strt break;
run;

Result:

t1	t2	t3	t4	t5	t6	t7	t8	t9	t10	sequence
Add	Add	No	Add	No	Add		No	Add		T1-T2
Add	Add	Add	No	Add	Add	Add	Add			T1-T3,T5-T8

Finally, the last solution detects any sequence in any time period.

* capture any sequence at any period of time;
data want3;
set have;
length sequence $20;

array t(*) t1-t10;

seq_strt = 0;  * start of sequence;
break = 1;     * flag for break in sequence. start with break until new seq is found;
sequence = '';

do i = 2 to dim(t);  * start loop at t2 to compare at t1;
    * start of sequence - 2 consecutive 'Add' during break;
    if break = 1 and t{i] = 'Add' and t[i-1] = 'Add' then do;  * start of new sequence;
        break = 0;
        seq_strt = i-1;
    end;
    * end of sequence;
    else if break = 0 and t[i] ne 'Add' then do;
        break = 1;  * flag a break;
        sequence = catx(',', sequence, cats('T', put(seq_strt, 2.), '-T', put(i-1, 2.)));
    end;
end;
drop i seq_strt break;
run;

Result:

t1	t2	t3	t4	t5	t6	t7	t8	t9	t10	sequence
Add	Add	No	Add	No	Add		No	Add		T1-T2
Add	No	Add	Add	Add	Add			No		T3-T6
Add	Add	Add	No	Add	Add	Add	Add			T1-T3,T5-T8