ECS 36A语言编程辅导、讲解C/C++程序、辅导data编程

日期：2020-11-09 09:41

ECS 36A: Programming Assignment #3
Fall 2020
Contents
1 Changelog 1
2 General Submission Details 1
3 Grading Breakdown 2
4 Submitting on Gradescope 2
4.1 Regarding Autograder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
4.1.1 Number of Visible vs. Hidden Cases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
4.1.2 Test Cases’ Inputs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
5 Programming Problems 3
5.1 File Organization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
5.2 Restrictions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
5.3 Part #1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
5.4 Part #2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
5.5 Part #3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
5.6 Part #4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
5.7 Part #5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1 Changelog
You should always refer to the latest version of this document.
? v.1: Initial version.
? v.2: For part #5, you may assume that the strings are mutable.
? v.3: Updated deadline to be Friday night, as was confirmed in a previous Canvas announcement. Added autograder
details and grading breakdown.
? v.4: Explicitly stated what the function in part #1 is supposed to return.
2 General Submission Details
Partnering on this assignment is prohibited. If you have not already, you should read the section on
academic misconduct in the syllabus.
This assignment is due the night of Friday, November 6. Gradescope will say 12:30 AM on Saturday, November 7, due
to the “grace period” (as described in the syllabus). Be careful about relying on the grace period for extra time; this could be
risky.
You should use the -Wall and -Werror flags when compiling. The autograder will use these flags when it compiles your
program.
?This content is protected and may not be shared, uploaded, or distributed.
1
3 Grading Breakdown
The autograder score will be out of 50 points. Below is the number of points corresponding to each part:
? Part #1: 10
? Part #2: 5
? Part #3: 10
? Part #4: 10
? Part #5: 15
4 Submitting on Gradescope
You should only submit your C files with the names indicated below. You may be penalized for submitting additional
files. You have infinite submissions until the deadline.
During the 10/02 lecture, I talked about how to change the active submission, just in case that is something that you
find yourself wanting to do.
4.1 Regarding Autograder
Your output must match mine exactly.
There is a description about how to interpret some of the autograder error messages in the directions for the previous
two programming assignments. I will not repeat that description here.
Only submit prog3.c.
4.1.1 Number of Visible vs. Hidden Cases
Below is the breakdown of visible vs. hidden test cases on each part.
Part No. Cases No. Visible No. Hidden
4.1.2 Test Cases’ Inputs
For the visible test cases, the autograder uses the files part1_visible.c, part2_visible.c, part3_visible.c, part4_visible.c,
and part5_visible.c. You can find all of these on Canvas. Note that these do not use the same main() implementations that
were shown in the examples for each of the parts.
In compiling your code, the autograder first does the line gcc -Wall -Werror -c prog3.c -o prog3.o to see if your own code
has any compiler errors. If your own code has no compiler errors, then it will be converted into an object file called prog3.o;
we’ll talk more about how this works once we get to slide deck #7, but for now, you can take the command for granted.
After executing the aforementioned command, the autograder then does one of the following commands, depending on which
part is being tested:
? Part #1: gcc -Wall -Werror part1_visible.c prog3.o -o part1_visible
? Part #2: gcc -Wall -Werror part2_visible.c prog3.o -o part2_visible
? Part #3: gcc -Wall -Werror part3_visible.c prog3.o -o part3_visible
? Part #4: gcc -Wall -Werror part4_visible.c prog3.o -o part4_visible
? Part #5: gcc -Wall -Werror part5_visible.c prog3.o -o part5_visible
When running the appropriate executable based on which part is being tested, the case number is passed as a “commandline
argument”. You should look closely at each of the autograder C files to see how this is done, if you are trying to use the
autograder files to manually test your own code. Below are a few examples.
Run case #2 of part #1, using the inputs mentioned a few paragraphs below.
1 $ ./ part1_visible 2
2 Calling enterUntilN () ...
3 Entered : 15
4 Entered : -15
5 Entered : 35
2
6 Finished call to enterUntilN () ...
7 Return value of enterUntilN () : 3
Run case #1 of part #2.
1 $ ./ part2_visible 1
2 Calling sum3 () ...
3 Finished call to sum3 () ...
4 Variable referenced by fourth argument was set to ( original value -1000) : 10
Run case #3 of part #3.
1 $ ./ part3_visible 3
2 Calling getNthOccurrence () ...
3 Finished call to getNthOccurrence () ...
4 Return value of getNthOccurrence () : 8
For the hidden test cases, the autograder uses the files part3_hidden.c, part4_hidden.c, and part5_hidden.c. These files will
not be released until after the deadline.
The function for part #1, enterUntilN(), asks for user input. Below are the user inputs that the autograder uses for the
three test cases for part #1.
? Case #1:
5 Programming Problems
5.1 File Organization
Each function mentioned below will go in a file called prog3.c. Each such function is declared in the file prog3.h on Canvas.
We will eventually talk about managing C code that spans multiple files, but for now, it suffices to think of the purpose of
prog3.h as being to allow prog3.c and the tester programs (which have their own implementations of main()) to “know about”
the same functions and those functions’ information. Compiling files that involve multiple C files is not much more difficult
than the compilation you’ve done so far, and you can see how such compilation is done in the examples for each part.
You should start with the skeleton version of prog3.c that is provided on Canvas.
5.2 Restrictions
When you submit your prog3.c to Gradescope, it cannot have a main() implementation in it.
Since you will only submit prog3.c to the autograder, you are not allowed to modify prog3.h.
Below is a list of headers that you are allowed to include in prog3.c. You may not need all of these.
? prog3.h (isn’t necessary; we’ll talk about why one might do this later)
?
?
?
?
3
5.3 Part #1
In prog3.c, implement the enterUntilN() function that is declared in prog3.h. This function takes a single argument, an
unsigned integer we’ll call n. The function should continue to prompt the user to enter integers until the absolute value of
the sum of the integers entered by the user is at least n.
You may assume that arithmetic overflow will never be an issue, unless you do something bizarre such as use a short to
store the sum or use a char to store the user’s input.
This function should return the number of values entered by the user.
Below are examples of how your program should behave.
1 $ cat test_enterUntilN . c
2 # include < stdio .h >
3
4 # include " prog3 .h"
5
6 int main ()
7 {
8 unsigned numVals = enterUntilN (8) ;
9 printf (" numVals =% d\n" , numVals );
10 }
11 $ gcc - Wall - Werror test_enterUntilN .c prog3 .c -o test_enterUntilN
12 $ ./ test_enterUntilN
13 Entered : 5
14 Entered : 2
15 Entered : 3
16 numVals =3
17 $ ./ test_enterUntilN
18 Entered : -4
19 Entered : -4
20 numVals =2
21 $
5.4 Part #2
In prog3.c, implement the sum3() function that is declared in prog3.h. This function takes four arguments: three integers
and one pointer to an integer. This function should place the sum of the three integers into the variable referenced by the
fourth argument.
If the pointer given is NULL, then your function should do nothing (and avoid crashing).
Below are examples of how your program should behave.
1 $ cat test_sum3 .c
2 # include " prog3 .h"
3
4 # include < stdio .h >
5
6 int main ()
7 {
8 int s;
9 sum3 (4 , 10 , -1 , & s);
10 printf ("% d\n ", s);
11 sum3 (0 , 2, -10 , & s);
12 printf ("% d\n ", s);
13 }
14 $ gcc - Wall - Werror test_sum3 . c prog3 . c -o test_sum3
15 $ ./ test_sum3
16 13
17 -8
18 $
5.5 Part #3
In prog3.c, implement the function getNthOccurrence() that is defined in prog3.h. The first two arguments of this function
are an array of integers and the length of this array. The third argument is a target integer, and the fourth argument is
an integer that we’ll call n. The function should return the index of the n-th occurrence of the target in the array. If the
function is given a null pointer as the first argument or if n is not positive, then the function should return ?1. If there is
no n-th occurrence of the target (i.e. if the target does not appear at least n times in the array), then the function should
return ?2.
Below are examples of how your program should behave.
4
1 $ cat test_getNthOccurrence . c
2 # include < stdio .h >
3
4 # include " prog3 .h"
5
6 int main ()
7 {
8 int arr [] = {17 , 11 , 14 , 17 , 19 , 11 , 15 , 17};
9 int x = getNthOccurrence ( arr , 8, 17 , 2) ;
10 printf ("% d\n ", x); // 3
11 x = getNthOccurrence ( arr , 8 , 17 , 3) ;
12 printf ("% d\n ", x); // 7
13 x = getNthOccurrence ( arr , 8 , 11 , 1) ;
14 printf ("% d\n ", x); // 1
15 x = getNthOccurrence ( arr , 8 , 14 , 2) ;
16 printf ("% d\n ", x); // -2
17 }
18 $ gcc - Wall - Werror test_getNthOccurrence .c prog3 .c -o test_getNthOccurrence
19 $ ./ test_getNthOccurrence
20 3
21 7
22 1
23 -2
24 $
5.6 Part #4
This function is intentionally similar to the previous one.
In prog3.c, implement the function countOccurrences() that is defined in prog3.h. The first two arguments of this function
are an array of integers and the length of this array. The third argument is a target integer, and the fourth argument is a
pointer called first that references an integer. countOccurrences() should return ?1 if it is given any null pointers. Otherwise,
the function should return the number of times that the target integer appears in the array. The function should place the
index of the first occurrence of the target into the integer that is referenced by first. If the target integer never appears in
the array, then the integer referenced by first should not be modified.
Below are examples of how your program should behave.
1 $ cat test_countOccurrences . c
2 # include < stdio .h >
3
4 # include " prog3 .h"
5
6 int main ()
7 {
8 int arr [] = {18 , 52 , 52 , 49 , 52 , 61};
9 int first = -1;
10 int num = countOccurrences ( arr , 6, 52 , & first );
11 printf (" num : %d \n", num );
12 printf (" first : %d\n" , first ) ;
13 }
14 $ gcc - Wall - Werror test_countOccurrences .c prog3 .c -o test_countOccurrences
15 $ ./ test_countOccurrences
16 num : 3
17 first : 1
18 $
5.7 Part #5
In prog3.c, implement the function getNumBackwards() that is defined in prog3.h. This function takes two strings as its
arguments. This function should return ?1 if it is given a null pointer. Otherwise, the function should return the number of
times that the second string appears backwards in the first string.
You may assume that the given strings are both mutable.
Below are examples of how your program should behave.
1 $ cat test_getNumBackwards .c
2 # include < stdio .h >
3
4 # include " prog3 .h"
5
6 int main ()
5
7 {
8 char s1 [] = " abracadabra ";
9 char s2 [] = " arb ";
10 int num = getNumBackwards (s1 , s2 );
11 printf ("% d\n ", num ); // 2
12 char s3 [] = " apple ";
13 char s4 [] = " pa ";
14 num = getNumBackwards (s3 , s4 ) ;
15 printf ("% d\n ", num ); // 1
16 }
17 $ gcc - Wall - Werror test_getNumBackwards .c prog3 .c -o test_getNumBackwards
18 $ ./ test_getNumBackwards
19 2
20 1
21 $
6