Chapter 13 Overheads

PROBLEM : PRINT OUT A LIST OF THE STUDENTS AND THEIR LETTER GARDES. THE LIST SHOULD BE IN ALPHABETIC ORDER. THE GRADING SCHEME IS AS FOLLOWS:

THE NUMBER GRADE IS THE
AVERAGE OF THE SIX TEST GRADES

NUMBER GRADE

90 +
80 - 89
67 - 79
55 - 66
below 55 		LETTER GRADE

A
B
C
D
F


TOP DOWN DESIGN
INPUT : LAST NAME (last)
FIRST NAME (first)
SIX TEST GRADES (grade)
OUTPUT : LAST NAME
FIRST NAME LETTER GRADE (letgrade)

DATA STRUCTURES
RECORD :

LAST : PACKED ARRAY[1..20] OF CHAR
FIRST : PACKED ARRAY[1..20] OF CHAR
LETGRADE : CHAR

ARRAY OF SUCH RECORDS


LEVEL 0:
WHILE MORE STUDENTS
GET NAME
GET AVERAGE
GET LETTER GRADE
SORT
PRINT

LEVEL 1:
GET AVERAGE & GET LETTER GRAD CAN BE USED EXACTLY AS THEY WERE WRITTEN FOR IN CHAPTER SIX !!!


GET NAME (a ',' seperates the first name and last name)
GET LAST
GET FIRST

LEVEL 2:
GET LAST
GET NEXT LETTER
IF NOT A ',' ADD TO LAST NAME
GET FIRST
GET NEXT LETTER
IF NOT A ' ' ADD TO FIRST NAME

*get first and get last are the same except for the separator


LEVEL 1:
SORT
COULD WE POSSIBLY USE THE ONE IN MODULE 12?
PROBLEM : THE RECORD DESCRIPTION IS DIFFERENT.

SINCE WE ARE DEALING WITH PACKED ARRAY, WHAT HAPPENS IF WE JUST CHANGE THE TYPE IN THE PROCEDURE AND FUNCTION HEADINGS?

YES, IT WILL WORK

NOTE : SORTING IMPLIES THAT THE NUMBER OF STUDENTS MUST BE CALCULATED


TYPE CLASS LOOKS AS FOLLOWS :
LAST
(string20) 		FIRST
(string20) 		L
E
T
G
R
A
D
E
1

2



500
     
     
   .
   .
   . 		   
     

ROLL IS A VARIABLE OF TYPE CLASS. ROLL CAN CONTAIN VALUES.
DALE
ORSHALICK 		NELL
DAVID 		A
A


PROGRAM GRADES(INPUT, OUTPUT);

CONST
   LIMIT = 500;
   COMMA = ',';
   BLANK = ' ';

TYPE
   STRING20 = PACKED ARRAY [1..20] OF CHAR;
   PERSON = RECORD
      LAST : STRING20
      FIRST : STRING20
      LETGRADE : CHAR;
   END;
   CLASS = ARRAY [1..LIMIT] OF PERSON;

VAR
   ROLL : CLASS;
   I, NUMSTUDENTS : INTEGER;
   AVERAGE : REAL;
   GRADE : CHAR
   NAME : STRING20;

BEGIN
   I := 0;
   WHILE NOT EOF DO
      BEGIN
         I := I + 1;
         GETNAME( NAME, COMMA );
         ROLL[I].LAST := NAME;
         GETNAME( NAME, BLANK );
         ROLL[I].FIRST := NAME;
         GETAVERAGE(AVERAGE);
         GETLETGRADE( AVERAGE, GRADE );
         ROLL[I].LETGRADE := GRADE;
         READLN;
      END;
   NUMSTUDENTS := I;
   SORT( ROLL, NUMSTUDENTS );
   PRINT( ROLL, NUMSTUDENTS );
END.

PROCEDURE GETNAME( VAR NAME : STRING20; SEPARATOR : CHAR );

CONST
   BLANKS = '                    ';

VAR
   CH : CHAR;
   I : INTEGER;

BEGIN
   I := I;
   NAME := BLANKS;
   READ(CH);
   WHILE CH = BLANK DO
      READ(CH);
   WHILE CH <> SEPARATOR DO
      BEGIN
         NAME[I] := CH;
         I := I + 1;
         READ(CH);
      END;
END;

PROCEDURE GETAVERAGE( VAR AVERAGE : REAL );

CONST
   NUMGRADES = 6;

VAR
   I, TOTAL, GRADE : INTEGER;

BEGIN
   TOTAL := 0;

   FOR I := 1 TO NUMGRADES DO
      BEGIN
         READ(GRADE);
         TOTAL := TOTAL + GRADE;
      END;
   AVERAGE := TOTAL / NUMGRADES;
END;

PROCEDURE GETLETGRADE( NUMGRADE : REAL; VAR LETGRADE : CHAR );

BEGIN
   IF NUMGRADE >= 90 THEN LETGRADE := 'A'
   ELSE IF NUMGRADE >= 80 THEN LETGRADE := 'B'
        ELSE IF NUMGRADE >= 67 THEN LETGRADE := 'C'
             ELSE IF NUMGRADE >= 55 THEN LETGRADE := 'D'
                  ELSE LETGRADE := 'F';
END;

PROCEDURE SORT in PROGRAM BANK SORTED A LIST WITH NUMCUST ITEMS IN IT.

WE CAN USE THE EXACT SAME CODE BY CHANGING ONLY THE HEADING:

PROCEDURE SORT( VAR LIST : CLASS; NUMCUST : INTEGER )

SORT( ROLL, NUMSTUDENTS )

FUNCTION MINI( VAR LIST : CLASS; NUMCUST, LL : INTEGER )

PROCEDURE PRINT( VAR LIST : CLASS; NUMCUST : INTEGER )


SUMMARIZE
DATA STRUCTURE
PACKED ARRAY :
EACH CHARACTER CAN BE ACCESSED BY ITS POSITIO : NAME[I]
PACKED ARRAY VARIABLE CAN BE ACCESSED AS A WHOLD ROLL[I].LAST := NAME
PROCEDURES & FUNCTIONS
WRITTEN FOR ONE PURPOSE CAN BE USED IN ANOTHER WITH LITTLE OR NO MODIFICATION