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.
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 _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_