--------------------------------------------------
Practice Unix/Linux Questions - Chapters 5, 10, 11
--------------------------------------------------
-IAN! idallen@ncf.ca

All scripts written must begin with a proper script header, including
the correct interpreter, comments, and a proper PATH and umask.

All scripts must work on both Linux (Linux Test Machine) and on AIX Unix.
(The same script must work in both places without modification, unless
otherwise indicated.)

All prompts for user input must appear on the terminal, even if standard
output is redirected.  (Do not send prompts for input into the output file!)
Test this!

Where possible, commands should open their own files.  (Do not use
"cat" needlessly - read more on this point in the week4.txt notes.)

Never let the shell expand glob patterns (wildcards) unexpectedly.
Test this!

Don't assume you can write temporary files into the current directory.
Test this by changing directories to a directory into which you cannot
write and running your script from there.

Pay close attention to the names and locations of output files.

Real scripts must check the error returns on the commands they use.
At minimum, exit the script if an important command fails.

Not all of these scripts are equally difficult to write.  Find the easy
ones first!  Problems in this file have been given a complexity rating
from 1-5, with 1 being "really simple" and 5 being "complex".

TimeSaver: Use filename completion in the shell to complete the names
           of these scripts when you want to test them or edit them.
           Don't keep typing the full path names of the scripts!
           Let your Shell do your typing for you!

--) Type in all the scripts in the parts of Chapter 11 that we study.
    Complexity: 1

    Start with "if1" and "chkargs".  Add the correct script headers to
    the scripts.  Fix the prompts.  Test them to make sure that they work.

--) Write this executable script named "10_top_five.sh"
    Complexity: 1

    Verify that the script has exactly one command line argument.  Verify
    that the argument is a file, and that it is readable.  (Print an
    error message and exit the script if these things are not true.)

    Sort the file and display the first five lines.

    Bonus: Prompt and read the file name if none is given on the
    command line.

--) Write this executable script named "11_file_lines_counter.sh"
    Complexity: 1

    From the command line arguments, select only arguments that are
    readable file names.  (Print warnings and skip over non-files or
    unreadable arguments.)  Output one line per file in this format:

        $ ./foo one . two .. nosuch
        The file 'one' contains    27 lines.
        Ignored non-file '.'.
        The file 'two' contains   123 lines.
        Ignored non-file '..'.
        Ignored non-file 'nosuch'.

--) Write this executable script named "12_string_compare.sh"
    Complexity: 1

    Prompt for and read a string.  Compare this string against each
    one of the command line arguments and print whether or not the
    string is an exact match:

        $ ./foo a two "this is three"
        Input:
        this is three
        You entered: this is three
        String 'this is three' does not match argument 'a'.
        String 'this is three' does not match argument 'two'.
        String 'this is three' matches argument 'this is three'.

--) Write this executable script named "13_many_file_mailer.sh"
    Complexity: 2

    Verify that all the command line arguments are names for non-empty,
    readable files.  Print an error message and exit if this is not true.

    Prompt for and read an email userid.  Email the content of each of
    the files (each argument on the command line) to the given userid,
    one per email message.  The script must check to see that the mail
    command works each time it is used.

    Bonus: Validate all the command line arguments and print *all*
    the errors, and then exit, instead of exiting on the first error
    (and thus not finding other errors in other arguments).

--) Write this executable script named "14_optional_arguments_demo.sh"
    Complexity: 2

    This script takes zero to three arguments.  Without arguments, the
    contents of three variables are displayed.  Each argument replaces
    one of the variables:

    With no arguments, display:   PWD   PATH   HOME
    With 1 argument, display:     arg1  PATH   HOME
    With 2 arguments, display:    arg1  arg2   HOME
    With 3 arguments, display:    arg1  arg2   arg3

        $ ./foo
	Output is: /home/idallen/tmp /bin:/usr/bin /home/idallen

        $ ./foo blue
	Output is: blue /bin:/usr/bin /home/idallen

        $ ./foo blue green
	Output is: blue green /home/idallen

        $ ./foo blue green red
	Output is: blue green red

        $ ./foo blue green red yellow
	./foo: Expecting less than 4 arguments; found 4 (blue green red yellow)

    Restrictions:

    You may only expand $PWD, $PATH, and $HOME *once* each in the script.
    You may only use *one* echo command to produce the output and
    *one* echo command to produce the error message.

    Hints (encrypted using rot13 on all the letters):

    Hfr guerr inevnoyrf gb ubyq gur guerr bhgchg inyhrf.  Vavgvnyvmr
    gur inevnoyrf gb gur inyhrf bs CJQ, CNGU, naq UBZR ng gur fgneg
    bs gur fpevcg.  Qrcraqvat ba gur ahzore bs nethzragf, ercynpr bar
    be zber bs gur inevnoyrf jvgu gur inyhrf sebz gur pbzznaq yvar.
    Gur pbafgehpg "pnfr $# va" vf hfrshy urer.  Ng gur raq bs gur
    fpevcg, hfr gur inevnoyrf va lbhe "rpub" bhgchg yvar.

--) Write this executable script named "15_file_sort_self_compare.sh"
    Complexity: 2

    Verify that the script has exactly one or zero command line file name
    arguments.  If there is no command line argument, prompt for and read
    a filename.

    Verify that the argument or input is a file, and that it is readable.

    Sort the file into the /tmp directory under a temporary name.
    (Use $$ somewhere in the name to help ensure uniqueness.)

    Run a "diff" on the original file and the temporary file and count
    the number of lines of output.  The output should look like this:

        $ ./foo /etc/resolv.conf
	Processing: /etc/resolv.conf
	The file differs from its sorted version by    4 lines.

        $ ./foo
	Enter a file name:
	/etc/passwd
	Processing: /etc/passwd
	The file differs from its sorted version by   69 lines.

    Remove the temporary file when you are done with it.
    The script must check to make sure that the sort worked.

    Bonus: Handle multiple command line arguments (multiple filenames),
    not just one.  (You don't have to handle zero arguments in this case,
    since you haven't learned how to alter the argument list in a script.)

--) Write this executable script named "16_comment_extractor.sh"
    Complexity: 2

    Verify that the script has exactly one command line argument, that
    it is a file, and that it is readable.

    Extract and display all the comment lines (starting with "#") from
    the argument file.

    Bonus: Don't display lines that begin "#!".

    Second Bonus: Handle multiple command line arguments (multiple
    filenames), not just one.  Print the name of the file before its
    list of comments.  Skip over (with a warning) nonexistent or non-file
    pathnames.

        $ ./foo a.sh b.sh no.such
	File a.sh:
	#  $0    (no arguments)
	# A la la script la la la la etc. la la la.
	# -IAN! idallen@ncf.ca    June 1988
	File b.sh:
	#  $0    [pathname]
	# Some other kind of script la la la ho ho ho.
	# -IAN! idallen@ncf.ca    June 1998
	./foo: 'no.such' is not a readable file.

--) Write this executable script named "17_script_interpreter_validator.sh"
    Complexity: 2

    Extract the first line of the script file that is the first command
    line argument.  Validate this first line.  To be valid, it must be
    one of the lines you use in your scripts to date.  Print a special
    message for invalid first lines that are blank.
    
    Make sure that each command line argument you process is a readable
    file - don't try to process directories or unreadable files given
    as arguments, print a warning and skip over them.

        $ head -3 script1.sh
	#!/bin/sh -u
	#  $0   (no arguments)
	# This script does the following:

	$ ./foo script1.sh
	Processing: script1.sh
	Found this first line: #!/bin/sh -u
	This is a valid first line of a script.

        $ head -3 script2.sh
	#/bin/sh -u
	#  $0  pathname
	# This script does the following:

	$ ./foo script2.sh
	Processing: script2.sh
	Found this first line: #/bin/sh -u
	*** This is not a valid first line of a shell script. ***

	$ touch empty.sh
	$ ./foo empty.sh
	Processing: empty.sh
	Found this first line: 
	*** The first line of this script is missing or empty. ***

    Suggestion:

      Use a case statement to compare the line you found with all
      possible valid first lines; each valid line becomes a separate
      pattern to match against the line extracted from the script,
      e.g.:   "#!/bin/sh -u") echo good! ;;
      If none of the valid lines match, the default case will print
      the error message.

    Bonus: Handle multiple command line arguments (multiple files),
    not just one.  Validate the first lines of all of the argument files.
    Skip over (with a warning) non-files or unreadable files.

--) Write this executable script named "18_userid_validator.sh"
    Complexity: 2

    Process all the arguments on the command line.  For each argument,
    validate it as being of the correct standard form for an Algonquin
    student email userid.  Algonquin userids must be exactly 8 characters
    long (with some odd exceptions).  Up to four letters of the last
    name start the userid; the rest of the 8 characters must be digits.

    Some userids may be shorter than 8 characters because they contain
    only 4 digits after a short last name.  (Our class list contains
    two such userids.)  Print warnings about them if you find one.

    Sample classifications:

        abcd0001 - valid
	abc00001 - valid
	ab000001 - valid
	abc0001  - valid, but print warning
	ab0001   - valid, but print warning

	a001     - invalid
	ab001    - invalid
        abcd001  - invalid  (must have at least 4 digits)
	a0001    - invalid
	a0000001 - invalid  (no single-character last names!)
	abcde001 - invalid  (only max 4 letters allowed)
	abcd00001 - invalid (only max 8 characters allowed)
	abc@0001 - invalid
	abc_0001 - invalid
	abc.0001 - invalid
	0001abcd - invalid
	a0a0a0a0 - invalid
	abc00abc - invalid

    Sample script usage:

	$ ./foo abcd0001 ab01 "" "*" alleni abc0001
	Argument 'abcd0001' is valid
	*** Argument 'ab01' is invalid
	*** Argument '' is invalid
	*** Argument '*' is invalid
	*** Argument 'alleni' is invalid
	Argument 'abc0001' is valid (Warning: short format)

    Hints (encrypted using rot13 on all the letters):

    Guvf vf rnfl gb qb hfvat n "pnfr" fgngrzrag gb cnggrea zngpu gur srj
    (5) inyvq hfrevq flagnkrf ntnvafg rnpu nethzrag.  Vs abar bs gur inyvq
    cnggreaf zngpu, gur hfrevq zhfg or vainyvq.  Gur "pnfr" cnggreaf ner
    znqr hc bs fbzr ahzoref bs yrggref sbyybjrq ol fbzr ahzoref bs qvtvgf.

    Bonus: Handle arguments that are either plain userids with no domain
    name attached (as above), or are userids with attached domain names
    of "@algonquincollege.com", e.g.  "abcd0001@algonquincollege.com".
    Any attached domain that is not correct should result in an "invalid"
    classification, even if the userid is of the correct form.  (Hint:
    duplicate your existing tests, but add the domain to the end.)

    Second Bonus: Redo the script to output *all* the valid userids with
    attached Algonquin domain names, whether or not the domain names were
    supplied with the userids.  Send all errors and warnings to stderr.

      Redirecting output will give you a list of "approved" userids:

	$ ./foo abcd0001 ab01 "" "*" alleni abc0001 abcd9999@ncf.ca >out
	*** Argument 'ab01' is invalid
	*** Argument '' is invalid
	*** Argument '*' is invalid
	*** Argument 'alleni' is invalid
	*** Warning: 'abc0001' is a valid short form
	*** Argument 'abcd0001@ncf.ca' is invalid
	$ cat out
	abcd0001@algonquincollege.com
	abc0001@algonquincollege.com

      Amuse yourself by splitting up the passwd file into words and
      feeding it as command line arguments to your script (don't try
      this on ACADAIX - the passwd file is big and it will load down
      the machine - do it on my Linux machine only):

	$ ./foo $(tr ':' ' ' </etc/passwd) >out
	...lots and lots of errors...
	$ cat out | sort -u
	...a nice list of Algonquin userids...

--) Write this executable script named "19_email_validator.sh"
    Complexity: 2

    Process all the arguments on the command line.  For each argument,
    validate it as being of the correct standard form for an Internet
    email address.  No blanks are allowed, and only one "@" is permitted.
    The userid part cannot be empty, and the host part cannot be empty.

    Sample classifications:

        a@b   - valid
	a     - invalid (missing host)
	a@    - invalid (missing host)
	@a    - invalid (missing userid)
	@     - invalid (missing userid and missing host)
	a@@b  - invalid (only one @ allowed)
	got blanks@foo.com - invalid (blanks not allowed)
	foo@more blanks.com - invalid (blanks not allowed)

    Hints (encrypted using rot13 on all the letters):

    Ntnva, guvf pna or cebtenzzrq hfvat n fvzcyr frg bs "pnfr" cnggreaf
    gung pna or nccyvrq gb gur nethzrag gb qrpvqr vs vg zrrgf gur
    pevgrevba va dhrfgvba.  Or pnershy nobhg trggvat gur beqre bs gur
    "pnfr" fgngrzragf naq cnggreaf pbeerpg.  (Lbh znl arrq zber guna
    bar "pnfr" fgngrzrag gb cresbez nyy gur pynffvsvpngvbaf.)

--) Write this executable script named "20_bulk_mailer.sh"
    Complexity: 3

    Run "rusers" to the AIX Unix Machine.  Extract only the userids.
    (Get rid of the first word, which is the machine name.)  Remove
    duplicate userids.  (See the Hints for help.)

    For each userid on the machine, pretend to send them an email message.
    (Do not actually send the email!)  The contents of the email message
    is in the file given as the only command-line argument.  Sample:

      $ echo "Hello there." >msg.txt
      $ ./1_bulk_mailer.sh msg.txt
      Your bulk message file contains:
      Hello there.
      I would send to these userids on acadaix.algonquincollege.com:
      mail abcd0001@acadaix.algonquincollege.com <msg.txt
      mail abce0002@acadaix.algonquincollege.com <msg.txt
      mail abcf0013@acadaix.algonquincollege.com <msg.txt
      mail abcg0293@acadaix.algonquincollege.com <msg.txt
      Done!

    Reminder: Validate the command line argument before using it.
              Print an error and exit the script if the validation fails.
              - is exactly one argument present?
              - is it a file?
              - is it non-empty?
              (see Chapter 11, p.372)

    Note: You could implement this to send one message to *all* the
          userids, instead of one message to each userid.  (Call the
          "mail" command just once, and give it all of the userids.)
          Try writing it both ways.

    Hints: - It is easier to remove the first line than the first word,
             given the Unix commands you know so far.  Convert the
             rusers output to individual lines instead of one line.
           - Remember "man uniq" (also in Chapter 3).

    Bonus: Pass the machine name as another command line argument.
           Make sure the argument exists before you use it!
           (This happens automatically if the shell runs with "-u".)

--) Write this executable script named "21_directory_lister.sh"
    Complexity: 3

    Classify each of the command line arguments as to whether it
    is an existing directory, an existing file, or "anything else".
    Display all the directory arguments before all the file arguments
    before all the other things.

        $ ./foo /etc/motd /bin nosuch /etc/passwd /etc /dev/null
	Directories: /bin /etc
	Files: /etc/motd /etc/passwd
	Other: nosuch /dev/null

    Hints (encrypted using rot13 on all the letters):

    Fgneg jvgu guerr rzcgl inevnoyrf (fgevatf), rnpu bar hfrq gb ubyq bar
    bs gur guerr glcrf bs guvatf.  Nf lbh pynffvsl rnpu pbzznaq nethzrag,
    nccraq vgf anzr gb gur nccebcevngr inevnoyr (fgevat).  Ng gur raq
    bs gur fpevcg (nsgre cebprffvat nyy gur nethzragf), bhgchg gur
    guerr inevnoyrf.

--) Write this executable script named "22_pathname_classer.sh"
    Complexity: 4

    Verify that the script has exactly one command line argument.

    Classify the one pathname argument according to each of these criteria:

        - IN CURRENT DIRECTORY: argument contains no slashes
        - RELATIVE: argument does not start with a slash
        - ABSOLUTE: argument starts with a slash
        - UPWARD-LOOKING: contains a parent directory reference ("..")
        - TROUBLESOME: contains a blank, question mark, or asterisk

    Examples of input pathnames and the expected output classifications:

	$ ./foo abc
	"abc" - IN CURRENT DIRECTORY, RELATIVE

	$ ./foo abc/def
	"abc/def" - RELATIVE

	$ ./foo /abc/def
	"/abc/def" - ABSOLUTE

	$ ./foo /abc/../def
	"/abc/../def" - ABSOLUTE, UPWARD-LOOKING

	$ ./foo ..
	".." - IN CURRENT DIRECTORY, RELATIVE, UPWARD-LOOKING

	$ ./foo "/abc/../My Documents"
	"/abc/../My Documents" - ABSOLUTE, UPWARD-LOOKING, TROUBLESOME

    Make sure you test "upward-looking" using all possible upward-looking
    pathname syntaxes.

    Hints (encrypted using rot13 on all the letters):

    Hfr gur cnggrea-zngpuvat novyvgl bs gur "pnfr" fgngrzrag gb
    nccyl n cnggrea gb gur nethzrag gb frr vs vg zngpurf (be qbrf
    abg zngpu).  Lbh jvyy arrq frireny pnfr fgngrzragf, bar sbe rnpu
    glcr bs pynffvsvpngvba.  Fgneg jvgu na rzcgl fgevat (abguvat xabja
    nobhg gur nethzrag cnguanzr), naq nf lbh qvfpbire zber vasbezngvba
    nobhg gur cnguanzr, nccraq gb gur fgevat.  Ng gur raq bs gur fpevcg,
    bhgchg gur fgevat pbagnvavat nyy gur vasbezngvba nobhg gur cnguanzr.

    Bonus: Handle multiple command line arguments (multiple pathnames),
    not just one.

    Second Bonus: Get the commas correct in the output.  (Commas appear
    between classifications; trailing commas are not output.)  There are
    at least two ways to do this - don't put in commas that aren't needed
    (that aren't between classifications); or, remove extra trailing
    commas before you output the classifications.  You know enough
    scripting to do the first method.  Hint: A comma is only needed
    when appending to a classification to a string that is not empty.

--) Write this executable script named "23_empty_directory_tester.sh"
    Complexity: 3

    This script finds empty directories for you.  The output should
    look like this:

        $ ./foo /bin
	Argument '/bin' is a directory.
	Directory '/bin' is searchable.
	Directory '/bin' contains     90 non-hidden names.

	$ mkdir empty
	$ ./foo empty
	Argument 'empty' is a directory.
	Directory 'empty' is searchable.
	Directory 'empty' contains no non-hidden file names.

    Note: Do *not* output "contains     0 non-hidden names".

    Bonus: Include hidden names in the name count; but, if a directory
    only contains "." and ".." you must call it "empty" in the output:

	$ mkdir empty
	$ ./bonus empty
	Argument 'empty' is a directory.
	Directory 'empty' is searchable.
	Directory 'empty' is empty.

--) Write this executable script named "24_argument_size_classer.sh"
    Complexity: 3

    Process all the command line arguments.  Classify each argument
    according to the count of the number of characters it contains:

	0 characters: empty
	1-5 characters: very short
	6-10: short
	anything else: long

    Sample output:

	$ ./foo a 0123456789 01234567890abcdef ""
	Argument 'a' is: very short
	Argument '0123456789' is: short
	Argument '0123456789abcdef' is: long
	Argument '' is: empty

    Hints (encrypted using rot13 on all the letters):

    Lbh pna qb guvf frireny jnlf.  Bar jnl vf gb npghnyyl pbhag gur ahzore
    bs punenpgref va gur nethzrag naq gura hfr fbzr 'vs' fgngrzragf gb
    pynffvsl gur punenpgre pbhag.  Nabgure (fubegre) jnl vf gb fvzcyl
    cnggrea zngpu gur nccebcevngr ahzore bs punenpgref ntnvafg gur
    nethzrag va n "pnfr" fgngrzrag.  Sbe rknzcyr, gur cnggrea  ?|??)
    jbhyq zngpu na nethzrag gung vf bar be gjb punenpgref ybat.

    Bonus: Don't use the plural "1 characters" when only one character
    exists.  Use the singular "1 character".

--) Write this executable script named "25_file_size_classer.sh"
    Complexity: 3

    Process all the command line arguments.  Skip over (with a warning
    message) any arguments that are not readable files.

    Classify each file according to the count of the number of lines it
    contains:

	One digit (0-9): small
	Two digits (10-99): medium
	Three digits (100-999): large
	anything else (1000 or more): huge

    Sample output:

	$ ./foo a /bin c d
	File 'a' contains      4 lines and is: small
	non-file '/bin' ignored
	File 'b' contains     94 lines and is: medium
	File 'c' contains  10494 lines and is: huge

    Hints (encrypted using rot13 on all the letters):

    Lbh pna qb guvf hfvat 'vs' fgngrzragf gb rfgnoyvfu pynffvsvpngvbaf
    onfrq ba gur ahzrevp inyhr bs rnpu enatr; ubjrire, n "pnfr" fgngrzrag
    pna rnfvyl cnggrea zngpu bar, gjb, be guerr qvtvgf naq qb gur fnzr
    guvat jvgu yrff pbqr.  Gur "qrsnhyg" pnfr jvyy unaqyr gur erfg.
    Znxr fher lbh genafyngr njnl nal oynaxf nebhaq gur ahzore orsber lbh
    gel gb cnggrea zngpu vg.  (Qba'g eryl ba n svkrq ahzore bs oynaxf
    orvat bhgchg ol nal Havk pbzznaq!  Gur ahzore bs oynaxf znl inel
    sebz flfgrz gb flfgrz.)

--) Write this executable script named "26_script_permission_validator.sh"
    Complexity: 3

    Make sure that the given single pathname command line argument is a
    readable file and that the first line of the file starts with "#!".
    Print an error and skip this argument if these things are not true.

    Make sure that this pathname is executable by you.  Print a warning
    message and the permissions of the file if it is not.

        $ ./foo bar.sh
	Processing: bar.sh
	Found this first line: #!/bin/sh -u
	This line contains '#!' at the beginning.
	*** Warning: This script is not executable by you.
	-rw-r--r--    1 alleni  alleni       123 Jul  1 15:13 bar.sh

    Bonus: Handle multiple command line arguments (multiple files),
    not just one.  Check the all of the argument files.
    Skip over (with a warning) non-files or unreadable files.

--) Write this executable script named "27_permission_protector.sh"
    Complexity: 3

    For the given single pathname command line argument, make sure
    that neither "group" nor "other" write permission is turned on for
    that pathname.  The script must handle file pathnames or directory
    pathnames.  Print an error for nonexistent pathnames.

        $ ./foo .
	Pathname '.' is okay (not group or other writable).

	$ ./foo foo
	*** Pathname 'foo' is writable by group.
	    Permissions found: -rwxrwxr-x

	$ ./foo nosuch
	*** Pathname 'nosuch' does not exist.

    Hints (encrypted using rot13 on all the letters):

    Trg gur crezvffvbaf bs gur cnguanzr.  Rkgenpg whfg gur svefg jbeq bs
    gur ybat yvfgvat yvar (gur cneg gung ybbxf yvxr "-ejke-ke-k") vagb
    n inevnoyr.  (Gurer ner frireny jnlf gb qb guvf, vapyhqvat cvcvat
    vagb "ge" naq "urnq", be cvcvat vagb "phg".)  Hfr n pnfr fgngrzrag
    gb pbzcner guvf bar crezvffvbaf jbeq jvgu n frevrf bs cnggreaf gung
    qrgrpgf n "j" va gur cbfvgvba bs "tebhc" be "bgure" vafvqr gur jbeq,
    r.t. n cnggrea bs  ?????j????)  jbhyq zngpu tebhc jevgr crezvffvba
    va n pnfr inevnoyr pbagnvavat "-ejkejke-k".

    Bonus: Handle multiple command line arguments (multiple pathnames),
    not just one.  Skip over (with a warning) nonexistent pathnames.

    Second Bonus: Make sure that each pathname that is a directory also
    has read, write, and execute permissions for the owner, and that
    each pathname that is a file also has read and write permissions
    for the owner.  (There are several ways of doing this.  You can use
    the method described in the Hints above; or, you can use a series of
    "test" commands to test each of the permissions.)

--) Write this executable script named "28_third_test_demo.sh"
    Complexity: 3

    Display a menu of 6 choices.  Choices 1, 3, and 5 execute the code
    for the three scripts of the Third Unix test.  Choices 2, 4, and 6
    remove the output (if any) of those scripts.

--) Write this executable script named "29_make_backup.sh"
    Complexity: 3

    Verify that the script has exactly one command line argument.  Verify
    that the argument is a file, and that it is readable.  (Print an
    error message and exit the script if these things are not true.)

    See if a backup version of the given file exists.  (The backup
    version is named with ".bak" appended to the file name.)  If it does
    not exist, create a backup version of the file by copying it to the
    same name with ".bak" appended and then exit the script.  Use the
    "-p" option of the copy command to preserve the modify time on the
    backup copy of the file.  (Test the return code of the copy.)

    If a backup copy already exists, present the user with a menu of
    choices about what to do with the two files:

       1) Display a long listing of the two files.
       2) Display a "diff" of the two files.
       3) Run "more" on the original file.
       4) Run "more" on the backup file.
       5) Copy the original file onto the backup file.
       6) Remove the backup file.
       q) Quit (exit) the script.
    
    Implement these actions in the script and test that they work.

    Bonus: Prompt and read the file name if none is given on the
    command line.

    Second Bonus: Put the menu and actions in a loop, so that the menu is
    presented over and over (allowing several choices without re-running
    the script) until "q" is enterd to exit the loop and the script.

--) Write this executable script named "30_two_number_sort.sh"
    Complexity: 2

    Get two numbers, either as two command line arguments or prompting
    for two numbers from standard input.

    Validate that each of the two inputs is numeric (at least starts and
    ends with a digit).

    (You can't easily make sure an input is "only digits" in the shell;
    however, you can use patterns in a "case" statement to verify that
    each item you read at least starts and ends with a digit.  Make sure
    you also handle the case where the item read is a single digit!)

    Output the smaller number followed by the larger number, in this form:

       You entered 100 and 12.  In order, they are: 12 100

    You may use only one "echo" statement to produce the above message.
    (The "echo" statement that produces the standard output of the script
    must appear in only one place in the script.  Hint: Use variables
    to hold the smaller and larger numbers.)

--) Write this executable script named "31_integer_sorter_v1.sh"
    Complexity: 3

    Prompt for and read three integers.  Validate the input.

    Output the integers in order from smallest to largest, in this form:

        The numbers are, from smallest to largest: 23 156 9823

    You probably need to write a correct pseudocode algorithm to do
    this first, before you write the script to do it.

--) Write this executable script named "32_integer_sorter_v2.sh"
    Complexity: 3

    Same as above; but, use exactly three command line arguments
    instead of reading three inputs.

--) Write this executable script named "33_integer_sorter_v3.sh"
    Complexity: 4

    Same as above; but, use a mixture of command line arguments
    and prompts for input.

    If the user supplies three command line arguments, don't prompt for
    any input; use the command line arguments.  If the user supplies
    only two command line arguments, prompt for and read the missing
    third integer.  If the user supplies only one command line argument,
    prompt for and read the missing two ingegers.  If the user supplies
    no command line arguments, prompt for and read all three missing
    integers.

    Remember to validate the three inputs!

--) Write this executable script named "34_range_tester_v1.sh"
    Complexity: 3

    Prompt for and read two "range" integers.  In the prompts, tell the
    user that the second range integer must be bigger than the first
    range integer.

    Validate both inputs to make sure they start and end with digits,
    and to make sure the second integer is bigger than the first one.

    Validate each command line argument to make sure it starts and ends
    with a digit.  Compare the argument against the range and print
    whether or not it lies above the first range integer and below the
    second one.  The output must look like this (except that your prompts
    should be much more informative):

        $ ./foo 12 34 567
        Input:
        20
        Input:
        40
        Argument 12 lies below low range 20.
        Argument 34 lies between 20 and 40.
        Argument 567 lies above high range 40.

--) Write this executable script named "35_range_tester_v2.sh"
    Complexity: 4

    As above, but allow the user to enter the range integers in any
    order.  (Smallest could be first *or* second.)  Your program will 
    detect the reversed order and still give the correct results.

    Just to be sure, echo back the low range integer and the high
    range integer.

    Remember to validate the inputs!

--) Write this executable script named "36_range_tester_v3.sh"
    Complexity: 4

    As above, but use two command line arguments as the two range
    integers.  Loop, prompting for and reading the integers to be tested
    from the user (instead of from the command arguments).  Exit when
    the string "quit" is given as input.

        $ ./foo 40 20
        The low range integer is 20.
        The high range integer is 40.
        Input:
        12
        Input 12 lies below low range 20.
        Input:
        34
        Input 34 lies between 20 and 40.
        Input:
        567
        Input 567 lies above high range 40.
        Input:
        quit
        Input quit means Goodbye!
        $ 

    Remember - the range integers could be supplied in either order.
    Your script must work no matter whether the integers are given as
    smaller followed by larger or larger followed by smaller.

    Remember to validate the inputs!

--) Write this executable script named "37_file_ranger.sh"
    Complexity: 4

    Expect two command arguments to be numbers establishing a range (as
    above).  Validate the inputs.  Examine all the files in the current
    directory (ignore non-files).  Output the name and line count of
    any file that contains a number of lines that lies between the two
    range numbers given on the command line.  The range numbers may be
    supplied in either order - the script must still work correctly.

--) Write this executable script named "38_file_ranger_v2.sh"
    Complexity: 4

    As above; but, prompt for and read the two numbers from standard
    input.  (Validate the input!)  Process only the pathnames given as
    command line arguments, instead of processing the current directory.
    Instead of ignoring non-files, print a warning and skip them.

    As before, output the name and line count of any file that contains a
    number of lines that lies between the two numbers read from the user.

--) Write this executable script named "39_path_validator.sh"
    Complexity: 4

    The purpose of this script is to validate each of the directory
    components in the PATH variable of the person who executes the script.
    (Do not validate the PATH of the script itself!)  Sort and eliminate
    duplicate directories from the output.  Test to make sure each
    component of the PATH is a directory and that it is searchable.  Also,
    print a stern warning if the current directory is found in the PATH.

    Sample execution:

	$ echo "$PATH"
	/bin:/usr/bin:/etc:/usr/sbin:/usr/ucb:/usr/bin/X11:/usr/lpp/X11/bin:/sbin:/shome/abcd0001/bin:/sysadm/app:/sysadm/local/bin:/usr/local/bin:/usr/lib:.

        $ ./foo
	OK .
	WARNING: PATH contains CURRENT DIRECTORY!
	OK /bin
	OK /etc
	OK /sbin
	Not searchable: /shome/abcd0001/bin
	OK /sysadm/app
	OK /sysadm/local/bin
	OK /usr/bin
	OK /usr/bin/X11
	OK /usr/lib
	OK /usr/local/bin
	OK /usr/lpp/X11/bin
	OK /usr/sbin
	OK /usr/ucb

    Hints (encrypted using rot13 on all the letters):

    - fnir n pbcl bs gur pheerag CNGU va n inevnoyr orsber lbh frg gur
      fpevcg CNGU naq hznfx
    - fcyvg gur fnirq cngu ncneg vagb frcnengr yvarf ol gheavat gur 
      pbybaf vagb arjyvarf (rnpu yvar jvyy or n qvssrerag qverpgbel)
    - fbeg gur qverpgbel yvarf naq erzbir gur qhcyvpngrf (Puncgre 3)
    - chg gur qverpgbevrf vagb gur yvfg bs n "sbe" ybbc naq grfg rnpu bar
    - bayl frnepunoyr qverpgbevrf pbagnva n ivfvoyr anzr ".", r.t.  /qve/.
      (Vs /qve vf n qverpgbel; ohg, vg vf abg frnepunoyr, gura lbh
      jba'g or noyr gb npprff /qve/. vafvqr gur qverpgbel.)

--) Write this executable script named "40_script_path_validator.sh"
    Complexity: 4

    As above, except the script must pick out the "PATH=" line from the
    script file that is the first command line argument and validate it,
    instead of validating the current PATH.  Make sure the argument is
    a readable file - don't try to process directories or unreadable
    files given as arguments.

	$ grep 'PATH=' myscript.sh
	export PATH=/bin:/user/bin:/sbin

        $ ./foo myscript.sh
	Processing script file 'myscript.sh'.
	Found: export PATH=/bin:/user/bin:/sbin
	OK /bin
	OK /sbin
	Not searchable: /user/bin

    Hints (encrypted using rot13 on all the letters):

    - Inyvqngr gur fvatyr pbzznaq yvar nethzrag.
      (vf vg gurer?  vf vg n svyr?  vf vg ernqnoyr?  vf vg rzcgl?)
    - Rkgenpg gur svefg yvar pbagnvavat 'CNGU=' sebz gur nethzrag svyr
      naq fgber va n inevnoyr.  (Gb xrrc guvatf fvzcyr, whfg cvpx bhg
      gur svefg yvar, vs nal, abg nyy gur yvarf.)
    - Rkvg jvgu n zrffntr vs ab CNGU= yvar pna or sbhaq.
    - Fcyvg gur grkg bs gur inevnoyr ba "=" naq rkgenpg whfg gur 
      pbyba-frcnengrq yvfg bs qverpgbevrf.  (Lbh pna qb guvf va
      frireny jnlf, vapyhqvat hfvat "ge" naq "gnvy", be hfvat "phg".)
    - Cebprff gur yvfg bs qverpgbevrf nf va gur CNGU irevslvat fpevcg nobir.

    Bonus: Handle multiple command line arguments (multiple files),
    not just one.  Validate the PATH in all of the argument files.
    Skip over (with a warning) non-files or unreadable files.

--) Write this executable script named "41_which_path_finder.sh"
    Complexity: 4

    The purpose of this script is to mimic the way the shell searches
    in your PATH to find executable files when you enter a command name.

    For the command name given as the first command line argument to this
    script, print in which of your current PATH directories the given
    argument name may be found as an executable file.  (The script must
    search the current PATH of the person running the script, not the
    PATH set inside the script file itself!)

    Do not look up in PATH any command line argument that contains a
    slash.  (The shell doesn't look in PATH if the command name contains
    a slash, which is why "./foo" works the way it does.)

        $ ./foo date
	Looking for argument "date" in your PATH.
	Your PATH contains: /bin:/usr/bin:/sbin
	Found executable file: /bin/date

        $ ./foo ./foo
	Argument './foo' contains a slash - no PATH search will be done.
	Found executable file: ./foo

        $ ./foo /no/such
	Argument '/no/such' contains a slash - no PATH search will be done.

    Bonus: Print "Command name '/no/such' not found" if the script is
    unable to locate any executable file for the given argument /no/such.

    Second Bonus: Handle multiple command line arguments (multiple
    command names), not just one.

    Hints - same as previous questions dealing with PATH.