Before a final in computer science I heard some people talking about how one of the frqs was nearly impossible. I heard what the general prompt was, and quickly googled how to do it. However I found the frq that was given in class. I didn’t know it was the frq that would on the test, and I ended up essentially copying what was written onto the test. I substituted a while loop for a for loop and changed some variable names, but the code is essentially the same. I did all the other frq questions independently, but I’m worried that someone else will have intentionally cheated (since we did the frqs over two days they could have googled the prompt and found what I found), and put the same code as I did. My school has a very strict no cheating policy, and they notify colleges if a student is found to be cheating. Did I cheat and will I get caught?
In my humble opinion as a teacher: any teacher who gives the same test to more than one period HAS to expect the kids to talk about what was on the test.
You heard someone talk about what was on their test, and you made sure you were prepared if that same prompt ended up on your test. It did, but you had no way of knowing it would.
You lost me on the codes and loops, but it sounds to me as though you studied thoroughly and did nothing wrong.
@coolstudent54 I agree with @bjkmom, that is bound to happen when teachers give the same test to different class periods. Additionally, many problems in Java might only have one solution, in which everyone who gets it would have the same or very similar solutions (up to choice of variable names, assert statements, formatting, etc.).
For example, if we had to write a simple method that computes the nth Fibonacci number, I’d think that a lot of students would write something like this:
public static int fibonacci(int n){
assert n >= 0;
if (n == 0){ return 0;}
else if (n == 1){ return 1;}
else{ return fibonacci(n-1) + fibonacci(n-2);}
}
There are, of course, other ways to compute it, e.g. using Binet’s formula, or recursively constructing the sequence up to n (the advantage here is that only a constant amount of memory is needed), but the same basic idea is the same.