BASH Palindrome Checker

Question

This is my first time posting on here so bear with me please.

I received a bash assignment but my professor is completely unhelpful and so are his notes.

Our assignment is to filter and print out palindromes from a file. In this case, the directory is:

/usr/share/dict/words

The word lengths range from 3 to 45 and are supposed to only filter lowercase letters (the dictionary given has characters and uppercases, as well as lowercase letters). i.e. "-dkas-das" so something like "q-evvavve-q" may count as a palindrome but i shouldn't be getting that as a proper result.

Anyways, I can get it to filter out x amount of words and return (not filtering only lowercase though).

grep "^...$" /usr/share/dict/words |
grep "\(.\).\1" 

And I can use subsequent lines for 5 letter words and 7 and so on:

grep "^.....$" /usr/share/dict/words |
grep "\(.\)\(.\).\2\1" 

But the prof does not want that. We are supposed to use a loop. I get the concept but I don't know the syntax, and like I said, the notes are very unhelpful.

What I tried was setting variables x=... and y=.. and in a while loop, having x=$x$y but that didn't work (syntax error) and neither did x+=..

Any help is appreciated. Even getting my non-lowercase letters filtered out.

Thanks!

EDIT:

If you're providing a solution or a hint to a solution, the simplest method is prefered. Preferably one that uses 2 grep statements and a loop.

Thanks again.

Answer 1

Like this:

for word in `grep -E '^[a-z]{3,45}$' /usr/share/dict/words`;
    do [ $word == `echo $word | rev` ] && echo $word;
done;

Output using my dictionary:

aha
bib
bob
boob
...
wow

Update

As pointed out in the comments, reading in most of the dictionary into a variable in the for loop might not be the most efficient, and risks triggering errors in some shells. Here's an updated version:

grep -E '^[a-z]{3,45}$' /usr/share/dict/words | while read -r word;
    do [ $word == `echo $word | rev` ] && echo $word;
done;

Answer 2

The multiple greps are wasteful. You can simply do

grep -E '^([a-z])[a-z]\1$' /usr/share/dict/words

in one fell swoop, and similarly, put the expressions on grep's standard input like this:

echo '^([a-z])[a-z]\1$
^([a-z])([a-z])\2\1$
^([a-z])([a-z])[a-z]\2\1$' | grep -E -f - /usr/share/dict/words

However, regular grep does not permit backreferences beyond \9. With grep -P you can use double-digit backreferences, too.

The following script constructs the entire expression in a loop. Unfortunately, grep -P does not allow for the -f option, so we build a big thumpin' variable to hold the pattern. Then we can actually also simplify to a single pattern of the form ^(.)(?:.|(.)(?:.|(.)....\3)?\2?\1$, except we use [a-z] instead of . to restrict to just lowercase.

head=''
tail=''
for i in $(seq 1 22); do
    head="$head([a-z])(?:[a-z]|"
    tail="\\$i${tail:+)?}$tail"
done
grep -P "^${head%|})?$tail$" /usr/share/dict/words

The single grep should be a lot faster than individually invoking grep 22 or 43 times on the large input file. If you want to sort by length, just add that as a filter at the end of the pipeline; it should still be way faster than multiple passes over the entire dictionary.

The expression ${tail+:)?} evaluates to a closing parenthesis and question mark only when tail is non-empty, which is a convenient way to force the \1 back-reference to be non-optional. Somewhat similarly, ${head%|} trims the final alternation operator from the ultimate value of $head.

Answer 3

Why use grep? Bash will happily do that for you:

#!/bin/bash

is_pal() {
    local w=$1
    while (( ${#w} > 1 )); do
        [[ ${w:0:1} = ${w: -1} ]] || return 1
        w=${w:1:-1}
    done
 }

 while read word; do
     is_pal "$word" && echo "$word"
 done

Save this as banana, chmod +x banana and enjoy:

./banana < /usr/share/dict/words

If you only want to keep the words with at least three characters:

grep ... /usr/share/dict/words | ./banana

If you only want to keep the words that only contain lowercase and have at least three letters:

grep '^[[:lower:]]\{3,\}$' /usr/share/dict/words | ./banana

Answer 4

Ok here is something to get you started:

I suggest to use the plan you have above, just generate the number of "." using a for loop.

This question will explain how to make a for loop from 3 to 45:

How do I iterate over a range of numbers defined by variables in Bash?

for i in {3..45}; 
do 
   * put your code above here *
done

Now you just need to figure out how to make "i" number of dots "." in your first grep and you are done.

Also, look into sed, it can nuke the non-lowercase answers for you..

Answer 5

Another solution that uses a Perl-compatible regular expressions (PCRE) with recursion, heavily inspired by this answer:

grep -P '^(?:([a-z])(?=[a-z]*(\1(?(2)\2))$))++[a-z]?\2?$' /usr/share/dict/words