If your data are already sorted by id/test, and are in the desired order within each group, then it's beneficial to avoid proc sort, which would then need to be followed by a data step, and probably a re-sort into original order. That's three passes through the data. And in this case to make the re-sort work, you would need to take preliminary measures. Editted note: Oops, wrong on the "preliminary measures" requirement. @SuzanneDorinski shows that a proc sort option negates that need.
Consider interleaving data set HAVE with itself - group by group - a single step, and effectively a single pass through the data. This is analogous to the double "do until (last.test);" that I offered earlier, but might be a little more self-evident:
data have;
input id $ test $ visit $ result;
cards;
101 rbc visit1 222
101 rbc visit2 222
101 rbc visit3 300
101 wbc visit1 222
101 wbc visit2 222
101 wbc visit3 300
101 wbc visit4 300
102 rbc visit1 222
102 rbc visit2 222
102 rbc visit3 300
102 wbc visit1 222
102 wbc visit2 222
102 wbc visit3 300
102 wbc visit4 400
102 wbc visit5 400
;
data want (drop=_:);
set have (in=firstpass) have (in=secondpass);
by id test;
retain _maxresult;
if first.test then _maxresult=result; /*Was "if first.id"*/
else if firstpass then _maxresult=max(_maxresult,result);
if secondpass;
if result=_maxresult then flag='Y';
if flag='Y' then _maxresult=.X; /*Assign an impossible value for result*/
run;
This program reads each ID/TEST group twice. The first pass generates the retained variable _maxresult. The second passes uses _maxresult to identify the flagged record. Note the "if secondpass;" is a subsetting if statement, so only the secondpass records are output, meaning no duplicate records.
Although there are two "passes" through the data, you won't be doubling the disk channel activity. Since the two passes are tightly synchronized, they are almost always reading observations from the same disk block, which would have been cached in memory by the operating system.
