• This hw is SOLO.  As explained in the course syllabus, you must not discuss these problems or share your code with anyone else except for the course staff and the tutors at Academic Development.
• All your code must be placed in a file named hw1.py.  Follow the steps below to get the starter file from us.
• You must use Linux (either in the Cluster and/or via ssh).  You must use vi and no other editor.  You may not use loops, conditionals, imports, exceptions, lists, strings, recursion, or anything else we've not yet covered.  The autograder script will generally enforce this restriction, though it may miss some cases (which are still disallowed!).
• Some problems assigned this week would be more naturally and elegantly solved using conditionals or other techniques that are not available this week.  Why assign them now?  Because they present interesting challenges to solve given just the arithmetic and simple built-in functions we have covered.  Once you learn new techniques, you'll probably not solve these this way (nor should you), but you'll still benefit from doing so here.
• To get started:
  1. Log into AFS (either on a cluster machine or via ssh)
  2. Create a hw1 directory.  You may place this anywhere, but we recommend here:  ~/private/15112/hw/hw1/
  3. cd into your hw1 directory, with something like this:
          cd ~/private/15112/hw/hw1
  4. copy the hw1 starter file hw1.py into your hw1 directory, with something like this (where the dot (.) means "the current directory")
          cp /afs/cs.cmu.edu/academic/class/15112-s12/www/handouts/hw1.py .   [Don't miss the trailing dot!]
  5. copy the hw1 public autograder file hw1-public-grader.py into your hw1 directory, with something like this (where the dot (.) means "the current directory")
          cp /afs/cs.cmu.edu/academic/class/15112-s12/www/handouts/hw1-public-grader.py .    [Ditto!]
  6. Note that you will edit hw1.py, and you will use but not edit hw1-public-grader.py.
  7. To check if everything is working, try this:
          python hw1-public-grader.py
  8. If you see autograding output that indicates 0 points at the end, that's good.  If you see some other sort of error (no such file, etc), then you did not set things up correctly.  In that case, stop, try again, get some help, but in any case do not proceed until you have the files set up properly!
  9. Now you can edit hw1.py to solve the problems.  Then you can run either hw1.py or hw1-public-grader.py to test your solutions (you can run either one because we added code at the bottom of hw1.py that simply runs the autograder).  These tests are informal, and do not count as submissions.
• To submit for an official grade on Autolab:
  1. You should not submit your hw until you've tested it fairly well using the public autograder distributed with the homework.
  2. Once you are ready to submit, just cd to the directory where your hw1.py file is, and then enter this command in the ssh shell:
          submit-hw1
     If you did not properly set up your .cshrc file, then our course scripts will not be on your path.  in that case, you will get the error:  "submit-hw1:  Command not found".  If this occurs, go to the Getting Started class notes and set up your ~/.cshrc file exactly as described there, then exit ssh, relogin in, and try again (because the changes won't take affect until the next time you login).  if the problem persists, contact the course staff.
  3. It is possible that your publicly-autograded grade differs from the privately-autograded official grade, because we may use a more complete suite of tests in our private autograder.  However, we will not do that for hw1.
  4. You may resubmit your hw repeatedly (but please keep within reason), but only the last submission will be graded (even if a prior submission scored more points).  In particular, if you submit before the deadline, then again one day later, you will receive the late-day penalty even if your first submission was perfect!
  5. Do not leave submissions until just before the deadline.  You should anticipate that the server may be rather sluggish at that time.  You are responsible for on-time submissions even in the face of a slow server response time near the hw deadline.

Some possibly very helpful hints:

• All the functions you must write have already been started for you in hw1.py.  Just edit the part that says "return 42".  Don't retype everything we've already provided for you.
• Be sure to run your code in order to see how the autograder thinks you are doing.  No need to submit your code to find out where you stand!
• When the autograder reports a bug in your code, look very carefully at the autograder output.  It generally provides very useful and specific information about what led to the bug.
• While you may not import math functions (or anything else for that matter), you may use the built-in functions (max, min, round, int, complex, float, etc...)
• While you may not use strings this week, you may also use the ord and chr functions (even though we did not yet cover them in class).  These convert back and forth between letters and their ascii codes.  For example, if you look up "A" in any ascii table (easily found with Google), you'll see that its code is 65.  And so, ord("A") returns 65.  And in reverse, chr(65) returns "A".  The letters are in order, so chr(66) returns "B", chr(67) returns "C", and so on.  You will need this in order to solve some problems in this hw.
• When working with bitwise operators (as in the rgba problems below), it may be easier to represent your constants in hexadecimal.  In particular, 0xff in hex is equal to 255 in decimal and to 0b11111111.
• Also, with bitwise operators, you may wish to use masks.  These are usually well-chosen constants that can be and'ed with other numbers to turn off (set to 0) some of their bits (or, similarly, or'ed with them to turn on (set to 1) some of their bits).  For example, think what (x & 0x03) might do.  You'll want to do this, only not with the constant 0x03 most likely.
• For the bonus problem, you may convert a complex number z to a real number by using z.real.  Unfortunately, in older versions of Python (such as 2.5.x, which is on some Linux machines), you can only do this with complex numbers.  Since you cannot use a conditional to test if z is complex, this is a problem if you are running on such a system.  One way around this:  first convert z to a complex with complex(z), whether or not it was already complex.  At that point, you can safely use z.real.  Sweet (if a bit hacky).

1. Get to Know Your CA's and Tutors
2. nthFibonacciNumber
3. isPerfectIntCube
4. getInRange
5. encodeRgba
6. isGreen
7. getColorFamily
8. getSpecialSection
9. bonus/optional:  bonusGetLetterGrade
10. bonus/optional:  bonusFindIntRootsOfCubic

1. Get to Know Your CA's and Tutors  [20 pts]
   The point of this exercise is to get to know your CA's and Tutors (the ones assigned to your section).  Soon after this hw is posted, you will receive an email explaining how to sign up for a 30-minute small-group (~3 students) meeting with your section's CA and tutors.  Sign up asap to get a time that works best for you.  In any case, in that session, you will review some of the problems from these week1 practice problems.  Specifically, you will review the even-numbered sub-problems in these meetings (and you will review the other problems in this week's recitation).  You are encouraged to work through the problems prior to your meeting, but this is not required.  Everyone who attends such a session will receive the full 20 points that this exercise is worth.
    
2. nthFibonacciNumber  [12 pts]
   Write the function nthFibonacciNumber that takes a positive integer n and (without using loops) returns the nth Fibonacci number, so:
      nthFibonacciNumber(1) returns 1
      nthFibonacciNumber(2) returns 1
      nthFibonacciNumber(3) returns 2
      nthFibonacciNumber(4) returns 3
      nthFibonacciNumber(5) returns 5
      nthFibonacciNumber(6) returns 8
   Hint: look at formula (8) here, where phi (in the numerator) is the Golden Ratio. Cool!
    
3. isPerfectIntCube [12 pts]
   Write the function isPerfectIntCube(x), which takes an arbitrary value x (which may or may not be an int) and returns True if x is an int value and it is a perfect cube (that is, it is the cube of another int value).  For example, 27 is a perfect cube, because 27 equals 3 cubed.
    
4. getInRange [12 pts]
   Write the function getInRange which takes 3 values (which you may assume are all numeric) -- x, bound1, and bound2, where bound1 is not necessarily less than bound2. If x is between the two bounds, just return it unmodified.  Otherwise, if x is less than the lower bound, return the lower bound, or if x is greater than the upper bound, return the upper bound.
   For example:
       getInRange(1, 3, 5) returns 3 (the lower bound, since 1 lies to the left of the range [3,5])
       getInRange(4, 3, 5) returns 4 (the original value, since 4 is in the range [3,5])
       getInRange(6, 3, 5) returns 5 (the upper bound, since 6 lies to the right of the range [3,5])
       getInRange(6, 5, 3) also returns 5 (the upper bound, since 6 lies to the right of the range [3,5])
    
5. encodeRgba [12 pts]
   Background:  computer programs often store colors using their red, green, blue, and alpha (transparency) components.  These are often stored in a single 32-bit integer, where each successive 8-bit portion of the 32-bit number represents each of red (most-significant), green, blue, and alpha (least-significant) in order.  So, for example, consider the rgba value 0x40ff0080 (which is hex for the decimal value 1090453632).  This single number represents a color with some red (0x40, or 64, with a max of 255, so about 1/4th intensity), full-on green (0xff, or 255, which is full intensity), no blue at all (0x00, or 0, so none), and an alpha transparency of 0x80 (or 128, or about half-transparent).
   
   With this in mind, write the function encodeRgba that takes 4 values representing the red, green, blue, and alpha portions of an rgba value. You may assume those values are int's, but you may not assume they are in the right range. Use the getInRange function you just wrote to adjust each value as needed to be in the range [0,255] (inclusive). Then, use bitwise operators as needed to encode a single 32-bit int value with these 4 8-bit values, with red on the top, then green, then blue, and finally alpha at the bottom. Finally, return that int value.  For example:
       encodeRgba(0x12, 0x34, 0x56, 0x78) returns 0x12345678
       encodeRgba(1234,-1234, 1234,-1234) returns 0xff00ff00
    
6. isGreen [12 pts]
   Write the function isGreen that takes a single 32-bit rgba value (which you may assume is an int value) and returns True if it represents some pure shade of green, and False otherwise. That is, return True if the green value is positive, both red and blue are zero, and the alpha is positive.
    
7. getColorFamily [10 pts]
   Write the function getColorFamily that takes a single 32-bit rgba value (which you may assume is an int value) and returns 1 if that value is "mostly red" (that is, if the red value is greater than both the blue value and the green value), 2 if it is "mostly green", 3 if it is "mostly blue", and 4 otherwise (for example, if there is just as much red as green).
    
8. getSpecialSection [10 pts]
   In a certain fictitious CMU course, each week a section is designated as a "special" section. This is done in a simple rotation, where section "A" gets the first two weeks, "B" gets the next two weeks, and so on, wrapping around as needed.  Sections are lettered "A", "B", "C", etc, and you may assume there are no more than 26 sections.  Sections may contain up to 30 students, and a course always offers the minimum number of sections required.  Write the function getSpecialSection which takes the total number of students in the course (which you may assume is a positive integer) and the week number (which you may also assume is a positive integer), and returns the letter of the specially designated section for that week.  So, for example, getSpecialSection(60, 5) returns "A", because with 60 students there would be 2 sections, and in week #5, we'd wraparound back to section A being special.
   Note: this problem may be more naturally and elegantly solved using conditionals (which are not available this week).
   Hint: 31/30 equals 1, but -31/30 equals -2. Why might this be a hint? Hmmm...
    
9. bonus/optional:  bonusGetLetterGrade [2 pts]
   Write the function bonusGetLetterGrade which takes a score, which you may assume is a numeric value, and returns the corresponding letter grade, where 90 or higher is an "A", 80-89 is a "B", 70-79 is a "C", 60-69 is a "D", and below 60 is an "F".  Scores should be rounded, so 89.5 rounds to 90 and hence an "A".  Also, there is no upper or lower limit to incoming scores (thus, for example, 101 gets an "A").
   Note: this problem would be more naturally and elegantly solved using conditionals (which are not available this week)
    
10. bonus/optional:  bonusFindIntRootsOfCubic [4 pts]
    Write the function bonusFindIntRootsOfCubic that takes the real (float) coefficients a, b, c, d of a cubic equation of this form:
         y = ax³ + bx² + cx + d
    You are guaranteed the function has 3 real roots, and in fact that the roots are all integers.  Your function should return these 3 roots in increasing order.  How does a function return multiple values?  Like so:
        return root1, root2, root3
    To get started, you'll want to read about Cardano's cubic formula here (great stuff!).  Then, from that page, use this formula:
     x   =   {q + [q² + (r-p²)³]^1/2}^1/3   +   {q - [q² + (r-p²)³]^1/2}^1/3   +   p

    where:

    p = -b/(3a),   q = p³ + (bc-3ad)/(6a²),   r = c/(3a)

    This isn't quite as simple as it seems, because your solution for x will not only be approximate (and not exactly an int, so you'll have to do something about that), but it may not even be real!  Though the solution is real, the intermediate steps may include some complex values, and in these cases the solution will include a (possibly-negligibly-small) imaginary value.  So you'll have to convert from complex to real (see hint above), and then convert from real to int.
    
    Great, now you have one root.  What about the others?  Well, we can divide the one root out and that will leave us with a quadratic equation, which of course is easily solved.  A brief, clear explanation of this step is provided here.  Don't forget to convert these to int values, too!
    
    So now you have all three int roots.  Great job!  All that's left is to sort them.  Now, if this were later in the course, you could put them in a list and call a built-in function that will sort for you.  But it's not, so you can't.  Instead, figure out how to sort these values using the limited built-in functions and arithmetic available this week.  Then just return these 3 values and you're done.
    
    Good luck!!!

carpe diem   -   carpe diem   -   carpe diem   -   carpe diem   -   carpe diem   -   carpe diem   -   carpe diem   -   carpe diem   -   carpe diem