Fibonacci Numbers

3. In mathematics, the Fibonacci sequence is a sequence of positive integers, as follows.

   • the first two numbers of the sequence are both 1's.

   • after the first two elements, an element of the sequence is obtained by adding the results of the previous two sequence elements.

   Thus, the first 10 elements of the Fibonacci sequence are: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55

   Write and test a Scheme procedure Fibonacci which takes a parameter n and returns the nth Fibonacci element in the sequence. Also, write a test a procedure Fib-seq which takes a parameter n and returns a list containing the first n elements of the Fibonacci sequence.

   
   (Fibonacci 10)  ===> 55
   (Fib-seq 10)    ===> (55 34 21 13 8 5 3 2 1 1)
   

4. A common processing task involves analyzing dates, such as January 8, 1999. In particular, one often must determine if a date is the last one in a year or the last one in a month.

   For this problem, dates will have three parts:
   month day year,
   where the month and day are integers and the month is a symbol (e.g., january, february, etc.). Write the following procedures:

   • year-end? which returns true if and only if a date ends a year (e.g., December 31, 1998)

   • month-end? which returns true if and only if a date ends a month (e.g., March 31, 1999 or November 30, 1776)

   Notes:

   1. January, March, May, July, August, October, and December have 31 days.

   2. April, June, September, and November have 30 days.
   3. February has 28 days in non-leap years, but 29 days in leap years. A leap year occurs in years when the year is divisible by 4, except that century years are not leap years unless they are divisible by 400. Thus, the years 1999 and 1900 are not leap years, while 1996 and 2000 are leap years.

   Examples: These procedures should produce the following results:

   
   (year-end? 'march 31 1999)      ===> #f
   (year-end? 'december 30 1999)   ===> #f
   (year-end? 'december 31 1999)   ===> #t
   (month-end? 'january 8 1999)    ===> #f
   (month-end? 'january 31 1999)   ===> #t
   (month-end? 'february 28 1999)  ===> #t
   (month-end? 'feburary 28 1999)  ===> #f
   (month-end? 'february 28 2000)  ===> #f
   

5. In a private game, a gambler sets the following personal limits. The gambler starts the evening with $20; he bets $2 on each game and stops when he either runs out of money or has a total of $50. To be more specific, for a specifc game, the gambler bets $2. If the gambler loses the bet, then $2 is deducted from his account. If the gambler wins the bet, then the gambler wins a payoff amount, and the gambler's new balance is increased by that payoff -- the $2 is not deducted. For example, if the payoff is $5 and if the gambler starts the game with $20, then the gambler's new balance would be $18 if the gambler loses a bet and $25 if the gambler wins the bet.

   The following problems will allow you to investigate the likelihood of the gambler winning by simulating games each evening over a period of 1000 nights of gambling. To accomplish this simulation, you are to proceed in three steps:

   1. Write a procedure game which simulates a single bet. Thus, game should have parameters for the gambler's purse amount before the bet, the payoff from a $2 bet, and the probability of the gambler winning the single bet. Then game should return the amount the gambler has after that single bet, using a random number generator and the probability to determine if the gambler won. For example,

      
         (game  37  5  0.7)
      

      should represent the result of a bet, when the gambler starts with $37, when the return on a $2 bet is $5, and when the gambler has a 70% chance of winning the bet. With these values, game should return 35 if the gambler loses the bet and 42 if the gambler wins.

      Note that one way to simulate a bet is to compare (random 1.0) with the probability 0.7:

      
         (cond ((< (random 1.0) 0.7) ;winning part
                    )
               (else ;losing part
                    )
          )
      

   2. Modify game to obtain a procedure evening as follows:
      • the gambler always begins an evening with a $20 purse.
      • if the gambler is cleaned out (the balance is less than $2, the amount required for another bet), evening should return "lost";
      • if the gambler's balance is $50 or more, evening should return "won";
      • if the gambler is still playing and wins the current bet, the gambler continues playing, with the winnings added to his purse; and
      • if the gambler is still playing and loses a bet, then gambler continues playing, with the $2 bet deducted.

      For example, the call

      
         (evening  5  0.7)
      

      should simulate an evening of gambling, where the balance begins at $20, the payoff amount is $5, and the probability of winning a game is 0.7 . The result of this call will be the conclusion "won" or "lost".

   3. Using evening, write a procedure simulate-evenings which takes the payoff from a $2 bet, the probability of winning a single bet, and a number of evenings to be played as parameters and returns the number of evenings won. For example, if the gambler consistently plays (fair) games which have a $2 payoff and a 50% chance of winning, and if the gambler plays 1000 evenings of gambling, then an appropriate procedure call would be:

      
         (simulate-evenings  2  0.5  1000)
      

      Similarly, if the gambler consistently plays (fair) games which have a $4 payoff and a 1/3 change of winning, and if the gambler plays 500 eveings of gambling, then an appropriate procedure call would be:

      
         (simulate-evenings  4  1/3  500)
      

      Hint: Since the number of evenings to be played is the new element distinguishing simulate-evenings from evening, you might focus upon that parameter as the basis for processing in simulate-evenings. An appropriate call to the evening procedure already will handle other details of betting for an evening.

   4. After you have written your procedures, be sure to test them in several cases. What test cases and results can help you determine that your code might be correct?

7. In 1843 Gregor Mendel noticed that certain traits were inherited among the pea plants he was growing. Over the next 25 years he kept careful records of the appearance of parent plants and their offspring, and in 1866 published a paper describing how these traits were controlled by "factors" that could be inherited.

   Mendel determined that a factor (what we now call a gene) has two components. A child gets one component from each of its parents.

   A gene can either be "Dominant" in which case it will control how a trait is expressed, or "Recessive", in which case the expression of the trait may be controlled by the other gene.

   For example, Gregor Mendel noticed that some pea plants are tall, and some are short. If he crossed two short plants, he always got short offspring. If he crossed two tall plants, he sometimes got all tall offspring, as you'd expect, but sometimes a short plant would appear among the offspring. Often, 3/4 of the offspring would be tall, while 1/4 were short.

   Mendel determined that there was a gene for tallness, and that the grow-tall gene was dominant. If one of the genes in a plant was the dominant form of that gene, the plant grew tall. Only when both of the genes were for shortness would the plant be short.

   We denote the dominant form of a gene with a capital letter, and the recessive form with a small letter. The possible combinations of Tallness genes are:

   • TT Tall Plant
   • Tt Tall Plant
   • tT Tall Plant
   • tt Short Plant

   The combination of genes is an individual's genotype. The way a pair of genes is expressed controls an individual's physical appearance. We call the individual's appearance its phenotype.

   If Gregor crossed one of the plants with two dominant genes with a plant with two recessive genes the offspring would each have one dominant Tall gene and one recessive short gene. So the phenotype for these children would be tall, even though the genotype was one Tall and one short gene.

   We might write this cross like this:

   
   TT x tt -> Tt - Tt - Tt - Tt
   

   The genotype for the offspring is "Tt", while the phenotype is "Tall".

   If we crossed one of these Tall offspring with a single Dominant gene for tallness with another plant with a single dominant gene and a single recessive, (two plants with a genotype of "Tt") the results would look like this:

   
   Tt x Tt -> TT - Tt - tT - tt
   

   Three out of 4 offspring have the "Tall" phenotype, and 1/4 would have the "Short" phenotype. One quarter of the offspring would have a genotype of two dominant genes, and one quarter of the offspring would have a genotype of two recessive genes, and one half of the offspring would have a genotype of one dominant and one recessive gene.

   The Current Problem: (While the details of what follows are ficitious, the basic problem arises with remarkable frequency in practice in many business and research settings.)

   In order to celebrate the 150th anniversary of the publishing of Mendel's paper, a group of researchers have been duplicating his work. They've planted several fields of peas, and counted the offspring in each field to start their records. They are counting whether or not the plants are tall or short, whether the seeds are round or wrinkled, and whether the seeds are yellow or green.

   Following current modes of research, the researchers placed their records of the work within a computer database, and they systematically made a backup copy of each disk. For safety against water damage (from a sometimes leaky roof), they kept the backups in another room on a lower floor at the far end of the building. They also kept printouts of some of their data sets.

   Unfortunately, a fire recently swept through much of the building, destroying both the computer system and the room with the backups. Thus, all electronic records were lost. Of course, an off-site storage location for the backups would have resolved this problem, but it is a bit late for second guessing at this point.

   From paper records and from their memories, they have reconstructed the following:

   • They know that the parents for each field are geneticly identical, but they don't know what that genotype is.
   • From their general knowledge of the parent plants, they can reconstruct all the possible combinations of parents. For each combination, they have recently recomputed the expected ratios of offspring would be.
   • They have gone back to the experimental fields and obtained counts of the number of plants of each phenotype for each plot. All of this data from the experimental fields has been entered into a spreadsheet program.

   While all of this raw data is available within the spreadsheet, the program they use doesn't have the capability of comparing all the experimental data with the expected ratios to find out which ones match. So, they've exported the data into two files: one with theoretical and one with experimental data. They need your help to figure out what the possible genotypes of the parents are.

   Following a common format for exporting data from spreadsheets, the files have a single record on each line, and the fields are separated by commas. The file format is:

   Line 1:
   A header line that describes each of the phenotypes:

   Short-Round-Yellow,Short-Round-Green,Short-Wrinkled-Yellow,Short-Wrinkled-Green,Tall-Round-Yellow,Tall-Round-Green,Tall-Wrinkled-Yellow,Tall-Wrinkled-Green
   

   Line 2-N: An identifier, a value for Short-Round-Yellow, a value for Short-Round-Green, ...

   The first few lines of the expected data file look like this:

   Short-Round-Yellow,Short-Round-Green,Short-Wrinkled-Yellow,Short-Wrinkled-Green,Tall-Round-Yellow,Tall-Round-Green,Tall-Wrinkled-Yellow,Tall-Wrinkled-Green,
   tt rr yy x tt rr yy,0,0,0,1.0,0,0,0,0
   tt rr yy x tt rr Yy,0,0,0.5,0.5,0,0,0,0
   tt rr yy x tt rr YY,0,0,1.0,0,0,0,0,0
   tt rr yY x tt rr YY,0,0,1.0,0,0,0,0,0
   tt rr YY x tt rr YY,0,0,1.0,0,0,0,0,0
   tt rr YY x tt rr Yy,0,0,1.0,0,0,0,0,0
   tt rr YY x tt rr yy,0,0,1.0,0,0,0,0,0
   

   For example, the first lineshows that if you have two parents who have all recessive genes (tt rr yy x tt rr yy), all the offspring have recessive phenotypes (Short with Wrinkled, Green seeds).

   If one parent has only recessive genes for yellow, and the other has a dominant and a recessive gene, then half of the offspring will display the dominant trait, and half will display the recessive trait. (From the second line, half will be Short-Wrinkled-Yellow, and half will be Short-Wrinkled-Green.)

   If one parent has two dominant genes, then the offspring will all be of the dominant phenotype. Notice that there are 5 combinations of parents that will produce offspring that all have yellow seeds.

   The experimental data looks like this:

   Short-Round-Yellow,Short-Round-Green,Short-Wrinkled-Yellow,Short-Wrinkled-Green,Tall-Round-Yellow,Tall-Round-Green,Tall-Wrinkled-Yellow,Tall-Wrinkled-Green,
   field1-0,64,60,72,48991,22,49,49,56
   field2-1,29,44,24520,24518,62,33,49,7
   field3-2,23,69,49023,35,27,5,48,24
   

   It is relatively easy to convert one of these lines of data into a line of fractions. If we total up the numbers in each field (64, 60, 72, 48991, 22, 49, 49, 56) and divide each number by that total we get:

   
   64/49363, 60/49363, 72/49363, 48991/49363, 22/49363, 49/49363, 49/49363, 56/49363
   

   or (in decimal)

   
   .0012, .0012, .0014, .9924, .0004, .0009, .0009, .0011
   

   We can compare this set of fractions to the expected values by subtracting each field from the appropriate expected field and adding the absolute values of the differences. If we did it by hand, it would look like this if we compared this line to the first line of the expected data:

   
   | 0 - .0012 | + | 0 - .0012 | + | 0 - .0014 | + | 1 - .9924 | + | 0 - .0004 | + | 0 - .0009 | + | 0 - .0011 |
   

   This returns a value that represents the absolute difference between the expected data and the experimental data. The lower this value is, the closer the match between the experimental and theoretical data. (While there are several techniques for comparing sets of numbers, the absolute value is the simplest, and works well for this application.)

   For this problem you should write a program that can accept a list of fractions, and compare that list to the lists of fractions in the theoretical data file and return the best match. If several theoretical ratios give the same best match, your program may return any of the most likely parents.

   If your program is named find-parents, it might be invoked like this:

   
   (find-parents "/home/flynt/public_html/GeneticTheo" .0012 .0012 .0014 .9924 .0004 .0009 .0009 .0011)
   
   Possible Parents for: (.0012 .0012 .0014 .9924 .0004 .0009 .0009 .0011)
   tt rr yy x tt rr yy,0,0,0,1.0,0,0,0,0
   

   Test your program with:

   (find-parents "/home/flynt/public_html/GeneticTheo"  0.0008 0.0004 0.49 0.49 0.0007 0.0009 0.001 0.0002)
   (find-parents "/home/flynt/public_html/GeneticTheo"  0.0006 0.49 0.0003 0.49 0.0006 0.0004 0.0005 0.0007)
   (find-parents "/home/flynt/public_html/GeneticTheo"  0.002 0.0004 0.0004 0.49 0.001 0.001 0.001 0.49)
   (find-parents "/home/flynt/public_html/GeneticTheo"  0.001 .0004 0.99 0.001 0.0001 0.0001 0.0001 0.0014)
   

   For extra credit, you may do one or both of the following:

   A. Extend your program, so that it returns all such best candidates for parents.

   B. Write an additional program that can:

   1. read each line from the experimental data file.
   2. convert the raw data counts into a set of percentages.
   3. compare that set of percentages to each line in the theoretical data file.
   4. return a list of all the possible parents for each field.

   Hints:

   1. You can modify the get-word and chop-word procedures in your string library to look for a character other than a whitespace to identify a word.
   2. The map and apply commands will be useful for comparing two lists of fractions.

   The experimental data file is in /home/flynt/public_html/GeneticExpt, and the theoretical ratios are in the file /home/flynt/public_html/GeneticTheo.

10. Write a procedure show-multiplication that has two three-digit integers as parameters and then prints their product in the following format:

    
            749
        x   381
        -------
            749
          5992
         2247
        -------
         285369
    

    Use the following cases as part of your testing:

    
    (show-multiplication 749 381)
    (show-multiplication 381 749)
    (show-multiplication 599 100)
    (show-multiplication 120 102)
    (show-multiplication 102 120)
    

11. The fraction 64/16 has the unusual property that its reduced value of 4 may be obtained by "canceling" the 6 in the numerator with that in the denominator. Write a program to find the other fractions whose numerators and denominators are two-digit numbers and whose values remain unchanged after "canceling."

    Of course, some fractions trivially have this property. For example, when numerator and denominator are multiples of 10, such as 20/30, one can always "cancel" the zeroes. Similarly, cancelation is always possible when the numerator and denominator are equal, as in 22/22. Your program should omit these obvious cases.

12. Write a procedure that reads an integer between 1 and 1000 from the keyboard and prints the equivalent number in Roman numerals.

13. Sometimes one can simplify a problem by removing the parts that don't matter, and then looking at what's left.

    For instance if you wanted to figure out if two collections of "stuff" were the same, you might remove matching items from each collection until you see if there are items left over. If you have leftover items, the collections were different, and if both collections become empty at the same time, they areidentical.

    Use this technique to write a program which will determine whether or not two strings are anagrams of each other.

    Test it by deciding whether or not "one plus twelve" is the same as "eleven plus two" .

14. This exercise involves the completion of one of the following problems:

1. Racquetball: Racquetball is a game played by two players on an indoor, enclosed court. Scoring proceeds as follows:
   • The score starts at 0 - 0.
   • Player A starts serving.
     • When Player A wins a volley, she scores a point and is allowed to serve again.
     • When Player A loses a volley, she loses the serve but no points are scored.
   • Player B starts serving.
     • When Player B wins a volley, she scores a point and is allowed to serve again.
     • When Player B loses a volley, she loses the serve but no points are scored.

   A player can only score points while she has the serve. A player loses the serve when she loses a volley, but no points are scored on the change of serve. Play continues until either the score is 11-0, which is a shut-out, or one player scores 21 points. (The rules do not require a player to win by two points.)

   Write a program that reads the probability of Player A winning a volley and then simulates the playing of 500 games with Player A having the first serve on each game. Record the number of wins (including shut-outs) for each player and the percentage of wins. Also record the number of shut-outs for each player.

2. Volleyball:Volleyball is a game played on a court by two teams, separated by a net. Scoring proceeds much the same way as in racquetball (as explained above). In particular, scoring starts at 0-0. A team can only score points while it serves. A team loses the serve when it loses a volley, but no points are scored on the change of serve. Play continues until one team scores 15 points, and a team must win by at least two points (if the score is 15-14, play must continue until one team leads by 2 points). There is no special rule for ending a game due to a shut-out.

   Write a procedure that has as parameter the probability of Team A winning a volley and then simulates the playing of 500 games with Team A having the first serve on each game. The procedure should print the number of wins for each team and the percentage of wins. The procedure also should print the number of shut-outs for each team.

   Hint: Since the flow of activity in this problem is a bit complex, you might write an initial outline describing the overall flow of work for the simulation and/or within a game. Then write main procedures which follow this overall structure and which call other procedures to handle specific details. For example, an overall simulation procedure for the entire 500 games might call an individual game procedure to find the result of each game. The overall simulation procedure then would only have to tabulate results -- the individual game procedure would handle details of a game.

15. The file ~walker/151p/labs/lab26.dat contains several items of information about large American cities. More specifically, in ~walker/151p/labs/lab26.dat , each entry consists of the name of the city (line 1), the county or counties (line 2) and the state (line 3) in which it is situated, the year in which it was incorporated (line 4), its population as determined by the census of 1980 (line 5), its area in square kilometers (line 6), an estimate of the number of telephones in the city (line 7), and the number of radio stations (line 8) and television stations (line 9) serving the city. Thus a typical entry reads as follows:

    
    Albuquerque
    Bernalillo
    New Mexico
    1891
    331767
    247
    323935
    14
    5
    

    A blank line follows each entry, including the last.

    Write a procedure which has a filename as parameter and which answers the following questions about the cities represented in the data files.

    1. Which of those cities has the highest population density (population divided by area)?
    2. Which of these cities has over one million telephones?
    3. Which city has the lowest per capita number of radio and television stations (together)?
    The answers to each of these questions should be printed neatly and clearly by the procedure.

16. Write a procedure file-analysis that takes the name of a file as its argument, opens the file, reads through it to determine the number of words in each sentence, displays the total number of words and sentences, and computes the average number of words per sentence. The results should be printed in a table (at standard output), such as shown below:

    
         This program counts words and sentences in file "comp.text ".
    
         Sentence:  1    Words: 29
         Sentence:  2    Words: 41
         Sentence:  3    Words: 16
         Sentence:  4    Words: 22
         Sentence:  5    Words: 44
         Sentence:  6    Words: 14
         Sentence:  7    Words: 32
    
         File "comp.text" contains 198 words words in 7 sentences
         for an average of 28.3 words per sentence.
    

    In this program, you should count a word as any contiguous sequence of letters, and apostrophies should be ignored. Thus, "word", "sentence", "O'Henry", "government's", and "friends'" should each be considered as one word.

    Also in the program, you should think of a sentence as any sequence of words that ends with a period, exclamation point, or question mark.
    Exception: A period after a single capital letter (e.g., an initial) or embedded within digits (e.g., a real number) should not be counted as being the end of a sentence.
    White space, digits, and other punctuation should be ignored.