Strings

Literal Strings

   "This is a string!"

   "Type \"stop\" to quit."

Zero-based Indexing

   "I am very excited by the Scheme programming language!!!"

Some String Procedures

Procedure	Sample Call	Result of Example	Comment
string	(string #\a #\b #\c)	"abc"	make a string of the given characters
string?	(string? "sample string")	True (#t)	is argument a string?
string-length	(string-length "sample string")	13	number of characters in string
string-append	(string-append "Big" "Small")	"BigSmall"	concatenate two strings
substring	(substring "sample string" 3 10)	"ple str"	extract characters from first to before second designated position from string
string-ref	(string-ref "sample string" 4)	#\l	return character at given position
string->list	(string->list "example")	(#\e #\x #\a #\m #\p #\l #\e)	makes a list of the characters in a string
list->string	(list->string '(#\e #\x #\a #\m #\p #\l #\e))	"example"	makes a string of the characters in a list
symbol->string	(symbol->string 'example)	"example"	change a given symbol to a string
string->symbol	(string->symbol "example")	example	convert a given string to a symbol
number->string	(number->string 3.141592)	"3.141592"	change a given number to a string
string->number	(string->number "3.141592")	3.141592	convert a given string to a number

Some Comparison Predicates for Strings

Predicate	Comment
string=?	Are two strings equal?
string	Does first string come first?
string>?	Does first string come after?
string<=?	Is first string equal the second or does the first come before the second?
string>=?	Are the strings equal or does the first come after the second?
string-ci=?	Same as string=?, but ignoring case
string-ci	Same as string, but considering uppercase and lowercase letters to be equivalent
string-ci>?	Same as string>?, but ignoring case
string-ci<=?	Same as string<=?, but ignoring case
string-ci>=?	Same as string>=?, but ignoring case

Additional Discussion

Picking Appropriate Passwords

With this in mind, we might consider how to generate appropriate passwords in some random way. One approach begins by noting that it is relatively easy for a user to remember a sequence of three letters, if the first letter is a consonant, the second letter is a vowel, and the third is again a consonant. Such three-letter "words" generally are pronounceable and possible to remember.

To make passwords more secure, it also is desirable to include a mix of characters, including uppercase and lowercase letters, digits, and punctuation. The following password generator incorporates each of these ideas:

(define gen-password
   (lambda ()
      (let* ((consonants "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ")
             (cons-len (string-length consonants))
             (vowels "aeiouAEIOU")
             (vowel-len (string-length vowels))
             (digits "0123456789")
             (punctuation ".,<>?/`~!@#$%^&*()_-+={[}]|")
             (punc-len (string-length punctuation))
            )
          (string  (string-ref consonants (random cons-len))
                   (string-ref vowels (random vowel-len))
                   (string-ref consonants (random cons-len))
                   (string-ref digits (random 10))
                   (string-ref punctuation (random punc-len))
                   (string-ref consonants (random cons-len))
                   (string-ref vowels (random vowel-len))
                   (string-ref consonants (random cons-len))
          )
      )
   )
)

1. Run this procedure with the command (gen-password) several times to obtain several candidates for passwords.

2. Explain how the (gen-password) produces a password, and what format one can expect for this format. To what extent do these passwords satisfy the common guidelines of being hard to guess, but relatively easy for the user to remember?

3. Determine the number of different passwords which can be generated by this procedure.
   Hint: Counting upper and lower case letters separately, there are 42 consonants, 10 vowels, 10 digits, and 27 punctuation marks in the above lists.

   It has been estimated that a modern password-cracking program working on a medium-level personal computer can analyze about 70,000 passwords in a day to determine if a user has chosen that password. Using this estimate, about how long might it take a modern personal computer to analyze all the passwords generated by the above (gen-password) procedure?

4. (gen-password) includes a one-digit number in the resulting password, based upon looking up that digit within a string. Another approach would be to generate an random number directly and convert that number to a string. This may be accomplished with the code: (number->string (random 10)). Remove the variable digits in the above procedure, and replace it (and the corresponding string-ref statement) with this direct computation of a number.

   Note: number->string returns a string of characters, and you can use the string-append procedure to put strings of characters together.

5. How would you change the procedure in the previous step to include a two-digit number instead of a one-digit number in the resulting password?

6. The (gen-password) procedure generates 2 three-character consonant-vowel-consonant sequences, by explicitly choosing individual characters from specific strings of letters. Another approach would be to define a procedure gen-syllable, which would return a consonant-vowel-consonant string, and then call this procedure twice in the body of (gen-password). Rewrite the original (gen-password) to include a procedure gen-syllable which is defined locally.

Checking For Appropriate Passwords

1. uppercase letters
2. lowercase letters
3. digits
4. punctuation (considered to be anything not a letter or a digit)

The next part of this lab develops a procedure to determine if a password satisfies this guideline. The first task is to define a procedure that checks if any letter in a string contains an uppercase letter. One approach searches subsequent characters in the string until either an uppercase letter is found or until all letters have been checked. Organizing this work into a husk-and-kernel yields the following code:

(define contains-upper?
   (lambda (str)
      (upper-kernel str (- (string-length str) 1))
   )
)
(define upper-kernel
   (lambda (str pos)
      (cond ((< pos 0) #f)
            ((char-upper-case? (string-ref str pos)) #t)
            (else (upper-kernel str (- pos 1)))
      )
   )
)

7. Test these procedures on several strings to check that they work as claimed.

8. Describe in a paragraph how this code works. In your paragraph, be sure to mention the purpose of each test in the cond. Also, explain why contains-upper? must subtract 1 from the string length when calling upper-kernel.

9. Rewrite contains-upper?, so that upper-kernel is defined locally, using a named let expression.

10. Write a similar procedure to check if a string contains a lower case character.

11. Write a similar procedure to check if a string contains a digit.

12. Write a similar procedure to check if a string contains a punctuation character.

13. Use your procedures in the previous parts to write a procedure good-password?, which takes a string as parameter and which returns true if the string would make an appropriate password according to the guidelines given above. Thus, good-password? should return the following results:

    
    (good-password? "aEioU")  ==> #f  (only 2 categories)
    (good-password? "aei12U") ==> #t  
    (good-password? "A;e")    ==> #f  (too short)
    (good-password? "abc-?B") ==> #t 
    (good-password? ";!$XYZ") ==> #f  (only 2 categories)
    (good-password? ";3BB45") ==> #t 
    

Work To Turn In:

• Commentary for steps 2, 5, 8
• Computations for step 3.
• Complete code (with full procedures) for steps 4, 6, 9-13.

This document is available on the World Wide Web as

http://www.cs.grinnell.edu/~walker/courses/151.sp99/lab-strings.html