Java to C programming assignment help

Are you pressed for time and haven’t started working on your assignment yet? Would you like to buy an assignment? Use our custom writing services for better grades. Even if your deadline is approaching fast, our writers can handle your task right when you need it. Our writers will complete your order from scratch and make sure it’s completely unique.


Order a Similar Paper Order a Different Paper

java files are in the Zip file. And need make a C file can do the same function. Then add some new function to it._x000D_
All the requirements are below._x000D_
_x000D_
PROGRAM REQUIREMENTS_x000D_
_x000D_
The program will read all lines from a text (ascii) file using the_x000D_
facilities of fgets for C (see "man fgets")._x000D_
_x000D_
The program should do exactly what graph.java does in the text appendix,_x000D_
except that you may (optionally) improve the appearance of the output._x000D_
You should be able to get the entire java program, including all_x000D_
ADTs, libraries, whatever, from AppendixCode.tar in Handouts._x000D_
Probably the Java program will run correctly with no changes._x000D_
_x000D_
The above READING section tells you where to find documentation on_x000D_
what graph.java does.  Trying to figure it out from the code only is not_x000D_
recommended._x000D_
_x000D_
This assigned program will use data structures that are different from_x000D_
graph.java.  Only the observable behavior is to be mimicked._x000D_
_x000D_
Most of this handout is about how to go about the assignment._x000D_
It does not repeat what is in the text appendix and other sections_x000D_
mentioned in READING above. It does not teach C._x000D_
_x000D_
We recommend that you work directly on your C program, using the_x000D_
text and possibly the Java code as a guide to expected behavior._x000D_
Do not try to convert from java line by line._x000D_
_x000D_
We'll follow the C convention of lowercase file names, but type names_x000D_
will remain capitalized._x000D_
_x000D_
Give your binary compiled C program the name graph01._x000D_
Your main source file should be named graph01.c._x000D_
_x000D_
Your source file that IMPLEMENTS the IntVec ADT should be named intVec.c._x000D_
The ADT header file is intVec.h, supplied in the class locker, a directory_x000D_
named cmps101-avg.  The complete path is given in the syllabus and on_x000D_
the class web page and later in this handout._x000D_
The file standardVec.txt in Handouts/ and in the course locker_x000D_
describes how "vector" ADTs are usually implemented in C._x000D_
_x000D_
(graph.java uses an IntList ADT, which is more flexible and simpler to_x000D_
implement, compared to the "vector" idea, but experience shows that_x000D_
the IntList approach is less efficient on modern hardware.)_x000D_
_x000D_
Reading input in C is trickier than it sounds, so don't wait too long to_x000D_
get started.  As a C program, this is a pretty simple warm-up to get some_x000D_
routines in place that you will need later.  Also, there is a lot to do_x000D_
besides write C code._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
COMMAND-LINE ARGUMENTS_x000D_
_x000D_
If your program receives no command-line arguments, it should print_x000D_
a usage message on stderr using fprintf() and exit 0._x000D_
_x000D_
Note that the Unix convention is that an exit code of 0 means_x000D_
"normal completion" and non-zero exit codes denote various errors._x000D_
The exit code of 0 is established by "return 0" from main() or by calling_x000D_
exit(0) anywhere.  Similarly, non-zero codes may be established._x000D_
_x000D_
Command-line arguments of the form "-something" are often called "flags",_x000D_
and provide the means for varying the way the program runs,_x000D_
or varying the form of the output.  ("-" by itself denotes stdin.)_x000D_
This assignment does not require flags._x000D_
_x000D_
The final command-line argument is the name of the  input file,_x000D_
and this name will not begin with a "-" unless it is "-" by itself._x000D_
_x000D_
If the program has command-line arguments but cannot get the file name_x000D_
from the command line or cannot open the input file,_x000D_
then a non-zero exit code should be returned._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
INPUT FORMAT_x000D_
_x000D_
Input consists of a sequence of lines on ``standard input'' or in_x000D_
an ascii file (also called text file)._x000D_
The line formats are as described in the text appendix for graph.java._x000D_
_x000D_
Standard input is called stdin for C.  stdin is of type FILE *._x000D_
_x000D_
End-of-file signals the end of input, and is typed on the keyboard_x000D_
as cntl-D in Unix (Linux is Unix; maybe cntl-Z in DOS, Windows, etc.)._x000D_
Disk files do not need an End-of-file character, though._x000D_
_x000D_
Part of the assignment is to create a set of useful test files on disk._x000D_
We do NOT supply a thorough set of test files._x000D_
_x000D_
In the course locker (see below) gr01_test1.in is an example input._x000D_
It contains:_x000D_
8_x000D_
6 1 2.2_x000D_
1 2 1.0_x000D_
4 3_x000D_
1 3_x000D_
4 5 1.2_x000D_
2 4 0.0_x000D_
5 2_x000D_
6 6_x000D_
3 4_x000D_
_x000D_
Line 1 has a single positive int (8 in this case) that tells you the_x000D_
input may contain vertices in the range 1-8 (not 0)._x000D_
_x000D_
Each subsequent line defines one directed edge.  The first two ints_x000D_
are vertices usually named "from" and "to"._x000D_
The third number, if present, states the weight or cost of that edge._x000D_
If there is no third number, the edge weight is 0.0.  weights are doubles._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
OUTPUT FORMAT_x000D_
_x000D_
Running graph.java on example inputs is the easiest way to see the_x000D_
expected output format.  What is most important is that the correct NUMBERs_x000D_
in the correct sequence appear on each line.  The punctuation like commas_x000D_
and brackets is for human readability._x000D_
_x000D_
A common convention in programming languages is that lists print as_x000D_
[4, 5, 1] for a list whose first element is 4, etc. [] is the empty list._x000D_
For this assignment the entire list should print on a single line._x000D_
_x000D_
When you run graph.java you will notice that a number appears on each_x000D_
line BEFORE the list.  That is explained in the reading material._x000D_
_x000D_
When you run graph.java you will notice that weights do not appear in the_x000D_
output.  For this assignment the weights are read if present, and stored_x000D_
temporarily, but are not stored in the permanent graph data structure._x000D_
Later assignments will use weights._x000D_
_x000D_
PRINT AN INFORMATIVE ERROR MESSAGE on stderr if the input contains a bad vertex_x000D_
number, outside 1,...,n, or has the wrong number of words on a line._x000D_
This is for your own protection.  It is not a grading issue and_x000D_
submitting a lot of tests to check bad input is not asked or desired,_x000D_
and does not gain credit._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
INFORMATION SOURCES_x000D_
_x000D_
All code in the Appendix is on-line, and it worked when it was created,_x000D_
but java might have evolved.  The subset of Java used is described in Ch. 1.2_x000D_
(8 pp.) and the Appendix of the text.  See READING above._x000D_
You should be able to see the general logic of the program by looking at_x000D_
this code, but many details will not translate literally._x000D_
_x000D_
As advised in ho01.pdf (the first handout), to easily access the locker_x000D_
set up this symbolic link (colloquially called "soft link" or "s-link")_x000D_
in any directory that you are working in:_x000D_
_x000D_
    ln -s /afs/cats.ucsc.edu/courses/cmps101-avg ._x000D_
_x000D_
Don't forget the final dot, preceded by a space. ^^^_x000D_
If this does not work due to file-sytem changes, another form is:_x000D_
_x000D_
    ln -s ~avg/cmps101-avg ._x000D_
_x000D_
This points to my symbolic link._x000D_
_x000D_
After this command, cmps101-avg appears to be a subdirectory, so you can_x000D_
do "pushd cmps101-avg" and you are in the course locker._x000D_
_x000D_
Then you can do "popd" and you are back where you came from._x000D_
_x000D_
Or you can do "pushd" again while in cmps101-avg._x000D_
That command puts you back where you came from, and cmps101-avg_x000D_
is remembered on the directory stack.  This might sound confusing,_x000D_
but just try it and you will see what happens._x000D_
Use "pwd" to check what your current working directory is._x000D_
_x000D_
Notice that "cd cmps101-avg" would get you into cmps101-avg, but then_x000D_
"cd .." would NOT bring you back where you came from._x000D_
So learn "pushd" by reading "man pushd" and get in the habit of using it._x000D_
_x000D_
AppendixCode and Supplements are subdirectories in the course locker._x000D_
_x000D_
There are usually quite a few questions and clarifications about programs_x000D_
on the "C101" mailing list, so keep up.  Consider the source when_x000D_
evaluating a message, because there is no screening of the postings._x000D_
_x000D_
The class web page and the syllabus handout have a lot of "orientation"_x000D_
information.  Check them if you see things whose meaning is not clear._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
WORDS AND DELIMITERS_x000D_
_x000D_
In C, allocate a character array larger than you expect to need_x000D_
(e.g., 2000 characters).  Say you call this array "inbuff"._x000D_
_x000D_
Use fgets to get ONE input line into it._x000D_
See javaToC.pdf for more details._x000D_
Use the search function in pdf to find the fgets discussion._x000D_
_x000D_
There are several ways to extract words from that line._x000D_
javaToC.pdf gives a straightforward method using sscanf()._x000D_
It relies on knowing the expected format of one line, which is our case._x000D_
An appendix in javaToC.pdf describes an overly general, complicated approach,_x000D_
based on strtok_r() and strdup().  DO NOT use these functions for this class._x000D_
_x000D_
For this assignment we will use sscanf() to get the words out of the_x000D_
input line as stored in "inbuff" by fgets()._x000D_
_x000D_
The simplest, and quite common case is that you expect a specific_x000D_
sequence of words to be on the line.  Then one sscanf() call can extract_x000D_
the expected words, and its return code can be checked to see how many_x000D_
words were successfully extracted._x000D_
Assume these declarations_x000D_
_x000D_
    int p, q;_x000D_
    double wgt;_x000D_
    char junk;_x000D_
    int sscanfRetn;_x000D_
_x000D_
The call might be_x000D_
_x000D_
    sscanfRetn = sscanf(inbuff, " %d %d %lf %c ", &p, &q, &wgt, &junk);_x000D_
_x000D_
Note the spaces between the quotes._x000D_
_x000D_
If you are expecting a weighted graph, sscanfRetn should be 3;_x000D_
for an unweighted graph sscanfRetn should be 2; and any other_x000D_
value indicates the line is not formatted as expected._x000D_
_x000D_
This assignment expects a weighted graph, but does not use the weight_x000D_
and permits zero weights to be omitted._x000D_
The function parseEdge() in the AppendixCode should be imitated, as it_x000D_
extracts both weighted and unweighted edges.  In C, parseEdge() should_x000D_
return a struct as shown in javaToC.pdf._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
HOW TO PROCEED_x000D_
_x000D_
Find the AppendixCode directory and make a soft link to it (ln -s ...),_x000D_
to make it easier to find again.  Become familiar with what files are_x000D_
there._x000D_
_x000D_
Copy any java files that look useful to your own directory._x000D_
They are all mentioned in the text appendix discussion of graph.java._x000D_
They might help as starters even if you are working in C._x000D_
_x000D_
(Note that ho05.txt has Unix commands and editor skills that you are_x000D_
expected to have to do this class work.  Take a look at that if you see_x000D_
terms that are unfamiliar in the ensuing discussion.  TAs will help_x000D_
you brush up EARLY in the quarter; then we expect you to be up to speed.)_x000D_
_x000D_
Make up several small test files, following the format described above, and_x000D_
in the text appendix for graph.java.  Try to test a wide variety of_x000D_
conditions in the input.  In your README file, state what each test file_x000D_
is testing for.  It is best to do this BEFORE running your tests._x000D_
Then you can go back and compare what you got with what you expected,_x000D_
and try to resolve discrepancies._x000D_
_x000D_
To run graph.java you need to compile it first with javac, together with_x000D_
the associated java files it calls, in your own directory._x000D_
We assume students learned this in a beginning course; if not,_x000D_
Appendix A.1 gives some URLs that may be obsolete, but there are many_x000D_
other sources.  After compiling, type_x000D_
_x000D_
    java graph mytest1.in_x000D_
_x000D_
to run the compiled program.  Making a jar file is not necessary. 

Keep it simple.

PROGRAM REQUIREMENTS

This program (named graph02) will perform the same functions as pa01,_x000D_
plus some new functions, once the input graph is loaded._x000D_
_x000D_
Give your binary compiled C program the name graph02._x000D_
Your main source file should be named graph02.c._x000D_
Your source file that IMPLEMENTS the IntVec ADT should be named intVec.c._x000D_
The ADT header file is intVec.h, supplied in the class locker, a directory_x000D_
named cmps101-avg.  The complete path is given in the syllabus and on_x000D_
the class web page and in ho04.txt._x000D_
_x000D_
In this assignment, your intVec.o will be tested with_x000D_
other students' programs and their intVec.o will be tested with_x000D_
yours.  So use the standard names in this class._x000D_
_x000D_
A starter intVec.h is in the course locker, but you should replace the_x000D_
questions with your own comments.  It is unchanged from pa01._x000D_
_x000D_
graph01.c, etc.,_x000D_
can be used right from pa01, except that the "main" procedure_x000D_
will be changed to check for some command-line flags and_x000D_
call different procedures depending on whether the input file is to be_x000D_
interpreted as a directed or undirected graph._x000D_
Thus, the loadGraph functionality will be separated if it has not_x000D_
been separated in an earlier assignment.  See HOW TO PROCEED below_x000D_
for more details._x000D_
_x000D_
Allocating all the arrays in graph02.c makes it easier to pass them as_x000D_
arguments to functions in other files, without making any global arrays._x000D_
However, if you already have working code that allocates and returns_x000D_
an array from a different file (such as loadGraph.c),_x000D_
it is okay to use and build upon that code._x000D_
_x000D_
Aside from intVec.h, intVec.c, graph02.c and graph02,_x000D_
the names of files, functions and arrays should be understandable but_x000D_
do not need to be strictly the same as this handout._x000D_
_x000D_
==========================================================================_x000D_
COMMAND-LINE ARGUMENTS_x000D_
_x000D_
If your program receives no command-line arguments, it should print_x000D_
a usage message and exit with return code 0._x000D_
_x000D_
Command-line arguments of the form "-something" are often called "flags",_x000D_
and provide the means for varying the way the program runs,_x000D_
or varying the form of the output.  ("-" by itself denotes stdin.)_x000D_
_x000D_
The final command-line argument is the name of the  input file,_x000D_
and this name will not begin with a "-" unless it is "-" by itself._x000D_
_x000D_
The command-line flag "-U" instructs the program to build the_x000D_
UNdirected unweighted graph from the input using ADT IntVec._x000D_
_x000D_
If the command-line arguments do not make sense or the file cannot be read,_x000D_
print an error message on stderr (use fprintf(stderr, ...)) and exit with code 1 or 2._x000D_
_x000D_
Note that the Unix convention is that an exit code of 0 means_x000D_
"normal completion" and non-zero exit codes denote various errors._x000D_
The exit code of 0 is established by "return 0" from main() or by calling_x000D_
exit(0) anywhere.  Similarly, non-zero codes may be established._x000D_
_x000D_
==========================================================================_x000D_
INPUT FORMAT_x000D_
_x000D_
Just like pa01; see ho04.txt and related mailing list messages._x000D_
_x000D_
In the class locker (see below) gr01_test1.in is an example input._x000D_
_x000D_
It is NOT an error to have duplicate edges; just load them all._x000D_
_x000D_
OUTPUT FORMAT_x000D_
_x000D_
Print information on stdout._x000D_
_x000D_
The first part is just like pa01.  See ho04.txt and related mailing list messages._x000D_
The "array of adjacency lists" data structure is printed,_x000D_
followed by at least one blank line to separate it from the following parts._x000D_
_x000D_
A common convention in programming languages is that lists print as_x000D_
[4, 5, 1] for a list whose first element is 4, etc. [] is the empty list._x000D_
For this assignment the entire list should print on a single line._x000D_
_x000D_
When you run graph.java you will notice that a number appears on each_x000D_
line BEFORE the list.  That is explained in the reading material._x000D_
_x000D_
Although the program is using the IntVec ADT, you want the order to be the same_x000D_
as it WOULD BE if the IntList ADT as specified in the text were used._x000D_
_x000D_
PRINT AN INFORMATIVE ERROR MESSAGE if the input contains a bad vertex_x000D_
number, outside 1,...,n, or has the wrong number of words on a line._x000D_
This is for your own protection.  It is not a grading issue and_x000D_
submitting a lot of tests to check bad input is not asked or desired._x000D_
_x000D_
Example 1 input, unweighted_x000D_
_x000D_
6_x000D_
1 4_x000D_
5 4_x000D_
1 3_x000D_
2 3_x000D_
3 3_x000D_
5 6_x000D_
6 5_x000D_
4 3_x000D_
1 2_x000D_
_x000D_
Example 2, with weights:_x000D_
6_x000D_
1 3 2.7_x000D_
5 4 -3_x000D_
1 5 0.0_x000D_
1 4 0.0_x000D_
_x000D_
The weights should be parsed to prepare for future programs, but they_x000D_
are not entered into the data structure for the graph._x000D_
_x000D_
Remember that graphs want to start on index 1, not index 0._x000D_
So allocate 1 extra space in the arrays and start loading at 1._x000D_
_x000D_
Do not worry if edges are not unique.  The algorithms will work anyway._x000D_
_x000D_
Example 2 output would look something like this for the array of adjacency lists:_x000D_
    1  [4, 5, 3]_x000D_
    2  []_x000D_
    3  []_x000D_
    4  []_x000D_
    5  [4]_x000D_
    6  []_x000D_
_x000D_
Remember, the punctuation can be to taste, but the numbers should be_x000D_
in the same order as shown, line by line._x000D_
_x000D_
When running the program on a large input file remember to use ">"_x000D_
to redirect the stdout to a file.  DO NOT SUBMIT VERY LARGE TEST FILES_x000D_
OR THEIR OUTPUTS.  We will supply some large files._x000D_
_x000D_
When printing an adjacency matrix, print a line above it to show the second index_x000D_
and print the first index before the matrix row contents.  Make things line up_x000D_
correctly for human readability.  Learn how to use things like "%3d" in printf_x000D_
to do that._x000D_
_x000D_
Example 2 output should look something like this for the adjacency matrix:_x000D_
_x000D_
         1  2  3  4  5  6_x000D_
       ------------------_x000D_
    1 :  0  0  1  1  1  0_x000D_
    2 :  0  0  0  0  0  0_x000D_
    3 :  0  0  0  0  0  0_x000D_
    4 :  0  0  0  0  0  0_x000D_
    5 :  0  0  0  1  0  0_x000D_
    6 :  0  0  0  0  0  0_x000D_
_x000D_
As stated later, if n > 20, do not print the adjacency matrix._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
STANDARD VEC DATA STRUCTURE_x000D_
_x000D_
See ho04.txt and related mailing-list messages._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
HOW TO PROCEED_x000D_
_x000D_
Make a new directory to work in.  Do this first._x000D_
Assuming pa01 was in pretty good shape, copy those files into your_x000D_
new directory as starters for pa02._x000D_
UPDATING files from a previous assignment is VERY BAD practice._x000D_
Copy them to a new directory and work in the new directory._x000D_
_x000D_
If your pa01 was incomplete, you might need to refer to ho04.txt_x000D_
for how to complete it.  This file does not repeat that information._x000D_
_x000D_
YOU NEED TO USE THE STANDARD NAMES GIVEN IN THIS SECTION so your ADTs_x000D_
can interface with other students' clients and vice versa._x000D_
_x000D_
The function names in the intVec ADT must be as given in the intVec.h_x000D_
starter file for pa01._x000D_
_x000D_
These names must be spelled and capitalized as shown in that file._x000D_
_x000D_
For this program, loadGraph.c should be a separate file, although that_x000D_
was not required before.  loadGraph.h will provide the interface._x000D_
Functions in loadGraph.c that are only called WITHIN loadGraph.c should NOT_x000D_
appear in loadGraph.h._x000D_
_x000D_
loadGraph is NOT required to be an ADT, so the functions and prototypes_x000D_
do not need to agree with other students._x000D_
_x000D_
NEW OR MODIFIED FUNCTION: adding undirected edges_x000D_
_x000D_
When the -U flag is specified each line after the first defines TWO edges_x000D_
in the "array of adjacency lists" structure: (from, to) AND (to, from), both_x000D_
with the same weight._x000D_
_x000D_
NEW FUNCTION: makeAdjMatrix()_x000D_
_x000D_
Write a function to create the adjacency matrix that corresponds to an_x000D_
"array of adjacency lists" data structure, which it takes as a parameter._x000D_
The adjacency matrix should be an (n+1)X(n+1) 2-D array in C.  Index 0 is not used_x000D_
but is allocated by the rules of C._x000D_
The type is "int * *" in C.  It should NOT use IntVec because all sizes are known_x000D_
when construction starts._x000D_
_x000D_
It may be implemented in loadGraph.c or in a separate file._x000D_
_x000D_
NEW FUNCTION: transposeGraph()_x000D_
_x000D_
Write a function to transpose a graph, after it is built._x000D_
_x000D_
Make your function as simple as you can to be sure it is correct._x000D_
There is a fast way to do this, but if you do not see it, think of a_x000D_
simpler, possibly slower, way._x000D_
_x000D_
For C the function prototype is_x000D_
_x000D_
        IntVec* transposeGraph(IntVec* origGraph, int n);_x000D_
_x000D_
It may be implemented in loadGraph.c or in a separate file._x000D_
_x000D_
The transpose graph has edges in the opposite direction of the_x000D_
original graph, in one-to-one correspondence._x000D_
Suppose the original graph prints like this_x000D_
_x000D_
        1  [ 3, 2 ]_x000D_
        2  [ 3, 4 ]_x000D_
        3  [ ]_x000D_
        4  [ 1 ]_x000D_
_x000D_
The transpose graph should have edges (2,1), (3,1), (4,2), (3,2), (1,4),_x000D_
and print accordingly.  Most likely it would appear as_x000D_
_x000D_
        1  [ 4 ]_x000D_
        2  [ 1 ]_x000D_
        3  [ 2, 1 ]_x000D_
        4  [ 1 ]_x000D_
_x000D_
but other orders are possible._x000D_
See the text for more details. if needed._x000D_
_x000D_
NEW FUNCTIONS: printAdjVerts() and printAdjMatrix()_x000D_
_x000D_
If you had printAdjVerts() in pa01 you need to make sure it takes the graph data structure_x000D_
(array of adjacency lists) as a parameter so it can print various graphs._x000D_
If you did not have printAdjVerts() in pa01, make that function for pa02._x000D_
See OUTPUT FORMAT above for details._x000D_
_x000D_
Print the transpose graph in the same format as the original graph._x000D_
The same print function should work for both (the title can be printed_x000D_
before calling the function or passed as a parameter)._x000D_
_x000D_
printAdjMatrix() takes the matrix to be printed as a parameter so it can print_x000D_
various matrices created by makeAdjMatrix().  See OUTPUT FORMAT above for details._x000D_
_x000D_
Print functions may be implemented in loadGraph.c or in a separate file._x000D_
The spelling can vary as long as the purpose is recognizable.  Be sure you get_x000D_
the prototypes in the appropriate .h file._x000D_
_x000D_
OVERALL REQUIREMENT:_x000D_
_x000D_
Call the main program graph02.c._x000D_
Do you need a graph02.h too?  Why or why not?_x000D_
Hint: Think about the command-line flags like -U._x000D_
Do you want to "share" this value or pass it to all functions?_x000D_
Both decisions have merit, but stick to one or the other._x000D_
_x000D_
The function main() will guide the program through the following sequence:_x000D_
_x000D_
    Read input file setting up original array of adjacency lists;_x000D_
    Print original array of adjacency lists;_x000D_
    makeAdjMatrix() on original array of adjacency lists;_x000D_
    printAdjMatrix() IF n <= 20 on original array of adjacency lists;_x000D_
_x000D_
    transposeGraph() on original array of adjacency lists giving_x000D_
        transposed array of adjacency lists;_x000D_
    Print transposed array of adjacency lists;_x000D_
    makeAdjMatrix() on transposed array of adjacency lists;_x000D_
    printAdjMatrix() IF n <= 20 on transposed array of adjacency lists;_x000D_
_x000D_
    transposeGraph() on transposed array of adjacency lists giving_x000D_
        twice-transposed array of adjacency lists;_x000D_
    Print twice-transposed array of adjacency lists;_x000D_
    makeAdjMatrix() on twice-transposed array of adjacency lists;_x000D_
    printAdjMatrix() IF n <= 20 on twice-transposed array of adjacency lists;_x000D_
_x000D_
Do you observe anything interesting by comparing original array of adjacency lists_x000D_
and twice-transposed array of adjacency lists?_x000D_
What about the matrices?_x000D_
Mention observations in your README._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
SUBMITTING_x000D_
_x000D_
The assignment name is pa02.  An example (but incomplete) submit command is:_x000D_
_x000D_
	submit cmps101-avg.s17 pa02  graph02.c  intVec.c README  Makefile_x000D_
_x000D_
Submit ALL the work you want to be considered for grading, but DO NOT SUBMIT_x000D_
files produced by compilers, such as *.o and binaries._x000D_
Also, DO NOT SUBMIT VERY LARGE TEST FILES OR THEIR OUTPUTS._x000D_
_x000D_
You can list as many files as you want to submit.  If you update files,_x000D_
just submit them again.  Don't resubmit unchanged files needlessly._x000D_
_x000D_
Simply typing "make" should compile your program, creating a binary_x000D_
named after the main program, graph02._x000D_
To accomplish this, simply list graph02 as the first "target" in Makefile._x000D_
_x000D_
Your Makefile should have an entry for each file that needs to be compiled._x000D_
A "generic" that just compiles everything it can find will lose credit._x000D_
The example mentioned in pa01 is a guide.  It is in the CMake directory._x000D_
_x000D_
You should understand your own Makefile._x000D_
Do not use fancy features, as the grading script will not_x000D_
recognize that you understand Makefile structure._x000D_
_x000D_
Submit a README that includes the certification mentioned at the beginning of_x000D_
this file, then briefly describes your program with a few sentences,_x000D_
mainly to tell the reader how to compile it, how to run it,_x000D_
what test inputs and outputs you supplied, any known bugs._x000D_
If the purpose of some files might be mysterious, here is the place to_x000D_
explain them._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
PROGRAMMING STANDARDS_x000D_
_x000D_
All code to be graded should follow good style practices including_x000D_
appropriate indentation, descriptive names, consistent capitalization,_x000D_
and useful comments.  Comments should indicate the purpose, preconditions,_x000D_
and postconditions of important procedures.  Avoid comments of_x000D_
self-explanatory code.  The reader may grade your program low_x000D_
if it is sloppily done, making it hard to understand or follow._x000D_
RESPECT THE READER'S TIME._x000D_

Writerbay.net

Do you need help with this or a different assignment? Even when your task is complicated and the deadline is in less than 2 days, you still have every chance to get a good grade for it. How? By completing the order form, you will get the finest custom-written assignment at an affordable price. We also deliver a number of services for free (e.g., revisions, editing, checking the text for authenticity). Use our paper writing service to receive effective help with your homework.


Order a Similar Paper Order a Different Paper