Java to C programming assignment help

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_

 
Do you need a similar assignment done for you from scratch? We have qualified writers to help you. We assure you an A+ quality paper that is free from plagiarism. Order now for an Amazing Discount! Use Discount Code “Newclient” for a 15% Discount!NB: We do not resell papers. Upon ordering, we do an original paper exclusively for you.

The post Java to C programming assignment help appeared first on Quality Nursing Writers.