Chapter 9 Overheads

PROBLEM :

THE COOKIE COMPANY IS HAVING A SALES CONTEST. CAN YOU WRITE A PROGRAM TO DETERMINE THE WINNER?

DATA IS PROVIDED AS FOLLOWS:

SALESPERSON'S NUMBER (between 1 and 25)
NUMBER OF BOXES OF COOKIES SOLD

THESE SALES SLIPS ARE IN RANDOM ORDER WITH ONE SLIP PER SALE.

UNDERSTAND THE PROBLEM?

HOW MIGHT I DO IT BY HAND?

TOP DOWN DESIGN

INPUT :	SALESPERSON'S NUMBER (saleno)
OUTPUT :	NUMBER OF WINNING SALESPERSON NUMBER OF BOXES SOLD BY WINNER

DATA STRUCTURES :

A ONE DIMENSIONAL ARRAY (totals) WHICH WILL CONTAIN THE RUNNING SUMS OF THE VARIOUS SALES PEOPLE

LEVEL 0 :

CALCULATE TOTALS
LOCATE WINNER
PRINT WINNER

LEVEL 1:

CALCULATE TOTALS
	WHILE MORE SALES SLIPS
		GET SALES UPDATE TOTALS
LOCATE WINNER
	FIND WHICH TOTAL IS THE LARGEST
PRINT WINNER

LEVEL 2:

FIND WHICH TOTAL IS THE LARGEST
	SET MAXBOXES TO FIRST TOTAL SET WINNER TO 1 WHILE MORE TOTALS
		IF MAXBOXES < CURRENT TOTAL
			THEN MAXBOXES IS CURRENT TOTAL
				SET WINNER TO CURRENT SALESPERSON
GET SALES
	READ(SALENO, BOXES)
UPDATE TOTALS
	TOTALS[SALENO] IS TOTAL[SALENO] + BOXES


PROGRAM CONTEST(INPUT, OUTPUT);

CONST


N = 25;

TYPE


ARY = ARRAY[1..N] OF INTEGER;

VAR


MAXBOXES, WINNER : INTEGER;

    TOTALS : ARY;

(PROCEDURES)


BEGIN


ZERO(TOTALS);

    CALCULATE(TOTALS);

    LOCATE(WINNER, MAXBOXES, TOTALS);

    WRITELN(WINNER, MAXBOXES);


END.


PROCEDURE ZERO( VAR TOTALS : ARY );

VAR I : INTEGER;

BEGIN



    I := 1;

    WHILE I <= N DO




BEGIN





    TOTALS[I] := 0;

    I := I + 1




END;

END;


PROCEDURE CALCULATE( VAR TOTALS : ARY );

VAR


SALENO, BOXES : INTEGER;

BEGIN



    READ( SLAENO );

    WHILE NOT EOF DO




BEGIN





    READ( BOXES );

    TOTALS[SALENO] := TOTALS[SALENO] + BOXES;

    READ( SALENO );




END;

END;


PROCEDURE LOCATE( VAR WINNER, MAXBOXES : INTEGER, VAR TOTALS : ARY );

VAR


I : INTEGER

BEGIN



    MAXBOXES := TOTALS[1];

    WINNER := 1;

    I := 2;

    WHILE I <= N DO




BEGIN




IF MAXBOXES < TOTALS[I] THEN





BEGIN







    WINNER := I;

    MAXBOXES := TOTALS[I];






END;




I := I + 1;



END;

END;

SUMMARIZE

DATA STRUCTURES

ONE DIMENSION ARRAY
DEFINE:
TYPE ARY = ARRAY[1..25]
VAR TOTALS :ARY

USE:
TOTALS[I] where I must be between 1 and 25

RUNNING SUMS
FOR I := 1 TO 25 DO statment

`I := 1; WHILE I <= N DO`
	`BEGIN`
		`TOTALS[I] := 0; I := I + 1`
	`END;`

`READ( SLAENO ); WHILE NOT EOF DO`
	`BEGIN`
		`READ( BOXES ); TOTALS[SALENO] := TOTALS[SALENO] + BOXES; READ( SALENO );`
	`END;`

`MAXBOXES := TOTALS[1]; WINNER := 1; I := 2; WHILE I <= N DO`
	`BEGIN`
		`IF MAXBOXES < TOTALS[I] THEN`
			`BEGIN`
				`WINNER := I; MAXBOXES := TOTALS[I];`
			`END;`
		`I := I + 1;`
	`END;`