Daily Homework 

Finish below by end of Oct 15, 2011
===================================

17.1) On Practice Test 3, do problems 8, 9, and 10, using the same 
original 3x3 table from Problem 7.

17.2) Then do:

           void changepixels(int** imgtemp)
            {
              int i,j;

              for (i=0;i<numRows;i++)
                 { for (j=numCols/2;j<numCols;j++)
                     {
                       imgtemp[numRows - i - 1][j - numCols/2] = imgtemp[i][j];
                     }
                 }
            }

17.3) Start doing Homework 4. Your first task is to write modify assign4.c 
to be a menu program, and make the current parts of the program to be 
option 1. Finish it, so that the new program accomplishes the same task
as the original assign4.c

17.4) Once you have finished option 1 for the assignment 4, you are in
a position to cut out each of the functions in Practice Test 3, Problems
7, 8, 9, 10, and the one above in 17.2, and to insert them as functions
in your actual program. Run the actual program with these new functions
to get practice at writing programs, which will help with preparing for
test 3 and later for test 4.

17.5) Test 3 has 4 questions: one like Practice Test 3, Problem 1;
the second is like the trace-program in Daily Homework 16.1;
the third is like the second but without the ampersand/* (so it
should be easier than the second). The last (fourth) is similar
in skill-level to Daily Homework 17.2. Good Luck studying.



Finish below by end of Oct 12, 2011
===================================

16.1) For studying for Test 3, start with Problem 3 on the 
Practice Test, then do Problem 4, then Problem 2, and then
Problem 5. The actual (two) problems  on Test 3 will probably
have three parameters for the function call. See example
later.

Remember when doing a problem that is without the ampersand/asterisk,
the return step does two things: the function wrap up and  the copying of
the value following the return word to the
place where the function was called. (you think of it as writing
over the over the called function's name in the call statement.
When doing a problem that has the ampersand/asterisk, the return step
does three things: the function wrap up, the copying of
the value following the return word, AND the sending back of the 
ampersand/asterisk value.

Note that if the function is declared as type void, it cannot have a return
statement in it, and hence does not do the copying of the value to erase
the called function in the calling line.

This example below is indicative of using three parameters,
similar to what could be on a test.

     #include<stdio.h>
     int f(int *a, int b, int *c);
     int main (void) {
         
           int a=2, b=3, c=4, d=5, e=6;
         
           printf("a=%d b=%d c=%d d=%d e=%d\n", a, b, c, d, e);
         
           a =  f(&b, f(&c, c-4, &d), &e);
  
           printf("a=%d b=%d c=%d d=%d e=%d\n", a, b, c, d, e);
     
  
           system ("pause"); 
           return 0;
    
     }
     int f(int *a, int b, int *c){
             
          b = *a + 1;
          *c = *a - 2;
          *a = b - *c;
        
          printf("In f(), a=%d b=%d c=%d\n", *a, b, *c);
             
          return *a - *c;
          }
        
16.2) 
Start doing Problem 7 on Practice Test 3.






Finish below by end of Oct 9, 2011
==================================

15.1) Continue Food Bank , as follows:

if (choice==3)
  {
    if (req_count == 0)
      { message 1 : No hunger
      }
    else if (don_count == 0)
           { message 2 : Scrooges in this town
           }
         else 
           {   // request does not find a match in donations
             found = -99;
             for (i=0; i<don_count; i++)
                {
                  if ( strcmp(don_inv_type[i],req_inv_type[0]) == 0)
                      found = i;
                }
             if (found == -1)
                {
                   message 3 : Request does not have a match in donations. System Will now stall  till someone donates it.
                }
             else
                { //we found it!! Now must do the tests to see if request is == donations, or exceeds, or is less 
                  if (don_amt[found]==req_amt[0])
                     { 
                        message 4 : You will be satisfied (and will use up all of the donation)
                          //  need to delete the request by moving all the others up by one position
                        for (i=1;i<req_count;i++)  
                          {
                             strcpy(req_inv_type[i-1], req_inv_type[i]);    // copy the lower value into a higher position
                             req_amt[i-1] = req_amt[i];
                          }
                        req_count -- ;  //we just lost an entry, so lower the counter
                          // now, need to delete the donation, as well
                        for (i=found;i<don_count - 1;i++)
                          {
                             strcpy(don_inv_type[i], don_inv_type[i+1]);
                             don_amt[i]= don_amt[i+1];
                          }
                        don_count -- ;  
                      }
                    else if (don_amt[found]>req_amt[0])
                           {  
                              don_amt[found] -= req_amt[0];  //reduce the donation table's amount;
                              //remove the request as above
                              for (i=1;i<req_count;i++)  
                                {
                                  strcpy(req_inv_type[i-1], req_inv_type[i]);   
 // copy the lower value into a higher position
                                  req_amt[i-1] = req_amt[i];
                                }
                              req_count -- ;
                            }
                      else { // need to  remove donation and reduce request
                             req_amt[0] -= don_amt[found];
                             for (i=found;i<don_count - 1;i++)
                               {
                                  strcpy(don_inv_type[i], don_inv_type[i+1]);
                                  don_amt[i]= don_amt[i+1];
                               }
                             don_count -- ; 
                           }
                          

Finish below by end of Oct 6, 2011
==================================


14.1) Continue working on the Foodbank program. You need to first
completely finish Option 1, and test it by doing (completing) Option 4.
Option 4 simply loops through the entries in the pair 
don_inv_type and don_amt arrays, and prints out the contents.
After completely testing option 1, by doing lengthy sequences of
donations (like 8 different donations, or five similar, or
combinations of similar and different, and then printing 
reports by option 4, every now and then), you are ready for
Option 2. Do it carefully. Know that you do not need to find the 
word in the Req_Inv_Type table, but you simply put the new request at
the bottom of the table (in the position req_count).

After thoroughly testing combinations of options 1, 2 and 4, and
being sure that everything works, you are ready for Option 3.
Remember, in option 3, you are only to take the earliest entry
and try to satisfy it, only the earliest entry, NONE other. 
It needs you to check in order, 1) if Req_Inv_Type array is empty,
2) if Don_Inv_Type is empty 3) if Req_Inv_Type's zero position entry
is not found in Don_Inv_Type, 4) and several comparisons
to decide whether to fully satisfy the request, only partially satisfy it,
and lastly whether to remove the entry from the donation table because
it is depleted. Removal from either table requires you to move the
remaining entries (if they exist) up by one position. This  part
is complicated, and needs further attention, will do on Friday in class.

14.2) Do problem 2 in the Practice Test 3. The big deal here is the
lining up of the &parameter from the calling line, and the *parameter
from the header in the function (the header is the first line in
the function definition). The two must line up (for our purposes now),
and then if they line up, that quantity loses its Vegas-protection.
(the default, i.e., the simpler example in problem 3 in Practice Test 3, 
is to have the Vegas-protection.)




Finish below by end of Oct 4, 2011
==================================

13.1) Do Assignment 3. It does not need functions. Follow the notes
from class to get started. Finish processing option 1 and option 4.

The structure for Option 1 looks something like:

    15   scanf ("%s",&option);
    16   while (option != 5)
    17       {
    18       if (option == 1)
    19          {
    20             prompt for word, don_quant
    21             scanf ("%s", &word);  scanf ("%d", &don_quant);
    22             found = -99;
    23             for (i=0;i<don_count; i++)
    24               {
    25                   if (strcmp(don_inv_type[i], word)==0)
    26                        found = i;
    27               } // end-for
    28             if (found == -99)
    29                {
    30                   strcpy(don_inv_type[i],word);
    31                   don_amt[i] = don_quant;
    32                   don_count ++;
    33                } // end-if-found
    34             else
    35                don_amt[found] += don_quant;
    36            } // end-if-option-1
    37        else 
    38           ... // other options
    .
    .
    .
    67       } // end-while



Ensure that in the code above, you understand that lines 22 to 27 are 
implementing an equivalent IN ENGLISH to "if we find it, make found be the
position of it"

Lines 28 to 33 handle the case where it is not found and needs to
be put in the list. Lines 34 and 35 handle the case where it was found. 




13.2) Start Practice Test 3, Question 3. 


Finish below by end of Oct 2, 2011
==================================

12.1) By this point you need to know how characters are processed 
so that we can easily transition between their character values 
and their positions within the alphabet.

We should be good at handling two-dimensional  arrays, either
rectangular tables of numbers; and rectangular tables of characters
which basically could represent  a one-dimensional array of
strings.

When it comes to strings, we now need to be familiar with how we 
move (back-arrow or the equal sign) strings from one holder to the next
(we do it with strcpy); familiar with seeing if two strings are equal 
(equal-equal, or math-equality) (we do this by strcmp).
This is highly important for Assignment 3.
For other purposes, we need to understand how to call strcat, strlen, etc.

We need to understand how to look for something in an array, and 
record the position that we find it in (if we find it). This will 
be repeatedly used in the food bank.

Overall, the food bank is an accounting or tracking program. We will
need to get good at having the program keep track of details, and we
have to help the program tell us how good it is doing at tracking
(we need to help it do this for our debugging purposes, not for 
turning in the final code).

Next we need to have understood all the sample programs from Practice
Test Two, and actual Test Two. You need to get good at the three-column
description of programs and tasks.
For the three-column description, 
one important example, among many, is the looking for a max within 
a group of things. We did this for the Second rollercoaster program (2C),
in which the group of Number_of_Persons were being spat out one-at-a-time
by the loop that tried out different TrainLengths. Similarly, we did
this for the histogram printing program. You need to try doing this
(if not already done) for the Test Two Question 4, in which you are required 
to read in some numbers and find the maximum amongst them, to use as a 
spot to put the H in the calendar. What is important is that you see
that there are four steps to finding a max (A. initialize the recorder of
the max, B. ensure something generates the group of quantities, C. challenge
the max by a new contestant, and D. replace max if challenger wins).
So, when you need to find the max for any new task, use these four steps.
Also, you should note the subtle difference between the step A (initializing
the recorder) in the trains (and the Test Two) versus the Histogram
examples. In the Histogram example,  the initial max is set to a member of
all the challengers, while in the trains (and Test Two), the initial max
is set to a non-existent nonsensical value which is definitely going to be
beaten; this subtlety saves one testing step for the Histogram example.

On Oct 3, we will start doing functions, so feel free to read ahead.

If you need any additional help, think about coming to the Phoenix
Rising sessions.


Finish below by end of Sep 22, 2011
===================================

11.1) For Assign Two Part C, ensure you are getting answers like:

   Please input the total length of the track in feet.
   1000
   Please input the maximum length of the train.
   42
   
   Your ride can have at most 112 people on it at one time.
   This can be achieved with trains of 4 cars.
   AVG Ratio 0.451
   
   
   Please input the total length of the track in feet.
   4025
   Please input the maximum length of the train.
   89
   
   Your ride can have at most 480 people on it at one time.
   This can be achieved with trains of 6 cars.
   AVG Ratio 0.467

11.2) Start working on Assign Two, Part D (the menu part). Plan to 
finish it soon. It can be finished without finishing all of
parts A, B, and C.

11.3) Carefully understand the calendar program Prac Test 2, Ques 9.

11.4) Study the Sudoko.c program in Chapter 12.


Finish below by end of Sep 20, 2011
===================================

10.1) Finish Practice Test 2, Question 1. For the input, type
in: aaabbCCCdddBDD7
At this point, you must 
understand how line 7 (the while loop) does multiple steps, how
line 9 (the ++ line) does multiple steps. You need to have
mastery over those steps, try to re-write them yourself without
the notes. Then ensure you are understanding how lines 5-6
together achieve a zeroing-out of the tally array; how lines 7-10
together are responsible for the tallying task; how lines 11-15
compute the maximum tally; how lines 17-24 print out the histogram.
Finally, you need to start to grasp how the task of drawing the 
histogram is achieved by those subtasks (zeroing-out of the tally 
array; tally the input letters; compute the maximum tally;
and lastly print out the histogram) is that specific order.
The relationships between these three levels of description
are at the heart of our work this semester.

10.2) For Assignment 2 part C, start to put the per-train results 
into an array, so that the array is filled up for all the
train designs. Then get the average of the  multiple designs.

10.3) For Assignment 2 part D, you must use the menu program
(called bankinclass.c) in Chapter 7.

10.4) Start to look at the calendar program of 
Practice Test 2, Question 9.

Finish below by end of Sep 18, 2011
===================================

9.1) You must start Assignment 2 part C and be familiar with its
requirements. Start designing the program, and getting some results.

9.2) Understand the diamond1.c program, and re-create it. Make sure
you are not merely memorizing it, but that you actually see how the
parts in it give you the complete solution.

9.3) Start doing Practice Test 2, Question 1. Again, for this, start
to understand how  the groups of statement achieve some small tasks; 
and then, how the small tasks achieve the overall goal. I will be 
repeating this theme of the three levels of description a lot for a 
few days.

9.4) Obviously, do as much of daily homework 8.4 and 8.5 that you can.


Finish below by end of Sep 13, 2011
===================================
8.1) Go to Lecture 11, click Notes, and read subsection titled
Arrays. Then read  Update 9 titled Array Figure. Then return to
Lecture 11's Notes, and read subsections A Sample Program, What's
Relatively Simple ..., What Is Difficult ..., Searching For a Value ...,


8.2) Now, do Practice Test 2, Question 2. Ensure you understand
everything that this program is doing.


8.3) Start Assignment Two, parts A and B.

8.4) Start working on Practice Test 2's programming questions
beginning at Question 3.

8.5) Start doing the programs in Short Practice Programs (in 
main course's website), consider doing problems 1 through 15.


Finish below by end of Sep, 8  2011
===================================

7.1) Ensure you are running and understanding all programs in
Chapter 7 and Chapter 8. Also understand stars2.c (update 6).
You really, really need to erase and try to re-write them.

7.2) Finish all review of Practice Test 1. Make sure you actually
pretend it is the real test, and write out the answers line by line
in the required area, so you run through the test-taking experience;
ensure that you think up all questions to ask the instructor about 
the test and how to write answers, etc., well before the test.
THERE IS NO CHANCE TO ASK QUESTIONS DURING THE TEST AT ALL.

7.3) Finish all parts (including the additional requirements 
for Part C) of Assignment 1, and turn the three programs in
carefully on Webcourses. Ensure you put the systempause and stdlib
statements in each of the three programs. Ensure that you give us
only the programs that have the .c extensions. Remember to submit 
only one program per submission portal (one for parts a, 
one for b, one for c).

7.4) Start to work on writing all the programs (beginning at
Question 3, and onwards) listed in Practice Test 2.

7.5) To prepare for the lecture on Sep 12, you can read ahead
Chapter 11 (we are skipping chapters 9 and 10 for now).




Finish below by end of Sep 5, 2011
===================================

6.1) Ensure you have read and understood Update 4 (ForLoop.pdf) on
our Section 2 website.

6.2) Download forloop.c and stars.c, run, erase/re-create.

6.3) Edit stars.c to produce a) longer half-pyramids, b) right half
of a diamond.

6.4) Assuming you finished 5.7 (by Sep 2), now complete the
second added requirement for Homework's Part C.

6.5) Read Chapter 7, Sections  While Loop, and Menu-driven..., How-to-
choose-between...

6.6) Finish Practice Test 1's question 3.

6.7) Write Practice Test 1's question 4, and question 5.

6.8) If you can, download/run all the rest of the programs in Chapter 7.




Finish below by end of Sep  1, 2011
===================================

5.1) Read Chapter 5's sections Use of Else if, Couple Other Notes ...,
Determining the slope of a line.

5.2) Download tax.c, age.c, irs.c. Examine, study, erase, re-create.

5.3) All of the ifs in 4.5, 4.6, and 5.2 are meant to give you
familiarity with the use of the if statement. Ensure you get familiar.

5.4) In Chapter 6, read the 3 sections titled Couple Notes ...,
Compound-and-Empty Statements and Switch Statement (can skip the rest). 

5.5) Read Chapter 7, sections For Loop, and Some Examples Using a For Loop.

5.6) Finish solving Homework's Part C without the added requirements.

5.7) Finish the first added requirement for Homework's Part C.



Finish below by end of Aug 30, 2011
===================================

4.1) Read Chapter 5's sections How to use Prew...., How to use C Math ...

4.2) Read Chapter 5's sections Conditional Expressions, if-else Construct

4.3) Finish Part B of Required Homework Assignment 1.

4.4) Download quadratic.c run it, and erase and re-create.

4.5) Download quadratic2.c, tempconvert.c, tempconvert2.c, priceisright.c,
ltrgrade.c, wage.c, slope.c, scholarship.c. Run them, examine the 
programs carefully, try to re-create them one at a time from a blank 
canvas.

4.6) For priceisright.c, ensure that you understand how to call 
the functions needed to produce random numbers.

4.7) Start reading and solving Part C of Required Homework Assignment 1.

4.8) Do Practice Test 1's question 2.




Finish below by end of Aug 28, 2011
===================================

3.1) Read Parts A and B of Required Homework Assignment 1. Finish Part A.

3.2) Download sphere.c, easytax.c, tall.c, sleep.c, digits.c and run all.

3.3) Try to re-create easytax.c, tall.c, sleep.c, and digits.c from
a blank canvas. It is very important that you begin to learn how to
manipulate data to get the kind of desired effect of digits.c

3.4) Think up and create new versions of the programs in 3.3

3.5) Think and create totally new math applications using skills in 3.4

3.6) Do Practice Test 1's question 1.

3.7) Read Chapter 4's sections Use of Printf, and Formatting Output Spacing




Finish below by end of Aug 25, 2011
===================================

2.1) Understand all the four types of variables in Chap 2. Try writing
feettomile.c as floats. Make up additional calculations, such as
as computing the amount of tax  from a six percent sales tax on a 
ten dollar purchase. Do these (new) programs with ints and floats. 

2.2) Make sure you write programs that have statements such as a++; 
or a += 10; ensure you understand the meanings of these statements.

2.3) Download feettomile2.c, and learn about the use of scanf.
For additional programs that you might have written for 2.1 (such
as a sales tax program), modify them to read in most of the 
quantities, and get expertise using the scanf in a variety of
situations.

2.4) Read the Notes for Chapter 3.

2.5) Download arithmetic.c and grade.c. Run both of them and study
them carefully. Ensure you can explain why the outputs turn out to
be what they are. 

2.6) Ensure that you understand the percent operator used to get 
the remainder of a calculation.

2.7) Read the Notes for Chapter 4.





Finish the steps below by end of Aug 23, 2011
=============================================

1.1) Install the compiler DevCpp, or equivalent, on your
computer (if you do not have a computer, contact me immediately).

1.2) Download from class website the programs: hello.c, feettomile.c
Remember to add the line #include <stdlib.h> as the first line, and
to add the line system("pause");   just before the return statement.
Make sure both programs run on your computer. When you run each one, 
it should produce output on the black screen. 

1.3) After you have verified that you can run both programs in 1.2,  
erase each one, and try to write it yourself without looking at 
any notes. Get help from the notes to finish each program. 
Finally, keep repeating 1.3 until you are able to write each program 
by starting from an empty page and without any help from notes.

1.4) Read Lecture notes, Chapter 2, skipping the Brief Intro to Pointers.