PROGRAM 26


PROGRAM SORT_ARRAY_FROM_ANOTHER_FILE (INPUT, OUTPUT, FILEVAR, FILEVAR2);
        {ANTHONY F. ORTIZ, ASSIGNMENT 10B, JULY 26, 1994}
        {THIS PROGRAM SORTS AND PRINTS AN ARRAY.}

USES CRT;

TYPE
   DATATYPE = ARRAY [1..1000] OF INTEGER;
   FILETYPE = FILE OF INTEGER;

VAR
   DATAARRAY:  DATATYPE;
   SIZE, D:  INTEGER;

PROCEDURE OPENFILE (VAR FILEVAR:  FILETYPE);

BEGIN
     ASSIGN (FILEVAR, 'A:\TEMPDATA.DAT');
     RESET (FILEVAR);
END;

PROCEDURE INITIALIZE (VAR FILEVAR:  FILETYPE; VAR SUM, HIGH, LOW:  INTEGER);

BEGIN
     WRITELN ('UNSORTED ARRAY OF INTEGERS');
     WRITELN;
     D := 1;
     READ (FILEVAR, DATAARRAY [D]);
     WRITE (DATAARRAY [D]:5);
     SUM :=  DATAARRAY [D];
     HIGH := DATAARRAY [D];
     LOW  := DATAARRAY [D];
END;

PROCEDURE LOADARRAY (VAR FILEVAR:  FILETYPE; VAR DATAARRAY:  DATATYPE; VAR SIZE:  INTEGER);

BEGIN
     WHILE NOT EOF (FILEVAR) DO
           BEGIN
                D := D + 1;
                READ (FILEVAR, DATAARRAY [D]);
                WRITE (DATAARRAY [D]:5)
           END;
     SIZE := D;
END;

PROCEDURE PAUSE;

BEGIN
     WRITELN;
     WRITELN;
     WRITE ('PRESS ENTER KEY TO DISPLAY SORTED ARRAY AND THE RESULTS. ');
     READLN;
END;

PROCEDURE SWAP (VAR A, B:  INTEGER);

VAR
   TEMPORARY:  INTEGER;

BEGIN
     TEMPORARY := A;
     A := B;
     B := TEMPORARY;
END;

PROCEDURE SORT (VAR DATAARRAY:  DATATYPE; SIZE:  INTEGER);

VAR
   INDEX, LARGESTINDEX:  INTEGER;

BEGIN
     FOR INDEX := 1 TO SIZE - 1 DO
         BEGIN
              LARGESTINDEX := INDEX;
              FOR D := INDEX + 1 TO SIZE DO
                  IF (DATAARRAY [D]) > DATAARRAY [LARGESTINDEX] THEN
                     LARGESTINDEX := D;
              SWAP (DATAARRAY [LARGESTINDEX], DATAARRAY [INDEX]);
         END;
END;

PROCEDURE CALCULATE (VAR DATAARRAY:  DATATYPE; SIZE:  INTEGER; VAR AVERAGE:  REAL; VAR HIGH, LOW, SUM:  INTEGER);

BEGIN
     FOR D := 2 TO SIZE DO
         BEGIN
              SUM := SUM + DATAARRAY [D];
              AVERAGE := SUM / SIZE;
              IF HIGH < DATAARRAY [D] THEN
                 HIGH := DATAARRAY [D];
              IF LOW > DATAARRAY [D] THEN
                 LOW := DATAARRAY [D];
         END;
END;

PROCEDURE PRINTTABLE (VAR DATAARRAY:  DATATYPE; VAR ROWS, COLS:  INTEGER);

VAR
   R, C:  INTEGER;

BEGIN
     WRITE ( 'ENTER NUMBER OF COLUMNS FOR THE SORTED ARRAY.  I HIGHLY RECOMMEND 16. ');
     READLN (COLS);
     CLRSCR;
     WRITELN;
     D := 0;
     ROWS := SIZE DIV COLS;
     WRITELN ('SORTED ARRAY OF INTEGERS');
     WRITELN;
     FOR R := 1 TO ROWS DO
         BEGIN
              FOR C := 1 TO COLS DO
                  BEGIN
                       D := D + 1;
                       WRITE (DATAARRAY [D]:  80 DIV COLS);
                  END;
         END;
     FOR C := D + 1 TO SIZE DO
         BEGIN
              D := D + 1;
              WRITE (DATAARRAY [D]: 80 DIV COLS);
         END;
     WRITELN;
     WRITELN;
END;

PROCEDURE PRINTRESULTS (VAR DATAARRAY:  DATATYPE; SIZE:  INTEGER; AVERAGE:  REAL; HIGH, LOW:  INTEGER);

VAR
   ROWS, COLS:  INTEGER;

BEGIN
     PRINTTABLE (DATAARRAY, ROWS, COLS);
     WRITELN ('COUNTER = ', SIZE:3);
     WRITELN ('AVERAGE = ', AVERAGE:3:2);
     WRITELN ('HIGH    = ', HIGH:3);
     WRITELN ('LOW     = ', LOW:3);
END;

PROCEDURE PAUSE2;

BEGIN
     WRITE ('                           PRESS ENTER KEY TO CONTINUE. ');
     READLN;
END;

PROCEDURE CLOSEFILE (VAR FILEVAR:  FILETYPE);

BEGIN
     CLOSE (FILEVAR);
END;

PROCEDURE UNLOADDATA (VAR FILEVAR2:  TEXT; VAR DATAARRAY:  DATATYPE; VAR SIZE:  INTEGER);

VAR
   ANS:  STRING;

BEGIN
     WRITE ('WOULD YOU LIKE TO COPY THE SORTED ARRAY TO A TEXT FILE?  TYPE ''YES'' TO COPY. ');
     READLN (ANS);
     IF ANS = 'YES' THEN
        BEGIN
             ASSIGN (FILEVAR2, 'A:\NEWTEMP.TXT');
             REWRITE (FILEVAR2);
             FOR D := 1 TO SIZE DO
                 WRITELN (FILEVAR2, DATAARRAY [D]);
             CLOSE (FILEVAR2);
        END;
END;

VAR
                      FILEVAR:  FILETYPE;
                     FILEVAR2:  TEXT;
   SUM, HIGH, LOW, ROWS, COLS:  INTEGER;
                      AVERAGE:  REAL;

BEGIN
     CLRSCR;
     OPENFILE (FILEVAR);
     INITIALIZE (FILEVAR, SUM, HIGH, LOW);
     LOADARRAY (FILEVAR, DATAARRAY, SIZE);
     CALCULATE (DATAARRAY, SIZE, AVERAGE, HIGH, LOW, SUM);
     PAUSE;
     SORT (DATAARRAY, SIZE);
     CLRSCR;
     PRINTRESULTS (DATAARRAY, SIZE, AVERAGE, HIGH, LOW);
     PAUSE2;
     CLOSEFILE (FILEVAR);
     CLRSCR;
     UNLOADDATA (FILEVAR2, DATAARRAY, SIZE);
END.

{  OUTFILE:  TEMPDATA.DAT  }

{  NOT A TEXT FILE  }

{  OUTFILE:  PROG26.OUT  }

UNSORTED ARRAY OF INTEGERS

  119   90  112  128  127  124   94   94  110  102  100  125  134  132   98   86
  118   98   90  108  126   94   87  110   96  131  114   97  118   84   82  130
   80  107  125   83   84   81   82   87   93  129  138   83   90  139  127  126
  120  112  135  119   97   92  117  138  110   83  139  117  134  134   99  128
  104  124   88   88   83  113  116   83  132   99  136  119  113  131  130   84
  116   86  110   92  102   87  127  126   88  104   84  104  125  134  131  121
  118  104   85   82   83  127  110  104   96  130   82   99  103   96   85  133
   98   99  103  137   91  134   87   82  134  115  113  107  100  105  126   88
  139  104  124  104   81  132  137   81   95  114  100  126  112  113  102   80
   99   99  138  107  102   99   92  109  121  103   94   96  114   94  123  124
   89  136  116   96   99  119   97   86  112  100  122   92  133  139  126   92
  106  128   82  103  119  106  121  121   89  113   91  136  136  135  132  115
  130  139  134  129   92  125  106  135   88   88   99  133   85  101  116  135
  115   91  116  139   89   97  119  125   96  108   99   96  117   88  115  132
  106   85   98   83  113  137  135  112  105  117  121   97   97  100  106   84
  138   95   84   92  104  129  110   85  120  105   83  110  101  106   92  111
  111

PRESS ENTER KEY TO DISPLAY SORTED ARRAY AND THE RESULTS.

ENTER NUMBER OF COLUMNS FOR THE SORTED ARRAY.  I HIGHLY RECOMMEND 16. 16

SORTED ARRAY OF INTEGERS

  139  139  139  139  139  139  138  138  138  138  137  137  137  136  136  136
  136  135  135  135  135  135  134  134  134  134  134  134  134  133  133  133
  132  132  132  132  132  131  131  131  130  130  130  130  129  129  129  128
  128  128  127  127  127  127  126  126  126  126  126  126  125  125  125  125
  125  124  124  124  124  123  122  121  121  121  121  121  120  120  119  119
  119  119  119  119  118  118  118  117  117  117  117  116  116  116  116  116
  115  115  115  115  114  114  114  113  113  113  113  113  113  112  112  112
  112  112  111  111  110  110  110  110  110  110  110  109  108  108  107  107
  107  106  106  106  106  106  106  105  105  105  104  104  104  104  104  104
  104  104  103  103  103  103  102  102  102  102  101  101  100  100  100  100
  100   99   99   99   99   99   99   99   99   99   99   98   98   98   98   97
   97   97   97   97   97   96   96   96   96   96   96   96   95   95   94   94
   94   94   94   93   92   92   92   92   92   92   92   92   91   91   91   90
   90   90   89   89   89   88   88   88   88   88   88   88   87   87   87   87
   86   86   86   85   85   85   85   85   84   84   84   84   84   84   83   83
   83   83   83   83   83   83   82   82   82   82   82   82   81   81   81   80
   80

COUNTER = 257
AVERAGE = 108.62
HIGH    = 139
LOW     =  80
                           PRESS ENTER KEY TO CONTINUE.

WOULD YOU LIKE TO COPY THE SORTED ARRAY TO A TEXT FILE?  TYPE 'YES' TO COPY. no




BACK TO COMP151 PAGE.