Dailyhomework: DO NOT TURN ANYTHING IN, simply do for your own learning.



Some new notes: 

Problem made up in class on March 29:

Assume you are given:

 struct MenuItem {  int itemID;    float cost;   };

struct CustomerRequest { int itemID;  int quant;  float totalBill; };

Write only a function ComputeBill which takes one struct MenuItem and another struct CustomerRequest if the items in both agree, it will compute the total cost and fill up the
unfilled field in CustomerRequest and return this complted struct via the functions name. if this is being done a flag which was passed by adress to the  function must be set to 1.




Do as much as you can before the end of March 24
================================================

23.1)  Begin to work on Assignment 4 (Update 19).
Here are some suggested steps for finishing it.

1) Write a starting program that will read in the information from the input 
file. Show yourself that reading is being done correctly by printing out
the values that you are reading in (print simply to the screen, not to another 
file). For this step to work correctly, you will need to set up multiple
FOR-loops.

2) Store the quantities that are read in in Step 1,  store them as needed by 
the assignment. Read the assignment carefully to create the correct data 
structures (array of structs), then store the quantities, and then print from 
these structures.

3) For each day's entry from the file, now compute the actual time worked 
that day. Devise a correct formula for this step, print out the actual time
worked each time and see if it correct.

4) Then start to enter the time worked in the array of structs, and continue 
to implement the logic of taxation and so on.


23.2) Remember that in Test 4, there will be 3 questions: a structure/function
question, a files question, and finally a question related to linked lists
 which we will  study as our next topic in class.




Do as much as you can before the end of March 10  
================================================

22.1) Today we are going to study how to use files for input and output.
We will look at Update 19 to understand the steps needed to work with files.
The example problem used will be Question 10 from Prac Test 4 (Update 17).

22.2) Look at Question 10  about files on Prac Test 4 (Update 17). Go through 
the steps in Update 18 to solve it.

22.3) This files question is important both to students barely trying to 
scrape a passing grade of C, and to those trying to get an A. Both  groups 
MUST get this question perfectly perfect on the final exam. So, definitely 
try hard to study for this before Test Four, and use Test Four as a means 
to see how good you are, and what additional studying you need to do to 
get this question perfectly finished on the final exam.



Do as much as you can before the end of March 7    
===============================================


21.1) Examine structure/function questions from Practice Test FOUR.
Repeat review the solution to Question 4a. Then study the solution to Question 
4B. It is employing pass-by-address parameters.

21.2) Work on Question 6 of Practice Test FOUR.



Do as much as you can before the end of March 5    
===============================================


20.1) This will prepare for the structure-function question on Test FOUR.

Notes on how to do the questions on passing structures to functions (Test 4)

Step 1) write the function name (typically f, or some given required name)

Step 2) write a blank underscore to the left of this name

Step 3) put a pair of parens (with lots of space in between), to the right 
of the function name

Step 4) read the question carefully to determine how many parameters are 
needed; put that number minus one, number of commas in parens. Eg. if four 
params are needed, then use 3 commas.

Step 5) carefully put each param in with its type. The type always precedes the
variable name. Types can be such as int, char, float, int*, or struct gas.
Note that if it is a struct, then it needs both words: struct and the
required name for that struct. This requirement to say both words is
only if the struct is defined in the way shown in class, this would
not be used if using typedef.

Step 6) carefully figure out if any of the params are pass by value or pass by
reference (pass by reference is also sometimes called the address of
something).

Step 7) read carefully several times to ensure that the function header line is
completed correctly.

Step 8) Put a pair of open-close braces (with many lines in between them) to
contain the function code.

Step 9) declare any obviously needed local variables

Step 10) start to write up the logic that is needed to access the struct
components and manipulate any data (such as, filling in new struct
components of local variables, or pass by reference params).
Ensure that components are accessed by using the period between the
variable and the component, e.g., a.part or (*a).part (which could/should be
written as a->part)

Step 11) carefully read the instructions to see what is to be returned and
under what logic e.g., return 1, or return 0, or return a (where a is a struct)

Step 12) when you know the type of what is being returned (only one such type
can exist in the function) write that type in for note 2 (the blank
underscore that is to the left of the function name).

Step 13) if nothing is to be returned by the return statement, then do not
put any return statements, and write void in the place for note 12.




Do as much as you can before the end of March 3    
===============================================


19.1) Test 3 will have 4 questions. The fourth is similar to Prac Test 3 
Question 13.
The third is similar to Prac Test 3 Question 12. The second is a mixture of 
the skills in Prac Test 3 Question 4, Program ptr6.c (at Update 14), and 
Programs ptr1.c and ptr2.c at Update 15. The first is based on ptr5.c at
Update 14, but it will involve more variables and their pointers.
These topics are also covered in Labs 6, 7, and 8.

19.2)  Today, we will start a new topic, Structs.
We start working on Chapters 24 and 25 of the Lectures. STRUCTS are extremely
important to the future work you will do in this class and in the next class 
for majors (Computer Science One). Different from arrays (which collect data 
of the same type), a struct holds data together that is held together by 
some concept that we humans want to keep the parts of that concept together.
To prepare for this question of Test Four, we will spend two weeks of Lectures,
and Lab 9.



Do as much as you can before the end of February 27
===================================================


18.1) For the foodbank program,
try to complete option One and option Four. Then, later,  start option Two.

Here is how to proceed:

If you do not know how to start the food-bank program, do the
following steps:

Step 1: start with bankinclass.c (Lectures website, see Chapter 7)
or start from assign 2 Part C

Step 2: Gut (remove) the contents of each option

Step 3: compile to ensure no damage during surgery
(Make sure code is compilable. Repeat Step 2 and  3 till success)

Step 4: Now copy daily homework 17.2 into option 1 of your program, after
making all the code be "cleaned up"

Step  4.1 for the comment line that says "prompt", put in REAL CODE


Step 5: Now declare everything to make option 1 work
   i.e., must  compile

     Step 5.1: Copy 2 array declarations from the assign 3 instruction sheet.
     Make up the 3rd array "char word[20];"

     Step 5.2: Declare don_count, don_quant, found, i;

     Step 5.3: Run it.  Put stuff in as input,
     example: milk 20

Step 6: Put in part of Option 4 from 17.3

Step 7: Then RUN with:
     1 MILK 20
     1 EGGS 30
     1 MILK 14
     4
     1 EGGS 7
     1 MILK 13
     4

Step 8: Fix anything that does not work perfectly. Do not proceed to option 2
or option 3 till these 8 steps have been completed.


18.2) Food Bank, Option 2 is simply an easier version of option 1, you
only always need to put the new entry in the Req_Inv_Type table, and the
amount in Req_Amount Table. This means you do not need to search for the
word in the Request Table.


18.3) Food Bank, Option 3 is:
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 == -99)
                {
                   message 3 : Request does not have a match in donations. Syst em 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 othe rs up by one position
                        for (i=1;i<req_count;i++)
                          {
                             strcpy(req_inv_type[i-1], req_inv_type[i]);    //c opy the lower value into a higher position
                             req_amt[i-1] = req_amt[i];
                          }
                        req_count -- ;  //we just lost an entry, so lower the c ounter
                          // 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 donat ion 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 -- ;
                           }





Do as much as you can before the end of February 21
===================================================

17.1) Let us now turn to the Food Bank program (Assignment 3)

      For Option 1, the Donation action, the program must read in the
      item type and the quantity, and either add this quantity to an existing
      table item, or create a new item in the table (if the item does not exist
      already).

      So, first proceed to write pseudocode for this option, then convert this
      pseudocode to code.


17.2) The code structure for Option 1 will look something like:

    15   scanf ("%d",&option);
    16   while (option != 5)
    17       {
    18       if (option == 1)
    19          {
    20             // put in a 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



17.3) Put in part of Option 4 as follows:
               if (option == 4)
                 {  for (i=0;i<don_count; i++)
                     {
                       printf(" Report %s %d \n", don_inv_type[i],don_amt[i]);
                     }
                 }






Do as much as you can before the end of February 18
===================================================


16.1)  Last class and in Lab  7, we have looked and will look at
the case of functions that have simple variables as their parameters
(that is, no And symbol).
These are examples Question 6,  9 and 12 of Practice Test Three.

16.2)  The new topic today is cases where the parameter has an And symbol.
These  are called pass-by-reference or pass-by-address. The earlier, simple
case, is called pass-by-value.
The only difference in the pass-by-address case, is that when we come to the
RETURN statement, we need to do one more new step just before we quit the
function, we must transfer the values from within the DUNGEON to outside to the
caller, only for those which are pass-by-address.

16.3)  We are doing Prac Test Three's Question 7, and then Question 13 in
class today. The Lab 8 in two weeks, and just before Test 3)
will cover Question 13 and 10.



Do as much as you can before the end of February 15
===================================================


15.1) Practice Test 3, Question 6.  This is a trace of a function, which we 
will sometimes refer to as a DUNGEON.


In this style of problem, we see the "int main" line, and we immediately do
our first step: we write


      MAIN

then we see the main variables, so we write our workspace to look like

      MAIN

      a  |  b  |  c
      ---|-----|-----
         |     |
      2  |  3  |  5

then we do the printf (line 7), so in our output box, we get
 
                            ______________
                           | a=2 b=3 c=5  |
                           |______________|

then, we try to do line 9, and say  uh-oh, we have a function call, we write
it in our workspace:

      MAIN

      a  |  b  |  c
      ---|-----|-----
         |     |
      2  |  3  |  5


                  a = f (b, a, b+c)

and we start to do new work, that will let us carefully trace the function.


We do steps S1, S2, and S3.

      MAIN

      a  |  b  |  c
      ---|-----|-----
         |     |
      2  |  3  |  5


                  a = f (b, a, b+c)




                        S1          MAIN      b |  a  |  b+c

                        S2       ########################### we BUILD THE WALL
                                                |     |                  |
                        S3          DUNGEON   c |  b  |   a              |
                                                                     (I have
                                                                      said this
                                                                     since 2010
                                                                    long before
                                                                   other people
                                                                   used it in a
                                                            different context).

Then we start to do the work of tracing:


     MAIN

      a  |  b  |  c
      ---|-----|-----
         |     |
      2  |  3  |  5


                  a = f (b, a, b+c)


                        S4                    3    2      8 (came  from  3+5)

                        S1          MAIN      b |  a  |  b+c

                        S2        ########################### we BUILD THE WALL

                        S3          DUNGEON   c |  b  |   a



We drop those values of our Step 4 (S4) into the Dungeon


     MAIN

      a  |  b  |  c
      ---|-----|-----
         |     |
      2  |  3  |  5


                  a = f (b, a, b+c)

                       S4                    3    2      8 (came  from  3+5)
                                            /
                       S1          MAIN    / b |  a  |  b+c
                                          /
                       S2         #######|################### we BUILD THE WALL
                                         |     |     |
                       S3          DUNGEO|   c |  b  |   a
                                         |  ---|-----|------
                                          \    |     |
                                           \   |     |
                       S5                    3 |  2  |   8

We start doing the Dungeon steps:

We see that we have a local variable, sum, so we write it to the table's side


     MAIN

      a  |  b  |  c
      ---|-----|-----
         |     |
      2  |  3  |  5


                  a = f (b, a, b+c)

                       S4                    3    2      8 (came  from  3+5)

                       S1          MAIN      b |  a  |  b+c

                       S2         ########################### we BUILD THE WALL

                       S3          DUNGEON   c |  b  |   a   |  sum   <---- S6
                                            ---|-----|-------|------
                                               |     |       |
                       S5                    3 |  2  |   8   |

Now we do Line 18  (USING ONLY DUNGEON VALUES):


     MAIN

      a  |  b  |  c
      ---|-----|-----
         |     |
      2  |  3  |  5


                  a = f (b, a, b+c)

                       S4                    3    2      8 (came  from  3+5)

                       S1          MAIN      b |  a  |  b+c

                       S2         ########################### we BUILD THE WALL

                       S3          DUNGEON   c |  b  |   a   |  sum   <---- S6
                                            ---|-----|-------|------
                                               |     |       |
                       S5                    3 |  2  |   8   |   13 (add 3,2,8)



Line 19 tests sum (which is 13) versus 24 (which  is a*c  i.e.  8*3)

Because the test is false,  we skip line 20.

Doing line 21, sum (i.e., 13) is not Less than b*c (i.e., 3*2),
so skip line 22.

Then line 24 says "return"; when we see return we need to do THREE new steps.
These 3 steps are:  Fill Envelope; Fly Envelope; DUNGEON goes poof,
up in smoke.

  Fill Envelope
            _______
           |\     /|
           | \___/ |
           |       |
           |   16  |
           |_______|

  Fly Envelope to replace the calling "f" and its parenths and contents.

  Then poof the DUNGEON.

So, our workspace looks like:


     MAIN

      a  |  b  |  c
      ---|-----|-----
         |     |
      2  |  3  |  5


                        _______________
                  a =  |\f (b, a, b+c)/| <--------- Erase this f and parens
                       | \           / |             Replace by 16.
                       |  \_________/  |
                       |               |
                       |      16       |
                       |_______________|

So, our line (number 9) is  a = 16, so our final workspace looks like


     MAIN

      a  |  b  |  c
      ---|-----|-----
         |     |
      16 |  3  |  5


Hence, line 10 causes our updated output box to be


                                       _______________
                                      | a=2 b=3 c=5   |
                                      | a=16 b=3 c=5  |
                                      |_______________|



15.2)  Next, do Question 9. It is a double DUNGEON, so need to solve the
inner dungeon first, and then use its result (envelope) as a number that is
needed by the outer dungeon.
Questions 12 and  9 will also be covered in the Lab next week.






Do as much as you can before the end of February 13
===================================================

14.1) Do update 15, the two programs coordinated with Lab 6 (ptr1.c, ptr2.c).



Do as much as you can before the end of February 11
===================================================

13.1) Do update 13, about Intro to Pointers.

13.2) Look at Practice Test THREE (Update 14), do question 3, then 4.




Do as much as you can before the end of February 8
==================================================

12.1)  Look at Chapter 23 on strings.  We need to understand how to declare the
variable for a string, then how to read in a string from the keyboard,
then how to move a string from one variable to another, and then how to 
compare two strings.

The first page of the notes (remember to change the ending to .doc from .pdf)
describes what a String is and how it is stored.
Then, the Section titled "Finding the First String alphabetically" is to 
be read and understood.



12.2) Examine and start to work on Assignment TWO Part B.


12.3)  Twist-ups for Question TRACE (i.e., plot-frequency-star) on real Test 2,
(see Practice Test Two Q 1) could include twists like (this will be 
covered in Lab 5, next week):

  while ( (c = getchar()) != '7') {
    if (isalpha(c))
           {
            freq[tolower(c)-'a'] += 1;
            freq[tolower(c)-'a' + 1]--;
           }
  }


Remember, when practicing for Test Two Question 1, do
Practice Test Two Question 1 and Question 2, and DO NOT SUMMARIZE;
instead, make sure you know how to do the individual tiny steps, to get
the answer/s. Take the time to be patient, and get lots of practice,
working on examples, so that you can do all the small steps in
a speedy manner on the real test. So, lots of practice now (the days
BEFORE the test), will help.


12.4) Study Bankinclass.c  (get it from Chapter 7). It will be needed to finish
Assignment TWO (Part C).



Do as much as you can before the end of February 6
==================================================


11.1) Please look at your Trajectory-January grade in Webcourses to know
where you stand in the class currently. Take the center of that listed range, 
to estimate where you will land at the semester end, if your study habits 
stay the same.
If you study more, you can move up in that range, and if you do not keep up, 
you will drop to the bottom of that range.

11.2)  Read Required Homework Assignment 2, part A (Update 12).
It will be easier if you understand the concept that there is a search
to be done for the train length choice that will house the most people
simultaneously on the rollercoaster.
So, the program design must try out all the legitimate train lengths,
each time keeping track of how many people that train length will permit
on the rollercoaster (which is also dependent on the number of trains
that can be fit on the coaster).
Do the problem in small stages. First, ensure that you are getting the
correct enumeration of the various train-lengths, then compute how many
trains can fit on the track; that gives the number of people on the
track simultaneously, check if this beats the max-so-far, if so, replace max.
For each train length choice, you need to compute the ratio  of people
to cummulative car length, and store this in a one-dimensional array that
can store decimal values. Finally, compute the average of the ratios, and
print that out.

To compute the average, you need to keep a tally of all the ratios, and then
divide by the number of ratios (which is the number of train designs)


11.3) Here are some numbers that you can have your Assignment 2.A program
trace-print for you, using the inputs from sample 1.

TL     N_cars      N_trains     Total_cars    Cumul_car_len    Peop     Ratio

10       1            25            25             250          100    0.40000

18       2            13            26             234          104    0.44444

26       3            9             27             234          108    0.46153

34       4            7             28             238          112    0.47059

42       5            5             25             210          100    0.47619

So, you need to find the winning design by comparing the People result.

Each time through the loop, you could store the ratio in an array,
as,       ratio_array[N_cars-1] = ratio;

Later, as a separate step,  have a loop that adds up the array contents and,
lastly, divides by
the number of entries.  For the case above, the average ratio then comes
out to be 0.45055



11.4) The best way to start is to write a For-loop that will generate the
numbers in either Column 1 or Column 2 of the Table in DailyHomework  10.3.

Write that For-loop in such a way that the required numbers in your chosen
column appear one number per line (just as in that table). (Of course, before
the For-loop, you need to read in the two numbers -- TrackLen and MaxTrainLen
-- and the For-loop should be based on the information in MaxTrainLen.

One way to proceed is to have a loop: Call this Approach One.
   For (TL=10; TL<= MaxTrainLen; TL +=8 )

Approach Two would be:
   numCars=  1 +  ( (MaxTrainLen-10)/8 );
   For (car=1; car <= numCars; car++)


Approach One produces Column 1 (of that table) and Approach Two produces Col 2.


Then, after choosing Approach One or Two, and then you should get the code to
produce the other column (either 1 or 2, depending on which one the loop is
producing), when you are within the loop. So, if you are able to see how to get
the other column, then you must think about how to get column 3 and then later
how to get column 4, and so on.



Do as much as you can before the end of February 4
==================================================

10.1) Today we discussed grades and the upcoming Test TWO, and reviewed the
basic diamond code. It will be important to listen to the zoom recording of 
today to understand how to get the best grade that you can for this class.




Do as much as you can before the end of February 1  
==================================================

9.1) Review  the final preparations for Test ONE, see DailyHW 8.1, MUST see zoom
recording of Jan 26 (listen to the first 15 minutes of that class).

9.2) We ran out of time last class; so now do DailyHW 8.3, 8.4, 8.5

9.3) Twist-ups for Diamonds:

Change Diamonds to look like

i)   *
    **  *
   ***  **
    **  *
     *


ii)    *
      ***
     *****


      ***
       *



iii)   *
      ---
     *****
      ---
       *


iv)    S
      *S*
     **S**
    ***S***
   SSSSSSSSS
    ***S***
     **S**
      *S*
       S






Do as much as you can before the end of January 28  
==================================================

8.1) Do final preparations for the Test One on Jan 31.

Remember 1) When you arrive, take a seat in the FRONT of class (NOT AT BACK).
         2) Total silence during the test.
         3) If you have to leave the room for any reason, you will not be
            allowed to resume the test after that.
         4) You MUST put your Last name (& First name) in ALL CAPS on EACH page.
         5) You can write your solution to Question 4 on either the
            front of the page or on the back, but not on another page.
            If writing on the back, please indicate in Bold letters [SEE BACK].
         6) Your solutions to Q 1, 2, and 3, should be in the space provided.
         7) For the program writing question (4), if you are concerned about
            us understanding the ordering of your lines, just simply put
            line numbers, and you can also use arrows to indicate where the
            lines should go.
         8) ONLY for Q 1, you must show each output blank as a single underscore
            symbol.
         9) Bring only writing implements, all else must be in your school-bag.
        10) Good-luck!!
        11) Test will go till the end of class,  so you should leave room if
            finish early.
        12) This Test One is much easier than the others, so your goal should
            be to try to score as close to 100 percent as you can get. If you
            finish early, think about checking all your answers several times
            before turning the pages in to us.
         

8.2) We ran out of time last class, so we will cover DailyHW 7.3, 7.4, and 7.5 now

8.3) From the Lectures (Chapter 7) page, download, run and understand stars.c.
It is IMPORTANT to erase and re-write. You need to be able to write this
type of code by yourself. So, keep on erasing and trying to re-write it,
till you can easily do so, without any help from the notes.

8.4) Keep learning about printing stars in patterns, look at starsbacktri.c
in Lectures (Chapter 8). Also examine and study Update 10, stars2.c

8.5) This is very important. Study Update 11, diamond1.c




Do as much as you can before the end of January 25  
==================================================


7.1) Do Practice Test Two, Question 2 (Upper half of the code).

7.2) Our next concept is the calling of functions.
Whenever you see a pattern like blahblah followed by a left paren (and then
later a right paren), this pattern generally means that blahblah is a function
similar to the math functions f(x) that you saw in high-school math.

The stuff within the parens is called the PARAMETER or ARGUMENT of the function.

So, suppose f(x) was defined as:  f(x) is x*x*x + 10.
Then later if someone writes f(2) we would know to replace that "f(2)" by 18.

HENCE, FOR US HERE ALSO, in programming, WE WILL THINK OF THE ANSWER AS COMING
AND REPLACING THE FUNCTION NAME AND ITS PARAMETER.

So, blahblah(3)  will be replaced by whatever the function "blahblah" will
produce if it was given the input of 3.

Let us skim through the material in Chapter 5's Notes (which is accessed by
manually changing the .pdf to .doc in the link in Chapter 5.)
Read the sections How to Use Prewritten C Functions, and How to Use C Math
Library Functions. Example math functions are: sin, cos, arctan, sqrt, pow. 

7.3) We can now do Practice Test 2, Question 1. For the input, type
in: aaBcc*cC7

Work through all the lines in this Question 1, and trace the program.
We are doing till Line 10 in class; uptil Line 25 will be completed in
the Lab next week.

7.4) After finishing the trace, 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 (which are: zeroing-out of the tally
array; tally the input letters; compute the maximum tally;
and lastly print out the histogram) in that specific order.
The relationships between these three levels of description
are at the heart of our work this semester.

To summarize, we are understanding how the groups of statements
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.


7.5) The three levels of description from 7.4, for
the histogram plotting code are:

Actual code   |    English single sentences           | English Terse Phrase
===========   |    ========================           | ====================
              |                                       |
Lines 5-6     |    Zero out histogram array           |
              |                                       |
Lines 7-10    |    Put tally marks in histogram array |  Tallies up the
              |                                       |  freq and plots hist
Lines 11-15   |    Compute Maximum Tally              |
              |                                       |
Lines 17-24   |    Use max tally to get plot of Hist  |


There are other terse programs descriptions that we will see soon.





Do as much as you can before the end of January 23  
==================================================


6.1) Ensure you look at the EXTRA HELP links under IMMEDIATE HELP. 

6.2) Let us review Question 3 of Practice Test ONE.

6.3) Review the calendar and its twist-ups, DailyHW 5.6 and 5.7.

6.4) Examine Update 9, about Arrays.

6.5) Do Practice Test Two, Question 2 (Upper half of the code).




Do as much as you can of all this before the end of January 21
==============================================================


5.1) Let us complete the steps for Assignment ONE, part A, the issue being
how to do the task without using an IF or Looping (or any conditional)
statement.

5.2) Do a quick review of Assignment ONE, part B.

5.3) We will work through Update 7, which is about Assignment ONE, part C.

5.4) The Actual Test One has only 4 questions, the first three are similar
to Q1, Q2, and Q3 of the Practice Test One,  and the 4th question on the
Actual Test is of the style that is a combination of the questions in
Q4, Q5, Q6, and Q7 of the Practice Test One.

5.5) Today, we will start PRACTICE TEST TWO  (Update 8), we will look at Q9.

5.6) Here is the complete calendar program for Q9:

#include <stdio.h>

int main(void) {
  int i, start=3, days=31, p;

  for (i=1; i<start;i++)
   printf("...");

  for (i=1; i<=days; i++){
      printf(" %2d",i);
      if ( (start-1 +i)%7==0)
       printf("\n");
    }
}

5.7) Do many twists on the calendar program.
a) if date is divisible by 6 put an additional digit 6 to the immediate
right of the actual date.
b) isolate the third week (by keeping a counter) and isolate
the Wednesday of that week. Make that date blank.
c) Print the normal calendar, but while doing it must add up the numbers
in the third row, and then at end of program test if that sum is divisible by 7,
if so, say so at end of Calendar.


Do as much as you can of all this before the end of January 18
==============================================================


4.1) Read and examine  the program ifpitfalls.c in Chapter 6 of the lectures.


4.2) Issues about IF:

a. It is a fork in the road, so must make one choice, cannot do both pathways.
This IF statement is sometimes called a control statement because it controls
which statements will be run.

b. The line (or lines) within the IF can be thought of as being protected by the
IF test (or question or condition); that is, the line/s are only done if the
test is TRUE. Similarly for the ELSE, its lines are only done if its IF is
false.

c. If the lines within the IF are only one, then we do not need the curly
brackets to surround the lines. If the lines are more than one, then to ensure
that they happen as a group, we must use the curly brackets to surround these
lines.

d. It is OK to have only the IF-part and no ELSE part.

e. Note that this is the first type of statement that we do not put a semi-colon
at the right end of the statement.
So far, it is IF, ELSE, INT MAIN (VOID){, #include, and #define

f. There is such a thing as a NESTED-IF, for example, see Q2 of Prac Test One.

g. The part that is the test or question must be enclosed with a pair of parens.

h. The lines within the IF or within the ELSE, if these lines are not special
lines (like IF statements), then  they generally must end with a semicolon;


4.3) Practice Test One, Question 2  was done in the last class as well as being
repeated in the Lab One.

4.4)  Do Parts A and B of the Assignment One. There is a TA (Connor Rick) simply for
Required Assignments and all programming issues. Please send that TA email
(after Jan 23, co660640@ucf.edu), if you need help.

4.5) Download the .pdf file forloop.pdf (update 5) and read it and
understand it. This is a different type of control statement, giving REPETITION.

4.6) Download the program forloop.c (from Chapter 7) and run it, and
study it carefully.

4.7) Ensure that you understand how to quickly count how many times
a for-loop is going to run. e.g.,    "for(i=17;i<27;i++)" runs 10 times.
"for(i=17;i<27;i+=2)" runs 5 times. "for(i=26;i>16;i--)" runs 10 times.


4.8) Let us focus on Practice Test One's Question 4. Its solution involves
first writing a for loop that runs 50 times.
So, as your first step, write

        for (i=0;i<50;i++)


Then, you are told that the loop must  read in 50 numbers:
So, Write:

        for (i=0;i<50;i++)
          {
                       scanf("%d", &NumFromKeyboard);
          }


Note how you must get to the point where you are comfortable
writing a simple for-loop as above, based on the problem sheet.
Now that you have the 50 numbers coming in, one at a time, each
one of them being temporarily available in NumFromKeyboard, you can
examine each one immediately after the scanf. The problem sheet
tells us to check to see if the number is greater than 100.
So, our next step is to expand the code to:

        for (i=0;i<50;i++)
          {
                       scanf("%d", &NumFromKeyboard);

                       if (NumFromKeyboard > 100)
                               ...
          }

The ... should be replaced by whatever we are being asked to do.
We are being asked to add each number into an adder that will
tally up these big numbers. The tally needs to be initialized
to zero (per the problem sheet).

So, our next step is:

        sum = 0;
        for (i=0;i<50;i++)

          {
                       scanf("%d", &NumFromKeyboard);
                       if (NumFromKeyboard > 100)
                               sum += NumFromKeyboard;
          }

Finally, we incorporate the requirement that the tally gets multiplied by 85.
We get:
       sum=0;
       for (i=0;i<50;i++)
          {
            scanf("%d", &NumFromKeyboard);
            if (NumFromKeyboard > 100)
                sum += NumFromKeyboard;
          }
       sum *=85;
       printf("%d", sum);

To wrap up, we merely need to declare all our variables, and put the
starting lines (#include, etc.)  and the ending lines (return zero, etc.).



Do as much as you can of all this before the end of January 16
==============================================================


3.1) Ensure that you complete the submission of Assignment Zero before Friday
night.  (See Update 2 on the class webpage).


3.2) Read Chapter 5's sections Conditional Expressions, if-else Construct
(Note that the author of Lectures webpage may have an error, so you need to
change .pdf to .doc, if needed)


3.3)  Practice Test One (see Update 3 on class page). Do Question 1.

These are all you must know for Test One Question 1.

=

+=

++

8%3

%3d

%7.4f

scanf

printf ("P=_%7d ...     do not ignore the single _

int/int gives truncated answer

%M.Pf means   *** . --------
                    \  P   /
                  \  P+1  /
               \   D     /

         1.  P spaces after .
         2.  then P+1 for the .
         3.  then put in the quant  that goes before .
         4.  Then, count up all used, say D
         5.  if D<M, then give M-D spaces at left,  else ignore M.

         6.  Thus, final length is either M or D whichever is greater.


3.4) Do Practice Test One, Question 2.

3.5) Assignment One is now posted (Update 4 on class webpage). Read and do
Part A.

3.6) For  Assignment One, Read and do Part B.


3.7) If you have time and wish to get ahead,  start looking at Loops. Look at 
Update 5; then read Chapter 7 (read only the part about FOR loops, skip 
WHILE loops). For these notes too, replace .pdf by .doc in the  link.



Do as much as you can of all this before the end of January 11
==============================================================


2.1) Look in "Notes" under "Language Basics Chapter 3"; download the
"Notes", the file is titled IO.doc. Read the sections titles Use of Scanf and 
Increment and Decrement Operators, and Other Shorthand Assignments;
read  them carefully.
Make sure you write programs that have statements such as a++;
or a += 10; ensure you understand the meanings of these statements.


2.2) Download feettomile2.c, and learn about the use of scanf.
For additional programs that you might have written for 1.5 (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.3) At this point you need to have been able to run at least three
programs, and got the OUTPUT screens working for them. You need to
have understood what  integers are, then you should have tried
something with floats, doubles, and chars.
Ensure that you know that for printing them, you know that you use
%d, %f, %lf, and %c respectively. Ensure that you understand how to use
Placeholders in the printf statement.
Ensure that you understand that in a program, first you write
the four-ish lines that you always need, then you put a gap in to write
the rest of the code, then in that gap you first declare your variables,
and then you do something with them. But, you cannot use a variable
on the right-hand-side of an EQUAL sign if you have not yet given it
a value. (also, you cannot use it in printf yet till you give it a value).

2.4) Ensure that you are remembering that a single EQUAL sign means 
BACKWARDS-ARROW. That is, the concept is that of movement  (from the right 
to the left), and is not just thought of as a logical relationship between
the two sides (in C, that logical relationship of equivalence is shown by
the == symbol.

2.5) When you have some time (in the future) read the rest of the 
Notes for Chapter 3, IO.pdf.

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

2.7) For the online compilers, you will need to have a way to save all of 
your programs that you are writing: one way may be to save them as simple 
text or word files, and then you copy/paste them into the online compiler's 
program box.

2.8) Download  grade.c from Chapter 4. Also download arithmetic.c.  Run both 
of them and study them carefully. Ensure you can explain why the outputs 
turn out to be what they are.

2.9) Ensure that you know that any calculation that is INT DIVIDE BY INT
(e.g., 7/2) produces a TRUNCATED result, which is an int (7/2 yields 3).
To ensure that you do not truncate (if you do not INTEND to truncate), you can
convert one of the values to float or double before the division, so can
do:  (1.0*7)/2,  or  7/(2*1.0), or you can CAST by saying ((float)7)/2.

2.10) Ensure that you understand the percent operator that is used to
get the remainder of a calculation. Examine and study the program digits.c.
A % B means you must mentally do the steps of taking away as many B's from
A to get closer to zero, and then what you are finally left with, is the
answer needed. So, (-17) % (4) yields -1. While, (-17) % (-4) also yields -1.


2.11) When writing a program such as area of a rectangle (or, another may be,
E = M times cSquared), make sure that we are not tempted to state the equation
atop of (at the top of) the lines that give the values for M and c, or, in the
rectangle program, the lines that read in length  and width.
This is simply re-emphasizing the issue in 1.8 seen earlier.

2.12) Ensure that you complete the submission of Assignment Zero before Friday
night.  (See Update 2 on the class webpage).




Do as much as you can of all this before the end of January 9
=============================================================

1.1) If you do not have a computer, contact Dr. Lobo immediately by 
email at nlobo@ucf.edu.

All students must start using a C compiler on our first day. 
and test that compiler with the programs that we are giving you.

We recommend that  you use an Online Compiler:
you can use the one at

https://www.tutorialspoint.com/compile_c_online.php


or you can google "free online c compiler", and select one.
Other popular solutions are to employ the GDB compiler, and the one at 
Programiz.
These are simple to use, but require an internet connection while using it.
If you have trouble using such a compiler, 
immediately send email to nlobo@ucf.edu.

1.2) Download from class website (the Lectures link) the 
programs: hello.c, feettomile.c
Make sure both programs (i.e., hello.c and feettomile.c) run on your 
computer. When you run each one, it should produce output on your OUTPUT 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 (the title is Introduction, First
Program), read the sections titled Our First C Program, and Variables. 

1.5) Understand all the four types of variables in Chap 2 (the four
are int, float, double, and char). Try writing feettomile.c as floats. 
Make up additional calculations, such as computing the amount of tax  
from a six percent sales tax on a ten dollar purchase. Do these (new) 
programs both ways, first with ints and then with floats.
Note that the formats needed for printing them to the screen (with the
printf statement) are: %d, %f, %lf and %c for the four types above.

Keep in mind that programming is similar to organizing any large operation.
When you order a BigMac, the store does not go out and start by killing the 
cow, harvesting the wheat for the bun, and plucking the vegetables.
The store has them all ready to go in proper positions, so that the 
Sandwich-Artist can easily get the parts needed to finish completing the 
bun and feed you fast. Getting all the parts ready to finish the job is what
programming is.

Other example programs to try writing are: 1) compute the area of
a rectangle, from its length and width; 2) compute the area of
a triangle, from its base and height; 3) compute the total Financial
Aid from the two numbers: grants and loans; 4) calculate the
sum total of the cost of four textbooks; 5) grandma gave N (like 200) dollars
to be divided among Q grandkids, how much will each kid get? 6) compute
the Soccer World Cup Year which will be, say, five, World Cups tournaments
from now (which you can assume now is 2024); 7) use other simple mathematical 
calculations, such as, converting kilograms to pounds;


1.6) Look in "Notes" under "Language Basics Chapter 3"; download the
"Notes", the file is titled IO.doc. Read the sections titles Use of Scanf and 
Increment and Decrement Operators, and Other Shorthand Assignments;
read  them carefully.
Make sure you write programs that have statements such as a++;
or a += 10; ensure you understand the meanings of these statements.


1.7) Download feettomile2.c, and learn about the use of scanf.
For additional programs that you might have written for 1.5 (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.



1.8) At this point you need to have been able to run at least three
programs, and got the OUTPUT screens working for them. You need to
have understood what  integers are, then you should have tried
something with floats, doubles, and chars.
Ensure that you know that for printing them, you know that you use
%d, %f, %lf, and %c respectively. Ensure that you understand how to use
Placeholders in the printf statement.
Ensure that you understand that in a program, first you write
the four-ish lines that you always need, then you put a gap in to write
the rest of the code, then in that gap you first declare your variables,
and then you do something with them. But, you cannot use a variable
on the right-hand-side of an EQUAL sign if you have not yet given it
a value. (also, you cannot use it in printf yet till you give it a value).

1.9) Ensure that you are remembering that a single EQUAL sign means 
BACKWARDS-ARROW. That is, the concept is that of movement  (from the right 
to the left), and is not just thought of as a logical relationship between
the two sides (in C, that logical relationship of equivalence is shown by
the == symbol.

1.10) When you have some time (in the future) read the rest of the 
Notes for Chapter 3, IO.pdf.

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

1.12) For the online compilers, you will need to have a way to save all of 
your programs that you are writing: one way may be to save them as simple 
text or word files, and then you copy/paste them into the online compiler's 
program box.