SAS - Find Palindromes for all Datasets in a Directory - macros

Question

Task:
I need to identify all palindromes within a directory. I use a proc contents and proc sort to identify the datasets within a directory, like so:
proc contents data = dPath._all_ out = dFiles (keep = memname);
run;
proc sort data = dFiles nodupkey; by memname;run;
I want to identify palindromes within this directory.
Issue:
I plan to use macros because I need to do this for all datasets within a directory. So, instead of the user inputting the string to check if there is a palindrome, I need that to be done dynamically, i.e. identify any palindromes within a dataset.
Updates:
As you can see in the above pictures, I am able to successfully flag the palindromes for case sensitive and case insensitive situations. I would like to output the specific element that is a palindrome to a separate dataset. Currently, I am only able to output the entire row with the palindrome in it.
Code:
data palindrome_set (drop = i) palindrome_case_sensitive palindrome_case_insensitive;
set reverse_rows;
array palindrome[*] _all_ ;
do i = 1 to dim(palindrome);
palindrome_cs = (trim(palindrome[i]) eq reverse(trim(palindrome[i])));
/* if palindrome_cs = 1 then output palindrome[i]; WANT TO OUTPUT SPECIFIC ELEMENT, NOT ENTIRE ROW*/
palindrome_cis = (lowcase(trim(palindrome[i])) eq reverse(lowcase(trim(palindrome[i]))));
end;
output palindrome_set;
if palindrome_cs = 1 then output palindrome_case_sensitive; *WANT TO OUTPUT SPECIFIC ELEMENT, NOT ENTIRE ROW;
if palindrome_cis = 1 then output palindrome_case_insensitive; *WANT TO OUTPUT SPECIFIC ELEMENT, NOT ENTIRE ROW;
run;

Answer 1

If memtype ="DATA" then the Memname in your code will hold the table names only.
To check palindromes in table names using your code above; try:
%macro palindrome (parameter = );
%let string = %sysfunc(reverse(%sysfunc(compress("&parameter ",,sp);
%let reverse = %sysfunc(compress(["&parameter ");
%if %upcase(&string.) = %upcase(&reverse.) %then %do;
ods output = "/palindrome"
%end;
data work.palindromes;
set work.dfiles;
%macro palindrome (parameter = Memname);
run;

Answer 2

Not sure why your image showed a reversal of the variable names as well.
The underlying variable name corresponding to an array reference can be retrieved using the data step function VNAME(). Also, the formatted value of a variable can be obtained using the data step function VVALUE. Both these functions have a dynamic version -- VNAMEX and VVALUEX. An array based solution will not need to utilize the X versions of the functions.
Processing all variables via an array is a little tricky because you need additional variables to perform the processing, and you don't want those tested for palindromicity. In this example, worker variable names use the convention of starting with _pal in the hopes of avoiding variable name collision with the data sets being processed. The example processes a single data set, but it should be obvious how to macro-ize the code and have it work for a data set name that is passed.
data want(keep=_palds_ _palrow_ _palvar_ _palval_);
set sashelp.class;
array _pals_ _character_; * array elements are those character variables in the pdv at this point in the data step;
array _palx_ _numeric_; * array elements are those numeric variables in the pdv at this point in the data step;
attrib
_palds_ length = $42
_palrow_ length = 8
_palvar_ length = $32
_palval_ length = $500
;
* check raw character value;
do _palindex_ = 1 to dim(_pals_);
if length (_pals_(_palindex_)) > lengthm(_palval_) then do;
_palvar_ = vname (_pals_(_palindex_));
put "NOTE: sashelp.class " _n_= _palVar_ " had a value that is longer than _palval_ container";
continue;
end;
if _pals_(_palindex_) = reverse(trim(_pals_(_palindex_))) then do;
_palds_ = "sashelp.class";
_palrow_ = _n_;
_palvar_ = vname (_pals_(_palindex_));
_palval_ = _pals_(_palindex_);
end;
end;
* check formatted numeric value;
do _palindex_ = 1 to dim(_palx_);
if left(vvalue(_palx_(_palindex_))) = reverse(trim(vvalue(_palx_(_palindex_)))) then do;
_palds_ = "sashelp.class";
_palrow_ = _n_;
_palvar_ = vname (_palx_(_palindex_));
_palval_ = _palx_(_palindex_);
end;
end;
run;
A macro that wants to explicitly avoid name collision must perform some navel-gazing on the data set to be processed in order to generate worker variable names that do not collide.
Processing all members of the libref can be very resource intensive if the libref connects to a remote host -- so a robust solution may want skip over those.
Some other approaches:
use CALL VNEXT routine to iterate through the pdv variables
use the dictionary table or proc contents output as a basis for generating a wall of variable tests in a data step that does not rely on arrays.