Page 1
Student ID: 423, P-Value: 7.25e-07
Nearest Neighbor ID: 152
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
n | for x in range(4): | n | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
n | try: | n | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
n | except Exception: | n | except Exception: |
| print("File not found")import csv | | print("File not found") import csv |
| input1 = input() | | input1 = input() |
n | with open(input1, 'r') as wordsfile: | n | with open(input1, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
t | for row in words_reader: | t | for row in words_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| listlength = len(no_duplicates_in_list) | | listlength = len(no_duplicates_in_list) |
| for i in range(listlength): | | for i in range(listlength): |
| print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))import csv | | ))import csv |
| file_input = input() | | file_input = input() |
| with open(file_input, 'r') as csvfile: | | with open(file_input, 'r') as csvfile: |
| reader = csv.reader(csvfile, delimiter='\t') | | reader = csv.reader(csvfile, delimiter='\t') |
| students = [] | | students = [] |
| totals = [0,0,0] | | totals = [0,0,0] |
| for row in reader: | | for row in reader: |
| final_grade = (int(row[2])+int(row[3])+int(row[4]))/3 | | final_grade = (int(row[2])+int(row[3])+int(row[4]))/3 |
| if final_grade >= 90: | | if final_grade >= 90: |
| final_letter = "A" | | final_letter = "A" |
| elif final_grade >= 80: | | elif final_grade >= 80: |
| final_letter = "B" | | final_letter = "B" |
| elif final_grade >= 70: | | elif final_grade >= 70: |
| final_letter = "C" | | final_letter = "C" |
| elif final_grade >= 60: | | elif final_grade >= 60: |
| final_letter = "D" | | final_letter = "D" |
| else: | | else: |
| final_letter = "F" | | final_letter = "F" |
| row.append(final_letter) | | row.append(final_letter) |
| totals[0] += int(row[2]) | | totals[0] += int(row[2]) |
| totals[1] += int(row[3]) | | totals[1] += int(row[3]) |
| totals[2] += int(row[4]) | | totals[2] += int(row[4]) |
| students.append(row) | | students.append(row) |
| averages = [i/len(students) for i in totals] | | averages = [i/len(students) for i in totals] |
| f = open("report.txt","w") | | f = open("report.txt","w") |
| for i in students: | | for i in students: |
| f.write("\t".join(i)+"\n") | | f.write("\t".join(i)+"\n") |
| f.write(f"\nAverages: midterm1 {averages[0]:.2f}, midterm2 {averages[1]:.2f} | | f.write(f"\nAverages: midterm1 {averages[0]:.2f}, midterm2 {averages[1]:.2f} |
| , final {averages[2]:.2f}\n") | | , final {averages[2]:.2f}\n") |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 2
Student ID: 152, P-Value: 7.25e-07
Nearest Neighbor ID: 423
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
n | for x in range(4): | n | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
n | try: | n | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
n | except Exception: | n | except Exception: |
| print("File not found") import csv | | print("File not found")import csv |
| input1 = input() | | input1 = input() |
n | with open(input1, 'r') as wordsfile: | n | with open(input1, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
t | for row in words_reader: | t | for row in words_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| listlength = len(no_duplicates_in_list) | | listlength = len(no_duplicates_in_list) |
| for i in range(listlength): | | for i in range(listlength): |
| print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))import csv | | ))import csv |
| file_input = input() | | file_input = input() |
| with open(file_input, 'r') as csvfile: | | with open(file_input, 'r') as csvfile: |
| reader = csv.reader(csvfile, delimiter='\t') | | reader = csv.reader(csvfile, delimiter='\t') |
| students = [] | | students = [] |
| totals = [0,0,0] | | totals = [0,0,0] |
| for row in reader: | | for row in reader: |
| final_grade = (int(row[2])+int(row[3])+int(row[4]))/3 | | final_grade = (int(row[2])+int(row[3])+int(row[4]))/3 |
| if final_grade >= 90: | | if final_grade >= 90: |
| final_letter = "A" | | final_letter = "A" |
| elif final_grade >= 80: | | elif final_grade >= 80: |
| final_letter = "B" | | final_letter = "B" |
| elif final_grade >= 70: | | elif final_grade >= 70: |
| final_letter = "C" | | final_letter = "C" |
| elif final_grade >= 60: | | elif final_grade >= 60: |
| final_letter = "D" | | final_letter = "D" |
| else: | | else: |
| final_letter = "F" | | final_letter = "F" |
| row.append(final_letter) | | row.append(final_letter) |
| totals[0] += int(row[2]) | | totals[0] += int(row[2]) |
| totals[1] += int(row[3]) | | totals[1] += int(row[3]) |
| totals[2] += int(row[4]) | | totals[2] += int(row[4]) |
| students.append(row) | | students.append(row) |
| averages = [i/len(students) for i in totals] | | averages = [i/len(students) for i in totals] |
| f = open("report.txt","w") | | f = open("report.txt","w") |
| for i in students: | | for i in students: |
| f.write("\t".join(i)+"\n") | | f.write("\t".join(i)+"\n") |
| f.write(f"\nAverages: midterm1 {averages[0]:.2f}, midterm2 {averages[1]:.2f} | | f.write(f"\nAverages: midterm1 {averages[0]:.2f}, midterm2 {averages[1]:.2f} |
| , final {averages[2]:.2f}\n") | | , final {averages[2]:.2f}\n") |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 3
Student ID: 318, P-Value: 1.24e-06
Nearest Neighbor ID: 495
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
t | print("File not found") | t | print("File not found")import csv |
| import csv | | |
| input1 = input() | | input1 = input() |
| with open(input1, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
| for row in words_reader: | | for row in words_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| listlength = len(no_duplicates_in_list) | | listlength = len(no_duplicates_in_list) |
| for i in range(listlength): | | for i in range(listlength): |
| print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))def determine_grade(avg): | | ))def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
| fileName = input("Enter the filename: ") | | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
| totalM1 = 0 | | totalM1 = 0 |
| totalM2 = 0 | | totalM2 = 0 |
| totalFinal = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 4
Student ID: 495, P-Value: 1.24e-06
Nearest Neighbor ID: 318
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
t | print("File not found")import csv | t | print("File not found") |
| | | import csv |
| input1 = input() | | input1 = input() |
| with open(input1, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
| for row in words_reader: | | for row in words_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| listlength = len(no_duplicates_in_list) | | listlength = len(no_duplicates_in_list) |
| for i in range(listlength): | | for i in range(listlength): |
| print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))def determine_grade(avg): | | ))def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
| fileName = input("Enter the filename: ") | | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
| totalM1 = 0 | | totalM1 = 0 |
| totalM2 = 0 | | totalM2 = 0 |
| totalFinal = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 5
Student ID: 79, P-Value: 1.47e-06
Nearest Neighbor ID: 127
Student (left) and Nearest Neighbor (right).
t | import random | t | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return resultimport csv | | return resultimport csv |
| input1 = input() | | input1 = input() |
| with open(input1, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
| for row in words_reader: | | for row in words_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| listlength = len(no_duplicates_in_list) | | listlength = len(no_duplicates_in_list) |
| for i in range(listlength): | | for i in range(listlength): |
| print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))def determine_grade(avg): | | ))def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
| fileName = input("Enter the filename: ") | | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
| totalM1 = 0 | | totalM1 = 0 |
| totalM2 = 0 | | totalM2 = 0 |
| totalFinal = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 6
Student ID: 127, P-Value: 1.47e-06
Nearest Neighbor ID: 79
Student (left) and Nearest Neighbor (right).
t | import random | t | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return resultimport csv | | return resultimport csv |
| input1 = input() | | input1 = input() |
| with open(input1, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
| for row in words_reader: | | for row in words_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| listlength = len(no_duplicates_in_list) | | listlength = len(no_duplicates_in_list) |
| for i in range(listlength): | | for i in range(listlength): |
| print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))def determine_grade(avg): | | ))def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
| fileName = input("Enter the filename: ") | | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
| totalM1 = 0 | | totalM1 = 0 |
| totalM2 = 0 | | totalM2 = 0 |
| totalFinal = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 7
Student ID: 142, P-Value: 1.75e-06
Nearest Neighbor ID: 193
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
t | result += ',' +str(random.randint(0,9)) | t | result += ','+str(random.randint(0,9)) |
| return result | | return resultimport csv |
| import csv | | |
| input_given = input() | | input_given = input() |
| with open(input_given, 'r') as wordslife: | | with open(input_given, 'r') as wordslife: |
| word_reader = csv.reader(wordslife) | | word_reader = csv.reader(wordslife) |
| for row in word_reader: | | for row in word_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| length = len(no_duplicates_in_list) | | length = len(no_duplicates_in_list) |
| for i in range(length): | | for i in range(length): |
| print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))def getGrade(averageGrade): | | ))def getGrade(averageGrade): |
| if averageGrade >= 90: | | if averageGrade >= 90: |
| return 'A' | | return 'A' |
| elif averageGrade >= 80: | | elif averageGrade >= 80: |
| return 'B' | | return 'B' |
| elif averageGrade >= 70: | | elif averageGrade >= 70: |
| return 'C' | | return 'C' |
| elif averageGrade >= 60: | | elif averageGrade >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(x): | | def main(x): |
| input_File = x | | input_File = x |
| output_File = 'report.txt' | | output_File = 'report.txt' |
| mid_T1, mid_T2, final, total_MT1, total_MT2, total_Final, count = 0, 0, 0, 0 | | mid_T1, mid_T2, final, total_MT1, total_MT2, total_Final, count = 0, 0, 0, 0 |
| , 0, 0, 0 | | , 0, 0, 0 |
| infile = open(input_File, 'r') | | infile = open(input_File, 'r') |
| outfile = open(output_File, 'w+') | | outfile = open(output_File, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
| fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( | | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| line[3]), int(line[4]) | | line[3]), int(line[4]) |
| count += 1 | | count += 1 |
| total_MT1 += midT1 | | total_MT1 += midT1 |
| total_MT2 += midT2 | | total_MT2 += midT2 |
| total_Final += final | | total_Final += final |
| grade = getGrade((midT1 + midT2 + final) / 3) | | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| ile) | | ile) |
| infile.close() | | infile.close() |
| total_MT1 /= count | | total_MT1 /= count |
| total_MT2 /= count | | total_MT2 /= count |
| total_Final /= count | | total_Final /= count |
| print(f'\nAverages: midterm1 {total_MT1:.2f}, midterm2 {total_MT2:.2f}, fina | | print(f'\nAverages: midterm1 {total_MT1:.2f}, midterm2 {total_MT2:.2f}, fina |
| l {total_Final:.2f}', | | l {total_Final:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| file = input() | | file = input() |
| main(file) | | main(file) |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 8
Student ID: 193, P-Value: 1.75e-06
Nearest Neighbor ID: 142
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
t | result += ','+str(random.randint(0,9)) | t | result += ',' +str(random.randint(0,9)) |
| return resultimport csv | | return result |
| | | import csv |
| input_given = input() | | input_given = input() |
| with open(input_given, 'r') as wordslife: | | with open(input_given, 'r') as wordslife: |
| word_reader = csv.reader(wordslife) | | word_reader = csv.reader(wordslife) |
| for row in word_reader: | | for row in word_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| length = len(no_duplicates_in_list) | | length = len(no_duplicates_in_list) |
| for i in range(length): | | for i in range(length): |
| print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))def getGrade(averageGrade): | | ))def getGrade(averageGrade): |
| if averageGrade >= 90: | | if averageGrade >= 90: |
| return 'A' | | return 'A' |
| elif averageGrade >= 80: | | elif averageGrade >= 80: |
| return 'B' | | return 'B' |
| elif averageGrade >= 70: | | elif averageGrade >= 70: |
| return 'C' | | return 'C' |
| elif averageGrade >= 60: | | elif averageGrade >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(x): | | def main(x): |
| input_File = x | | input_File = x |
| output_File = 'report.txt' | | output_File = 'report.txt' |
| mid_T1, mid_T2, final, total_MT1, total_MT2, total_Final, count = 0, 0, 0, 0 | | mid_T1, mid_T2, final, total_MT1, total_MT2, total_Final, count = 0, 0, 0, 0 |
| , 0, 0, 0 | | , 0, 0, 0 |
| infile = open(input_File, 'r') | | infile = open(input_File, 'r') |
| outfile = open(output_File, 'w+') | | outfile = open(output_File, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
| fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( | | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| line[3]), int(line[4]) | | line[3]), int(line[4]) |
| count += 1 | | count += 1 |
| total_MT1 += midT1 | | total_MT1 += midT1 |
| total_MT2 += midT2 | | total_MT2 += midT2 |
| total_Final += final | | total_Final += final |
| grade = getGrade((midT1 + midT2 + final) / 3) | | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| ile) | | ile) |
| infile.close() | | infile.close() |
| total_MT1 /= count | | total_MT1 /= count |
| total_MT2 /= count | | total_MT2 /= count |
| total_Final /= count | | total_Final /= count |
| print(f'\nAverages: midterm1 {total_MT1:.2f}, midterm2 {total_MT2:.2f}, fina | | print(f'\nAverages: midterm1 {total_MT1:.2f}, midterm2 {total_MT2:.2f}, fina |
| l {total_Final:.2f}', | | l {total_Final:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| file = input() | | file = input() |
| main(file) | | main(file) |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 9
Student ID: 56, P-Value: 2.18e-06
Nearest Neighbor ID: 67
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| word = str(random.randint(0,100)) | | word = str(random.randint(0,100)) |
| for i in range(0,4): | | for i in range(0,4): |
| word += "," + str(random.randint(0,100)) | | word += "," + str(random.randint(0,100)) |
| return word | | return word |
| file = open('randomNums.txt','w') | | file = open('randomNums.txt','w') |
| for j in range(5): | | for j in range(5): |
t | file.write(randomGen()+'\n')import csv | t | file.write(randomGen()+'\n') |
| | | file.close()import csv |
| input1 = input() | | input1 = input() |
| with open(input1, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
| for row in words_reader: | | for row in words_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| listlength = len(no_duplicates_in_list) | | listlength = len(no_duplicates_in_list) |
| for i in range(listlength): | | for i in range(listlength): |
| print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))def determine_grade(avg): | | ))def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
| fileName = input("Enter the filename: ") | | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
| totalM1 = 0 | | totalM1 = 0 |
| totalM2 = 0 | | totalM2 = 0 |
| totalFinal = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 10
Student ID: 67, P-Value: 2.18e-06
Nearest Neighbor ID: 56
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| word = str(random.randint(0,100)) | | word = str(random.randint(0,100)) |
| for i in range(0,4): | | for i in range(0,4): |
| word += "," + str(random.randint(0,100)) | | word += "," + str(random.randint(0,100)) |
| return word | | return word |
| file = open('randomNums.txt','w') | | file = open('randomNums.txt','w') |
| for j in range(5): | | for j in range(5): |
t | file.write(randomGen()+'\n') | t | file.write(randomGen()+'\n')import csv |
| file.close()import csv | | |
| input1 = input() | | input1 = input() |
| with open(input1, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
| for row in words_reader: | | for row in words_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| listlength = len(no_duplicates_in_list) | | listlength = len(no_duplicates_in_list) |
| for i in range(listlength): | | for i in range(listlength): |
| print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))def determine_grade(avg): | | ))def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
| fileName = input("Enter the filename: ") | | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
| totalM1 = 0 | | totalM1 = 0 |
| totalM2 = 0 | | totalM2 = 0 |
| totalFinal = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 11
Student ID: 297, P-Value: 3.19e-06
Nearest Neighbor ID: 199
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| afile = open("randomNums.txt", "w" ) | | afile = open("randomNums.txt", "w" ) |
| def rnum(): | | def rnum(): |
| r=random.randint(1, 100) | | r=random.randint(1, 100) |
n | return r | n | return r |
| def randomGen(): | | def randomGen(): |
| randomstring='{},{},{},{},{}'.format(rnum(),rnum(),rnum(),rnum(),rnum()) | | randomstring='{},{},{},{},{}'.format(rnum(),rnum(),rnum(),rnum(),rnum()) |
| return randomstring | | return randomstring |
| b=5 | | b=5 |
| file = open('randomNums.txt', 'a') | | file = open('randomNums.txt', 'a') |
| while b>0: | | while b>0: |
| file.write(randomGen()) | | file.write(randomGen()) |
t | b-=1import csv | t | b-=1 |
| | | import csv |
| input1 = input() | | input1 = input() |
| with open(input1, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
| for row in words_reader: | | for row in words_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| listlength = len(no_duplicates_in_list) | | listlength = len(no_duplicates_in_list) |
| for i in range(listlength): | | for i in range(listlength): |
| print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))fname=input("Enter the file name: ") | | ))fname=input("Enter the file name: ") |
| file = open(fname) | | file = open(fname) |
| f = open("report.txt", "w") | | f = open("report.txt", "w") |
| mid1 = 0 | | mid1 = 0 |
| mid2 = 0 | | mid2 = 0 |
| final = 0 | | final = 0 |
| students = 0 | | students = 0 |
| for line in file: | | for line in file: |
| students = students + 1 | | students = students + 1 |
| data = ('\t'.join(line.split())).split() | | data = ('\t'.join(line.split())).split() |
| m1=int(data[2].strip()) | | m1=int(data[2].strip()) |
| m2=int(data[3].strip()) | | m2=int(data[3].strip()) |
| m3 = int(data[4].strip("\n")) | | m3 = int(data[4].strip("\n")) |
| mid1 = mid1+m1 | | mid1 = mid1+m1 |
| mid2 = mid2+m2 | | mid2 = mid2+m2 |
| final = final + m3 | | final = final + m3 |
| avg = (m1+m2+m3)/3.0 | | avg = (m1+m2+m3)/3.0 |
| grade = 'F' | | grade = 'F' |
| if avg > 90: | | if avg > 90: |
| grade = 'A' | | grade = 'A' |
| elif avg > 80: | | elif avg > 80: |
| grade='B' | | grade='B' |
| elif avg > 70: | | elif avg > 70: |
| grade='C' | | grade='C' |
| elif avg > 60: | | elif avg > 60: |
| grade='D' | | grade='D' |
| f.write('\t'.join(data)+"\t" + str(grade)+"\n") | | f.write('\t'.join(data)+"\t" + str(grade)+"\n") |
| avg1=mid1/students | | avg1=mid1/students |
| avg2=mid2/students | | avg2=mid2/students |
| avg3=final/students | | avg3=final/students |
| f.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3:.2f} | | f.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3:.2f} |
| \n") | | \n") |
| f.close() | | f.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 12
Student ID: 199, P-Value: 3.19e-06
Nearest Neighbor ID: 297
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| afile = open("randomNums.txt", "w" ) | | afile = open("randomNums.txt", "w" ) |
| def rnum(): | | def rnum(): |
| r=random.randint(1, 100) | | r=random.randint(1, 100) |
n | return r | n | return r |
| def randomGen(): | | def randomGen(): |
| randomstring='{},{},{},{},{}'.format(rnum(),rnum(),rnum(),rnum(),rnum()) | | randomstring='{},{},{},{},{}'.format(rnum(),rnum(),rnum(),rnum(),rnum()) |
| return randomstring | | return randomstring |
| b=5 | | b=5 |
| file = open('randomNums.txt', 'a') | | file = open('randomNums.txt', 'a') |
| while b>0: | | while b>0: |
| file.write(randomGen()) | | file.write(randomGen()) |
t | b-=1 | t | b-=1import csv |
| import csv | | |
| input1 = input() | | input1 = input() |
| with open(input1, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
| for row in words_reader: | | for row in words_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| listlength = len(no_duplicates_in_list) | | listlength = len(no_duplicates_in_list) |
| for i in range(listlength): | | for i in range(listlength): |
| print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))fname=input("Enter the file name: ") | | ))fname=input("Enter the file name: ") |
| file = open(fname) | | file = open(fname) |
| f = open("report.txt", "w") | | f = open("report.txt", "w") |
| mid1 = 0 | | mid1 = 0 |
| mid2 = 0 | | mid2 = 0 |
| final = 0 | | final = 0 |
| students = 0 | | students = 0 |
| for line in file: | | for line in file: |
| students = students + 1 | | students = students + 1 |
| data = ('\t'.join(line.split())).split() | | data = ('\t'.join(line.split())).split() |
| m1=int(data[2].strip()) | | m1=int(data[2].strip()) |
| m2=int(data[3].strip()) | | m2=int(data[3].strip()) |
| m3 = int(data[4].strip("\n")) | | m3 = int(data[4].strip("\n")) |
| mid1 = mid1+m1 | | mid1 = mid1+m1 |
| mid2 = mid2+m2 | | mid2 = mid2+m2 |
| final = final + m3 | | final = final + m3 |
| avg = (m1+m2+m3)/3.0 | | avg = (m1+m2+m3)/3.0 |
| grade = 'F' | | grade = 'F' |
| if avg > 90: | | if avg > 90: |
| grade = 'A' | | grade = 'A' |
| elif avg > 80: | | elif avg > 80: |
| grade='B' | | grade='B' |
| elif avg > 70: | | elif avg > 70: |
| grade='C' | | grade='C' |
| elif avg > 60: | | elif avg > 60: |
| grade='D' | | grade='D' |
| f.write('\t'.join(data)+"\t" + str(grade)+"\n") | | f.write('\t'.join(data)+"\t" + str(grade)+"\n") |
| avg1=mid1/students | | avg1=mid1/students |
| avg2=mid2/students | | avg2=mid2/students |
| avg3=final/students | | avg3=final/students |
| f.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3:.2f} | | f.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3:.2f} |
| \n") | | \n") |
| f.close() | | f.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 13
Student ID: 158, P-Value: 4.37e-06
Nearest Neighbor ID: 242
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
n | print("File not found") | n | print("File not found")import csv |
| import csv | | |
| filename = input() | | filename = input() |
| f = open(filename) | | f = open(filename) |
| data = csv.reader(f, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
| count += 1 | | count += 1 |
| print(words[i], count) | | print(words[i], count) |
t | | t | f.close() |
| f.close()def determine_grade(avg): | | def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
| fileName = input("Enter the filename: ") | | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
| totalM1 = 0 | | totalM1 = 0 |
| totalM2 = 0 | | totalM2 = 0 |
| totalFinal = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 14
Student ID: 242, P-Value: 4.37e-06
Nearest Neighbor ID: 158
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
n | print("File not found")import csv | n | print("File not found") |
| | | import csv |
| filename = input() | | filename = input() |
| f = open(filename) | | f = open(filename) |
| data = csv.reader(f, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
| count += 1 | | count += 1 |
| print(words[i], count) | | print(words[i], count) |
t | f.close() | t | |
| def determine_grade(avg): | | f.close()def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
| fileName = input("Enter the filename: ") | | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
| totalM1 = 0 | | totalM1 = 0 |
| totalM2 = 0 | | totalM2 = 0 |
| totalFinal = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 15
Student ID: 254, P-Value: 5.36e-06
Nearest Neighbor ID: 398
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
t | result += ","+str(random.randint(0,9)) | t | result += ','+str(random.randint(0,9)) |
| return resultimport csv | | return result |
| | | import csv |
| filename = input() | | filename = input() |
| f = open(filename) | | f = open(filename) |
| data = csv.reader(f, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
| count += 1 | | count += 1 |
| print(words[i], count) | | print(words[i], count) |
| f.close()def getGrade(averageScore): | | f.close()def getGrade(averageScore): |
| if averageScore >= 90: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
| elif averageScore >= 80: | | elif averageScore >= 80: |
| return 'B' | | return 'B' |
| elif averageScore >= 70: | | elif averageScore >= 70: |
| return 'C' | | return 'C' |
| elif averageScore >= 60: | | elif averageScore >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
| inputFile = input() | | inputFile = input() |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
| midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, | | midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, |
| 0, 0 | | 0, 0 |
| infile = open(inputFile, 'r') | | infile = open(inputFile, 'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
| fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( | | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| line[3]), int(line[4]) | | line[3]), int(line[4]) |
| count += 1 | | count += 1 |
| totalMT1 += midT1 | | totalMT1 += midT1 |
| totalMT2 += midT2 | | totalMT2 += midT2 |
| totalFinal += final | | totalFinal += final |
| grade = getGrade((midT1 + midT2 + final) / 3) | | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| ile) | | ile) |
| infile.close() | | infile.close() |
| totalMT1 /= count | | totalMT1 /= count |
| totalMT2 /= count | | totalMT2 /= count |
| totalFinal /= count | | totalFinal /= count |
| print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final | | print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final |
| {totalFinal:.2f}', | | {totalFinal:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 16
Student ID: 398, P-Value: 5.36e-06
Nearest Neighbor ID: 254
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
t | result += ','+str(random.randint(0,9)) | t | result += ","+str(random.randint(0,9)) |
| return result | | return resultimport csv |
| import csv | | |
| filename = input() | | filename = input() |
| f = open(filename) | | f = open(filename) |
| data = csv.reader(f, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
| count += 1 | | count += 1 |
| print(words[i], count) | | print(words[i], count) |
| f.close()def getGrade(averageScore): | | f.close()def getGrade(averageScore): |
| if averageScore >= 90: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
| elif averageScore >= 80: | | elif averageScore >= 80: |
| return 'B' | | return 'B' |
| elif averageScore >= 70: | | elif averageScore >= 70: |
| return 'C' | | return 'C' |
| elif averageScore >= 60: | | elif averageScore >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
| inputFile = input() | | inputFile = input() |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
| midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, | | midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, |
| 0, 0 | | 0, 0 |
| infile = open(inputFile, 'r') | | infile = open(inputFile, 'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
| fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( | | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| line[3]), int(line[4]) | | line[3]), int(line[4]) |
| count += 1 | | count += 1 |
| totalMT1 += midT1 | | totalMT1 += midT1 |
| totalMT2 += midT2 | | totalMT2 += midT2 |
| totalFinal += final | | totalFinal += final |
| grade = getGrade((midT1 + midT2 + final) / 3) | | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| ile) | | ile) |
| infile.close() | | infile.close() |
| totalMT1 /= count | | totalMT1 /= count |
| totalMT2 /= count | | totalMT2 /= count |
| totalFinal /= count | | totalFinal /= count |
| print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final | | print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final |
| {totalFinal:.2f}', | | {totalFinal:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 17
Student ID: 113, P-Value: 5.64e-06
Nearest Neighbor ID: 158
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
t | except Brobro: | t | except Exception: |
| print("File not found")import csv | | print("File not found") |
| | | import csv |
| filename = input() | | filename = input() |
| f = open(filename) | | f = open(filename) |
| data = csv.reader(f, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
| count += 1 | | count += 1 |
| print(words[i], count) | | print(words[i], count) |
| f.close()def determine_grade(avg): | | f.close()def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
| fileName = input("Enter the filename: ") | | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
| totalM1 = 0 | | totalM1 = 0 |
| totalM2 = 0 | | totalM2 = 0 |
| totalFinal = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 18
Student ID: 386, P-Value: 1.41e-05
Nearest Neighbor ID: 142
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
n | result += ','+str(random.randint(0,9)) | n | result += ',' +str(random.randint(0,9)) |
| return result | | return result |
| import csv | | import csv |
n | given = input() | n | input_given = input() |
| with open(given, 'r') as wordsfile: | | with open(input_given, 'r') as wordslife: |
| word_reader=csv.reader(wordsfile) | | word_reader = csv.reader(wordslife) |
| for row in word_reader: | | for row in word_reader: |
t | list_of_words=row | t | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| length = len(no_duplicates_in_list) | | length = len(no_duplicates_in_list) |
| for i in range(length): | | for i in range(length): |
| print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))def getGrade(averageGrade): | | ))def getGrade(averageGrade): |
| if averageGrade >= 90: | | if averageGrade >= 90: |
| return 'A' | | return 'A' |
| elif averageGrade >= 80: | | elif averageGrade >= 80: |
| return 'B' | | return 'B' |
| elif averageGrade >= 70: | | elif averageGrade >= 70: |
| return 'C' | | return 'C' |
| elif averageGrade >= 60: | | elif averageGrade >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(x): | | def main(x): |
| input_File = x | | input_File = x |
| output_File = 'report.txt' | | output_File = 'report.txt' |
| mid_T1, mid_T2, final, total_MT1, total_MT2, total_Final, count = 0, 0, 0, 0 | | mid_T1, mid_T2, final, total_MT1, total_MT2, total_Final, count = 0, 0, 0, 0 |
| , 0, 0, 0 | | , 0, 0, 0 |
| infile = open(input_File, 'r') | | infile = open(input_File, 'r') |
| outfile = open(output_File, 'w+') | | outfile = open(output_File, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
| fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( | | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| line[3]), int(line[4]) | | line[3]), int(line[4]) |
| count += 1 | | count += 1 |
| total_MT1 += midT1 | | total_MT1 += midT1 |
| total_MT2 += midT2 | | total_MT2 += midT2 |
| total_Final += final | | total_Final += final |
| grade = getGrade((midT1 + midT2 + final) / 3) | | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| ile) | | ile) |
| infile.close() | | infile.close() |
| total_MT1 /= count | | total_MT1 /= count |
| total_MT2 /= count | | total_MT2 /= count |
| total_Final /= count | | total_Final /= count |
| print(f'\nAverages: midterm1 {total_MT1:.2f}, midterm2 {total_MT2:.2f}, fina | | print(f'\nAverages: midterm1 {total_MT1:.2f}, midterm2 {total_MT2:.2f}, fina |
| l {total_Final:.2f}', | | l {total_Final:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| file = input() | | file = input() |
| main(file) | | main(file) |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 19
Student ID: 345, P-Value: 1.54e-05
Nearest Neighbor ID: 490
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
n | for i in range(4): | n | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return resultimport csv | | return resultimport csv |
| filename = input() | | filename = input() |
| f = open(filename) | | f = open(filename) |
| data = csv.reader(f, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
| count += 1 | | count += 1 |
| print(words[i], count) | | print(words[i], count) |
n | | n | f.close() |
| | | fileName = input("Enter the filename: ") |
| | | outFile = "report.txt" |
| | | totalM1 = 0 |
| | | totalM2 = 0 |
| | | totalFinal = 0 |
| | | count = 0 |
| f.close()def determine_grade(avg): | | def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
t | fileName = input("Enter the filename: ") | t | |
| outFile = "report.txt" | | |
| totalM1 = 0 | | |
| totalM2 = 0 | | |
| totalFinal = 0 | | |
| count = 0 | | |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 20
Student ID: 490, P-Value: 1.54e-05
Nearest Neighbor ID: 345
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
n | for x in range(4): | n | for i in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return resultimport csv | | return resultimport csv |
| filename = input() | | filename = input() |
| f = open(filename) | | f = open(filename) |
| data = csv.reader(f, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
| count += 1 | | count += 1 |
| print(words[i], count) | | print(words[i], count) |
n | f.close() | n | |
| fileName = input("Enter the filename: ") | | |
| outFile = "report.txt" | | |
| totalM1 = 0 | | |
| totalM2 = 0 | | |
| totalFinal = 0 | | |
| count = 0 | | |
| def determine_grade(avg): | | f.close()def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
t | | t | fileName = input("Enter the filename: ") |
| | | outFile = "report.txt" |
| | | totalM1 = 0 |
| | | totalM2 = 0 |
| | | totalFinal = 0 |
| | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 21
Student ID: 280, P-Value: 1.69e-05
Nearest Neighbor ID: 65
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| randoms = str(random.randint(0,9)) | | randoms = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| randoms += ","+str(random.randint(0,9)) | | randoms += ","+str(random.randint(0,9)) |
| return randoms | | return randoms |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
| print("File not found") | | print("File not found") |
| import csv | | import csv |
| fname = input() | | fname = input() |
| f = open(fname) | | f = open(fname) |
| data = csv.reader(f, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
| count += 1 | | count += 1 |
| print(words[i], count) | | print(words[i], count) |
t | f.close() | t | |
| fname=input("Enter the file name: ") | | f.close()fname=input("Enter the file name: ") |
| file = open(fname) | | file = open(fname) |
| f = open("report.txt", "w") | | f = open("report.txt", "w") |
| mid1 = 0 | | mid1 = 0 |
| mid2 = 0 | | mid2 = 0 |
| final = 0 | | final = 0 |
| students = 0 | | students = 0 |
| for line in file: | | for line in file: |
| students = students + 1 | | students = students + 1 |
| data = ('\t'.join(line.split())).split() | | data = ('\t'.join(line.split())).split() |
| m1=int(data[2].strip()) | | m1=int(data[2].strip()) |
| m2=int(data[3].strip()) | | m2=int(data[3].strip()) |
| m3 = int(data[4].strip("\n")) | | m3 = int(data[4].strip("\n")) |
| mid1 = mid1+m1 | | mid1 = mid1+m1 |
| mid2 = mid2+m2 | | mid2 = mid2+m2 |
| final = final + m3 | | final = final + m3 |
| avg = (m1+m2+m3)/3.0 | | avg = (m1+m2+m3)/3.0 |
| grade = 'F' | | grade = 'F' |
| if avg > 90: | | if avg > 90: |
| grade = 'A' | | grade = 'A' |
| elif avg > 80: | | elif avg > 80: |
| grade='B' | | grade='B' |
| elif avg > 70: | | elif avg > 70: |
| grade='C' | | grade='C' |
| elif avg > 60: | | elif avg > 60: |
| grade='D' | | grade='D' |
| f.write('\t'.join(data)+"\t" + str(grade)+"\n") | | f.write('\t'.join(data)+"\t" + str(grade)+"\n") |
| avg1=mid1/students | | avg1=mid1/students |
| avg2=mid2/students | | avg2=mid2/students |
| avg3=final/students | | avg3=final/students |
| f.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3:.2f} | | f.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3:.2f} |
| \n") | | \n") |
| f.close() | | f.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 22
Student ID: 65, P-Value: 1.69e-05
Nearest Neighbor ID: 280
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| randoms = str(random.randint(0,9)) | | randoms = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| randoms += ","+str(random.randint(0,9)) | | randoms += ","+str(random.randint(0,9)) |
| return randoms | | return randoms |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
| print("File not found") | | print("File not found") |
| import csv | | import csv |
| fname = input() | | fname = input() |
| f = open(fname) | | f = open(fname) |
| data = csv.reader(f, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
| count += 1 | | count += 1 |
| print(words[i], count) | | print(words[i], count) |
t | | t | f.close() |
| f.close()fname=input("Enter the file name: ") | | fname=input("Enter the file name: ") |
| file = open(fname) | | file = open(fname) |
| f = open("report.txt", "w") | | f = open("report.txt", "w") |
| mid1 = 0 | | mid1 = 0 |
| mid2 = 0 | | mid2 = 0 |
| final = 0 | | final = 0 |
| students = 0 | | students = 0 |
| for line in file: | | for line in file: |
| students = students + 1 | | students = students + 1 |
| data = ('\t'.join(line.split())).split() | | data = ('\t'.join(line.split())).split() |
| m1=int(data[2].strip()) | | m1=int(data[2].strip()) |
| m2=int(data[3].strip()) | | m2=int(data[3].strip()) |
| m3 = int(data[4].strip("\n")) | | m3 = int(data[4].strip("\n")) |
| mid1 = mid1+m1 | | mid1 = mid1+m1 |
| mid2 = mid2+m2 | | mid2 = mid2+m2 |
| final = final + m3 | | final = final + m3 |
| avg = (m1+m2+m3)/3.0 | | avg = (m1+m2+m3)/3.0 |
| grade = 'F' | | grade = 'F' |
| if avg > 90: | | if avg > 90: |
| grade = 'A' | | grade = 'A' |
| elif avg > 80: | | elif avg > 80: |
| grade='B' | | grade='B' |
| elif avg > 70: | | elif avg > 70: |
| grade='C' | | grade='C' |
| elif avg > 60: | | elif avg > 60: |
| grade='D' | | grade='D' |
| f.write('\t'.join(data)+"\t" + str(grade)+"\n") | | f.write('\t'.join(data)+"\t" + str(grade)+"\n") |
| avg1=mid1/students | | avg1=mid1/students |
| avg2=mid2/students | | avg2=mid2/students |
| avg3=final/students | | avg3=final/students |
| f.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3:.2f} | | f.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3:.2f} |
| \n") | | \n") |
| f.close() | | f.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 23
Student ID: 252, P-Value: 1.69e-05
Nearest Neighbor ID: 398
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | file=str(random.randint(0,9)) | n | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
t | file+=','+str(random.randint(0,9)) | t | result += ','+str(random.randint(0,9)) |
| return fileimport csv | | return result |
| | | import csv |
| filename = input() | | filename = input() |
| f = open(filename) | | f = open(filename) |
| data = csv.reader(f, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
| count += 1 | | count += 1 |
| print(words[i], count) | | print(words[i], count) |
| f.close()def getGrade(averageScore): | | f.close()def getGrade(averageScore): |
| if averageScore >= 90: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
| elif averageScore >= 80: | | elif averageScore >= 80: |
| return 'B' | | return 'B' |
| elif averageScore >= 70: | | elif averageScore >= 70: |
| return 'C' | | return 'C' |
| elif averageScore >= 60: | | elif averageScore >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
| inputFile = input() | | inputFile = input() |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
| midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, | | midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, |
| 0, 0 | | 0, 0 |
| infile = open(inputFile, 'r') | | infile = open(inputFile, 'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
| fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( | | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| line[3]), int(line[4]) | | line[3]), int(line[4]) |
| count += 1 | | count += 1 |
| totalMT1 += midT1 | | totalMT1 += midT1 |
| totalMT2 += midT2 | | totalMT2 += midT2 |
| totalFinal += final | | totalFinal += final |
| grade = getGrade((midT1 + midT2 + final) / 3) | | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| ile) | | ile) |
| infile.close() | | infile.close() |
| totalMT1 /= count | | totalMT1 /= count |
| totalMT2 /= count | | totalMT2 /= count |
| totalFinal /= count | | totalFinal /= count |
| print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final | | print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final |
| {totalFinal:.2f}', | | {totalFinal:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 24
Student ID: 125, P-Value: 2.30e-05
Nearest Neighbor ID: 75
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | result = str(random.randint(0,9)) | n | number = str(random.randint(0,9)) |
| for x in range(4): | | for i in range(4): |
| result += ","+str(random.randint(0,9)) | | number += ","+str(random.randint(0,9)) |
| return result | | return number |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
n | print("File not found")import csv | n | print("File not found") |
| | | import csv |
| filename = input() | | filename = input() |
| f = open(filename) | | f = open(filename) |
n | data = csv.reader(f, delimiter=',') | n | data = csv.reader(f, delimiter = ',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
n | count += 1 | n | count+= 1 |
| print(words[i], count) | | print(words[i], count) |
t | f.close() | t | |
| def getAverageGrade(average): | | f.close()def getAverageGrade(average): |
| if average >= 90: | | if average >= 90: |
| return 'A' | | return 'A' |
| elif average >= 80: | | elif average >= 80: |
| return 'B' | | return 'B' |
| elif average >= 70: | | elif average >= 70: |
| return 'C' | | return 'C' |
| elif average >= 60: | | elif average >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
| fileName = input("Enter the filename: ") | | fileName = input("Enter the filename: ") |
| inputFile = fileName | | inputFile = fileName |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
| midterm1 = 0 | | midterm1 = 0 |
| midterm2 = 0 | | midterm2 = 0 |
| final = 0 | | final = 0 |
| midterm1Total = 0 | | midterm1Total = 0 |
| midterm2Total = 0 | | midterm2Total = 0 |
| finalTotal = 0 | | finalTotal = 0 |
| count = 0 | | count = 0 |
| inFile = open(inputFile, 'r') | | inFile = open(inputFile, 'r') |
| outFile = open(outputFile, 'w+') | | outFile = open(outputFile, 'w+') |
| for line in inFile: | | for line in inFile: |
| line = line.strip().split() | | line = line.strip().split() |
| fistName = line[0] | | fistName = line[0] |
| lasName = line[1] | | lasName = line[1] |
| midterm1 = int(line[2]) | | midterm1 = int(line[2]) |
| midterm2 = int(line[3]) | | midterm2 = int(line[3]) |
| final = int(line[4]) | | final = int(line[4]) |
| count = count + 1 | | count = count + 1 |
| midterm1Total = midterm1Total + midterm1 | | midterm1Total = midterm1Total + midterm1 |
| midterm2Total = midterm2Total + midterm2 | | midterm2Total = midterm2Total + midterm2 |
| finalTotal = finalTotal + final | | finalTotal = finalTotal + final |
| grade = getAverageGrade((midterm1 + midterm2 + final) / 3) | | grade = getAverageGrade((midterm1 + midterm2 + final) / 3) |
| print(f'{fistName}\t{lasName}\t{midterm1}\t{midterm2}\t{final}\t{grade}' | | print(f'{fistName}\t{lasName}\t{midterm1}\t{midterm2}\t{final}\t{grade}' |
| , file=outFile) | | , file=outFile) |
| inFile.close() | | inFile.close() |
| midterm1Total = midterm1Total / count | | midterm1Total = midterm1Total / count |
| midterm2Total = midterm2Total / count | | midterm2Total = midterm2Total / count |
| finalTotal = finalTotal / count | | finalTotal = finalTotal / count |
| print(f'\nAverages: midterm1 {midterm1Total:.2f}, midterm2 {midterm2Total:.2 | | print(f'\nAverages: midterm1 {midterm1Total:.2f}, midterm2 {midterm2Total:.2 |
| f}, final {finalTotal:.2f}', | | f}, final {finalTotal:.2f}', |
| file=outFile) | | file=outFile) |
| outFile.close() | | outFile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 25
Student ID: 75, P-Value: 2.30e-05
Nearest Neighbor ID: 125
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | number = str(random.randint(0,9)) | n | result = str(random.randint(0,9)) |
| for i in range(4): | | for x in range(4): |
| number += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return number | | return result |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
n | print("File not found") | n | print("File not found")import csv |
| import csv | | |
| filename = input() | | filename = input() |
| f = open(filename) | | f = open(filename) |
n | data = csv.reader(f, delimiter = ',') | n | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
n | count+= 1 | n | count += 1 |
| print(words[i], count) | | print(words[i], count) |
t | | t | f.close() |
| f.close()def getAverageGrade(average): | | def getAverageGrade(average): |
| if average >= 90: | | if average >= 90: |
| return 'A' | | return 'A' |
| elif average >= 80: | | elif average >= 80: |
| return 'B' | | return 'B' |
| elif average >= 70: | | elif average >= 70: |
| return 'C' | | return 'C' |
| elif average >= 60: | | elif average >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
| fileName = input("Enter the filename: ") | | fileName = input("Enter the filename: ") |
| inputFile = fileName | | inputFile = fileName |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
| midterm1 = 0 | | midterm1 = 0 |
| midterm2 = 0 | | midterm2 = 0 |
| final = 0 | | final = 0 |
| midterm1Total = 0 | | midterm1Total = 0 |
| midterm2Total = 0 | | midterm2Total = 0 |
| finalTotal = 0 | | finalTotal = 0 |
| count = 0 | | count = 0 |
| inFile = open(inputFile, 'r') | | inFile = open(inputFile, 'r') |
| outFile = open(outputFile, 'w+') | | outFile = open(outputFile, 'w+') |
| for line in inFile: | | for line in inFile: |
| line = line.strip().split() | | line = line.strip().split() |
| fistName = line[0] | | fistName = line[0] |
| lasName = line[1] | | lasName = line[1] |
| midterm1 = int(line[2]) | | midterm1 = int(line[2]) |
| midterm2 = int(line[3]) | | midterm2 = int(line[3]) |
| final = int(line[4]) | | final = int(line[4]) |
| count = count + 1 | | count = count + 1 |
| midterm1Total = midterm1Total + midterm1 | | midterm1Total = midterm1Total + midterm1 |
| midterm2Total = midterm2Total + midterm2 | | midterm2Total = midterm2Total + midterm2 |
| finalTotal = finalTotal + final | | finalTotal = finalTotal + final |
| grade = getAverageGrade((midterm1 + midterm2 + final) / 3) | | grade = getAverageGrade((midterm1 + midterm2 + final) / 3) |
| print(f'{fistName}\t{lasName}\t{midterm1}\t{midterm2}\t{final}\t{grade}' | | print(f'{fistName}\t{lasName}\t{midterm1}\t{midterm2}\t{final}\t{grade}' |
| , file=outFile) | | , file=outFile) |
| inFile.close() | | inFile.close() |
| midterm1Total = midterm1Total / count | | midterm1Total = midterm1Total / count |
| midterm2Total = midterm2Total / count | | midterm2Total = midterm2Total / count |
| finalTotal = finalTotal / count | | finalTotal = finalTotal / count |
| print(f'\nAverages: midterm1 {midterm1Total:.2f}, midterm2 {midterm2Total:.2 | | print(f'\nAverages: midterm1 {midterm1Total:.2f}, midterm2 {midterm2Total:.2 |
| f}, final {finalTotal:.2f}', | | f}, final {finalTotal:.2f}', |
| file=outFile) | | file=outFile) |
| outFile.close() | | outFile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 26
Student ID: 309, P-Value: 2.41e-05
Nearest Neighbor ID: 423
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
n | print("File not found") | n | print("File not found")import csv |
| import csv | | |
| input_1 = input() | | input1 = input() |
| with open(input_1, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
| for row in words_reader: | | for row in words_reader: |
t | word_list = row | t | list_of_words = row |
| no_duplicates = list(dict.fromkeys(word_list)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| list_length = len(no_duplicates) | | listlength = len(no_duplicates_in_list) |
| for i in range(list_length): | | for i in range(listlength): |
| print(no_duplicates[i], word_list.count(no_duplicates[i]))import csv | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| | | ))import csv |
| file_input = input() | | file_input = input() |
| with open(file_input, 'r') as csvfile: | | with open(file_input, 'r') as csvfile: |
| reader = csv.reader(csvfile, delimiter='\t') | | reader = csv.reader(csvfile, delimiter='\t') |
| students = [] | | students = [] |
| totals = [0,0,0] | | totals = [0,0,0] |
| for row in reader: | | for row in reader: |
| final_grade = (int(row[2])+int(row[3])+int(row[4]))/3 | | final_grade = (int(row[2])+int(row[3])+int(row[4]))/3 |
| if final_grade >= 90: | | if final_grade >= 90: |
| final_letter = "A" | | final_letter = "A" |
| elif final_grade >= 80: | | elif final_grade >= 80: |
| final_letter = "B" | | final_letter = "B" |
| elif final_grade >= 70: | | elif final_grade >= 70: |
| final_letter = "C" | | final_letter = "C" |
| elif final_grade >= 60: | | elif final_grade >= 60: |
| final_letter = "D" | | final_letter = "D" |
| else: | | else: |
| final_letter = "F" | | final_letter = "F" |
| row.append(final_letter) | | row.append(final_letter) |
| totals[0] += int(row[2]) | | totals[0] += int(row[2]) |
| totals[1] += int(row[3]) | | totals[1] += int(row[3]) |
| totals[2] += int(row[4]) | | totals[2] += int(row[4]) |
| students.append(row) | | students.append(row) |
| averages = [i/len(students) for i in totals] | | averages = [i/len(students) for i in totals] |
| f = open("report.txt","w") | | f = open("report.txt","w") |
| for i in students: | | for i in students: |
| f.write("\t".join(i)+"\n") | | f.write("\t".join(i)+"\n") |
| f.write(f"\nAverages: midterm1 {averages[0]:.2f}, midterm2 {averages[1]:.2f} | | f.write(f"\nAverages: midterm1 {averages[0]:.2f}, midterm2 {averages[1]:.2f} |
| , final {averages[2]:.2f}\n") | | , final {averages[2]:.2f}\n") |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 27
Student ID: 498, P-Value: 3.38e-05
Nearest Neighbor ID: 490
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
n | return result | n | return resultimport csv |
| import csv | | |
| filename = input() | | filename = input() |
n | x = open(filename) | n | f = open(filename) |
| data = csv.reader(x, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
| count += 1 | | count += 1 |
| print(words[i], count) | | print(words[i], count) |
n | x.close() | n | f.close() |
| | | fileName = input("Enter the filename: ") |
| | | outFile = "report.txt" |
| | | totalM1 = 0 |
| | | totalM2 = 0 |
| | | totalFinal = 0 |
| | | count = 0 |
| def determine_grade(avg): | | def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
t | fileName = input("Enter the filename: ") | t | |
| outFile = "report.txt" | | |
| totalM1 = 0 | | |
| totalM2 = 0 | | |
| totalFinal = 0 | | |
| count = 0 | | |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 28
Student ID: 118, P-Value: 5.51e-05
Nearest Neighbor ID: 199
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
n | def randomGen(): | n | |
| afile = open("randomNums.txt", "w" ) | | afile = open("randomNums.txt", "w" ) |
| def rnum(): | | def rnum(): |
| r=random.randint(1, 100) | | r=random.randint(1, 100) |
| return r | | return r |
| def randomGen(): | | def randomGen(): |
| randomstring='{},{},{},{},{}'.format(rnum(),rnum(),rnum(),rnum(),rnum()) | | randomstring='{},{},{},{},{}'.format(rnum(),rnum(),rnum(),rnum(),rnum()) |
| return randomstring | | return randomstring |
| b=5 | | b=5 |
| file = open('randomNums.txt', 'a') | | file = open('randomNums.txt', 'a') |
| while b>0: | | while b>0: |
| file.write(randomGen()) | | file.write(randomGen()) |
t | b-=1import csv | t | b-=1 |
| x = input() | | import csv |
| | | input1 = input() |
| with open(x, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
| for row in words_reader: | | for row in words_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| listlength = len(no_duplicates_in_list) | | listlength = len(no_duplicates_in_list) |
| for i in range(listlength): | | for i in range(listlength): |
| print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))fname=input("Enter the file name: ") | | ))fname=input("Enter the file name: ") |
| file = open(fname) | | file = open(fname) |
| f = open("report.txt", "w") | | f = open("report.txt", "w") |
| mid1 = 0 | | mid1 = 0 |
| mid2 = 0 | | mid2 = 0 |
| final = 0 | | final = 0 |
| students = 0 | | students = 0 |
| for line in file: | | for line in file: |
| students = students + 1 | | students = students + 1 |
| data = ('\t'.join(line.split())).split() | | data = ('\t'.join(line.split())).split() |
| m1=int(data[2].strip()) | | m1=int(data[2].strip()) |
| m2=int(data[3].strip()) | | m2=int(data[3].strip()) |
| m3 = int(data[4].strip("\n")) | | m3 = int(data[4].strip("\n")) |
| mid1 = mid1+m1 | | mid1 = mid1+m1 |
| mid2 = mid2+m2 | | mid2 = mid2+m2 |
| final = final + m3 | | final = final + m3 |
| avg = (m1+m2+m3)/3.0 | | avg = (m1+m2+m3)/3.0 |
| grade = 'F' | | grade = 'F' |
| if avg > 90: | | if avg > 90: |
| grade = 'A' | | grade = 'A' |
| elif avg > 80: | | elif avg > 80: |
| grade='B' | | grade='B' |
| elif avg > 70: | | elif avg > 70: |
| grade='C' | | grade='C' |
| elif avg > 60: | | elif avg > 60: |
| grade='D' | | grade='D' |
| f.write('\t'.join(data)+"\t" + str(grade)+"\n") | | f.write('\t'.join(data)+"\t" + str(grade)+"\n") |
| avg1=mid1/students | | avg1=mid1/students |
| avg2=mid2/students | | avg2=mid2/students |
| avg3=final/students | | avg3=final/students |
| f.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3:.2f} | | f.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3:.2f} |
| \n") | | \n") |
| f.close() | | f.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 29
Student ID: 384, P-Value: 8.43e-05
Nearest Neighbor ID: 56
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | strnum= str(random.randint(0,999)) | n | word = str(random.randint(0,100)) |
| for q in range(0,4): | | for i in range(0,4): |
| strnum+=","+ str(random.randint(0,999)) | | word += "," + str(random.randint(0,100)) |
| return strnum | | return word |
| file= open('randomNums.txt','w') | | file = open('randomNums.txt','w') |
| for w in range(0,5): | | for j in range(5): |
| file.write(randomGen()+'\n') | | file.write(randomGen()+'\n')import csv |
| import csv | | |
| input1 = input() | | input1 = input() |
| with open(input1, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
| for row in words_reader: | | for row in words_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| listlength = len(no_duplicates_in_list) | | listlength = len(no_duplicates_in_list) |
| for i in range(listlength): | | for i in range(listlength): |
| print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))def determine_grade(avg): | | ))def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
t | fileName = input() | t | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
| totalM1 = 0 | | totalM1 = 0 |
| totalM2 = 0 | | totalM2 = 0 |
| totalFinal = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 30
Student ID: 29, P-Value: 2.20e-04
Nearest Neighbor ID: 450
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
n | result += ","+str(random.randint(0,9)) | n | result += "," + str(random.randint(0,9)) |
| return resultinput_file=input() | | return resultinput_file = input() |
| import csv | | import csv |
| with open(input_file) as csv_file: | | with open(input_file) as csv_file: |
n | data = csv.reader(csv_file, delimiter=',') | n | data = csv.reader(csv_file, delimiter=',') |
| dictionary = {} | | dictionary = {} |
| for row in data: | | for row in data: |
| for string in row: | | for string in row: |
| if string in dictionary: | | if string in dictionary: |
| dictionary[string] += 1 | | dictionary[string] += 1 |
| else: | | else: |
| dictionary[string] = 1 | | dictionary[string] = 1 |
| for key in dictionary: | | for key in dictionary: |
n | print(f"{key} {dictionary[key]}")import csv | n | print(f'{key} {dictionary[key]}')import csv |
| file = open("StudentInfo.tsv") | | file = open("StudentInfo.tsv") |
| nFile = open("report.txt","w") | | nFile = open("report.txt","w") |
| lst1 = [] | | lst1 = [] |
| lst2 = [] | | lst2 = [] |
| lst3 = [] | | lst3 = [] |
| read_file = csv.reader(file, delimiter = "\t") | | read_file = csv.reader(file, delimiter = "\t") |
| for data in read_file: | | for data in read_file: |
| lst1.append(int(data[2])) | | lst1.append(int(data[2])) |
| lst2.append(int(data[3])) | | lst2.append(int(data[3])) |
| lst3.append(int(data[4])) | | lst3.append(int(data[4])) |
| avg = (int(data[2])+int(data[3])+int(data[4]))/3 | | avg = (int(data[2])+int(data[3])+int(data[4]))/3 |
| for item in data: | | for item in data: |
| nFile.writelines(item + "\t") | | nFile.writelines(item + "\t") |
| if avg >= 90: | | if avg >= 90: |
| nFile.write("A\n") | | nFile.write("A\n") |
| elif avg >= 80 and avg < 90: | | elif avg >= 80 and avg < 90: |
| nFile.write("B\n") | | nFile.write("B\n") |
| elif avg >= 70 and avg < 80: | | elif avg >= 70 and avg < 80: |
| nFile.write("C\n") | | nFile.write("C\n") |
| elif avg >= 60 and avg < 70: | | elif avg >= 60 and avg < 70: |
| nFile.write("D\n") | | nFile.write("D\n") |
| else: | | else: |
| nFile.write("F\n") | | nFile.write("F\n") |
| avg1 = sum(lst1)/len(lst1) | | avg1 = sum(lst1)/len(lst1) |
| avg2 = sum(lst2)/len(lst2) | | avg2 = sum(lst2)/len(lst2) |
| avg3 = sum(lst3)/len(lst3) | | avg3 = sum(lst3)/len(lst3) |
t | nFile.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3: | t | nFile.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3: |
| .2f}"'/n') | | .2f}\n") |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 31
Student ID: 450, P-Value: 2.20e-04
Nearest Neighbor ID: 29
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
n | result += "," + str(random.randint(0,9)) | n | result += ","+str(random.randint(0,9)) |
| return resultinput_file = input() | | return resultinput_file=input() |
| import csv | | import csv |
| with open(input_file) as csv_file: | | with open(input_file) as csv_file: |
n | data = csv.reader(csv_file, delimiter=',') | n | data = csv.reader(csv_file, delimiter=',') |
| dictionary = {} | | dictionary = {} |
| for row in data: | | for row in data: |
| for string in row: | | for string in row: |
| if string in dictionary: | | if string in dictionary: |
| dictionary[string] += 1 | | dictionary[string] += 1 |
| else: | | else: |
| dictionary[string] = 1 | | dictionary[string] = 1 |
| for key in dictionary: | | for key in dictionary: |
n | print(f'{key} {dictionary[key]}')import csv | n | print(f"{key} {dictionary[key]}")import csv |
| file = open("StudentInfo.tsv") | | file = open("StudentInfo.tsv") |
| nFile = open("report.txt","w") | | nFile = open("report.txt","w") |
| lst1 = [] | | lst1 = [] |
| lst2 = [] | | lst2 = [] |
| lst3 = [] | | lst3 = [] |
| read_file = csv.reader(file, delimiter = "\t") | | read_file = csv.reader(file, delimiter = "\t") |
| for data in read_file: | | for data in read_file: |
| lst1.append(int(data[2])) | | lst1.append(int(data[2])) |
| lst2.append(int(data[3])) | | lst2.append(int(data[3])) |
| lst3.append(int(data[4])) | | lst3.append(int(data[4])) |
| avg = (int(data[2])+int(data[3])+int(data[4]))/3 | | avg = (int(data[2])+int(data[3])+int(data[4]))/3 |
| for item in data: | | for item in data: |
| nFile.writelines(item + "\t") | | nFile.writelines(item + "\t") |
| if avg >= 90: | | if avg >= 90: |
| nFile.write("A\n") | | nFile.write("A\n") |
| elif avg >= 80 and avg < 90: | | elif avg >= 80 and avg < 90: |
| nFile.write("B\n") | | nFile.write("B\n") |
| elif avg >= 70 and avg < 80: | | elif avg >= 70 and avg < 80: |
| nFile.write("C\n") | | nFile.write("C\n") |
| elif avg >= 60 and avg < 70: | | elif avg >= 60 and avg < 70: |
| nFile.write("D\n") | | nFile.write("D\n") |
| else: | | else: |
| nFile.write("F\n") | | nFile.write("F\n") |
| avg1 = sum(lst1)/len(lst1) | | avg1 = sum(lst1)/len(lst1) |
| avg2 = sum(lst2)/len(lst2) | | avg2 = sum(lst2)/len(lst2) |
| avg3 = sum(lst3)/len(lst3) | | avg3 = sum(lst3)/len(lst3) |
t | nFile.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3: | t | nFile.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3: |
| .2f}\n") | | .2f}"'/n') |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 32
Student ID: 194, P-Value: 2.68e-04
Nearest Neighbor ID: 65
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | rand_nums = str(random.randint(0,9)) | n | randoms = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
n | rand_nums += ","+str(random.randint(0,9)) | n | randoms += ","+str(random.randint(0,9)) |
| return rand_nums | | return randoms |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
n | print("File not found")import csv | n | print("File not found") |
| | | import csv |
| file_name = input() | | fname = input() |
| file = open(file_name) | | f = open(fname) |
| data = csv.reader(file, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
| count += 1 | | count += 1 |
| print(words[i], count) | | print(words[i], count) |
t | file.close() | t | |
| file_name = input("Enter the file name: ") | | f.close()fname=input("Enter the file name: ") |
| file = open(file_name) | | file = open(fname) |
| f = open("report.txt", "w") | | f = open("report.txt", "w") |
| mid1 = 0 | | mid1 = 0 |
| mid2 = 0 | | mid2 = 0 |
| final = 0 | | final = 0 |
| students = 0 | | students = 0 |
| for line in file: | | for line in file: |
| students = students + 1 | | students = students + 1 |
| data = ('\t'.join(line.split())).split() | | data = ('\t'.join(line.split())).split() |
| m1=int(data[2].strip()) | | m1=int(data[2].strip()) |
| m2=int(data[3].strip()) | | m2=int(data[3].strip()) |
| m3 = int(data[4].strip("\n")) | | m3 = int(data[4].strip("\n")) |
| mid1 = mid1+m1 | | mid1 = mid1+m1 |
| mid2 = mid2+m2 | | mid2 = mid2+m2 |
| final = final + m3 | | final = final + m3 |
| avg = (m1+m2+m3)/3.0 | | avg = (m1+m2+m3)/3.0 |
| grade = 'F' | | grade = 'F' |
| if avg > 90: | | if avg > 90: |
| grade = 'A' | | grade = 'A' |
| elif avg > 80: | | elif avg > 80: |
| grade='B' | | grade='B' |
| elif avg > 70: | | elif avg > 70: |
| grade='C' | | grade='C' |
| elif avg > 60: | | elif avg > 60: |
| grade='D' | | grade='D' |
| f.write('\t'.join(data)+"\t" + str(grade)+"\n") | | f.write('\t'.join(data)+"\t" + str(grade)+"\n") |
| avg1=mid1/students | | avg1=mid1/students |
| avg2=mid2/students | | avg2=mid2/students |
| avg3=final/students | | avg3=final/students |
| f.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3:.2f} | | f.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3:.2f} |
| \n") | | \n") |
| f.close() | | f.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 33
Student ID: 296, P-Value: 3.35e-04
Nearest Neighbor ID: 254
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | result=str(random.randint(0,9)) | n | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return resultimport csv | | return resultimport csv |
n | filename=input() | n | filename = input() |
| f=open(filename) | | f = open(filename) |
| data=csv.reader(f, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words=[] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
n | count=0 | n | count = 0 |
| for w in words: | | for w in words: |
n | if words[i]==w: | n | if words[i] == w: |
| count += 1 | | count += 1 |
| print(words[i], count) | | print(words[i], count) |
| f.close()def getGrade(averageScore): | | f.close()def getGrade(averageScore): |
| if averageScore >= 90: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
| elif averageScore >= 80: | | elif averageScore >= 80: |
| return 'B' | | return 'B' |
| elif averageScore >= 70: | | elif averageScore >= 70: |
| return 'C' | | return 'C' |
| elif averageScore >= 60: | | elif averageScore >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
t | inputFile = 'StudentInfo.tsv' | t | inputFile = input() |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
| midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, | | midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, |
| 0, 0 | | 0, 0 |
| infile = open(inputFile, 'r') | | infile = open(inputFile, 'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
| fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( | | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| line[3]), int(line[4]) | | line[3]), int(line[4]) |
| count += 1 | | count += 1 |
| totalMT1 += midT1 | | totalMT1 += midT1 |
| totalMT2 += midT2 | | totalMT2 += midT2 |
| totalFinal += final | | totalFinal += final |
| grade = getGrade((midT1 + midT2 + final) / 3) | | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| ile) | | ile) |
| infile.close() | | infile.close() |
| totalMT1 /= count | | totalMT1 /= count |
| totalMT2 /= count | | totalMT2 /= count |
| totalFinal /= count | | totalFinal /= count |
| print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final | | print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final |
| {totalFinal:.2f}', | | {totalFinal:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 34
Student ID: 73, P-Value: 3.35e-04
Nearest Neighbor ID: 490
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
n | return result | n | return resultimport csv |
| import csv | | filename = input() |
| file = open(input()) | | f = open(filename) |
| strings = csv.reader(file, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
n | for row in strings: | n | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
n | for j in range(len(words)): | n | for w in words: |
| if words[i] == words[j]: | | if words[i] == w: |
| count += 1 | | count += 1 |
| print(words[i], count) | | print(words[i], count) |
n | | n | f.close() |
| | | fileName = input("Enter the filename: ") |
| | | outFile = "report.txt" |
| | | totalM1 = 0 |
| | | totalM2 = 0 |
| | | totalFinal = 0 |
| | | count = 0 |
| file.close()def determine_grade(avg): | | def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
t | fileName = input("Enter the filename: ") | t | |
| outFile = "report.txt" | | |
| totalM1 = 0 | | |
| totalM2 = 0 | | |
| totalFinal = 0 | | |
| count = 0 | | |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 35
Student ID: 353, P-Value: 5.62e-04
Nearest Neighbor ID: 488
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
n | for x in range(4): | n | for i in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
n | for i in range(5): | n | for x in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
| print("File not found")import csv | | print("File not found")import csv |
n | input_given = input() | n | input1 = input() |
| with open(input_given, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| word_reader = csv.reader(wordsfile) | | w_reader = csv.reader(wordsfile) |
| for row in word_reader: | | for row in w_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| length = len(no_duplicates_in_list) | | length = len(no_duplicates_in_list) |
| for i in range(length): | | for i in range(length): |
n | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | n | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))def getGrade(averageGrade): | | ))def getGrade(averageScore): |
| if averageGrade >= 90: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
n | elif averageGrade >= 80: | n | elif averageScore >= 80: |
| return 'B' | | return 'B' |
n | elif averageGrade >= 70: | n | elif averageScore >= 70: |
| return 'C' | | return 'C' |
n | elif averageGrade >= 60: | n | elif averageScore >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(x): | | def main(x): |
n | input_File = x | n | inputFile = x |
| output_File = 'report.txt' | | outputFile = 'report.txt' |
| mid_T1, mid_T2, final, total_MT1, total_MT2, total_Final, count = 0, 0, 0, 0 | | midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, |
| , 0, 0, 0 | | 0, 0 |
| infile = open(input_File, 'r') | | infile = open(inputFile, 'r') |
| outfile = open(output_File, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
| fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( | | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| line[3]), int(line[4]) | | line[3]), int(line[4]) |
| count += 1 | | count += 1 |
n | total_MT1 += midT1 | n | totalMT1 += midT1 |
| total_MT2 += midT2 | | totalMT2 += midT2 |
| total_Final += final | | totalFinal += final |
| grade = getGrade((midT1 + midT2 + final) / 3) | | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| ile) | | ile) |
| infile.close() | | infile.close() |
t | total_MT1 /= count | t | totalMT1 /= count |
| total_MT2 /= count | | totalMT2 /= count |
| total_Final /= count | | totalFinal /= count |
| print(f'\nAverages: midterm1 {total_MT1:.2f}, midterm2 {total_MT2:.2f}, fina | | print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final |
| l {total_Final:.2f}', | | {totalFinal:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| file = input() | | file = input() |
| main(file) | | main(file) |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 36
Student ID: 488, P-Value: 5.62e-04
Nearest Neighbor ID: 353
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
n | for i in range(4): | n | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
n | for x in range(5): | n | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
| print("File not found")import csv | | print("File not found")import csv |
n | input1 = input() | n | input_given = input() |
| with open(input1, 'r') as wordsfile: | | with open(input_given, 'r') as wordsfile: |
| w_reader = csv.reader(wordsfile) | | word_reader = csv.reader(wordsfile) |
| for row in w_reader: | | for row in word_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| length = len(no_duplicates_in_list) | | length = len(no_duplicates_in_list) |
| for i in range(length): | | for i in range(length): |
n | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | n | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))def getGrade(averageScore): | | ))def getGrade(averageGrade): |
| if averageScore >= 90: | | if averageGrade >= 90: |
| return 'A' | | return 'A' |
n | elif averageScore >= 80: | n | elif averageGrade >= 80: |
| return 'B' | | return 'B' |
n | elif averageScore >= 70: | n | elif averageGrade >= 70: |
| return 'C' | | return 'C' |
n | elif averageScore >= 60: | n | elif averageGrade >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(x): | | def main(x): |
n | inputFile = x | n | input_File = x |
| outputFile = 'report.txt' | | output_File = 'report.txt' |
| midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, | | mid_T1, mid_T2, final, total_MT1, total_MT2, total_Final, count = 0, 0, 0, 0 |
| 0, 0 | | , 0, 0, 0 |
| infile = open(inputFile, 'r') | | infile = open(input_File, 'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(output_File, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
| fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( | | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| line[3]), int(line[4]) | | line[3]), int(line[4]) |
| count += 1 | | count += 1 |
n | totalMT1 += midT1 | n | total_MT1 += midT1 |
| totalMT2 += midT2 | | total_MT2 += midT2 |
| totalFinal += final | | total_Final += final |
| grade = getGrade((midT1 + midT2 + final) / 3) | | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| ile) | | ile) |
| infile.close() | | infile.close() |
t | totalMT1 /= count | t | total_MT1 /= count |
| totalMT2 /= count | | total_MT2 /= count |
| totalFinal /= count | | total_Final /= count |
| print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final | | print(f'\nAverages: midterm1 {total_MT1:.2f}, midterm2 {total_MT2:.2f}, fina |
| {totalFinal:.2f}', | | l {total_Final:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| file = input() | | file = input() |
| main(file) | | main(file) |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 37
Student ID: 492, P-Value: 5.78e-04
Nearest Neighbor ID: 490
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | string = str(random.randint(0,9)) | n | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
n | string += ',' + str(random.randint(0,9)) | n | result += ","+str(random.randint(0,9)) |
| return stringimport csv | | return resultimport csv |
| file_name = input() | | filename = input() |
| file = open(file_name) | | f = open(filename) |
| data = csv.reader(file, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
n | count+= 1 | n | count += 1 |
| print(words[i], count) | | print(words[i], count) |
n | file.close() | n | f.close() |
| | | fileName = input("Enter the filename: ") |
| | | outFile = "report.txt" |
| | | totalM1 = 0 |
| | | totalM2 = 0 |
| | | totalFinal = 0 |
| | | count = 0 |
| def grade(avg): | | def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
n | fileName = input("Enter the filename: ") | n | |
| outFile = "report.txt" | | |
| totalM1 = 0 | | |
| totalM2 = 0 | | |
| totalFinal = 0 | | |
| count = 0 | | |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
n | g = grade(avg) | n | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
t | str(m2) + "\t" + str(final) + "\t" + g + "\n") | t | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 38
Student ID: 476, P-Value: 8.84e-04
Nearest Neighbor ID: 434
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
n | afile = open("randomNums.txt", "w") | n | afile = open("randomNums.txt", "w" ) |
| def rnum(): | | def rnum(): |
n | r= random.randint(1, 100) | n | r=random.randint(1, 100) |
| return r | | return r |
| def randomGen(): | | def randomGen(): |
n | randomstring = '{},{},{},{},{}'.format(rnum(),rnum(),rnum(),rnum(),rnum()) | n | randomstring='{},{},{},{},{}'.format(rnum(),rnum(),rnum(),rnum(),rnum()) |
| return randomstring | | return randomstring |
| b=5 | | b=5 |
n | file = open('randomNums.txt','a') | n | file = open('randomNums.txt', 'a') |
| while b>0: | | while b>0: |
| file.write(randomGen()) | | file.write(randomGen()) |
| b-=1import csv | | b-=1import csv |
n | inputa = input() | n | input1 = input() |
| with open(inputa, 'r') as wordfile: | | with open(input1, 'r') as wordfile: |
| word_reader = csv.reader(wordfile) | | word_reader = csv.reader(wordfile) |
| for row in word_reader: | | for row in word_reader: |
| list_of_word = row | | list_of_word = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_word)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_word)) |
| list_len = len(no_duplicates_in_list) | | list_len = len(no_duplicates_in_list) |
| for i in range(list_len): | | for i in range(list_len): |
| print(no_duplicates_in_list[i], list_of_word.count(no_duplicates_in_list[i]) | | print(no_duplicates_in_list[i], list_of_word.count(no_duplicates_in_list[i]) |
| )file_name = input("Enter the file name: ") | | )file_name = input("Enter the file name: ") |
| file = open(file_name) | | file = open(file_name) |
| f = open('report.txt','w') | | f = open('report.txt','w') |
n | | n | mid_0 = 0 |
| mid_1 = 0 | | mid_1 = 0 |
n | mid_2 = 0 | n | |
| final = 0 | | final = 0 |
| students = 0 | | students = 0 |
| for line in file: | | for line in file: |
| students = students + 1 | | students = students + 1 |
| data = ('\t'.join(line.split())).split() | | data = ('\t'.join(line.split())).split() |
| m1 = int(data[2].strip()) | | m1 = int(data[2].strip()) |
| m2 = int(data[3].strip()) | | m2 = int(data[3].strip()) |
| m3 = int(data[4].strip('\n')) | | m3 = int(data[4].strip('\n')) |
n | | n | mid_0 = mid_0 +m1 |
| mid_1 = mid_1 + m1 | | mid_1 = mid_1+m2 |
| mid_2 = mid_2 + m2 | | |
| final = final + m3 | | final = final +m3 |
| avg = (m1 + m2 + m3)/3.0 | | avg = (m1+m2+m3)/3.0 |
| grade = 'F' | | grade = "F" |
| if avg > 90: | | if avg > 90: |
| grade = 'A' | | grade = 'A' |
| elif avg > 80: | | elif avg > 80: |
| grade = 'B' | | grade = 'B' |
| elif avg > 70: | | elif avg > 70: |
| grade = 'C' | | grade = 'C' |
| elif avg > 60: | | elif avg > 60: |
| grade = 'D' | | grade = 'D' |
t | f.write('\t'.join(data)+ '\t' +str(grade)+ '\n') | t | f.write('\t'.join(data)+'\t'+str(grade)+'\n') |
| | | avg_1 = mid_0/students |
| avg_0 = mid_1/students | | avg_2 = mid_1/students |
| avg_1 = mid_2/students | | |
| avg_2 = final/students | | avg_3 = final/students |
| f.write(f'\nAverages: midterm1 {avg_0:.2f}, midterm2 {avg_1:.2f}, final {avg_2:. | | f.write(f'\nAverages: midterm1 {avg_1:.2f}, midterm2 {avg_2:.2f}, final {avg_3:. |
| 2f}\n') | | 2f}\n') |
| f.close | | f.close |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 39
Student ID: 434, P-Value: 8.84e-04
Nearest Neighbor ID: 476
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
n | afile = open("randomNums.txt", "w" ) | n | afile = open("randomNums.txt", "w") |
| def rnum(): | | def rnum(): |
n | r=random.randint(1, 100) | n | r= random.randint(1, 100) |
| return r | | return r |
| def randomGen(): | | def randomGen(): |
n | randomstring='{},{},{},{},{}'.format(rnum(),rnum(),rnum(),rnum(),rnum()) | n | randomstring = '{},{},{},{},{}'.format(rnum(),rnum(),rnum(),rnum(),rnum()) |
| return randomstring | | return randomstring |
| b=5 | | b=5 |
n | file = open('randomNums.txt', 'a') | n | file = open('randomNums.txt','a') |
| while b>0: | | while b>0: |
| file.write(randomGen()) | | file.write(randomGen()) |
| b-=1import csv | | b-=1import csv |
n | input1 = input() | n | inputa = input() |
| with open(input1, 'r') as wordfile: | | with open(inputa, 'r') as wordfile: |
| word_reader = csv.reader(wordfile) | | word_reader = csv.reader(wordfile) |
| for row in word_reader: | | for row in word_reader: |
| list_of_word = row | | list_of_word = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_word)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_word)) |
| list_len = len(no_duplicates_in_list) | | list_len = len(no_duplicates_in_list) |
| for i in range(list_len): | | for i in range(list_len): |
| print(no_duplicates_in_list[i], list_of_word.count(no_duplicates_in_list[i]) | | print(no_duplicates_in_list[i], list_of_word.count(no_duplicates_in_list[i]) |
| )file_name = input("Enter the file name: ") | | )file_name = input("Enter the file name: ") |
| file = open(file_name) | | file = open(file_name) |
| f = open('report.txt','w') | | f = open('report.txt','w') |
n | mid_0 = 0 | n | |
| mid_1 = 0 | | mid_1 = 0 |
n | | n | mid_2 = 0 |
| final = 0 | | final = 0 |
| students = 0 | | students = 0 |
| for line in file: | | for line in file: |
| students = students + 1 | | students = students + 1 |
| data = ('\t'.join(line.split())).split() | | data = ('\t'.join(line.split())).split() |
| m1 = int(data[2].strip()) | | m1 = int(data[2].strip()) |
| m2 = int(data[3].strip()) | | m2 = int(data[3].strip()) |
| m3 = int(data[4].strip('\n')) | | m3 = int(data[4].strip('\n')) |
n | mid_0 = mid_0 +m1 | n | |
| mid_1 = mid_1+m2 | | mid_1 = mid_1 + m1 |
| | | mid_2 = mid_2 + m2 |
| final = final +m3 | | final = final + m3 |
| avg = (m1+m2+m3)/3.0 | | avg = (m1 + m2 + m3)/3.0 |
| grade = "F" | | grade = 'F' |
| if avg > 90: | | if avg > 90: |
| grade = 'A' | | grade = 'A' |
| elif avg > 80: | | elif avg > 80: |
| grade = 'B' | | grade = 'B' |
| elif avg > 70: | | elif avg > 70: |
| grade = 'C' | | grade = 'C' |
| elif avg > 60: | | elif avg > 60: |
| grade = 'D' | | grade = 'D' |
t | f.write('\t'.join(data)+'\t'+str(grade)+'\n') | t | f.write('\t'.join(data)+ '\t' +str(grade)+ '\n') |
| avg_1 = mid_0/students | | |
| avg_2 = mid_1/students | | avg_0 = mid_1/students |
| | | avg_1 = mid_2/students |
| avg_3 = final/students | | avg_2 = final/students |
| f.write(f'\nAverages: midterm1 {avg_1:.2f}, midterm2 {avg_2:.2f}, final {avg_3:. | | f.write(f'\nAverages: midterm1 {avg_0:.2f}, midterm2 {avg_1:.2f}, final {avg_2:. |
| 2f}\n') | | 2f}\n') |
| f.close | | f.close |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 40
Student ID: 8, P-Value: 1.74e-03
Nearest Neighbor ID: 158
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | nums = str(random.randint(0,9)) | n | result = str(random.randint(0,9)) |
| for i in range(4): | | for x in range(4): |
| nums += ',' + str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return nums | | return result |
| try: | | try: |
n | file = open('randomNums.txt') | n | out = open('randomNums.txt', "w") |
| line = '' | | line = "" |
| for i in range(5): | | for i in range(5): |
n | file.write(randomGen() + '\n') | n | out.write(randomGen()+"\n") |
| file.close() | | out.close() |
| except: | | except Exception: |
| print('File not found') | | print("File not found") |
| import csv | | import csv |
| filename = input() | | filename = input() |
| f = open(filename) | | f = open(filename) |
n | wordreader = csv.reader(f) | n | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
t | for row in wordreader: | t | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
| count += 1 | | count += 1 |
| print(words[i], count) | | print(words[i], count) |
| f.close()def determine_grade(avg): | | f.close()def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
| fileName = input("Enter the filename: ") | | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
| totalM1 = 0 | | totalM1 = 0 |
| totalM2 = 0 | | totalM2 = 0 |
| totalFinal = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 41
Student ID: 258, P-Value: 2.11e-03
Nearest Neighbor ID: 79
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
n | return result | n | return resultimport csv |
| import csv | | |
| input1 = input() | | input1 = input() |
t | with open(input1, 'r') as wf: | t | with open(input1, 'r') as wordsfile: |
| wr = csv.reader(wf) | | words_reader = csv.reader(wordsfile) |
| for row in wr: | | for row in words_reader: |
| lw = row | | list_of_words = row |
| nd = list(dict.fromkeys(lw)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| ll = len(nd) | | listlength = len(no_duplicates_in_list) |
| for i in range(ll): | | for i in range(listlength): |
| print(nd[i], lw.count(nd[i]))def determine_grade(avg): | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| | | ))def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
| fileName = input("Enter the filename: ") | | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
| totalM1 = 0 | | totalM1 = 0 |
| totalM2 = 0 | | totalM2 = 0 |
| totalFinal = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 42
Student ID: 10, P-Value: 2.21e-03
Nearest Neighbor ID: 239
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
| print("File not found")input_file = input() | | print("File not found")input_file = input() |
| import csv | | import csv |
| with open(input_file) as csv_file: | | with open(input_file) as csv_file: |
| data = csv.reader(csv_file, delimiter=',') | | data = csv.reader(csv_file, delimiter=',') |
| dictionary = {} | | dictionary = {} |
| for row in data: | | for row in data: |
| for string in row: | | for string in row: |
| if string in dictionary: | | if string in dictionary: |
| dictionary[string] += 1 | | dictionary[string] += 1 |
| else: | | else: |
| dictionary[string] = 1 | | dictionary[string] = 1 |
| for key in dictionary: | | for key in dictionary: |
n | print(f"{key} {dictionary[key]}") | n | print(f"{key} {dictionary[key]}")def getGrade(averageScore): |
| def getGrade(averageScore): | | |
| if averageScore >= 90: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
| elif averageScore >= 80: | | elif averageScore >= 80: |
| return 'B' | | return 'B' |
| elif averageScore >= 70: | | elif averageScore >= 70: |
| return 'C' | | return 'C' |
| elif averageScore >= 60: | | elif averageScore >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
| inputFile = 'StudentInfo.tsv' | | inputFile = 'StudentInfo.tsv' |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
n | midTrm1, midTrm2, final, totalMidTrm1, totalMidTrm2, totalFinal, count = 0, | n | midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0 | | 0, 0 |
| infile = open(inputFile, 'r') | | infile = open(inputFile, 'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
n | firstName, lastName, midTrm1, midTrm2, final = line[0], line[1], int(lin | n | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| e[2]), int(line[3]), int(line[4]) | | line[3]), int(line[4]) |
| count += 1 | | count += 1 |
n | totalMidTrm1 += midTrm1 | n | totalMT1 += midT1 |
| totalMidTrm2 += midTrm2 | | totalMT2 += midT2 |
| totalFinal += final | | totalFinal += final |
n | grade = getGrade((midTrm1 + midTrm2 + final) / 3) | n | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{firstName}\t{lastName}\t{midTrm1}\t{midTrm2}\t{final}\t{grade}' | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| , file=outfile) | | ile) |
| infile.close() | | infile.close() |
n | totalMidTrm1 /= count | n | totalMT1 /= count |
| totalMidTrm2 /= count | | totalMT2 /= count |
| totalFinal /= count | | totalFinal /= count |
t | print(f'\nAverages: midterm1 {totalMidTrm1:.2f}, midterm2 {totalMidTrm2:.2f} | t | print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final |
| , final {totalFinal:.2f}', | | {totalFinal:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 43
Student ID: 239, P-Value: 2.21e-03
Nearest Neighbor ID: 10
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
| print("File not found")input_file = input() | | print("File not found")input_file = input() |
| import csv | | import csv |
| with open(input_file) as csv_file: | | with open(input_file) as csv_file: |
| data = csv.reader(csv_file, delimiter=',') | | data = csv.reader(csv_file, delimiter=',') |
| dictionary = {} | | dictionary = {} |
| for row in data: | | for row in data: |
| for string in row: | | for string in row: |
| if string in dictionary: | | if string in dictionary: |
| dictionary[string] += 1 | | dictionary[string] += 1 |
| else: | | else: |
| dictionary[string] = 1 | | dictionary[string] = 1 |
| for key in dictionary: | | for key in dictionary: |
n | print(f"{key} {dictionary[key]}")def getGrade(averageScore): | n | print(f"{key} {dictionary[key]}") |
| | | def getGrade(averageScore): |
| if averageScore >= 90: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
| elif averageScore >= 80: | | elif averageScore >= 80: |
| return 'B' | | return 'B' |
| elif averageScore >= 70: | | elif averageScore >= 70: |
| return 'C' | | return 'C' |
| elif averageScore >= 60: | | elif averageScore >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
| inputFile = 'StudentInfo.tsv' | | inputFile = 'StudentInfo.tsv' |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
n | midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, | n | midTrm1, midTrm2, final, totalMidTrm1, totalMidTrm2, totalFinal, count = 0, |
| 0, 0 | | 0, 0, 0, 0, 0, 0 |
| infile = open(inputFile, 'r') | | infile = open(inputFile, 'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
n | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( | n | firstName, lastName, midTrm1, midTrm2, final = line[0], line[1], int(lin |
| line[3]), int(line[4]) | | e[2]), int(line[3]), int(line[4]) |
| count += 1 | | count += 1 |
n | totalMT1 += midT1 | n | totalMidTrm1 += midTrm1 |
| totalMT2 += midT2 | | totalMidTrm2 += midTrm2 |
| totalFinal += final | | totalFinal += final |
n | grade = getGrade((midT1 + midT2 + final) / 3) | n | grade = getGrade((midTrm1 + midTrm2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf | | print(f'{firstName}\t{lastName}\t{midTrm1}\t{midTrm2}\t{final}\t{grade}' |
| ile) | | , file=outfile) |
| infile.close() | | infile.close() |
n | totalMT1 /= count | n | totalMidTrm1 /= count |
| totalMT2 /= count | | totalMidTrm2 /= count |
| totalFinal /= count | | totalFinal /= count |
t | print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final | t | print(f'\nAverages: midterm1 {totalMidTrm1:.2f}, midterm2 {totalMidTrm2:.2f} |
| {totalFinal:.2f}', | | , final {totalFinal:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 44
Student ID: 190, P-Value: 4.06e-03
Nearest Neighbor ID: 334
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | nums = [str(random.randint(0,9)) for i in range(5)] | n | nums = [str(random.randint(0,9)) for i in range(5)] |
| nums = ','.join(nums) | | nums = ','.join(nums) |
| with open('randomNums.txt', 'w') as f: | | with open('randomNums.txt', 'w') as f: |
| f.write(nums) | | f.write(nums) |
| return nums | | return nums |
| randomGen() | | randomGen() |
n | with open('randomNums.txt', 'r') as f: | n | with open('randomNums.txt', 'r') as f: |
| print(f.read())import csv | | print(f.read())import csv |
| dictionary_file = {} | | dictionary_file = {} |
| message = input() | | message = input() |
| if message == 'input1.csv': | | if message == 'input1.csv': |
| with open('input1.csv', newline='') as f: | | with open('input1.csv', newline='') as f: |
| reader = csv.reader(f) | | reader = csv.reader(f) |
| for lineArray in reader: | | for lineArray in reader: |
| for i in lineArray: | | for i in lineArray: |
| if i in dictionary_file: | | if i in dictionary_file: |
| dictionary_file[i] = dictionary_file[i] + 1 | | dictionary_file[i] = dictionary_file[i] + 1 |
| else: | | else: |
| dictionary_file[i] = 1 | | dictionary_file[i] = 1 |
n | elif message == 'input2.csv': | n | if message == 'input2.csv': |
| with open('input2.csv', newline='') as f: | | with open('input2.csv', newline='') as f: |
| reader = csv.reader(f) | | reader = csv.reader(f) |
| for lineArray in reader: | | for lineArray in reader: |
| for i in lineArray: | | for i in lineArray: |
| if i in dictionary_file: | | if i in dictionary_file: |
| dictionary_file[i] = dictionary_file[i] + 1 | | dictionary_file[i] = dictionary_file[i] + 1 |
| else: | | else: |
| dictionary_file[i] = 1 | | dictionary_file[i] = 1 |
n | elif message == 'input3.csv': | n | if message == 'input3.csv': |
| with open('input3.csv', newline='') as f: | | with open('input3.csv', newline='') as f: |
| reader = csv.reader(f) | | reader = csv.reader(f) |
| for lineArray in reader: | | for lineArray in reader: |
| for i in lineArray: | | for i in lineArray: |
| if i in dictionary_file: | | if i in dictionary_file: |
| dictionary_file[i] = dictionary_file[i] + 1 | | dictionary_file[i] = dictionary_file[i] + 1 |
| else: | | else: |
| dictionary_file[i] = 1 | | dictionary_file[i] = 1 |
n | elif message == 'input4.csv': | n | if message == 'input4.csv': |
| with open('input4.csv', newline='') as f: | | with open('input4.csv', newline='') as f: |
| reader = csv.reader(f) | | reader = csv.reader(f) |
| for lineArray in reader: | | for lineArray in reader: |
| for i in lineArray: | | for i in lineArray: |
| if i in dictionary_file: | | if i in dictionary_file: |
| dictionary_file[i] = dictionary_file[i] + 1 | | dictionary_file[i] = dictionary_file[i] + 1 |
| else: | | else: |
| dictionary_file[i] = 1 | | dictionary_file[i] = 1 |
n | elif message == 'input5.csv': | n | if message == 'input5.csv': |
| with open('input5.csv', newline='') as f: | | with open('input5.csv', newline='') as f: |
| reader = csv.reader(f) | | reader = csv.reader(f) |
| for lineArray in reader: | | for lineArray in reader: |
| for i in lineArray: | | for i in lineArray: |
| if i in dictionary_file: | | if i in dictionary_file: |
| dictionary_file[i] = dictionary_file[i] + 1 | | dictionary_file[i] = dictionary_file[i] + 1 |
| else: | | else: |
| dictionary_file[i] = 1 | | dictionary_file[i] = 1 |
| for key, count in dictionary_file.items(): | | for key, count in dictionary_file.items(): |
n | print(key, count) | n | print(key, count) grades = [] |
| | | student_grades = [] |
| file = open('StudentInfo.tsv', 'r') | | file = open('StudentInfo.tsv', 'r') |
n | sg = [] | n | student_grades = [] |
| for lines in file: | | for lines in file: |
| grades = [] | | grades = [] |
n | line = lines.split(' ') | n | line = lines.split('\t') |
| for i in line: | | for i in line: |
| grades.append(i.rstrip()) | | grades.append(i.rstrip()) |
n | sg.append(grades) | n | student_grades.append(grades) |
| file.close() | | file.close() |
| f1 = open('report.txt','w') | | f1 = open('report.txt','w') |
n | midterm1 = 0 | n | m1 = 0 |
| midterm2 = 0 | | m2 = 0 |
| final = 0 | | final = 0 |
n | for i in range(len(sg)): | n | for i in range(len(student_grades)): |
| string = "" | | string = "" |
n | average = (int(sg[i][2])+int(sg[i][3])+int(sg[i][4]))/3 | n | average = (int(student_grades[2])+int(student_grades[3])+int(student_grades[ |
| | | 4]))/3 |
| midterm1+=int(sg[i][2]) | | m1+=int(student_grades[2]) |
| midterm2 += int(sg[i][3]) | | m2 += int(student_grades[3]) |
| final += int(sg[i][4]) | | final += int(student_grades[4]) |
| for j in range(len(sg[i])): | | for j in range(len(student_grades[i])): |
| string += sg[i][j]+" " | | string += student_grades[i][j] + " " |
| if average>=90: | | if average>=90: |
| string+="A\n" | | string+="A\n" |
n | elif average>=80: | n | if average>=80 and average<90: |
| string+="B\n" | | string+="B\n" |
n | elif average>=70: | n | if average>=70 and average<80: |
| string+="C\n" | | string+="C\n" |
n | elif average>=60: | n | if average>=60 and average<70: |
| string+="D\n" | | string+="D\n" |
n | elif average<60: | n | if average<60: |
| string+="F\n" | | string+="F\n" |
| f1.writelines(string) | | f1.writelines(string) |
t | f1.writelines("Averages: Midterm1 "+str(midterm1/len(sg))+", Midterm2 "+str(midt | t | f1.writelines("Averages: midterm1 "+str(m1/len(student_grades))+", midterm2 "+st |
| erm2/len(sg))+", Final "+str(final/len(sg))+"\n") | | r(m2/len(student_grades))+", Final "+str(final/len(student_grades))+"\n") |
| f1.close() | | f1.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 45
Student ID: 334, P-Value: 4.06e-03
Nearest Neighbor ID: 190
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | nums = [str(random.randint(0,9)) for i in range(5)] | n | nums = [str(random.randint(0,9)) for i in range(5)] |
| nums = ','.join(nums) | | nums = ','.join(nums) |
| with open('randomNums.txt', 'w') as f: | | with open('randomNums.txt', 'w') as f: |
| f.write(nums) | | f.write(nums) |
| return nums | | return nums |
| randomGen() | | randomGen() |
n | with open('randomNums.txt', 'r') as f: | n | with open('randomNums.txt', 'r') as f: |
| print(f.read())import csv | | print(f.read())import csv |
| dictionary_file = {} | | dictionary_file = {} |
| message = input() | | message = input() |
| if message == 'input1.csv': | | if message == 'input1.csv': |
| with open('input1.csv', newline='') as f: | | with open('input1.csv', newline='') as f: |
| reader = csv.reader(f) | | reader = csv.reader(f) |
| for lineArray in reader: | | for lineArray in reader: |
| for i in lineArray: | | for i in lineArray: |
| if i in dictionary_file: | | if i in dictionary_file: |
| dictionary_file[i] = dictionary_file[i] + 1 | | dictionary_file[i] = dictionary_file[i] + 1 |
| else: | | else: |
| dictionary_file[i] = 1 | | dictionary_file[i] = 1 |
n | if message == 'input2.csv': | n | elif message == 'input2.csv': |
| with open('input2.csv', newline='') as f: | | with open('input2.csv', newline='') as f: |
| reader = csv.reader(f) | | reader = csv.reader(f) |
| for lineArray in reader: | | for lineArray in reader: |
| for i in lineArray: | | for i in lineArray: |
| if i in dictionary_file: | | if i in dictionary_file: |
| dictionary_file[i] = dictionary_file[i] + 1 | | dictionary_file[i] = dictionary_file[i] + 1 |
| else: | | else: |
| dictionary_file[i] = 1 | | dictionary_file[i] = 1 |
n | if message == 'input3.csv': | n | elif message == 'input3.csv': |
| with open('input3.csv', newline='') as f: | | with open('input3.csv', newline='') as f: |
| reader = csv.reader(f) | | reader = csv.reader(f) |
| for lineArray in reader: | | for lineArray in reader: |
| for i in lineArray: | | for i in lineArray: |
| if i in dictionary_file: | | if i in dictionary_file: |
| dictionary_file[i] = dictionary_file[i] + 1 | | dictionary_file[i] = dictionary_file[i] + 1 |
| else: | | else: |
| dictionary_file[i] = 1 | | dictionary_file[i] = 1 |
n | if message == 'input4.csv': | n | elif message == 'input4.csv': |
| with open('input4.csv', newline='') as f: | | with open('input4.csv', newline='') as f: |
| reader = csv.reader(f) | | reader = csv.reader(f) |
| for lineArray in reader: | | for lineArray in reader: |
| for i in lineArray: | | for i in lineArray: |
| if i in dictionary_file: | | if i in dictionary_file: |
| dictionary_file[i] = dictionary_file[i] + 1 | | dictionary_file[i] = dictionary_file[i] + 1 |
| else: | | else: |
| dictionary_file[i] = 1 | | dictionary_file[i] = 1 |
n | if message == 'input5.csv': | n | elif message == 'input5.csv': |
| with open('input5.csv', newline='') as f: | | with open('input5.csv', newline='') as f: |
| reader = csv.reader(f) | | reader = csv.reader(f) |
| for lineArray in reader: | | for lineArray in reader: |
| for i in lineArray: | | for i in lineArray: |
| if i in dictionary_file: | | if i in dictionary_file: |
| dictionary_file[i] = dictionary_file[i] + 1 | | dictionary_file[i] = dictionary_file[i] + 1 |
| else: | | else: |
| dictionary_file[i] = 1 | | dictionary_file[i] = 1 |
| for key, count in dictionary_file.items(): | | for key, count in dictionary_file.items(): |
n | print(key, count) grades = [] | n | print(key, count) |
| student_grades = [] | | |
| file = open('StudentInfo.tsv', 'r') | | file = open('StudentInfo.tsv', 'r') |
n | student_grades = [] | n | sg = [] |
| for lines in file: | | for lines in file: |
| grades = [] | | grades = [] |
n | line = lines.split('\t') | n | line = lines.split(' ') |
| for i in line: | | for i in line: |
| grades.append(i.rstrip()) | | grades.append(i.rstrip()) |
n | student_grades.append(grades) | n | sg.append(grades) |
| file.close() | | file.close() |
| f1 = open('report.txt','w') | | f1 = open('report.txt','w') |
n | m1 = 0 | n | midterm1 = 0 |
| m2 = 0 | | midterm2 = 0 |
| final = 0 | | final = 0 |
n | for i in range(len(student_grades)): | n | for i in range(len(sg)): |
| string = "" | | string = "" |
n | average = (int(student_grades[2])+int(student_grades[3])+int(student_grades[ | n | average = (int(sg[i][2])+int(sg[i][3])+int(sg[i][4]))/3 |
| 4]))/3 | | |
| m1+=int(student_grades[2]) | | midterm1+=int(sg[i][2]) |
| m2 += int(student_grades[3]) | | midterm2 += int(sg[i][3]) |
| final += int(student_grades[4]) | | final += int(sg[i][4]) |
| for j in range(len(student_grades[i])): | | for j in range(len(sg[i])): |
| string += student_grades[i][j] + " " | | string += sg[i][j]+" " |
| if average>=90: | | if average>=90: |
| string+="A\n" | | string+="A\n" |
n | if average>=80 and average<90: | n | elif average>=80: |
| string+="B\n" | | string+="B\n" |
n | if average>=70 and average<80: | n | elif average>=70: |
| string+="C\n" | | string+="C\n" |
n | if average>=60 and average<70: | n | elif average>=60: |
| string+="D\n" | | string+="D\n" |
n | if average<60: | n | elif average<60: |
| string+="F\n" | | string+="F\n" |
| f1.writelines(string) | | f1.writelines(string) |
t | f1.writelines("Averages: midterm1 "+str(m1/len(student_grades))+", midterm2 "+st | t | f1.writelines("Averages: Midterm1 "+str(midterm1/len(sg))+", Midterm2 "+str(midt |
| r(m2/len(student_grades))+", Final "+str(final/len(student_grades))+"\n") | | erm2/len(sg))+", Final "+str(final/len(sg))+"\n") |
| f1.close() | | f1.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 46
Student ID: 192, P-Value: 4.14e-03
Nearest Neighbor ID: 254
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
n | result += "," + str(random.randint(0,9)) | n | result += ","+str(random.randint(0,9)) |
| return resultimport csv | | return resultimport csv |
n | in_file = input() | n | filename = input() |
| op_file = open(in_file) | | f = open(filename) |
| data = csv.reader(op_file, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
| count += 1 | | count += 1 |
n | print(words[i], count)def get_grade(average_score): | n | print(words[i], count) |
| | | f.close()def getGrade(averageScore): |
| if average_score >= 90: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
n | elif average_score >= 80: | n | elif averageScore >= 80: |
| return 'B' | | return 'B' |
n | elif average_score >= 70: | n | elif averageScore >= 70: |
| return 'C' | | return 'C' |
n | elif average_score >= 60: | n | elif averageScore >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
| inputFile = input() | | inputFile = input() |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
n | midterm1, midterm2, final, totalM1, totalM2, totalF, count = 0, 0, 0, 0, 0, | n | midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, |
| 0, 0 | | 0, 0 |
| infile = open(inputFile, 'r') | | infile = open(inputFile, 'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
n | fname, lname, midterm1, midterm2, final = line[0], line[1], int(line[2]) | n | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| , int(line[3]), int(line[4]) | | line[3]), int(line[4]) |
| count += 1 | | count += 1 |
n | totalM1 += midterm1 | n | totalMT1 += midT1 |
| totalM2 += midterm2 | | totalMT2 += midT2 |
| totalF += final | | totalFinal += final |
| grade = get_grade((midterm1 + midterm2 + final) / 3) | | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midterm1}\t{midterm2}\t{final}\t{grade}', fil | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| e=outfile) | | ile) |
| infile.close() | | infile.close() |
t | totalM1 /= count | t | totalMT1 /= count |
| totalM2 /= count | | totalMT2 /= count |
| totalF /= count | | totalFinal /= count |
| print(f'\nAverages: midterm1 {totalM1:.2f}, midterm2 {totalM2:.2f}, final {t | | print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final |
| otalF:.2f}', | | {totalFinal:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 47
Student ID: 273, P-Value: 4.60e-03
Nearest Neighbor ID: 158
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
n | print("File not found")import csv | n | print("File not found") |
| | | import csv |
| file_name = input() | | filename = input() |
| f = open(file_name) | | f = open(filename) |
| data = csv.reader(f,delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
n | for g in range(len(words)): | n | for i in range(len(words)): |
| if words[g] not in words[:g]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
n | if words[g] == w: | n | if words[i] == w: |
| count +=1 | | count += 1 |
| print(words[g], count) | | print(words[i], count) |
| f.close()def determine_grade(average): | | f.close()def determine_grade(avg): |
| average = int(average) | | avg = int(avg) |
| if average >= 90 and average <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
n | elif average >= 80 and average <= 89: | n | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
n | elif average >= 70 and average <= 79: | n | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
n | elif average >= 60 and average <= 69: | n | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
n | elif average <= 60: | n | elif avg <= 60: |
| return 'F' | | return 'F' |
n | file_name = input("Enter the filename: ") | n | fileName = input("Enter the filename: ") |
| out_file = "report.txt" | | outFile = "report.txt" |
| total_m1 = 0 | | totalM1 = 0 |
| total_m2 = 0 | | totalM2 = 0 |
| total_final = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
n | file_write = open(out_file, "w") | n | fileWrite = open(outFile, "w") |
| for line in enumerate(open(file_name, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
n | average = (m1 + m2 + final) / 3.0 | n | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(average) | | grade = determine_grade(avg) |
| total_m1 = total_m1 + m1 | | totalM1 = totalM1 + m1 |
| total_m2 = total_m2 + m2 | | totalM2 = totalM2 + m2 |
| total_final = total_final + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
n | file_write.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | n | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
n | file_write.write("\nAverages: midterm1 " + | n | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(total_m1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(total_m2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(total_final / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
t | file_write.close() | t | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 48
Student ID: 419, P-Value: 4.90e-03
Nearest Neighbor ID: 172
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | nums = str(random.randint(0,9)) | n | result = str(random.randint(0,9)) |
| for i in range(4): | | for x in range(4): |
| nums += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return nums | | return resultimport csv |
| f = open('randomNums.txt', 'w') | | |
| f.write (randomGen()) | | |
| f.close()import csv | | |
| input1 = input() | | input1 = input() |
| with open(input1, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
n | words = csv.reader(wordsfile) | n | words_reader = csv.reader(wordsfile) |
| for row in words: | | for row in words_reader: |
| list_of_words = row | | list_of_words = row |
n | remove_dup = list(dict.fromkeys(list_of_words)) | n | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| listlength = len(remove_dup) | | listlength = len(no_duplicates_in_list) |
| for i in range(listlength): | | for i in range(listlength): |
n | print(remove_dup[i], list_of_words.count(remove_dup[i])) | n | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| | | ))def getGrade(averageScore): |
| def getGrade(averageScore): | | averageScore = int(averageScore) |
| if averageScore >= 90: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
| elif averageScore >= 80: | | elif averageScore >= 80: |
| return 'B' | | return 'B' |
| elif averageScore >= 70: | | elif averageScore >= 70: |
| return 'C' | | return 'C' |
| elif averageScore >= 60: | | elif averageScore >= 60: |
| return 'D' | | return 'D' |
n | | n | else: |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
t | inputFile = input() | t | inputFile = input("Enter the filename: ") |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
| midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, | | midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, |
| 0, 0 | | 0, 0 |
| infile = open(inputFile, 'r') | | infile = open(inputFile, 'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
| fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( | | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| line[3]), int(line[4]) | | line[3]), int(line[4]) |
| count += 1 | | count += 1 |
| totalMT1 += midT1 | | totalMT1 += midT1 |
| totalMT2 += midT2 | | totalMT2 += midT2 |
| totalFinal += final | | totalFinal += final |
| grade = getGrade((midT1 + midT2 + final) / 3) | | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| ile) | | ile) |
| infile.close() | | infile.close() |
| totalMT1 /= count | | totalMT1 /= count |
| totalMT2 /= count | | totalMT2 /= count |
| totalFinal /= count | | totalFinal /= count |
| print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final | | print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final |
| {totalFinal:.2f}', | | {totalFinal:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 49
Student ID: 172, P-Value: 4.90e-03
Nearest Neighbor ID: 419
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | result = str(random.randint(0,9)) | n | nums = str(random.randint(0,9)) |
| for x in range(4): | | for i in range(4): |
| result += ","+str(random.randint(0,9)) | | nums += ","+str(random.randint(0,9)) |
| return resultimport csv | | return nums |
| | | f = open('randomNums.txt', 'w') |
| | | f.write (randomGen()) |
| | | f.close()import csv |
| input1 = input() | | input1 = input() |
| with open(input1, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
n | words_reader = csv.reader(wordsfile) | n | words = csv.reader(wordsfile) |
| for row in words_reader: | | for row in words: |
| list_of_words = row | | list_of_words = row |
n | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | n | remove_dup = list(dict.fromkeys(list_of_words)) |
| listlength = len(no_duplicates_in_list) | | listlength = len(remove_dup) |
| for i in range(listlength): | | for i in range(listlength): |
n | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | n | print(remove_dup[i], list_of_words.count(remove_dup[i])) |
| ))def getGrade(averageScore): | | |
| averageScore = int(averageScore) | | def getGrade(averageScore): |
| if averageScore >= 90: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
| elif averageScore >= 80: | | elif averageScore >= 80: |
| return 'B' | | return 'B' |
| elif averageScore >= 70: | | elif averageScore >= 70: |
| return 'C' | | return 'C' |
| elif averageScore >= 60: | | elif averageScore >= 60: |
| return 'D' | | return 'D' |
n | else: | n | |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
t | inputFile = input("Enter the filename: ") | t | inputFile = input() |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
| midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, | | midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, |
| 0, 0 | | 0, 0 |
| infile = open(inputFile, 'r') | | infile = open(inputFile, 'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
| fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( | | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| line[3]), int(line[4]) | | line[3]), int(line[4]) |
| count += 1 | | count += 1 |
| totalMT1 += midT1 | | totalMT1 += midT1 |
| totalMT2 += midT2 | | totalMT2 += midT2 |
| totalFinal += final | | totalFinal += final |
| grade = getGrade((midT1 + midT2 + final) / 3) | | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| ile) | | ile) |
| infile.close() | | infile.close() |
| totalMT1 /= count | | totalMT1 /= count |
| totalMT2 /= count | | totalMT2 /= count |
| totalFinal /= count | | totalFinal /= count |
| print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final | | print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final |
| {totalFinal:.2f}', | | {totalFinal:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 50
Student ID: 94, P-Value: 6.35e-03
Nearest Neighbor ID: 364
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | result = str(random.randint(0,9)) | n | result = str (random.randint(0,9)) |
| for x in range(4): | | for x in range (4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str (random.randint(0,9)) |
| return result | | return result |
n | try: | n | try: |
| out = open('randomNums.txt', "w") | | out = open ('randomNums.txt', "w") |
| line = "" | | line = "" |
n | for i in range(5): | n | for i in range (5): |
| out.write(randomGen()+"\n") | | out.write (randomGen ()+"\n") |
| out.close() | | out.close () |
| except Exception: | | except Exception: |
n | print("File not found")import csv | n | print ("File not found") |
| filename = input() | | import csv |
| f = open(filename) | | file = open (input()) |
| data = csv.reader(f, delimiter=',') | | strings = csv.reader (file, delimiter=',') |
| words = [] | | words = [] |
n | for row in data: | n | for row in strings: |
| for word in row: | | for word in row: |
n | words.append(word.strip()) | n | words.append (word.strip()) |
| for i in range(len(words)): | | for i in range (len(words)): |
| if words[i] not in words[:i]: | | if words [i] not in words [:i]: |
| count = 0 | | count = 0 |
n | for w in words: | n | for j in range (len(words)): |
| if words[i] == w: | | if words [i] == words [j]: |
| count += 1 | | count += 1 |
n | print(words[i], count) | n | print (words [i], count) |
| f.close() | | file.close () |
| import csv | | import csv |
n | file = open("StudentInfo.tsv") | n | file = open ("StudentInfo.tsv") |
| nFile = open("report.txt","w") | | nFile = open ("report.txt","w") |
| lst1 = [] | | lst1 = [] |
| lst2 = [] | | lst2 = [] |
| lst3 = [] | | lst3 = [] |
n | read_file = csv.reader(file, delimiter = "\t") | n | read_file = csv.reader (file, delimiter = "\t") |
| for data in read_file: | | for data in read_file: |
n | lst1.append(int(data[2])) | n | lst1.append (int(data[2])) |
| lst2.append(int(data[3])) | | lst2.append (int(data[3])) |
| lst3.append(int(data[4])) | | lst3.append (int(data[4])) |
| avg = (int(data[2])+int(data[3])+int(data[4]))/3 | | avg = (int(data[2])+int(data[3])+int(data[4]))/3 |
| for item in data: | | for item in data: |
| nFile.writelines(item + "\t") | | nFile.writelines(item + "\t") |
| if avg >= 90: | | if avg >= 90: |
n | nFile.write("A\n") | n | nFile.write ("A\n") |
| elif avg >= 80 and avg < 90: | | elif avg >= 80 and avg < 90: |
n | nFile.write("B\n") | n | nFile.write ("B\n") |
| elif avg >= 70 and avg < 80: | | elif avg >= 70 and avg < 80: |
n | nFile.write("C\n") | n | nFile.write ("C\n") |
| elif avg >= 60 and avg < 70: | | elif avg >= 60 and avg < 70: |
n | nFile.write("D\n") | n | nFile.write ("D\n") |
| else: | | else: |
| nFile.write("F\n") | | nFile.write("F\n") |
t | avg1 = sum(lst1)/len(lst1) | t | avg1 = sum (lst1)/len(lst1) |
| avg2 = sum(lst2)/len(lst2) | | avg2 = sum (lst2)/len(lst2) |
| avg3 = sum(lst3)/len(lst3) | | avg3 = sum (lst3)/len(lst3) |
| nFile.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3: | | nFile.write(f"\nAverages: midtrm1 {avg1:.2f}, midtrm2 {avg2:.2f}, final {avg3:.2 |
| .2f}\n") | | f}") |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 51
Student ID: 364, P-Value: 6.35e-03
Nearest Neighbor ID: 94
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | result = str (random.randint(0,9)) | n | result = str(random.randint(0,9)) |
| for x in range (4): | | for x in range(4): |
| result += ","+str (random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
n | try: | n | try: |
| out = open ('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
n | for i in range (5): | n | for i in range(5): |
| out.write (randomGen ()+"\n") | | out.write(randomGen()+"\n") |
| out.close () | | out.close() |
| except Exception: | | except Exception: |
n | print ("File not found") | n | print("File not found")import csv |
| | | filename = input() |
| | | f = open(filename) |
| | | data = csv.reader(f, delimiter=',') |
| | | words = [] |
| | | for row in data: |
| | | for word in row: |
| | | words.append(word.strip()) |
| | | for i in range(len(words)): |
| | | if words[i] not in words[:i]: |
| | | count = 0 |
| | | for w in words: |
| | | if words[i] == w: |
| | | count += 1 |
| | | print(words[i], count) |
| | | f.close() |
| import csv | | import csv |
n | file = open (input()) | n | |
| strings = csv.reader (file, delimiter=',') | | |
| words = [] | | |
| for row in strings: | | |
| for word in row: | | |
| words.append (word.strip()) | | |
| for i in range (len(words)): | | |
| if words [i] not in words [:i]: | | |
| count = 0 | | |
| for j in range (len(words)): | | |
| if words [i] == words [j]: | | |
| count += 1 | | |
| print (words [i], count) | | |
| file.close () | | |
| import csv | | |
| file = open ("StudentInfo.tsv") | | file = open("StudentInfo.tsv") |
| nFile = open ("report.txt","w") | | nFile = open("report.txt","w") |
| lst1 = [] | | lst1 = [] |
| lst2 = [] | | lst2 = [] |
| lst3 = [] | | lst3 = [] |
n | read_file = csv.reader (file, delimiter = "\t") | n | read_file = csv.reader(file, delimiter = "\t") |
| for data in read_file: | | for data in read_file: |
n | lst1.append (int(data[2])) | n | lst1.append(int(data[2])) |
| lst2.append (int(data[3])) | | lst2.append(int(data[3])) |
| lst3.append (int(data[4])) | | lst3.append(int(data[4])) |
| avg = (int(data[2])+int(data[3])+int(data[4]))/3 | | avg = (int(data[2])+int(data[3])+int(data[4]))/3 |
| for item in data: | | for item in data: |
| nFile.writelines(item + "\t") | | nFile.writelines(item + "\t") |
| if avg >= 90: | | if avg >= 90: |
n | nFile.write ("A\n") | n | nFile.write("A\n") |
| elif avg >= 80 and avg < 90: | | elif avg >= 80 and avg < 90: |
n | nFile.write ("B\n") | n | nFile.write("B\n") |
| elif avg >= 70 and avg < 80: | | elif avg >= 70 and avg < 80: |
n | nFile.write ("C\n") | n | nFile.write("C\n") |
| elif avg >= 60 and avg < 70: | | elif avg >= 60 and avg < 70: |
n | nFile.write ("D\n") | n | nFile.write("D\n") |
| else: | | else: |
| nFile.write("F\n") | | nFile.write("F\n") |
t | avg1 = sum (lst1)/len(lst1) | t | avg1 = sum(lst1)/len(lst1) |
| avg2 = sum (lst2)/len(lst2) | | avg2 = sum(lst2)/len(lst2) |
| avg3 = sum (lst3)/len(lst3) | | avg3 = sum(lst3)/len(lst3) |
| nFile.write(f"\nAverages: midtrm1 {avg1:.2f}, midtrm2 {avg2:.2f}, final {avg3:.2 | | nFile.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3: |
| f}") | | .2f}\n") |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 52
Student ID: 63, P-Value: 7.40e-03
Nearest Neighbor ID: 217
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
n | print("File not found") | n | print("File not found")import csv |
| import csv | | |
| name_file = input() | | name_file = input() |
n | with open(name_file), 'r')as myfile: | n | with open(name_file, 'r') as myfile: |
| reader = csv.reader(myfile, delimiter = ',') | | Reader = csv.reader(myfile, delimiter=',') |
| my_dict = dict() | | dictionary = dict() |
| for l in reader: | | for l in Reader: |
| for m in l: | | for m in l: |
n | if m in my_dict: | n | if m in dictionary: |
| my_dict[m] = my_dict[m] + 1 | | dictionary[m] = dictionary[m] + 1 |
| else: | | else: |
| my_dict[m] = 1 | | dictionary[m] = 1 |
| for n in list(dictionary.keys()): | | for n in list(dictionary.keys()): |
| print("{} {}".format(n, my_dict[n])) | | print("{} {}".format(n, dictionary[n]))last_name = [] |
| last_name = [] | | |
| first_name = [] | | first_name = [] |
n | test1 = [] | n | mid1 = [] |
| test2 = [] | | mid2 = [] |
| test3 = [] | | mid3 = [] |
| student_avg = [] | | student_avgs = [] |
| student_grade = [] | | student_grades = [] |
| student_total = 0 | | student_total = 0 |
| midterm1_avg = 0 | | midterm1_avg = 0 |
| total1 = 0 | | total1 = 0 |
| midterm2_avg = 0 | | midterm2_avg = 0 |
| total2 = 0 | | total2 = 0 |
| midterm3_avg = 0 | | midterm3_avg = 0 |
| total3 = 0 | | total3 = 0 |
| with open(input(), "r") as f: | | with open(input(), "r") as f: |
| for line in f: | | for line in f: |
| newline = line.strip("\n") | | newline = line.strip("\n") |
| item = newline.split("\t") | | item = newline.split("\t") |
| last_name.append(item[0]) | | last_name.append(item[0]) |
| first_name.append(item[1]) | | first_name.append(item[1]) |
n | test1.append(item[2]) | n | mid1.append(item[2]) |
| test2.append(item[3]) | | mid2.append(item[3]) |
| test3.append(item[4]) | | mid3.append(item[4]) |
| student_total += int(item[2]) | | student_total += int(item[2]) |
| student_total += int(item[3]) | | student_total += int(item[3]) |
| student_total += int(item[4]) | | student_total += int(item[4]) |
n | student_avg.append(student_total/3) | n | student_avgs.append(student_total/3) |
| student_total=0 | | student_total=0 |
n | for avgs in student_avg: | n | for avgs in student_avgs: |
| if int(avgs) >= 90: | | if int(avgs) >= 90: |
n | student_grade.append("A") | n | student_grades.append("A") |
| elif 90 > int(avgs) >= 80: | | elif 90 > int(avgs) >= 80: |
n | student_grade.append("B") | n | student_grades.append("B") |
| elif 80 > int(avgs) >= 70: | | elif 80 > int(avgs) >= 70: |
n | student_grade.append("C") | n | student_grades.append("C") |
| elif 70 > int(avgs) >= 60: | | elif 70 > int(avgs) >= 60: |
n | student_grade.append("D") | n | student_grades.append("D") |
| else: | | else: |
n | student_grade.append("F") | n | student_grades.append("F") |
| for grade in test1: | | for grade in mid1: |
| total1 += int(grade) | | total1 += int(grade) |
n | midterm1_avg = int(total1) / len(test1) | n | midterm1_avg = int(total1) / len(mid1) |
| for grade in test2: | | for grade in mid2: |
| total2 += int(grade) | | total2 += int(grade) |
n | midterm2_avg = int(total2) / len(test2) | n | midterm2_avg = int(total2) / len(mid2) |
| for grade in test3: | | for grade in mid3: |
| total3 += int(grade) | | total3 += int(grade) |
n | midterm3_avg = int(total3) / len(test3) | n | midterm3_avg = int(total3) / len(mid3) |
| with open("report.txt", "w") as new: | | with open("report.txt", "w") as new: |
| for x in range(len(last_name)): | | for x in range(len(last_name)): |
t | new.write(last_name[x]+'\t'+first_name[x]+'\t'+test1[x]+'\t'+test2[x]+'\ | t | new.write(last_name[x]+'\t'+first_name[x]+'\t'+mid1[x]+'\t'+mid2[x]+'\t' |
| t'+test3[x]+'\t'+student_grade[x]) | | +mid3[x]+'\t'+student_grades[x]) |
| new.write("\n") | | new.write("\n") |
| new.write("\n") | | new.write("\n") |
| new.write("Averages: midterm1 {:.2f}, midterm2 {:.2f}, final {:.2f}".format( | | new.write("Averages: midterm1 {:.2f}, midterm2 {:.2f}, final {:.2f}".format( |
| midterm1_avg, midterm2_avg, midterm3_avg)) | | midterm1_avg, midterm2_avg, midterm3_avg)) |
| new.write("\n") | | new.write("\n") |
| f.close() | | f.close() |
| new.close() | | new.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 53
Student ID: 217, P-Value: 7.40e-03
Nearest Neighbor ID: 63
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
n | print("File not found")import csv | n | print("File not found") |
| | | import csv |
| name_file = input() | | name_file = input() |
n | with open(name_file, 'r') as myfile: | n | with open(name_file), 'r')as myfile: |
| Reader = csv.reader(myfile, delimiter=',') | | reader = csv.reader(myfile, delimiter = ',') |
| dictionary = dict() | | my_dict = dict() |
| for l in Reader: | | for l in reader: |
| for m in l: | | for m in l: |
n | if m in dictionary: | n | if m in my_dict: |
| dictionary[m] = dictionary[m] + 1 | | my_dict[m] = my_dict[m] + 1 |
| else: | | else: |
| dictionary[m] = 1 | | my_dict[m] = 1 |
| for n in list(dictionary.keys()): | | for n in list(dictionary.keys()): |
| print("{} {}".format(n, dictionary[n]))last_name = [] | | print("{} {}".format(n, my_dict[n])) |
| | | last_name = [] |
| first_name = [] | | first_name = [] |
n | mid1 = [] | n | test1 = [] |
| mid2 = [] | | test2 = [] |
| mid3 = [] | | test3 = [] |
| student_avgs = [] | | student_avg = [] |
| student_grades = [] | | student_grade = [] |
| student_total = 0 | | student_total = 0 |
| midterm1_avg = 0 | | midterm1_avg = 0 |
| total1 = 0 | | total1 = 0 |
| midterm2_avg = 0 | | midterm2_avg = 0 |
| total2 = 0 | | total2 = 0 |
| midterm3_avg = 0 | | midterm3_avg = 0 |
| total3 = 0 | | total3 = 0 |
| with open(input(), "r") as f: | | with open(input(), "r") as f: |
| for line in f: | | for line in f: |
| newline = line.strip("\n") | | newline = line.strip("\n") |
| item = newline.split("\t") | | item = newline.split("\t") |
| last_name.append(item[0]) | | last_name.append(item[0]) |
| first_name.append(item[1]) | | first_name.append(item[1]) |
n | mid1.append(item[2]) | n | test1.append(item[2]) |
| mid2.append(item[3]) | | test2.append(item[3]) |
| mid3.append(item[4]) | | test3.append(item[4]) |
| student_total += int(item[2]) | | student_total += int(item[2]) |
| student_total += int(item[3]) | | student_total += int(item[3]) |
| student_total += int(item[4]) | | student_total += int(item[4]) |
n | student_avgs.append(student_total/3) | n | student_avg.append(student_total/3) |
| student_total=0 | | student_total=0 |
n | for avgs in student_avgs: | n | for avgs in student_avg: |
| if int(avgs) >= 90: | | if int(avgs) >= 90: |
n | student_grades.append("A") | n | student_grade.append("A") |
| elif 90 > int(avgs) >= 80: | | elif 90 > int(avgs) >= 80: |
n | student_grades.append("B") | n | student_grade.append("B") |
| elif 80 > int(avgs) >= 70: | | elif 80 > int(avgs) >= 70: |
n | student_grades.append("C") | n | student_grade.append("C") |
| elif 70 > int(avgs) >= 60: | | elif 70 > int(avgs) >= 60: |
n | student_grades.append("D") | n | student_grade.append("D") |
| else: | | else: |
n | student_grades.append("F") | n | student_grade.append("F") |
| for grade in mid1: | | for grade in test1: |
| total1 += int(grade) | | total1 += int(grade) |
n | midterm1_avg = int(total1) / len(mid1) | n | midterm1_avg = int(total1) / len(test1) |
| for grade in mid2: | | for grade in test2: |
| total2 += int(grade) | | total2 += int(grade) |
n | midterm2_avg = int(total2) / len(mid2) | n | midterm2_avg = int(total2) / len(test2) |
| for grade in mid3: | | for grade in test3: |
| total3 += int(grade) | | total3 += int(grade) |
n | midterm3_avg = int(total3) / len(mid3) | n | midterm3_avg = int(total3) / len(test3) |
| with open("report.txt", "w") as new: | | with open("report.txt", "w") as new: |
| for x in range(len(last_name)): | | for x in range(len(last_name)): |
t | new.write(last_name[x]+'\t'+first_name[x]+'\t'+mid1[x]+'\t'+mid2[x]+'\t' | t | new.write(last_name[x]+'\t'+first_name[x]+'\t'+test1[x]+'\t'+test2[x]+'\ |
| +mid3[x]+'\t'+student_grades[x]) | | t'+test3[x]+'\t'+student_grade[x]) |
| new.write("\n") | | new.write("\n") |
| new.write("\n") | | new.write("\n") |
| new.write("Averages: midterm1 {:.2f}, midterm2 {:.2f}, final {:.2f}".format( | | new.write("Averages: midterm1 {:.2f}, midterm2 {:.2f}, final {:.2f}".format( |
| midterm1_avg, midterm2_avg, midterm3_avg)) | | midterm1_avg, midterm2_avg, midterm3_avg)) |
| new.write("\n") | | new.write("\n") |
| f.close() | | f.close() |
| new.close() | | new.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 54
Student ID: 422, P-Value: 7.68e-03
Nearest Neighbor ID: 353
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | rand_nums = str(random.randint(0,9)) | n | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
n | rand_nums += ","+str(random.randint(0,9)) | n | result += ","+str(random.randint(0,9)) |
| return rand_nums | | return result |
| | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| import csv | | except Exception: |
| | | print("File not found")import csv |
| input_file = input() | | input_given = input() |
| with open(input_file, 'r') as wordsfile: | | with open(input_given, 'r') as wordsfile: |
| word_reader = csv.reader(wordsfile) | | word_reader = csv.reader(wordsfile) |
| for row in word_reader: | | for row in word_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| length = len(no_duplicates_in_list) | | length = len(no_duplicates_in_list) |
| for i in range(length): | | for i in range(length): |
n | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | n | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| )) | | ))def getGrade(averageGrade): |
| def getGrade(averageGrade): | | |
| if averageGrade >= 90: | | if averageGrade >= 90: |
| return 'A' | | return 'A' |
| elif averageGrade >= 80: | | elif averageGrade >= 80: |
| return 'B' | | return 'B' |
| elif averageGrade >= 70: | | elif averageGrade >= 70: |
| return 'C' | | return 'C' |
| elif averageGrade >= 60: | | elif averageGrade >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(x): | | def main(x): |
| input_File = x | | input_File = x |
| output_File = 'report.txt' | | output_File = 'report.txt' |
n | mid_T1 = 0 | n | mid_T1, mid_T2, final, total_MT1, total_MT2, total_Final, count = 0, 0, 0, 0 |
| | | , 0, 0, 0 |
| mid_T2 = 0 | | |
| final = 0 | | |
| total_MT1 = 0 | | |
| total_MT2 = 0 | | |
| total_Final = 0 | | |
| count = 0 | | |
| infile = open(input_File, 'r') | | infile = open(input_File, 'r') |
| outfile = open(output_File, 'w+') | | outfile = open(output_File, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
t | fname = line[0] | t | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| | | line[3]), int(line[4]) |
| lname = line[1] | | |
| midT1 = int(line[2]) | | |
| midT2 = int(line[3]) | | |
| final = int(line[4]) | | |
| count += 1 | | count += 1 |
| total_MT1 += midT1 | | total_MT1 += midT1 |
| total_MT2 += midT2 | | total_MT2 += midT2 |
| total_Final += final | | total_Final += final |
| grade = getGrade((midT1 + midT2 + final) / 3) | | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| ile) | | ile) |
| infile.close() | | infile.close() |
| total_MT1 /= count | | total_MT1 /= count |
| total_MT2 /= count | | total_MT2 /= count |
| total_Final /= count | | total_Final /= count |
| print(f'\nAverages: midterm1 {total_MT1:.2f}, midterm2 {total_MT2:.2f}, fina | | print(f'\nAverages: midterm1 {total_MT1:.2f}, midterm2 {total_MT2:.2f}, fina |
| l {total_Final:.2f}', | | l {total_Final:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| file = input() | | file = input() |
| main(file) | | main(file) |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 55
Student ID: 347, P-Value: 1.77e-02
Nearest Neighbor ID: 490
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | nums = str(random.randint(0,200)) | n | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
n | nums += ","+str(random.randint(0,200)) | n | result += ","+str(random.randint(0,9)) |
| return nums | | return resultimport csv |
| add = open('randomNums.txt', "w") | | filename = input() |
| for i in range(5): | | f = open(filename) |
| add.write(randomGen()+"\n") | | |
| add.close() | | |
| import csv | | |
| user_file=input() | | |
| f = open(user_file,'r') | | |
| data = csv.reader(f,delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words=[] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
n | for n in range(len(words)): | n | for i in range(len(words)): |
| if words[n] not in words[:n]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
n | if words[n] == w: | n | if words[i] == w: |
| count +=1 | | count += 1 |
| print(words[n], count) | | print(words[i], count) |
| f.close()def determine_avg(avg): | | f.close() |
| | | fileName = input("Enter the filename: ") |
| | | outFile = "report.txt" |
| | | totalM1 = 0 |
| | | totalM2 = 0 |
| | | totalFinal = 0 |
| | | count = 0 |
| | | def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
n | user_file = input() | n | |
| outFile = "report.txt" | | |
| totalM1 = 0 | | |
| totalM2 = 0 | | |
| totalFinal = 0 | | |
| count = 0 | | |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
n | for line in enumerate(open(user_file, 'r')): | n | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
t | grade = determine_avg(avg) | t | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 56
Student ID: 87, P-Value: 1.86e-02
Nearest Neighbor ID: 254
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
n | return result | n | return resultimport csv |
| import csv | | |
| f = input() | | filename = input() |
| csvf = open(f, "r") | | f = open(filename) |
| reader = csv.reader(csvf) | | data = csv.reader(f, delimiter=',') |
| words =[] | | words = [] |
| freq = [] | | for row in data: |
| for j in reader: | | |
| for word in j: | | for word in row: |
| if (len(word) == 0): | | |
| continue | | |
| elif (words.count(word) != 0): | | |
| index = words.index(word) | | |
| freq[index] += 1 | | |
| else: | | |
| words.append(word) | | words.append(word.strip()) |
| freq.append(1) | | |
| for i in range(len(words)): | | for i in range(len(words)): |
n | print(f'{words[i]} {freq[i]}')def getGrade(averageScore): | n | if words[i] not in words[:i]: |
| | | count = 0 |
| | | for w in words: |
| | | if words[i] == w: |
| | | count += 1 |
| | | print(words[i], count) |
| | | f.close()def getGrade(averageScore): |
| if averageScore >= 90: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
| elif averageScore >= 80: | | elif averageScore >= 80: |
| return 'B' | | return 'B' |
| elif averageScore >= 70: | | elif averageScore >= 70: |
| return 'C' | | return 'C' |
| elif averageScore >= 60: | | elif averageScore >= 60: |
| return 'D' | | return 'D' |
n | return 'F' | n | return 'F' |
| def main(): | | def main(): |
| inputFile = input() | | inputFile = input() |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
| midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, | | midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, |
| 0, 0 | | 0, 0 |
| infile = open(inputFile, 'r') | | infile = open(inputFile, 'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
| fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( | | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| line[3]), int(line[4]) | | line[3]), int(line[4]) |
| count += 1 | | count += 1 |
| totalMT1 += midT1 | | totalMT1 += midT1 |
| totalMT2 += midT2 | | totalMT2 += midT2 |
| totalFinal += final | | totalFinal += final |
| grade = getGrade((midT1 + midT2 + final) / 3) | | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| ile) | | ile) |
| infile.close() | | infile.close() |
| totalMT1 /= count | | totalMT1 /= count |
| totalMT2 /= count | | totalMT2 /= count |
| totalFinal /= count | | totalFinal /= count |
| print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final | | print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final |
| {totalFinal:.2f}', | | {totalFinal:.2f}', |
t | file=outfile) | t | file=outfile) |
| outfile.close() | | outfile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 57
Student ID: 360, P-Value: 1.94e-02
Nearest Neighbor ID: 297
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| afile = open("randomNums.txt", "w" ) | | afile = open("randomNums.txt", "w" ) |
| def rnum(): | | def rnum(): |
| r=random.randint(1, 100) | | r=random.randint(1, 100) |
n | return r | n | return r |
| def randomGen(): | | def randomGen(): |
| randomstring='{},{},{},{},{}'.format(rnum(),rnum(),rnum(),rnum(),rnum()) | | randomstring='{},{},{},{},{}'.format(rnum(),rnum(),rnum(),rnum(),rnum()) |
| return randomstring | | return randomstring |
n | i=0 | n | b=5 |
| file = open('randomNums.txt', 'a') | | file = open('randomNums.txt', 'a') |
n | while i>0: | n | while b>0: |
| file.write(randomGen()) | | file.write(randomGen()) |
n | i += 1import csv | n | b-=1import csv |
| input1 = input() | | input1 = input() |
| with open(input1, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
| for row in words_reader: | | for row in words_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| listlength = len(no_duplicates_in_list) | | listlength = len(no_duplicates_in_list) |
| for i in range(listlength): | | for i in range(listlength): |
n | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | n | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| )) | | ))fname=input("Enter the file name: ") |
| 7.14 | | |
| file_name = input() | | |
| my_file = open(file_name, 'r') | | |
| my_detail = my_file.readlines() | | |
| my_show = [] | | |
| my_season = []fname=input("Enter the file name: ") | | |
| file = open(fname) | | file = open(fname) |
| f = open("report.txt", "w") | | f = open("report.txt", "w") |
| mid1 = 0 | | mid1 = 0 |
| mid2 = 0 | | mid2 = 0 |
| final = 0 | | final = 0 |
| students = 0 | | students = 0 |
| for line in file: | | for line in file: |
| students = students + 1 | | students = students + 1 |
| data = ('\t'.join(line.split())).split() | | data = ('\t'.join(line.split())).split() |
| m1=int(data[2].strip()) | | m1=int(data[2].strip()) |
| m2=int(data[3].strip()) | | m2=int(data[3].strip()) |
| m3 = int(data[4].strip("\n")) | | m3 = int(data[4].strip("\n")) |
| mid1 = mid1+m1 | | mid1 = mid1+m1 |
| mid2 = mid2+m2 | | mid2 = mid2+m2 |
| final = final + m3 | | final = final + m3 |
| avg = (m1+m2+m3)/3.0 | | avg = (m1+m2+m3)/3.0 |
| grade = 'F' | | grade = 'F' |
| if avg > 90: | | if avg > 90: |
| grade = 'A' | | grade = 'A' |
| elif avg > 80: | | elif avg > 80: |
| grade='B' | | grade='B' |
| elif avg > 70: | | elif avg > 70: |
| grade='C' | | grade='C' |
| elif avg > 60: | | elif avg > 60: |
| grade='D' | | grade='D' |
| f.write('\t'.join(data)+"\t" + str(grade)+"\n") | | f.write('\t'.join(data)+"\t" + str(grade)+"\n") |
| avg1=mid1/students | | avg1=mid1/students |
| avg2=mid2/students | | avg2=mid2/students |
| avg3=final/students | | avg3=final/students |
| f.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3:.2f} | | f.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3:.2f} |
| \n") | | \n") |
| f.close() | | f.close() |
t | 7.20 | t | |
| filename = input() | | |
| with open(filename) as f: | | |
| for lx in f: | | |
| lx=lx.strip() | | |
| lx=lx.replace('_photo.jpg','_info.txt') | | |
| print(lx) | | |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 58
Student ID: 157, P-Value: 2.06e-02
Nearest Neighbor ID: 56
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | numbers = str(random.randint(0,100)) | n | word = str(random.randint(0,100)) |
| for n in range(0,4): | | for i in range(0,4): |
| numbers += "," + str(random.randint(0,100)) | | word += "," + str(random.randint(0,100)) |
| return numbers | | return word |
| file = open('randomNums.txt','w') | | file = open('randomNums.txt','w') |
n | for p in range(5): | n | for j in range(5): |
| file.write(randomGen()+'\n') | | file.write(randomGen()+'\n')import csv |
| file.close()import csv | | |
| input1 = input() | | input1 = input() |
| with open(input1, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
n | for word in words_reader: | n | for row in words_reader: |
| list_words = word | | list_of_words = row |
| no_duplicates = list(dict.fromkeys(list_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| listlen = len(no_duplicates) | | listlength = len(no_duplicates_in_list) |
| for n in range(listlen): | | for i in range(listlength): |
| print(no_duplicates[n], list_words.count(no_duplicates[n]))def score(avg): | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| | | ))def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
| fileName = input("Enter the filename: ") | | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
n | total1 = 0 | n | totalM1 = 0 |
| total2 = 0 | | totalM2 = 0 |
| totalFinal = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
n | name1 = data[0] | n | fName = data[0] |
| name2 = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
n | grade = score(avg) | n | grade = determine_grade(avg) |
| total1 = total1 + m1 | | totalM1 = totalM1 + m1 |
| total2 = total2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
n | count+=1 | n | count = count + 1 |
| fileWrite.write(name1 + "\t" + name2 + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
t | "{0:.2f}".format(total1 / count) + ", midterm2 " + | t | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(total2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 59
Student ID: 129, P-Value: 2.91e-02
Nearest Neighbor ID: 94
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
n | try: | n | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
| print("File not found")import csv | | print("File not found")import csv |
n | file = input() | n | filename = input() |
| frequency = {} | | f = open(filename) |
| with open(file, 'r') as csvfile: | | data = csv.reader(f, delimiter=',') |
| csvfile = csv.reader(csvfile) | | words = [] |
| for row in csvfile: | | for row in data: |
| for word in row: | | for word in row: |
| if word not in frequency.keys(): | | words.append(word.strip()) |
| frequency[word] = 1 | | for i in range(len(words)): |
| else: | | if words[i] not in words[:i]: |
| frequency[word] = frequency[word]+ 1 | | count = 0 |
| for i in frequency.keys(): | | for w in words: |
| print(i,frequency[i]) | | if words[i] == w: |
| | | count += 1 |
| | | print(words[i], count) |
| | | f.close() |
| import csv | | import csv |
| file = open("StudentInfo.tsv") | | file = open("StudentInfo.tsv") |
| nFile = open("report.txt","w") | | nFile = open("report.txt","w") |
| lst1 = [] | | lst1 = [] |
| lst2 = [] | | lst2 = [] |
| lst3 = [] | | lst3 = [] |
| read_file = csv.reader(file, delimiter = "\t") | | read_file = csv.reader(file, delimiter = "\t") |
| for data in read_file: | | for data in read_file: |
| lst1.append(int(data[2])) | | lst1.append(int(data[2])) |
| lst2.append(int(data[3])) | | lst2.append(int(data[3])) |
| lst3.append(int(data[4])) | | lst3.append(int(data[4])) |
| avg = (int(data[2])+int(data[3])+int(data[4]))/3 | | avg = (int(data[2])+int(data[3])+int(data[4]))/3 |
| for item in data: | | for item in data: |
| nFile.writelines(item + "\t") | | nFile.writelines(item + "\t") |
| if avg >= 90: | | if avg >= 90: |
| nFile.write("A\n") | | nFile.write("A\n") |
| elif avg >= 80 and avg < 90: | | elif avg >= 80 and avg < 90: |
| nFile.write("B\n") | | nFile.write("B\n") |
| elif avg >= 70 and avg < 80: | | elif avg >= 70 and avg < 80: |
| nFile.write("C\n") | | nFile.write("C\n") |
| elif avg >= 60 and avg < 70: | | elif avg >= 60 and avg < 70: |
| nFile.write("D\n") | | nFile.write("D\n") |
| else: | | else: |
| nFile.write("F\n") | | nFile.write("F\n") |
| avg1 = sum(lst1)/len(lst1) | | avg1 = sum(lst1)/len(lst1) |
| avg2 = sum(lst2)/len(lst2) | | avg2 = sum(lst2)/len(lst2) |
| avg3 = sum(lst3)/len(lst3) | | avg3 = sum(lst3)/len(lst3) |
t | nFile.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3: | t | nFile.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3: |
| .2f}"+"\n") | | .2f}\n") |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 60
Student ID: 363, P-Value: 2.95e-02
Nearest Neighbor ID: 67
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | rnumber = str(random.randint(0,100)) | n | word = str(random.randint(0,100)) |
| for x in range(0,4): | | for i in range(0,4): |
| rnumber += "," + str(random.randint(0,100)) | | word += "," + str(random.randint(0,100)) |
| return rnumber | | return word |
| file = open('randomNums.txt','w') | | file = open('randomNums.txt','w') |
n | for n in range(5): | n | for j in range(5): |
| file.write(randomGen()+'\n') | | file.write(randomGen()+'\n') |
n | file.close() | n | file.close()import csv |
| import csv | | |
| input1 = input() | | input1 = input() |
| with open(input1, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
| for row in words_reader: | | for row in words_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| listlength = len(no_duplicates_in_list) | | listlength = len(no_duplicates_in_list) |
| for i in range(listlength): | | for i in range(listlength): |
n | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | n | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| ))from distutils.log import info | | ))def determine_grade(avg): |
| def grade(avg): | | |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
| fileName = input("Enter the filename: ") | | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
n | totalx1 = 0 | n | totalM1 = 0 |
| totalx2 = 0 | | totalM2 = 0 |
| totalx3 = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
n | info = line[1].replace("\n", "").split() | n | data = line[1].replace("\n", "").split() |
| name1 = info[0] | | fName = data[0] |
| name2 = info[1] | | lName = data[1] |
| x1 = int(info[2]) | | m1 = int(data[2]) |
| x2 = int(info[3]) | | m2 = int(data[3]) |
| x3 = int(info[4]) | | final = int(data[4]) |
| avg = (x1 + x2 + x3) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| gradeofficial = grade(avg) | | grade = determine_grade(avg) |
| totalx1 = totalx1 + x1 | | totalM1 = totalM1 + m1 |
| totalx2 = totalx2 + x2 | | totalM2 = totalM2 + m2 |
| totalx3 = totalx3 + x3 | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
n | fileWrite.write(name1 + "\t" + name2 + "\t" + str(x1) + "\t" + | n | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(x2) + "\t" + str(x3) + "\t" + gradeofficial + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
t | "{0:.2f}".format(totalx1 / count) + ", midterm2 " + | t | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalx2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalx3 / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 61
Student ID: 477, P-Value: 3.46e-02
Nearest Neighbor ID: 65
Student (left) and Nearest Neighbor (right).
n | import random | n | import random |
| def randomGen(): | | def randomGen(): |
| randoms = str(random.randint(0,9)) | | randoms = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| randoms += ","+str(random.randint(0,9)) | | randoms += ","+str(random.randint(0,9)) |
| return randoms | | return randoms |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
| print("File not found") | | print("File not found") |
| import csv | | import csv |
n | file = input() | n | fname = input() |
| frequency = {} | | f = open(fname) |
| with open(file, 'r') as csvfile: | | data = csv.reader(f, delimiter=',') |
| csvfile = csv.reader(csvfile) | | words = [] |
| for row in csvfile: | | for row in data: |
| for word in row: | | for word in row: |
| if word not in frequency.keys(): | | words.append(word.strip()) |
| frequency[word] = 1 | | for i in range(len(words)): |
| else: | | if words[i] not in words[:i]: |
| frequency[word] = frequency[word] + 1 | | count = 0 |
| for i in frequency.keys(): | | for w in words: |
| print(i,frequency[i],end="\n")fname=input("Enter the file name: ") | | if words[i] == w: |
| | | count += 1 |
| | | print(words[i], count) |
| | | f.close()fname=input("Enter the file name: ") |
| file = open(fname) | | file = open(fname) |
| f = open("report.txt", "w") | | f = open("report.txt", "w") |
| mid1 = 0 | | mid1 = 0 |
| mid2 = 0 | | mid2 = 0 |
| final = 0 | | final = 0 |
| students = 0 | | students = 0 |
| for line in file: | | for line in file: |
| students = students + 1 | | students = students + 1 |
| data = ('\t'.join(line.split())).split() | | data = ('\t'.join(line.split())).split() |
| m1=int(data[2].strip()) | | m1=int(data[2].strip()) |
| m2=int(data[3].strip()) | | m2=int(data[3].strip()) |
| m3 = int(data[4].strip("\n")) | | m3 = int(data[4].strip("\n")) |
| mid1 = mid1+m1 | | mid1 = mid1+m1 |
| mid2 = mid2+m2 | | mid2 = mid2+m2 |
| final = final + m3 | | final = final + m3 |
| avg = (m1+m2+m3)/3.0 | | avg = (m1+m2+m3)/3.0 |
| grade = 'F' | | grade = 'F' |
| if avg > 90: | | if avg > 90: |
| grade = 'A' | | grade = 'A' |
| elif avg > 80: | | elif avg > 80: |
| grade='B' | | grade='B' |
| elif avg > 70: | | elif avg > 70: |
| grade='C' | | grade='C' |
| elif avg > 60: | | elif avg > 60: |
| grade='D' | | grade='D' |
| f.write('\t'.join(data)+"\t" + str(grade)+"\n") | | f.write('\t'.join(data)+"\t" + str(grade)+"\n") |
| avg1=mid1/students | | avg1=mid1/students |
| avg2=mid2/students | | avg2=mid2/students |
| avg3=final/students | | avg3=final/students |
| f.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3:.2f} | | f.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3:.2f} |
| \n") | | \n") |
t | | t | f.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 62
Student ID: 224, P-Value: 3.55e-02
Nearest Neighbor ID: 239
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
n | print("File not found") | n | print("File not found")input_file = input() |
| import csv | | import csv |
t | file = open(input()) | t | with open(input_file) as csv_file: |
| strings = csv.reader(file, delimiter=',') | | data = csv.reader(csv_file, delimiter=',') |
| words = [] | | dictionary = {} |
| for row in strings: | | for row in data: |
| for word in row: | | for string in row: |
| words.append(word.strip()) | | if string in dictionary: |
| for i in range(len(words)): | | dictionary[string] += 1 |
| if words[i] not in words[:i]: | | else: |
| count = 0 | | dictionary[string] = 1 |
| for j in range(len(words)): | | for key in dictionary: |
| if words[i] == words[j]: | | print(f"{key} {dictionary[key]}")def getGrade(averageScore): |
| count += 1 | | |
| print(words[i], count) | | |
| file.close() | | |
| def getGrade(averageScore): | | |
| if averageScore >= 90: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
| elif averageScore >= 80: | | elif averageScore >= 80: |
| return 'B' | | return 'B' |
| elif averageScore >= 70: | | elif averageScore >= 70: |
| return 'C' | | return 'C' |
| elif averageScore >= 60: | | elif averageScore >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
| inputFile = 'StudentInfo.tsv' | | inputFile = 'StudentInfo.tsv' |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
| midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, | | midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, |
| 0, 0 | | 0, 0 |
| infile = open(inputFile, 'r') | | infile = open(inputFile, 'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
| fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( | | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| line[3]), int(line[4]) | | line[3]), int(line[4]) |
| count += 1 | | count += 1 |
| totalMT1 += midT1 | | totalMT1 += midT1 |
| totalMT2 += midT2 | | totalMT2 += midT2 |
| totalFinal += final | | totalFinal += final |
| grade = getGrade((midT1 + midT2 + final) / 3) | | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| ile) | | ile) |
| infile.close() | | infile.close() |
| totalMT1 /= count | | totalMT1 /= count |
| totalMT2 /= count | | totalMT2 /= count |
| totalFinal /= count | | totalFinal /= count |
| print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final | | print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final |
| {totalFinal:.2f}', | | {totalFinal:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 63
Student ID: 370, P-Value: 3.93e-02
Nearest Neighbor ID: 318
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
| try: | | try: |
n | out = open('randomNums.txt',"w") | n | out = open('randomNums.txt', "w") |
| line= "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
| print("File not found") | | print("File not found") |
| import csv | | import csv |
| input1 = input() | | input1 = input() |
| with open(input1, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
| for row in words_reader: | | for row in words_reader: |
| list_of_words = row | | list_of_words = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_words)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| listlength = len(no_duplicates_in_list) | | listlength = len(no_duplicates_in_list) |
| for i in range(listlength): | | for i in range(listlength): |
n | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] | n | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| )) | | ))def determine_grade(avg): |
| def getGrade(averageScore): | | avg = int(avg) |
| averageScore = int(averageScore) | | |
| if averageScore >= 90 and averageScore <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
n | elif averageScore >= 80 and averageScore <= 89: | n | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
n | elif averageScore >= 70 and averageScore <= 79: | n | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
n | elif averageScore >= 60 and averageScore <= 69: | n | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
n | elif averageScore <= 60: | n | elif avg <= 60: |
| return 'F' | | return 'F' |
n | fileName = input("Enter the fulename: ") | n | fileName = input("Enter the filename: ") |
| report = "report.txt" | | outFile = "report.txt" |
| midterm1tot = 0 | | totalM1 = 0 |
| midterm2tot = 0 | | totalM2 = 0 |
| finaltot = 0 | | totalFinal = 0 |
| n = 0 | | count = 0 |
| fileWrite = open(report, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
n | data = line[1].replace("\n","").split() | n | data = line[1].replace("\n", "").split() |
| first_name = data[0] | | fName = data[0] |
| last_name = data[1] | | lName = data[1] |
| mid1 = int(data[2]) | | m1 = int(data[2]) |
| mid2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
t | midterm1tot = midterm1tot + mid1 | t | |
| midterm2tot = midterm2tot + mid2 | | |
| finaltot = finaltot + final | | |
| average = (mid1 + mid2 + final)/ 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = getGrade(average) | | grade = determine_grade(avg) |
| n += 1 | | totalM1 = totalM1 + m1 |
| | | totalM2 = totalM2 + m2 |
| | | totalFinal = totalFinal + final |
| | | count = count + 1 |
| fileWrite.write(first_name + "\t" + last_name + "\t" + str(mid1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(mid2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if n>0: | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 "+ | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(midterm1tot /n) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(midterm2tot /n) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(finaltot /n) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 64
Student ID: 74, P-Value: 4.03e-02
Nearest Neighbor ID: 254
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return resultimport csv | | return resultimport csv |
| filename = input() | | filename = input() |
| f = open(filename) | | f = open(filename) |
| data = csv.reader(f, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
| if words[i] not in words[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
| if words[i] == w: | | if words[i] == w: |
| count += 1 | | count += 1 |
| print(words[i], count) | | print(words[i], count) |
n | f.close()def RecieveGrades(average): | n | f.close()def getGrade(averageScore): |
| if average >= 90 and average <= 100: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
n | elif average >= 80 and average <= 89: | n | elif averageScore >= 80: |
| return 'B' | | return 'B' |
n | elif average>= 70 and average <= 79: | n | elif averageScore >= 70: |
| return 'C' | | return 'C' |
n | elif average >= 60 and average <= 69: | n | elif averageScore >= 60: |
| return 'D' | | return 'D' |
n | elif average <= 60: | n | |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
| inputFile = input() | | inputFile = input() |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
n | midTerm1, midTerm2, final, totalMidTerm1, totalMidTerm2, totalFinal, num_of_ | n | midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, |
| stud = 0, 0, 0, 0, 0, 0, 0 | | 0, 0 |
| infile = open(inputFile, 'r') | | infile = open(inputFile, 'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
n | fname, lname, midTerm1, midTerm2, final = line[0], line[1], int(line[2]) | n | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| , int(line[3]), int(line[4]) | | line[3]), int(line[4]) |
| num_of_stud += 1 | | count += 1 |
| totalMidTerm1 += midTerm1 | | totalMT1 += midT1 |
| totalMidTerm2 += midTerm2 | | totalMT2 += midT2 |
| totalFinal += final | | totalFinal += final |
n | grade = RecieveGrades((midTerm1 + midTerm2 + final) / 3) | n | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midTerm1}\t{midTerm2}\t{final}\t{grade}', fil | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| e=outfile) | | ile) |
| infile.close() | | infile.close() |
t | totalMidTerm1 /= num_of_stud | t | totalMT1 /= count |
| totalMidTerm2 /= num_of_stud | | totalMT2 /= count |
| totalFinal /= num_of_stud | | totalFinal /= count |
| print(f'\nAverages: midterm1 {totalMidTerm1:.2f}, midterm2 {totalMidTerm2:.2 | | print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final |
| f}, final {totalFinal:.2f}', | | {totalFinal:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 65
Student ID: 391, P-Value: 4.28e-02
Nearest Neighbor ID: 230
Student (left) and Nearest Neighbor (right).
n | | n | import os |
| import random | | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
n | result += ","+str(random.randint(0,9)) | n | result +=','+str(random.randint(0,9)) |
| return result | | return result |
n | try: | n | |
| out = open('randomNums.txt', "w") | | f = open('randomNums.txt' , 'w') |
| line = "" | | line = '' |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | f.write(randomGen()+'\n') |
| out.close() | | f.close() |
| except Exception: | | |
| print("File not found") | | |
| import csv | | import csv |
n | from collections import OrderedDict | n | from typing import OrderedDict |
| def word_freq(file_name): | | def word_freq(file_name): |
| words_list = [] | | words_list = [] |
| d = OrderedDict() | | d = OrderedDict() |
| with open(file_name,'rt')as f: | | with open(file_name,'rt')as f: |
| data = csv.reader(f) | | data = csv.reader(f) |
| for row in data: | | for row in data: |
| words_list = row | | words_list = row |
| for word in words_list: | | for word in words_list: |
| if word in d: | | if word in d: |
| d[word] = d[word] + 1 | | d[word] = d[word] + 1 |
| else: | | else: |
| d[word] = 1 | | d[word] = 1 |
| for key in list(d.keys()): | | for key in list(d.keys()): |
| print(key,d[key]) | | print(key,d[key]) |
n | if __name__ == '__main__': | n | |
| file_name = input() | | file_name = input() |
| word_freq(file_name)def getGrade(averageScore): | | word_freq(file_name)from asyncore import write |
| | | def getGrade(averageScore): |
| if averageScore >= 90: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
| elif averageScore >= 80: | | elif averageScore >= 80: |
| return 'B' | | return 'B' |
| elif averageScore >= 70: | | elif averageScore >= 70: |
| return 'C' | | return 'C' |
| elif averageScore >= 60: | | elif averageScore >= 60: |
| return 'D' | | return 'D' |
n | | n | else: |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
n | inputFile = 'StudentInfo.tsv' | n | inputFile = input() |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
| midTerm1, midTerm2, final, totalMidTerm1, totalMidTerm2, totalFinal, count = | | midTerm1, midTerm2, final, totalMidTerm1, totalMidTerm2, totalFinal, count = |
| 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0 |
n | infile = open(inputFile, 'r') | n | infile = open(inputFile,'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
n | line = line.strip().split() | n | line=line.strip().split() |
| fname, lname, midTerm1, midTerm2, final = line[0], line[1], int(line[2]) | | first_name,last_name,midTerm1,midTerm2, final = line[0], line[1], int(li |
| , int(line[3]), int(line[4]) | | ne[2]), int(line[3]), int(line[4]) |
| count += 1 | | count += 1 |
| totalMidTerm1 += midTerm1 | | totalMidTerm1 += midTerm1 |
| totalMidTerm2 += midTerm2 | | totalMidTerm2 += midTerm2 |
| totalFinal += final | | totalFinal += final |
n | grade = getGrade((midTerm1 + midTerm2 + final) / 3) | n | grade = getGrade((midTerm1 + midTerm2 + final ) /3 ) |
| print(f'{fname}\t{lname}\t{midTerm1}\t{midTerm2}\t{final}\t{grade}', fil | | print(f'{first_name}\t{last_name}\t{midTerm1}\t{midTerm2}\t{final}\t{gra |
| e=outfile) | | de}', file=outfile) |
| infile.close() | | infile.close() |
| totalMidTerm1 /= count | | totalMidTerm1 /= count |
| totalMidTerm2 /= count | | totalMidTerm2 /= count |
| totalFinal /= count | | totalFinal /= count |
t | print(f'\nAverages: midterm1 {totalMidTerm1:.2f}, midterm2 {totalMidTerm2:.2 | t | print(f'\nAverages: midterm1 {totalMidTerm1:.2f}, midterm2 {totalMidTerm2:.2 |
| f}, final {totalFinal:.2f}', | | f}, final {totalFinal:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 66
Student ID: 230, P-Value: 4.28e-02
Nearest Neighbor ID: 391
Student (left) and Nearest Neighbor (right).
n | import os | n | |
| import random | | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
n | result +=','+str(random.randint(0,9)) | n | result += ","+str(random.randint(0,9)) |
| return result | | return result |
n | | n | try: |
| f = open('randomNums.txt' , 'w') | | out = open('randomNums.txt', "w") |
| line = '' | | line = "" |
| for i in range(5): | | for i in range(5): |
| f.write(randomGen()+'\n') | | out.write(randomGen()+"\n") |
| f.close() | | out.close() |
| | | except Exception: |
| | | print("File not found") |
| import csv | | import csv |
n | from typing import OrderedDict | n | from collections import OrderedDict |
| def word_freq(file_name): | | def word_freq(file_name): |
| words_list = [] | | words_list = [] |
| d = OrderedDict() | | d = OrderedDict() |
| with open(file_name,'rt')as f: | | with open(file_name,'rt')as f: |
| data = csv.reader(f) | | data = csv.reader(f) |
| for row in data: | | for row in data: |
| words_list = row | | words_list = row |
| for word in words_list: | | for word in words_list: |
| if word in d: | | if word in d: |
| d[word] = d[word] + 1 | | d[word] = d[word] + 1 |
| else: | | else: |
| d[word] = 1 | | d[word] = 1 |
| for key in list(d.keys()): | | for key in list(d.keys()): |
| print(key,d[key]) | | print(key,d[key]) |
n | | n | if __name__ == '__main__': |
| file_name = input() | | file_name = input() |
| word_freq(file_name)from asyncore import write | | word_freq(file_name)def getGrade(averageScore): |
| def getGrade(averageScore): | | |
| if averageScore >= 90: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
| elif averageScore >= 80: | | elif averageScore >= 80: |
| return 'B' | | return 'B' |
| elif averageScore >= 70: | | elif averageScore >= 70: |
| return 'C' | | return 'C' |
| elif averageScore >= 60: | | elif averageScore >= 60: |
| return 'D' | | return 'D' |
n | else: | n | |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
n | inputFile = input() | n | inputFile = 'StudentInfo.tsv' |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
| midTerm1, midTerm2, final, totalMidTerm1, totalMidTerm2, totalFinal, count = | | midTerm1, midTerm2, final, totalMidTerm1, totalMidTerm2, totalFinal, count = |
| 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0 |
n | infile = open(inputFile,'r') | n | infile = open(inputFile, 'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
n | line=line.strip().split() | n | line = line.strip().split() |
| first_name,last_name,midTerm1,midTerm2, final = line[0], line[1], int(li | | fname, lname, midTerm1, midTerm2, final = line[0], line[1], int(line[2]) |
| ne[2]), int(line[3]), int(line[4]) | | , int(line[3]), int(line[4]) |
| count += 1 | | count += 1 |
| totalMidTerm1 += midTerm1 | | totalMidTerm1 += midTerm1 |
| totalMidTerm2 += midTerm2 | | totalMidTerm2 += midTerm2 |
| totalFinal += final | | totalFinal += final |
n | grade = getGrade((midTerm1 + midTerm2 + final ) /3 ) | n | grade = getGrade((midTerm1 + midTerm2 + final) / 3) |
| print(f'{first_name}\t{last_name}\t{midTerm1}\t{midTerm2}\t{final}\t{gra | | print(f'{fname}\t{lname}\t{midTerm1}\t{midTerm2}\t{final}\t{grade}', fil |
| de}', file=outfile) | | e=outfile) |
| infile.close() | | infile.close() |
| totalMidTerm1 /= count | | totalMidTerm1 /= count |
| totalMidTerm2 /= count | | totalMidTerm2 /= count |
| totalFinal /= count | | totalFinal /= count |
t | print(f'\nAverages: midterm1 {totalMidTerm1:.2f}, midterm2 {totalMidTerm2:.2 | t | print(f'\nAverages: midterm1 {totalMidTerm1:.2f}, midterm2 {totalMidTerm2:.2 |
| f}, final {totalFinal:.2f}', | | f}, final {totalFinal:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 67
Student ID: 373, P-Value: 4.55e-02
Nearest Neighbor ID: 391
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | outcome = str(random.randint(0,9)) | n | result = str(random.randint(0,9)) |
| for n in range(4): | | for x in range(4): |
| outcome += ','+ str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return outcome | | return result |
| try: | | try: |
n | d=open('randomNums.txt','w') | n | out = open('randomNums.txt', "w") |
| line = '' | | line = "" |
| for a in range(5): | | for i in range(5): |
| d.write(randomGen()+'\n') | | out.write(randomGen()+"\n") |
| d.close() | | out.close() |
| except Exception: | | except Exception: |
n | print('File not fouund')import csv | n | print("File not found") |
| | | import csv |
| from collections import OrderedDict | | from collections import OrderedDict |
n | def wordFreq(file_name): | n | def word_freq(file_name): |
| wordList = [] | | words_list = [] |
| d= OrderedDict() | | d = OrderedDict() |
| with open(file_name,'r') as f: | | with open(file_name,'rt')as f: |
| readData = csv.reader(f) | | data = csv.reader(f) |
| for row in readData: | | for row in data: |
| wordList = row | | words_list = row |
| for word in wordList: | | for word in words_list: |
| if word in d: | | if word in d: |
| d[word] = d[word] + 1 | | d[word] = d[word] + 1 |
| else: | | else: |
n | d[word] =1 | n | d[word] = 1 |
| for key in list(d.keys()): | | for key in list(d.keys()): |
| print(key,d[key]) | | print(key,d[key]) |
n | if __name__=='__main__': | n | if __name__ == '__main__': |
| file_name = input() | | file_name = input() |
n | wordFreq(file_name)def getGrade(averageScore): | n | word_freq(file_name)def getGrade(averageScore): |
| if averageScore >= 90: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
| elif averageScore >= 80: | | elif averageScore >= 80: |
| return 'B' | | return 'B' |
| elif averageScore >= 70: | | elif averageScore >= 70: |
| return 'C' | | return 'C' |
| elif averageScore >= 60: | | elif averageScore >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
| inputFile = 'StudentInfo.tsv' | | inputFile = 'StudentInfo.tsv' |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
n | midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0,0,0,0,0,0,0 | n | midTerm1, midTerm2, final, totalMidTerm1, totalMidTerm2, totalFinal, count = |
| | | 0, 0, 0, 0, 0, 0, 0 |
| infile = open(inputFile, 'r') | | infile = open(inputFile, 'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
n | fname,lname, midT1, midT2, final = line[0], line[1], int(line[2]), int(l | n | fname, lname, midTerm1, midTerm2, final = line[0], line[1], int(line[2]) |
| ine[3]), int(line[4]) | | , int(line[3]), int(line[4]) |
| count += 1 | | count += 1 |
n | totalMT1 += midT1 | n | totalMidTerm1 += midTerm1 |
| totalMT2 += midT2 | | totalMidTerm2 += midTerm2 |
| totalFinal += final | | totalFinal += final |
n | grade = getGrade((midT1 + midT2 + final) / 3) | n | grade = getGrade((midTerm1 + midTerm2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file = ou | | print(f'{fname}\t{lname}\t{midTerm1}\t{midTerm2}\t{final}\t{grade}', fil |
| tfile) | | e=outfile) |
| infile.close() | | infile.close() |
t | totalMT1 /= count | t | totalMidTerm1 /= count |
| totalMT2 /= count | | totalMidTerm2 /= count |
| totalFinal /= count | | totalFinal /= count |
| print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final | | print(f'\nAverages: midterm1 {totalMidTerm1:.2f}, midterm2 {totalMidTerm2:.2 |
| {totalFinal:.2f}', file=outfile) | | f}, final {totalFinal:.2f}', |
| | | file=outfile) |
| | | outfile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 68
Student ID: 272, P-Value: 4.55e-02
Nearest Neighbor ID: 434
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
n | file1 = open("randomNums.txt","w") | n | afile = open("randomNums.txt", "w" ) |
| def rnumero(): | | def rnum(): |
| r = random.randint(1,100) | | r=random.randint(1, 100) |
| return r | | return r |
| def randomGen(): | | def randomGen(): |
n | randomstring = '{},{},{},{},{}'.format(rnumero(),rnumero(),rnumero(),rnumero | n | randomstring='{},{},{},{},{}'.format(rnum(),rnum(),rnum(),rnum(),rnum()) |
| (),rnumero()) | | |
| return randomstring | | return randomstring |
n | b = 5 | n | b=5 |
| file = open('randomNums.txt','a') | | file = open('randomNums.txt', 'a') |
| while b>0: | | while b>0: |
| file.write(randomGen()) | | file.write(randomGen()) |
n | b-=1 | n | b-=1import csv |
| import csv | | |
| input1 = input() | | input1 = input() |
| with open(input1, 'r') as wordfile: | | with open(input1, 'r') as wordfile: |
| word_reader = csv.reader(wordfile) | | word_reader = csv.reader(wordfile) |
| for row in word_reader: | | for row in word_reader: |
| list_of_word = row | | list_of_word = row |
| no_duplicates_in_list = list(dict.fromkeys(list_of_word)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_word)) |
n | list_leno = len(no_duplicates_in_list) | n | list_len = len(no_duplicates_in_list) |
| for a in range(list_leno): | | for i in range(list_len): |
| print(no_duplicates_in_list[a],list_of_word.count(no_duplicates_in_list[a])) | | print(no_duplicates_in_list[i], list_of_word.count(no_duplicates_in_list[i]) |
| | | )file_name = input("Enter the file name: ") |
| file_name = input("Enter the name of file: ") | | |
| file = open (file_name) | | file = open(file_name) |
| f = open('report.txt', 'w') | | f = open('report.txt','w') |
| inter0 = 0 | | mid_0 = 0 |
| inter1 = 0 | | mid_1 = 0 |
| final = 0 | | final = 0 |
| students = 0 | | students = 0 |
| for line in file: | | for line in file: |
| students = students + 1 | | students = students + 1 |
n | data = ('\t'. join(line.split())) .split() | n | data = ('\t'.join(line.split())).split() |
| m_1 = int (data[2] . strip()) | | m1 = int(data[2].strip()) |
| m_2 = int (data[3]. strip()) | | m2 = int(data[3].strip()) |
| m_3 = int (data[4].strip('\n')) | | m3 = int(data[4].strip('\n')) |
| inter0 = inter0 + m_1 | | mid_0 = mid_0 +m1 |
| inter1 = inter1 + m_2 | | mid_1 = mid_1+m2 |
| final = final + m_3 | | final = final +m3 |
| avg = (m_1 + m_2 + m_3)/3.0 | | avg = (m1+m2+m3)/3.0 |
| grade = 'F' | | grade = "F" |
| if avg > 90: | | if avg > 90: |
| grade = 'A' | | grade = 'A' |
| elif avg > 80: | | elif avg > 80: |
| grade = 'B' | | grade = 'B' |
| elif avg > 70: | | elif avg > 70: |
| grade = 'C' | | grade = 'C' |
| elif avg > 60: | | elif avg > 60: |
| grade = 'D' | | grade = 'D' |
t | f.write('\t'.join(data) + '\t'+ str(grade) +'\n') | t | f.write('\t'.join(data)+'\t'+str(grade)+'\n') |
| avg_1 = inter0/students | | avg_1 = mid_0/students |
| avg_2 = inter1/students | | avg_2 = mid_1/students |
| avg_3 = final/students | | avg_3 = final/students |
| f.write(f'\nAverages: midterm1 {avg_1:.2f}, midterm2 {avg_2:.2f}, final {avg_3:. | | f.write(f'\nAverages: midterm1 {avg_1:.2f}, midterm2 {avg_2:.2f}, final {avg_3:. |
| 2f}\n') | | 2f}\n') |
| f.close | | f.close |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 69
Student ID: 325, P-Value: 5.42e-02
Nearest Neighbor ID: 56
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | numstr = str(random.randint(0,10)) | n | word = str(random.randint(0,100)) |
| for l in range(0,4): | | for i in range(0,4): |
| numstr += "," + str(random.randint(0,10)) | | word += "," + str(random.randint(0,100)) |
| return numstr | | return word |
| file = open('randomNums.txt','w') | | file = open('randomNums.txt','w') |
n | for each in range(5): | n | for j in range(5): |
| file.write(randomGen()+'\n')import csv | | file.write(randomGen()+'\n')import csv |
t | file1 = input() | t | input1 = input() |
| with open(file1, 'r') as file: | | with open(input1, 'r') as wordsfile: |
| inf = csv.reader(file, delimiter = ',') | | words_reader = csv.reader(wordsfile) |
| my_dict = {} | | for row in words_reader: |
| for i in inf: | | list_of_words = row |
| for j in i: | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| if j not in my_dict.keys(): | | listlength = len(no_duplicates_in_list) |
| my_dict[j] = 1 | | for i in range(listlength): |
| else: | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| | | ))def determine_grade(avg): |
| my_dict[j] += 1 | | |
| for i in my_dict: | | |
| print(i + ' ' + str(my_dict[i]))def determine_grade(avg): | | |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
| fileName = input("Enter the filename: ") | | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
| totalM1 = 0 | | totalM1 = 0 |
| totalM2 = 0 | | totalM2 = 0 |
| totalFinal = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
| totalM1 = totalM1 + m1 | | totalM1 = totalM1 + m1 |
| totalM2 = totalM2 + m2 | | totalM2 = totalM2 + m2 |
| totalFinal = totalFinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalM1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalM2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalFinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 70
Student ID: 178, P-Value: 5.48e-02
Nearest Neighbor ID: 391
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
t | print("File not found")import csv | t | print("File not found") |
| def count_frequency_word(words): | | import csv |
| word_count = {} | | from collections import OrderedDict |
| | | def word_freq(file_name): |
| | | words_list = [] |
| | | d = OrderedDict() |
| | | with open(file_name,'rt')as f: |
| | | data = csv.reader(f) |
| | | for row in data: |
| | | words_list = row |
| for word in words: | | for word in words_list: |
| if word in word_count: | | if word in d: |
| word_count[word] = word_count[word] + 1 | | d[word] = d[word] + 1 |
| else: | | else: |
| word_count[word] = 1 | | d[word] = 1 |
| for k, v in word_count.items(): | | for key in list(d.keys()): |
| print ("%s %d"%(k, v)) | | print(key,d[key]) |
| | | if __name__ == '__main__': |
| file_name = input() | | file_name = input() |
| try: | | word_freq(file_name)def getGrade(averageScore): |
| csv_file = open(file_name, 'r') | | |
| csv_reader = csv.reader(csv_file) | | |
| for words in csv_reader: | | |
| count_frequency_word(words) | | |
| except: | | |
| print('File does not exist please enter anoter file')def getGrade(averageSco | | |
| re): | | |
| if averageScore >= 90: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
| elif averageScore >= 80: | | elif averageScore >= 80: |
| return 'B' | | return 'B' |
| elif averageScore >= 70: | | elif averageScore >= 70: |
| return 'C' | | return 'C' |
| elif averageScore >= 60: | | elif averageScore >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
| inputFile = 'StudentInfo.tsv' | | inputFile = 'StudentInfo.tsv' |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
| midTerm1, midTerm2, final, totalMidTerm1, totalMidTerm2, totalFinal, count = | | midTerm1, midTerm2, final, totalMidTerm1, totalMidTerm2, totalFinal, count = |
| 0, 0, 0, 0, 0, 0, 0 | | 0, 0, 0, 0, 0, 0, 0 |
| infile = open(inputFile, 'r') | | infile = open(inputFile, 'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
| fname, lname, midTerm1, midTerm2, final = line[0], line[1], int(line[2]) | | fname, lname, midTerm1, midTerm2, final = line[0], line[1], int(line[2]) |
| , int(line[3]), int(line[4]) | | , int(line[3]), int(line[4]) |
| count += 1 | | count += 1 |
| totalMidTerm1 += midTerm1 | | totalMidTerm1 += midTerm1 |
| totalMidTerm2 += midTerm2 | | totalMidTerm2 += midTerm2 |
| totalFinal += final | | totalFinal += final |
| grade = getGrade((midTerm1 + midTerm2 + final) / 3) | | grade = getGrade((midTerm1 + midTerm2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midTerm1}\t{midTerm2}\t{final}\t{grade}', fil | | print(f'{fname}\t{lname}\t{midTerm1}\t{midTerm2}\t{final}\t{grade}', fil |
| e=outfile) | | e=outfile) |
| infile.close() | | infile.close() |
| totalMidTerm1 /= count | | totalMidTerm1 /= count |
| totalMidTerm2 /= count | | totalMidTerm2 /= count |
| totalFinal /= count | | totalFinal /= count |
| print(f'\nAverages: midterm1 {totalMidTerm1:.2f}, midterm2 {totalMidTerm2:.2 | | print(f'\nAverages: midterm1 {totalMidTerm1:.2f}, midterm2 {totalMidTerm2:.2 |
| f}, final {totalFinal:.2f}', | | f}, final {totalFinal:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 71
Student ID: 22, P-Value: 5.54e-02
Nearest Neighbor ID: 94
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
n | result += ','+str(random.randint(0,9)) | n | result += ","+str(random.randint(0,9)) |
| return resultimport csv | | return result |
| file = open(input()) | | try: |
| | | out = open('randomNums.txt', "w") |
| | | line = "" |
| | | for i in range(5): |
| | | out.write(randomGen()+"\n") |
| | | out.close() |
| | | except Exception: |
| | | print("File not found")import csv |
| | | filename = input() |
| | | f = open(filename) |
| strings = csv.reader(file, delimiter=',') | | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
n | for row in strings: | n | for row in data: |
| for word in row: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(words)): | | for i in range(len(words)): |
n | if words[i] not in words [:i]: | n | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
n | for j in range(len(words)): | n | for w in words: |
| if words[i] == words[j]: | | if words[i] == w: |
| count += 1 | | count += 1 |
| print(words[i], count) | | print(words[i], count) |
n | file.close()import csv | n | f.close() |
| | | import csv |
| file = open("StudentInfo.tsv") | | file = open("StudentInfo.tsv") |
| nFile = open("report.txt","w") | | nFile = open("report.txt","w") |
| lst1 = [] | | lst1 = [] |
| lst2 = [] | | lst2 = [] |
| lst3 = [] | | lst3 = [] |
| read_file = csv.reader(file, delimiter = "\t") | | read_file = csv.reader(file, delimiter = "\t") |
| for data in read_file: | | for data in read_file: |
| lst1.append(int(data[2])) | | lst1.append(int(data[2])) |
| lst2.append(int(data[3])) | | lst2.append(int(data[3])) |
| lst3.append(int(data[4])) | | lst3.append(int(data[4])) |
| avg = (int(data[2])+int(data[3])+int(data[4]))/3 | | avg = (int(data[2])+int(data[3])+int(data[4]))/3 |
| for item in data: | | for item in data: |
| nFile.writelines(item + "\t") | | nFile.writelines(item + "\t") |
| if avg >= 90: | | if avg >= 90: |
| nFile.write("A\n") | | nFile.write("A\n") |
| elif avg >= 80 and avg < 90: | | elif avg >= 80 and avg < 90: |
| nFile.write("B\n") | | nFile.write("B\n") |
n | elif avg >=70 and avg < 80: | n | elif avg >= 70 and avg < 80: |
| nFile.write("C\n") | | nFile.write("C\n") |
n | elif avg >= 60 and avg< 70: | n | elif avg >= 60 and avg < 70: |
| nFile.write("D\n") | | nFile.write("D\n") |
| else: | | else: |
| nFile.write("F\n") | | nFile.write("F\n") |
| avg1 = sum(lst1)/len(lst1) | | avg1 = sum(lst1)/len(lst1) |
| avg2 = sum(lst2)/len(lst2) | | avg2 = sum(lst2)/len(lst2) |
| avg3 = sum(lst3)/len(lst3) | | avg3 = sum(lst3)/len(lst3) |
t | nFile.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3: | t | nFile.write(f"\nAverages: midterm1 {avg1:.2f}, midterm2 {avg2:.2f}, final {avg3: |
| .2f}") | | .2f}\n") |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 72
Student ID: 231, P-Value: 5.60e-02
Nearest Neighbor ID: 398
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | numbers = str(random.randint(0,9)) | n | result = str(random.randint(0,9)) |
| for x in range (4): | | for x in range(4): |
| numbers += ',' + str(random.randint(0,9)) | | result += ','+str(random.randint(0,9)) |
| return numbers | | return result |
| import csv | | import csv |
| filename = input() | | filename = input() |
n | file = open(filename) | n | f = open(filename) |
| data = csv.reader(file, delimiter =',') | | data = csv.reader(f, delimiter=',') |
| wordlist = [] | | words = [] |
| for row in data: | | for row in data: |
| for word in row: | | for word in row: |
n | wordlist.append(word.strip()) | n | words.append(word.strip()) |
| for i in range(len(wordlist)): | | for i in range(len(words)): |
| if wordlist[i] not in wordlist[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
n | for w in wordlist: | n | for w in words: |
| if wordlist[i] == w: | | if words[i] == w: |
| count += 1 | | count += 1 |
n | print(wordlist[i],count) | n | print(words[i], count) |
| file.close()def getGrade(averagescore): | | f.close()def getGrade(averageScore): |
| if averagescore >= 90: | | if averageScore >= 90: |
| return 'A' | | return 'A' |
n | elif averagescore >= 80: | n | elif averageScore >= 80: |
| return 'B' | | return 'B' |
n | elif averagescore >= 70: | n | elif averageScore >= 70: |
| return 'C' | | return 'C' |
n | elif averagescore >= 60: | n | elif averageScore >= 60: |
| return 'D' | | return 'D' |
n | elif averagescore < 60: | n | |
| return 'F' | | return 'F' |
| def main(): | | def main(): |
n | inputFile = 'StudentInfo.tsv' | n | inputFile = input() |
| outputFile = 'report.txt' | | outputFile = 'report.txt' |
n | m1, m2, final, totalm1, totalm2, totalfinal, count = 0, 0, 0, 0, 0, 0, 0 | n | midT1, midT2, final, totalMT1, totalMT2, totalFinal, count = 0, 0, 0, 0, 0, |
| | | 0, 0 |
| infile = open(inputFile, 'r') | | infile = open(inputFile, 'r') |
| outfile = open(outputFile, 'w+') | | outfile = open(outputFile, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
n | fname, lname, m1, m2, final = line[0], line[1], int(line[2]), int(line[3 | n | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| ]), int(line[4]) | | line[3]), int(line[4]) |
| count += 1 | | count += 1 |
n | totalm1 += m1 | n | totalMT1 += midT1 |
| totalm2 += m2 | | totalMT2 += midT2 |
| totalfinal += final | | totalFinal += final |
| grade = getGrade((m1 + m2 + final) / 3) | | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{m1}\t{m2}\t{final}\t{grade}', file=outfile) | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| | | ile) |
| infile.close() | | infile.close() |
t | totalm1 /= count | t | totalMT1 /= count |
| totalm2 /= count | | totalMT2 /= count |
| totalfinal /= count | | totalFinal /= count |
| print(f'\nAverages: midterm1 {totalm1:.2f}, midterm2 {totalm2:.2f}, final {t | | print(f'\nAverages: midterm1 {totalMT1:.2f}, midterm2 {totalMT2:.2f}, final |
| otalfinal:.2f}', | | {totalFinal:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| main() | | main() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 73
Student ID: 177, P-Value: 5.60e-02
Nearest Neighbor ID: 473
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
n | randList = [] | n | file = open('randomNums.txt','w+') |
| | | numlist = [] |
| def randomGen(): | | def randomGen(): |
n | for n in range(5): | n | for x in range(5): |
| a = random.randrange(1,10,1) | | num = random.randint(1,10) |
| randList.append((a)) | | numlist.append(num) |
| for k in range(5): | | return ('{},{},{},{},{}'.format(numlist[0],numlist[1],numlist[2],numlist[3], |
| | | numlist[4])) |
| return ('{},{},{},{},{}'.format(int(randList[0]),(randList[1]),int(randL | | |
| ist[2]),int(randList[3]),int(randList[4]))) | | |
| f=open('randomNums.txt','w+') | | |
| print(randomGen())import csv | | file.write(randomGen())import csv |
| input1 = input() | | file = input() |
| with open(input1, 'r') as wordsfile: | | with open(file, 'r') as wordsfile: |
| words_reader = csv.reader(wordsfile) | | wordreader =csv.reader(wordsfile) |
| for row in words_reader: | | for row in wordreader: |
| wordLst = row | | wordslist = row |
| uniqueWordLst = list(dict.fromkeys(wordLst)) | | no_dupes = list(dict.fromkeys(wordslist)) |
| lstlength = len(uniqueWordLst) | | listlength= len(no_dupes) |
| for n in range(lstlength): | | for i in range(listlength): |
| print(uniqueWordLst[n], wordLst.count(uniqueWordLst[n]))studentInfo = input( | | print(no_dupes[i], wordslist.count(no_dupes[i]))studentInfo = input() |
| ) | | |
| infoList = [] | | info_list = [] |
| midterm1List = [] | | mid1List = [] |
| midterm2List = [] | | mid2List = [] |
| finalList = [] | | finalList = [] |
| f=open('report.txt','w+') | | f=open('report.txt','w+') |
| def computeGrade(): | | def computeGrade(): |
n | grade = ((int(infoList[2])+int(infoList[3])+int(infoList[4]))/3) | n | grade = ((int(info_list[2])+int(info_list[3])+int(info_list[4]))/3) |
| return grade | | return grade |
| def computeLetter(grade): | | def computeLetter(grade): |
| if grade >= 90: | | if grade >= 90: |
| letterGrade = 'A' | | letterGrade = 'A' |
| elif grade < 90 and grade >= 80: | | elif grade < 90 and grade >= 80: |
| letterGrade = 'B' | | letterGrade = 'B' |
| elif grade < 80 and grade >= 70: | | elif grade < 80 and grade >= 70: |
| letterGrade = 'C' | | letterGrade = 'C' |
| elif grade < 70 and grade >= 60: | | elif grade < 70 and grade >= 60: |
| letterGrade = 'D' | | letterGrade = 'D' |
| elif grade < 60: | | elif grade < 60: |
| letterGrade = 'F' | | letterGrade = 'F' |
| return letterGrade | | return letterGrade |
| def midterm1Avg(): | | def midterm1Avg(): |
n | midterm1Sum = sum(midterm1List) | n | midterm1Sum = sum(mid1List) |
| return (midterm1Sum / len(midterm1List)) | | return (midterm1Sum / len(mid1List)) |
| def midterm2Avg(): | | def midterm2Avg(): |
n | midterm2Sum = sum(midterm2List) | n | midterm2Sum = sum(mid2List) |
| return (midterm2Sum / len(midterm1List)) | | return (midterm2Sum / len(mid1List)) |
| def finalAvg(): | | def finalAvg(): |
| finalSum = sum(finalList) | | finalSum = sum(finalList) |
n | return (finalSum / len(midterm1List)) | n | return (finalSum / len(mid1List)) |
| with open(studentInfo,'r+') as studentFile: | | with open(studentInfo,'r+') as studentFile: |
| studentFile = studentFile.readlines() | | studentFile = studentFile.readlines() |
| for row in studentFile: | | for row in studentFile: |
n | infoList = row.split() | n | info_list = row.split() |
| grade = computeGrade() | | grade = computeGrade() |
n | midterm1List.append(int(infoList[2])) | n | mid1List.append(int(info_list[2])) |
| midterm2List.append(int(infoList[3])) | | mid2List.append(int(info_list[3])) |
| finalList.append(int(infoList[4])) | | finalList.append(int(info_list[4])) |
| letter = computeLetter(grade) | | letter = computeLetter(grade) |
n | infoList.append(letter) | n | info_list.append(letter) |
| pass | | pass |
t | f.write('{}\t{}\t{}\t{}\t{}\t{}\n'.format(infoList[0], infoList[1], info | t | f.write('{}\t{}\t{}\t{}\t{}\t{}\n'.format(info_list[0], info_list[1], in |
| List[2], infoList[3], infoList[4], infoList[5])) | | fo_list[2], info_list[3], info_list[4], info_list[5])) |
| midterm1 = midterm1Avg() | | midterm1 = midterm1Avg() |
| midterm2 = midterm2Avg() | | midterm2 = midterm2Avg() |
| final = finalAvg() | | final = finalAvg() |
| averages = f'Averages: midterm1 {midterm1:.2f}, midterm2 {midterm2:.2f}, fin | | averages = f'Averages: midterm1 {midterm1:.2f}, midterm2 {midterm2:.2f}, fin |
| al {final:.2f}' | | al {final:.2f}' |
| f.write('\n') | | f.write('\n') |
| f.write(averages) | | f.write(averages) |
| f.write('\n') | | f.write('\n') |
| f.close() | | f.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 74
Student ID: 473, P-Value: 5.60e-02
Nearest Neighbor ID: 177
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
n | file = open('randomNums.txt','w+') | n | randList = [] |
| numlist = [] | | |
| def randomGen(): | | def randomGen(): |
n | for x in range(5): | n | for n in range(5): |
| num = random.randint(1,10) | | a = random.randrange(1,10,1) |
| numlist.append(num) | | randList.append((a)) |
| return ('{},{},{},{},{}'.format(numlist[0],numlist[1],numlist[2],numlist[3], | | for k in range(5): |
| numlist[4])) | | |
| | | return ('{},{},{},{},{}'.format(int(randList[0]),(randList[1]),int(randL |
| | | ist[2]),int(randList[3]),int(randList[4]))) |
| | | f=open('randomNums.txt','w+') |
| file.write(randomGen())import csv | | print(randomGen())import csv |
| file = input() | | input1 = input() |
| with open(file, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| wordreader =csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
| for row in wordreader: | | for row in words_reader: |
| wordslist = row | | wordLst = row |
| no_dupes = list(dict.fromkeys(wordslist)) | | uniqueWordLst = list(dict.fromkeys(wordLst)) |
| listlength= len(no_dupes) | | lstlength = len(uniqueWordLst) |
| for i in range(listlength): | | for n in range(lstlength): |
| print(no_dupes[i], wordslist.count(no_dupes[i]))studentInfo = input() | | print(uniqueWordLst[n], wordLst.count(uniqueWordLst[n]))studentInfo = input( |
| | | ) |
| info_list = [] | | infoList = [] |
| mid1List = [] | | midterm1List = [] |
| mid2List = [] | | midterm2List = [] |
| finalList = [] | | finalList = [] |
| f=open('report.txt','w+') | | f=open('report.txt','w+') |
| def computeGrade(): | | def computeGrade(): |
n | grade = ((int(info_list[2])+int(info_list[3])+int(info_list[4]))/3) | n | grade = ((int(infoList[2])+int(infoList[3])+int(infoList[4]))/3) |
| return grade | | return grade |
| def computeLetter(grade): | | def computeLetter(grade): |
| if grade >= 90: | | if grade >= 90: |
| letterGrade = 'A' | | letterGrade = 'A' |
| elif grade < 90 and grade >= 80: | | elif grade < 90 and grade >= 80: |
| letterGrade = 'B' | | letterGrade = 'B' |
| elif grade < 80 and grade >= 70: | | elif grade < 80 and grade >= 70: |
| letterGrade = 'C' | | letterGrade = 'C' |
| elif grade < 70 and grade >= 60: | | elif grade < 70 and grade >= 60: |
| letterGrade = 'D' | | letterGrade = 'D' |
| elif grade < 60: | | elif grade < 60: |
| letterGrade = 'F' | | letterGrade = 'F' |
| return letterGrade | | return letterGrade |
| def midterm1Avg(): | | def midterm1Avg(): |
n | midterm1Sum = sum(mid1List) | n | midterm1Sum = sum(midterm1List) |
| return (midterm1Sum / len(mid1List)) | | return (midterm1Sum / len(midterm1List)) |
| def midterm2Avg(): | | def midterm2Avg(): |
n | midterm2Sum = sum(mid2List) | n | midterm2Sum = sum(midterm2List) |
| return (midterm2Sum / len(mid1List)) | | return (midterm2Sum / len(midterm1List)) |
| def finalAvg(): | | def finalAvg(): |
| finalSum = sum(finalList) | | finalSum = sum(finalList) |
n | return (finalSum / len(mid1List)) | n | return (finalSum / len(midterm1List)) |
| with open(studentInfo,'r+') as studentFile: | | with open(studentInfo,'r+') as studentFile: |
| studentFile = studentFile.readlines() | | studentFile = studentFile.readlines() |
| for row in studentFile: | | for row in studentFile: |
n | info_list = row.split() | n | infoList = row.split() |
| grade = computeGrade() | | grade = computeGrade() |
n | mid1List.append(int(info_list[2])) | n | midterm1List.append(int(infoList[2])) |
| mid2List.append(int(info_list[3])) | | midterm2List.append(int(infoList[3])) |
| finalList.append(int(info_list[4])) | | finalList.append(int(infoList[4])) |
| letter = computeLetter(grade) | | letter = computeLetter(grade) |
n | info_list.append(letter) | n | infoList.append(letter) |
| pass | | pass |
t | f.write('{}\t{}\t{}\t{}\t{}\t{}\n'.format(info_list[0], info_list[1], in | t | f.write('{}\t{}\t{}\t{}\t{}\t{}\n'.format(infoList[0], infoList[1], info |
| fo_list[2], info_list[3], info_list[4], info_list[5])) | | List[2], infoList[3], infoList[4], infoList[5])) |
| midterm1 = midterm1Avg() | | midterm1 = midterm1Avg() |
| midterm2 = midterm2Avg() | | midterm2 = midterm2Avg() |
| final = finalAvg() | | final = finalAvg() |
| averages = f'Averages: midterm1 {midterm1:.2f}, midterm2 {midterm2:.2f}, fin | | averages = f'Averages: midterm1 {midterm1:.2f}, midterm2 {midterm2:.2f}, fin |
| al {final:.2f}' | | al {final:.2f}' |
| f.write('\n') | | f.write('\n') |
| f.write(averages) | | f.write(averages) |
| f.write('\n') | | f.write('\n') |
| f.close() | | f.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 75
Student ID: 395, P-Value: 5.73e-02
Nearest Neighbor ID: 158
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | numbers = str(random.randint(0,9)) | n | result = str(random.randint(0,9)) |
| for num in range(4): | | for x in range(4): |
| numbers += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return numbers | | return result |
| try: | | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
n | for num in range(5): | n | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | except Exception: |
| print("File not found") | | print("File not found") |
| import csv | | import csv |
| filename = input() | | filename = input() |
| f = open(filename) | | f = open(filename) |
n | info = csv.reader(f, delimiter=',') | n | data = csv.reader(f, delimiter=',') |
| words = [] | | words = [] |
n | for a in info: | n | for row in data: |
| for word in a: | | for word in row: |
| words.append(word.strip()) | | words.append(word.strip()) |
n | for x in range(len(words)): | n | for i in range(len(words)): |
| if words[x] not in words[:x]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
| for w in words: | | for w in words: |
n | if words[x] == w: | n | if words[i] == w: |
| count += 1 | | count += 1 |
n | print(words[x], count) | n | print(words[i], count) |
| f.close() | | f.close()def determine_grade(avg): |
| def findgrade(grade): | | avg = int(avg) |
| grade = int(grade) | | |
| if grade >= 90 and grade <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
n | elif grade >= 80 and grade <= 89: | n | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
n | elif grade >= 70 and grade <= 79: | n | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
n | elif grade >= 60 and grade <= 69: | n | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
n | elif grade <= 60: | n | elif avg <= 60: |
| return 'F' | | return 'F' |
n | filename = input("Enter the filename: ") | n | fileName = input("Enter the filename: ") |
| outfile = "report.txt" | | outFile = "report.txt" |
| totalmid1 = 0 | | totalM1 = 0 |
| totalmid2 = 0 | | totalM2 = 0 |
| totalfinal = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
n | filewrite = open(outfile, "w") | n | fileWrite = open(outFile, "w") |
| for line in enumerate(open(filename, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
n | firstname = data[0] | n | fName = data[0] |
| lastname = data[1] | | lName = data[1] |
| midterm1 = int(data[2]) | | m1 = int(data[2]) |
| midterm2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
n | grade = (midterm1 + midterm2 + final) / 3.0 | n | avg = (m1 + m2 + final) / 3.0 |
| finalgrade = findgrade(grade) | | grade = determine_grade(avg) |
| totalmid1 = totalmid1 + midterm1 | | totalM1 = totalM1 + m1 |
| totalmid2 = totalmid2 + midterm2 | | totalM2 = totalM2 + m2 |
| totalfinal = totalfinal + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
n | filewrite.write(firstname + "\t" + lastname + "\t" + str(midterm1) + "\t" + | n | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(midterm2) + "\t" + str(final) + "\t" + finalgrade + "\n" | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| ) | | |
| if(count > 0): | | if(count > 0): |
n | filewrite.write("\nAverages: midterm1 " + | n | fileWrite.write("\nAverages: midterm1 " + |
| "{0:.2f}".format(totalmid1 / count) + ", midterm2 " + | | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalmid2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalfinal / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
t | filewrite.close() | t | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 76
Student ID: 333, P-Value: 7.62e-02
Nearest Neighbor ID: 258
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
| import csv | | import csv |
n | input_file = input() | n | input1 = input() |
| with open(input_file) as csv_file: | | with open(input1, 'r') as wf: |
| data = csv.reader(csv_file, delimiter=',') | | wr = csv.reader(wf) |
| dictionary = {} | | |
| for row in data: | | for row in wr: |
| for string in row: | | lw = row |
| if string in dictionary: | | nd = list(dict.fromkeys(lw)) |
| dictionary[string] += 1 | | ll = len(nd) |
| else: | | for i in range(ll): |
| dictionary[string] = 1 | | print(nd[i], lw.count(nd[i]))def determine_grade(avg): |
| for key in dictionary: | | |
| print(f"{key} {dictionary[key]}")def determine_grade(avg): | | |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
n | fileName = input() | n | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
n | M1 = 0 | n | totalM1 = 0 |
| M2 = 0 | | totalM2 = 0 |
| Final = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
n | M1 = M1 + m1 | n | totalM1 = totalM1 + m1 |
| M2 = M2 + m2 | | totalM2 = totalM2 + m2 |
| Final = Final + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
t | "{0:.2f}".format(M1 / count) + ", midterm2 " + | t | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(M2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(Final / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 77
Student ID: 149, P-Value: 8.01e-02
Nearest Neighbor ID: 272
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
n | afile = open('randomNums.txt','w') | n | file1 = open("randomNums.txt","w") |
| def random_number(): | | def rnumero(): |
| rnum = random.randint(1,100) | | r = random.randint(1,100) |
| return rnum | | return r |
| def randomGen(): | | def randomGen(): |
n | randomstr = '{},{},{},{},{}'.format(random_number(),random_number(),random_n | n | randomstring = '{},{},{},{},{}'.format(rnumero(),rnumero(),rnumero(),rnumero |
| umber(),random_number(),random_number()) | | (),rnumero()) |
| return randomstr | | return randomstring |
| b = 5 | | b = 5 |
| file = open('randomNums.txt','a') | | file = open('randomNums.txt','a') |
n | while b > 0: | n | while b>0: |
| file.write(randomGen()) | | file.write(randomGen()) |
n | b -= 1 | n | b-=1 |
| import csv | | import csv |
n | my_input = input() | n | input1 = input() |
| with open(my_input,'r') as wordfile: | | with open(input1, 'r') as wordfile: |
| doc_reader = csv.reader(wordfile) | | word_reader = csv.reader(wordfile) |
| for row in doc_reader: | | for row in word_reader: |
| list_of_word = row | | list_of_word = row |
n | my_list = list(dict.fromkeys(list_of_word)) | n | no_duplicates_in_list = list(dict.fromkeys(list_of_word)) |
| len_my_list = len(my_list) | | list_leno = len(no_duplicates_in_list) |
| for i in range(len_my_list): | | for a in range(list_leno): |
| print(my_list[i], list_of_word.count(my_list[i]))file_name = input ("Enter t | | print(no_duplicates_in_list[a],list_of_word.count(no_duplicates_in_list[a])) |
| he file name: ") | | |
| | | file_name = input("Enter the name of file: ") |
| file = open (file_name) | | file = open (file_name) |
| f = open('report.txt', 'w') | | f = open('report.txt', 'w') |
n | mid0 = 0 | n | inter0 = 0 |
| mid1 = 0 | | inter1 = 0 |
| final =0 | | final = 0 |
| students = 0 | | students = 0 |
| for line in file: | | for line in file: |
| students = students + 1 | | students = students + 1 |
| data = ('\t'. join(line.split())) .split() | | data = ('\t'. join(line.split())) .split() |
| m_1 = int (data[2] . strip()) | | m_1 = int (data[2] . strip()) |
| m_2 = int (data[3]. strip()) | | m_2 = int (data[3]. strip()) |
n | m_3 = int (data[4] .strip('\n')) | n | m_3 = int (data[4].strip('\n')) |
| mid0 = mid0 + m_1 | | inter0 = inter0 + m_1 |
| mid1 = mid1 + m_2 | | inter1 = inter1 + m_2 |
| final = final + m_3 | | final = final + m_3 |
n | avg = (m_1 + m_2 + m_3) /3.0 | n | avg = (m_1 + m_2 + m_3)/3.0 |
| grade = 'F' | | grade = 'F' |
| if avg > 90: | | if avg > 90: |
n | grade ='A' | n | grade = 'A' |
| elif avg > 80: | | elif avg > 80: |
n | grade ='B' | n | grade = 'B' |
| elif avg > 70: | | elif avg > 70: |
| grade = 'C' | | grade = 'C' |
| elif avg > 60: | | elif avg > 60: |
| grade = 'D' | | grade = 'D' |
| f.write('\t'.join(data) + '\t'+ str(grade) +'\n') | | f.write('\t'.join(data) + '\t'+ str(grade) +'\n') |
t | avg_1 = mid0/students | t | avg_1 = inter0/students |
| avg_2 = mid1/ students | | avg_2 = inter1/students |
| avg_3 = final/students | | avg_3 = final/students |
| f.write(f'\nAverages: midterm1 {avg_1:.2f}, midterm2 {avg_2:.2f}, final {avg_3:. | | f.write(f'\nAverages: midterm1 {avg_1:.2f}, midterm2 {avg_2:.2f}, final {avg_3:. |
| 2f}\n') | | 2f}\n') |
| f.close | | f.close |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 78
Student ID: 203, P-Value: 8.09e-02
Nearest Neighbor ID: 193
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | list = str(random.randint(0,9)) | n | result = str(random.randint(0,9)) |
| for y in range(4): | | for x in range(4): |
| list += ","+str(random.randint(0,9)) | | result += ','+str(random.randint(0,9)) |
| return listimport csv | | return resultimport csv |
| input_num = input() | | input_given = input() |
| with open(input_num, 'r') as wordsfile: | | with open(input_given, 'r') as wordslife: |
| reader = csv.reader(wordsfile) | | word_reader = csv.reader(wordslife) |
| for row in reader: | | for row in word_reader: |
| list_w = row | | list_of_words = row |
| no_dupes = list(dict.fromkeys(list_w)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| length = len(no_dupes) | | length = len(no_duplicates_in_list) |
| for i in range(length): | | for i in range(length): |
n | print(no_dupes[i], list_w.count(no_dupes[i]))def find_grade(average_grade): | n | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| | | ))def getGrade(averageGrade): |
| if average_grade >= 90: | | if averageGrade >= 90: |
| return 'A' | | return 'A' |
n | elif average_grade >= 80: | n | elif averageGrade >= 80: |
| return 'B' | | return 'B' |
n | elif average_grade >= 70: | n | elif averageGrade >= 70: |
| return 'C' | | return 'C' |
n | elif average_grade >= 60: | n | elif averageGrade >= 60: |
| return 'D' | | return 'D' |
| return 'F' | | return 'F' |
| def main(x): | | def main(x): |
n | file_input = x | n | input_File = x |
| file_output = 'report.txt' | | output_File = 'report.txt' |
| midterm_1, midterm_2, final, mt1_total, mt2_total, final_total, count = 0, 0 | | mid_T1, mid_T2, final, total_MT1, total_MT2, total_Final, count = 0, 0, 0, 0 |
| , 0, 0, 0, 0, 0 | | , 0, 0, 0 |
| infile = open(file_input, 'r') | | infile = open(input_File, 'r') |
| outfile = open(file_output, 'w+') | | outfile = open(output_File, 'w+') |
| for line in infile: | | for line in infile: |
| line = line.strip().split() | | line = line.strip().split() |
n | fname, lname, midterm1, midterm2, final = line[0], line[1], int(line[2]) | n | fname, lname, midT1, midT2, final = line[0], line[1], int(line[2]), int( |
| , int(line[3]), int(line[4]) | | line[3]), int(line[4]) |
| count += 1 | | count += 1 |
n | mt1_total += midterm1 | n | total_MT1 += midT1 |
| mt2_total += midterm2 | | total_MT2 += midT2 |
| final_total += final | | total_Final += final |
| grade = find_grade((midterm1 + midterm2 + final) / 3) | | grade = getGrade((midT1 + midT2 + final) / 3) |
| print(f'{fname}\t{lname}\t{midterm1}\t{midterm2}\t{final}\t{grade}', fil | | print(f'{fname}\t{lname}\t{midT1}\t{midT2}\t{final}\t{grade}', file=outf |
| e=outfile) | | ile) |
| infile.close() | | infile.close() |
t | mt1_total /= count | t | total_MT1 /= count |
| mt2_total /= count | | total_MT2 /= count |
| final_total /= count | | total_Final /= count |
| print(f'\nAverages: midterm1 {mt1_total:.2f}, midterm2 {mt2_total:.2f}, fina | | print(f'\nAverages: midterm1 {total_MT1:.2f}, midterm2 {total_MT2:.2f}, fina |
| l {final_total:.2f}', | | l {total_Final:.2f}', |
| file=outfile) | | file=outfile) |
| outfile.close() | | outfile.close() |
| file = input() | | file = input() |
| main(file) | | main(file) |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 79
Student ID: 183, P-Value: 8.17e-02
Nearest Neighbor ID: 345
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | string= str(random.randint(0,100000)) | n | result = str(random.randint(0,9)) |
| for i in range(4): | | for i in range(4): |
n | string += ","+str(random.randint(0,100000)) | n | result += ","+str(random.randint(0,9)) |
| return stringimport csv | | return resultimport csv |
| fn = input() | | filename = input() |
| f = open(fn) | | f = open(filename) |
| data = csv.reader(f, delimiter=',') | | data = csv.reader(f, delimiter=',') |
n | wd = [] | n | words = [] |
| for r in data: | | for row in data: |
| for word in r: | | for word in row: |
| wd.append(word.strip()) | | words.append(word.strip()) |
| for i in range(len(wd)): | | for i in range(len(words)): |
| if wd[i] not in wd[:i]: | | if words[i] not in words[:i]: |
| count = 0 | | count = 0 |
n | for w in wd: | n | for w in words: |
| if wd[i] == w: | | if words[i] == w: |
| count += 1 | | count += 1 |
n | print(wd[i], count)def determine_grade(avg): | n | print(words[i], count) |
| | | f.close()def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
n | fileName = input() | n | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
n | tmidterm1 = 0 | n | totalM1 = 0 |
| tmidterm2 = 0 | | totalM2 = 0 |
| tfinal = 0 | | totalFinal = 0 |
| c = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
n | tmidterm1 = tmidterm1 + m1 | n | totalM1 = totalM1 + m1 |
| tmidterm2 = tmidterm2 + m2 | | totalM2 = totalM2 + m2 |
| tfinal = tfinal + final | | totalFinal = totalFinal + final |
| c = c + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
n | if(c > 0): | n | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
t | "{0:.2f}".format(tmidterm1 / c) + ", midterm2 " + | t | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(tmidterm2 / c) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(tfinal / c) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| | | print("Done") |
| | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 80
Student ID: 277, P-Value: 8.66e-02
Nearest Neighbor ID: 363
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | num = str(random.randint(0,9)) | n | rnumber = str(random.randint(0,100)) |
| for n in range(4): | | for x in range(0,4): |
| num += ","+str(random.randint(0,9)) | | rnumber += "," + str(random.randint(0,100)) |
| return num | | return rnumber |
| try: | | |
| R = open('randomNums.txt', "w") | | file = open('randomNums.txt','w') |
| line = "" | | |
| for m in range(5): | | for n in range(5): |
| R.write(randomGen()+"\n") | | file.write(randomGen()+'\n') |
| R.close() | | file.close() |
| except Exception: | | |
| print("File not found") | | |
| import csv | | import csv |
n | uinput = input() | n | input1 = input() |
| with open(uinput, 'r') as wordsfile: | | with open(input1, 'r') as wordsfile: |
| word_reader = csv.reader(wordsfile) | | words_reader = csv.reader(wordsfile) |
| for r in word_reader: | | for row in words_reader: |
| wordlist = r | | list_of_words = row |
| noduplicates = list(dict.fromkeys(wordlist)) | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| length = len(noduplicates) | | listlength = len(no_duplicates_in_list) |
| for w in range(length): | | for i in range(listlength): |
| print(noduplicates[w], wordlist.count(noduplicates[w]))from distutils.log im | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| port info | | ))from distutils.log import info |
| def grade(avg): | | def grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
| fileName = input("Enter the filename: ") | | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
n | t1 = 0 | n | totalx1 = 0 |
| t2 = 0 | | totalx2 = 0 |
| t3 = 0 | | totalx3 = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
| for line in enumerate(open(fileName, 'r')): | | for line in enumerate(open(fileName, 'r')): |
| info = line[1].replace("\n", "").split() | | info = line[1].replace("\n", "").split() |
| name1 = info[0] | | name1 = info[0] |
| name2 = info[1] | | name2 = info[1] |
n | n1 = int(info[2]) | n | x1 = int(info[2]) |
| n2 = int(info[3]) | | x2 = int(info[3]) |
| n3 = int(info[4]) | | x3 = int(info[4]) |
| avg = (n1 + n2 + n3) / 3.0 | | avg = (x1 + x2 + x3) / 3.0 |
| gradeofficial = grade(avg) | | gradeofficial = grade(avg) |
n | t1 = t1 + n1 | n | totalx1 = totalx1 + x1 |
| t2 = t2 + n2 | | totalx2 = totalx2 + x2 |
| t3 = t3 + n3 | | totalx3 = totalx3 + x3 |
| count = count + 1 | | count = count + 1 |
n | fileWrite.write(name1 + "\t" + name2 + "\t" + str(n1) + "\t" + | n | fileWrite.write(name1 + "\t" + name2 + "\t" + str(x1) + "\t" + |
| str(n2) + "\t" + str(n3) + "\t" + gradeofficial + "\n") | | str(x2) + "\t" + str(x3) + "\t" + gradeofficial + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
t | "{0:.2f}".format(t1 / count) + ", midterm2 " + | t | "{0:.2f}".format(totalx1 / count) + ", midterm2 " + |
| "{0:.2f}".format(t2 / count) + ", final " + | | "{0:.2f}".format(totalx2 / count) + ", final " + |
| "{0:.2f}".format(t3 / count) + "\n") | | "{0:.2f}".format(totalx3 / count) + "\n") |
| print("Done") | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 81
Student ID: 116, P-Value: 9.08e-02
Nearest Neighbor ID: 355
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
n | | n | try: |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| import csv | | except Exception: |
| from os import read | | print("File not found")import csv |
| filepath = input() | | file = open(input()) |
| csvfile = open(filepath, "r") | | strings = csv.reader(file, delimiter=',') |
| reader = csv.reader(csvfile) | | |
| words = [] | | words = [] |
n | frequencies = [] | n | for row in strings: |
| for row in reader: | | |
| for word in row: | | for word in row: |
n | word = word.strip() | n | |
| if(len(word) == 0): | | |
| continue | | |
| elif(words.count(word) != 0): | | |
| index = words.index(word) | | |
| frequencies[index] += 1 | | |
| else: | | |
| words.append(word) | | words.append(word.strip()) |
| frequencies.append(1) | | |
| for i in range(len(words)): | | for i in range(len(words)): |
n | print(words[i], frequencies[i])fileName=input("Enter Filename: ") | n | if words[i] not in words[:i]: |
| | | count = 0 |
| | | for j in range(len(words)): |
| | | if words[i] == words[j]: |
| | | count += 1 |
| | | print(words[i], count) |
| | | file.close()fileName=input("Enter Filename: ") |
| inputFile=open(fileName,'r') | | inputFile=open(fileName,'r') |
| outputFile=open("report.txt",'w') | | outputFile=open("report.txt",'w') |
| midterm1Total=0 | | midterm1Total=0 |
| midterm2Total=0 | | midterm2Total=0 |
| finalTotal=0 | | finalTotal=0 |
| count=0 | | count=0 |
| while True: | | while True: |
| line=inputFile.readline() | | line=inputFile.readline() |
| if not line: | | if not line: |
| break | | break |
| count+=1 | | count+=1 |
| data=line.split("\t") | | data=line.split("\t") |
| firstname=data[0] | | firstname=data[0] |
| lastname=data[1] | | lastname=data[1] |
| midterm1=(int)(data[2]) | | midterm1=(int)(data[2]) |
| midterm2=(int)(data[3]) | | midterm2=(int)(data[3]) |
| final=(int)(data[4]) | | final=(int)(data[4]) |
| total=midterm1+midterm2+final | | total=midterm1+midterm2+final |
| avg=total/3 | | avg=total/3 |
| if(avg>=90): | | if(avg>=90): |
| grade='A' | | grade='A' |
| elif(avg>=80): | | elif(avg>=80): |
| grade='B' | | grade='B' |
| elif(avg>=70): | | elif(avg>=70): |
| grade='C' | | grade='C' |
| elif(avg>=60): | | elif(avg>=60): |
| grade='D' | | grade='D' |
| else: | | else: |
| grade='F' | | grade='F' |
| midterm1Total+=midterm1 | | midterm1Total+=midterm1 |
| midterm2Total+=midterm2 | | midterm2Total+=midterm2 |
| finalTotal+=final | | finalTotal+=final |
n | outputFile.write(firstname+"\t"+lastname+"\t"+str(midterm1)+"\t"+str(midterm | n | outputFile.write(firstname+"\t"+lastname+"\t"+str(midterm1)+"\t"+str(midterm |
| 2)+"\t"+str(final)+"\t"+grade+"\n") | | 2)+"\t"+str(final)+"\t"+grade+("\n")) |
| print('\t') | | |
| midterm1Total/=count | | midterm1Total/=count |
| midterm2Total/=count | | midterm2Total/=count |
| finalTotal/=count | | finalTotal/=count |
| avgOut="Averages: midterm1 %.2f, midterm2 %.2f, final %.2f"%(midterm1Total,midte | | avgOut="Averages: midterm1 %.2f, midterm2 %.2f, final %.2f"%(midterm1Total,midte |
| rm2Total,finalTotal) | | rm2Total,finalTotal) |
t | outputFile.write(avgOut) | t | outputFile.write(avgOut+'\n') |
| outputFile.close() | | outputFile.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 82
Student ID: 355, P-Value: 9.08e-02
Nearest Neighbor ID: 116
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
| result = str(random.randint(0,9)) | | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
| result += ","+str(random.randint(0,9)) | | result += ","+str(random.randint(0,9)) |
| return result | | return result |
n | try: | n | |
| out = open('randomNums.txt', "w") | | out = open('randomNums.txt', "w") |
| line = "" | | line = "" |
| for i in range(5): | | for i in range(5): |
| out.write(randomGen()+"\n") | | out.write(randomGen()+"\n") |
| out.close() | | out.close() |
| except Exception: | | import csv |
| print("File not found")import csv | | from os import read |
| file = open(input()) | | filepath = input() |
| strings = csv.reader(file, delimiter=',') | | csvfile = open(filepath, "r") |
| | | reader = csv.reader(csvfile) |
| words = [] | | words = [] |
n | for row in strings: | n | frequencies = [] |
| | | for row in reader: |
| for word in row: | | for word in row: |
n | | n | word = word.strip() |
| | | if(len(word) == 0): |
| | | continue |
| | | elif(words.count(word) != 0): |
| | | index = words.index(word) |
| | | frequencies[index] += 1 |
| | | else: |
| words.append(word.strip()) | | words.append(word) |
| | | frequencies.append(1) |
| for i in range(len(words)): | | for i in range(len(words)): |
n | if words[i] not in words[:i]: | n | print(words[i], frequencies[i])fileName=input("Enter Filename: ") |
| count = 0 | | |
| for j in range(len(words)): | | |
| if words[i] == words[j]: | | |
| count += 1 | | |
| print(words[i], count) | | |
| file.close()fileName=input("Enter Filename: ") | | |
| inputFile=open(fileName,'r') | | inputFile=open(fileName,'r') |
| outputFile=open("report.txt",'w') | | outputFile=open("report.txt",'w') |
| midterm1Total=0 | | midterm1Total=0 |
| midterm2Total=0 | | midterm2Total=0 |
| finalTotal=0 | | finalTotal=0 |
| count=0 | | count=0 |
| while True: | | while True: |
| line=inputFile.readline() | | line=inputFile.readline() |
| if not line: | | if not line: |
| break | | break |
| count+=1 | | count+=1 |
| data=line.split("\t") | | data=line.split("\t") |
| firstname=data[0] | | firstname=data[0] |
| lastname=data[1] | | lastname=data[1] |
| midterm1=(int)(data[2]) | | midterm1=(int)(data[2]) |
| midterm2=(int)(data[3]) | | midterm2=(int)(data[3]) |
| final=(int)(data[4]) | | final=(int)(data[4]) |
| total=midterm1+midterm2+final | | total=midterm1+midterm2+final |
| avg=total/3 | | avg=total/3 |
| if(avg>=90): | | if(avg>=90): |
| grade='A' | | grade='A' |
| elif(avg>=80): | | elif(avg>=80): |
| grade='B' | | grade='B' |
| elif(avg>=70): | | elif(avg>=70): |
| grade='C' | | grade='C' |
| elif(avg>=60): | | elif(avg>=60): |
| grade='D' | | grade='D' |
| else: | | else: |
| grade='F' | | grade='F' |
| midterm1Total+=midterm1 | | midterm1Total+=midterm1 |
| midterm2Total+=midterm2 | | midterm2Total+=midterm2 |
| finalTotal+=final | | finalTotal+=final |
n | outputFile.write(firstname+"\t"+lastname+"\t"+str(midterm1)+"\t"+str(midterm | n | outputFile.write(firstname+"\t"+lastname+"\t"+str(midterm1)+"\t"+str(midterm |
| 2)+"\t"+str(final)+"\t"+grade+("\n")) | | 2)+"\t"+str(final)+"\t"+grade+"\n") |
| | | print('\t') |
| midterm1Total/=count | | midterm1Total/=count |
| midterm2Total/=count | | midterm2Total/=count |
| finalTotal/=count | | finalTotal/=count |
| avgOut="Averages: midterm1 %.2f, midterm2 %.2f, final %.2f"%(midterm1Total,midte | | avgOut="Averages: midterm1 %.2f, midterm2 %.2f, final %.2f"%(midterm1Total,midte |
| rm2Total,finalTotal) | | rm2Total,finalTotal) |
t | outputFile.write(avgOut+'\n') | t | outputFile.write(avgOut) |
| outputFile.close() | | outputFile.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 83
Student ID: 151, P-Value: 9.69e-02
Nearest Neighbor ID: 73
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
n | file = open('randomNums.txt', "w") | n | |
| def randomGen(): | | def randomGen(): |
n | r = str(random.randint(0,9)) | n | result = str(random.randint(0,9)) |
| for x in range(4): | | for x in range(4): |
n | r += ","+str(random.randint(0,9)) | n | result += ","+str(random.randint(0,9)) |
| for i in range(5): | | |
| print(r) | | |
| return r | | return result |
| file.write(randomGen()+"\n") | | |
| import csv | | import csv |
n | file = input() | n | file = open(input()) |
| | | strings = csv.reader(file, delimiter=',') |
| words = [] | | words = [] |
n | new_words = [] | n | for row in strings: |
| with open(file, 'r') as csvfile: | | |
| reader = csv.reader(csvfile, delimiter = ',') | | |
| for row in reader: | | |
| for word in row: | | for word in row: |
| words.append(word) | | words.append(word.strip()) |
| for word in words: | | for i in range(len(words)): |
| freq = words.count(word) | | if words[i] not in words[:i]: |
| if word not in new_words: | | count = 0 |
| new_words.append(word) | | for j in range(len(words)): |
| print(word, freq) | | if words[i] == words[j]: |
| | | count += 1 |
| | | print(words[i], count) |
| def determine_grade(avg): | | file.close()def determine_grade(avg): |
| avg = int(avg) | | avg = int(avg) |
| if avg >= 90 and avg <= 100: | | if avg >= 90 and avg <= 100: |
| return 'A' | | return 'A' |
| elif avg >= 80 and avg <= 89: | | elif avg >= 80 and avg <= 89: |
| return 'B' | | return 'B' |
| elif avg >= 70 and avg <= 79: | | elif avg >= 70 and avg <= 79: |
| return 'C' | | return 'C' |
| elif avg >= 60 and avg <= 69: | | elif avg >= 60 and avg <= 69: |
| return 'D' | | return 'D' |
| elif avg <= 60: | | elif avg <= 60: |
| return 'F' | | return 'F' |
n | file_entered = input() | n | fileName = input("Enter the filename: ") |
| outFile = "report.txt" | | outFile = "report.txt" |
n | totalN1 = 0 | n | totalM1 = 0 |
| totalN2 = 0 | | totalM2 = 0 |
| totalF = 0 | | totalFinal = 0 |
| count = 0 | | count = 0 |
| fileWrite = open(outFile, "w") | | fileWrite = open(outFile, "w") |
n | for line in enumerate(open(file_entered, 'r')): | n | for line in enumerate(open(fileName, 'r')): |
| data = line[1].replace("\n", "").split() | | data = line[1].replace("\n", "").split() |
| fName = data[0] | | fName = data[0] |
| lName = data[1] | | lName = data[1] |
| m1 = int(data[2]) | | m1 = int(data[2]) |
| m2 = int(data[3]) | | m2 = int(data[3]) |
| final = int(data[4]) | | final = int(data[4]) |
| avg = (m1 + m2 + final) / 3.0 | | avg = (m1 + m2 + final) / 3.0 |
| grade = determine_grade(avg) | | grade = determine_grade(avg) |
n | totalN1 = totalN1 + m1 | n | totalM1 = totalM1 + m1 |
| totalN2 = totalN2 + m2 | | totalM2 = totalM2 + m2 |
| totalF = totalF + final | | totalFinal = totalFinal + final |
| count = count + 1 | | count = count + 1 |
| fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + | | fileWrite.write(fName + "\t" + lName + "\t" + str(m1) + "\t" + |
| str(m2) + "\t" + str(final) + "\t" + grade + "\n") | | str(m2) + "\t" + str(final) + "\t" + grade + "\n") |
| if(count > 0): | | if(count > 0): |
| fileWrite.write("\nAverages: midterm1 " + | | fileWrite.write("\nAverages: midterm1 " + |
t | "{0:.2f}".format(totalN1 / count) + ", midterm2 " + | t | "{0:.2f}".format(totalM1 / count) + ", midterm2 " + |
| "{0:.2f}".format(totalN2 / count) + ", final " + | | "{0:.2f}".format(totalM2 / count) + ", final " + |
| "{0:.2f}".format(totalF / count) + "\n") | | "{0:.2f}".format(totalFinal / count) + "\n") |
| | | print("Done") |
| fileWrite.close() | | fileWrite.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 84
Student ID: 338, P-Value: 9.13e-01
Nearest Neighbor ID: 320
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | count=0 | n | string = '' |
| mylist=[] | | for i in range(4): |
| mylist1=[] | | string += str(random.randint(0,9)) + ', ' |
| while count<=4: | | string += str(random.randint(0,9)) |
| mylist=(random.randint(1,100)) | | return string |
| mylist1.append(mylist) | | randstring = randomGen() |
| count+=1 | | randstring2 = randomGen() |
| count=0 | | randstring3 = randomGen() |
| mylist2=[] | | e = randomGen() |
| while count<=4: | | g = randomGen() |
| mylist=(random.randint(1,100)) | | |
| mylist2.append(mylist) | | |
| count+=1 | | |
| count=0 | | |
| mylist3=[] | | |
| while count<=4: | | |
| mylist=(random.randint(1,100)) | | |
| mylist3.append(mylist) | | |
| count+=1 | | |
| count=0 | | |
| mylist4=[] | | |
| while count<=4: | | |
| mylist=(random.randint(1,100)) | | |
| mylist4.append(mylist) | | |
| count+=1 | | |
| count=0 | | |
| mylist5=[] | | |
| while count<=4: | | |
| mylist=(random.randint(1,100)) | | |
| mylist5.append(mylist) | | |
| count+=1 | | |
| mylist1s=str(mylist1) | | |
| mylist2s=str(mylist2) | | |
| mylist3s=str(mylist3) | | |
| mylist4s=str(mylist4) | | |
| mylist5s=str(mylist5) | | |
| f = open('randomNums.txt', 'w') | | f = open('randomNums.txt', 'w') |
| f.write(mylist1s.strip("[()]")+'\n') | | f.write(randstring) |
| f.write(mylist2s.strip("[()]")+'\n') | | |
| f.write(mylist3s.strip("[()]")+'\n') | | |
| f.write(mylist4s.strip("[()]")+'\n') | | |
| f.write(mylist5s.strip("[()]")+'\n') | | |
| f.close() | | |
| return mylist1s | | |
| randomGen()import csv | | |
| csv_file = input() | | |
| with open(csv_file, 'r') as csvfile: | | |
| csv_reader = csv.reader(csvfile, delimiter=',') | | |
| for row in csv_reader: | | |
| def Convert(row): | | |
| j=1 | | |
| res_dct = {row[i]: j for i in range(len(row))} | | |
| return res_dct | | |
| Convert(row) | | |
| thelist=list(row) | | |
| def total(thelist): | | |
| num = {} | | |
| for thing in thelist: | | |
| if (thing in num): | | |
| num[thing] += 1 | | |
| else: | | |
| num[thing] = 1 | | |
| for z in num : | | |
| print(z, num[z]) | | |
| total(thelist) | | |
| tsv_file = input() | | |
| import csv | | |
| f=open('report.txt', 'w') | | |
| f.write('') | | f.write('\n') |
| | | f.write(randstring2) |
| | | f.write('\n') |
| | | f.write(randstring3) |
| | | f.write('\n') |
| | | f.write(e) |
| | | f.write('\n') |
| | | f.write(g) |
| f.close() | | f.close() |
n | count=0 | n | h = open('randomNums.txt', 'r') |
| midterm1tot=0 | | contents = h.read() |
| midterm2tot=0 | | print(contents) |
| finaltot=0 | | f.close()import csv |
| | | word_dict = {} |
| | | test_list = [] |
| | | file_name = input() |
| with open(tsv_file, 'r') as csvfile: | | with open(file_name, 'r') as csvfile: |
| | | csvreader = csv.reader(csvfile) |
| | | for row in csvreader: |
| | | test_list += row |
| | | for item in test_list: |
| | | word_dict[item] = test_list.count(item) |
| | | for word in word_dict: |
| | | print(f'{word} {word_dict[word]}')import csv |
| | | row_count = 0 |
| | | midterm1_avg = 0 |
| | | midterm2_avg = 0 |
| | | final_avg = 0 |
| | | iteration_count = 0 |
| | | grade_list = [] |
| | | file_name = input() |
| | | with open(file_name, 'r') as tsvfile: |
| grades_reader = csv.reader(csvfile, delimiter=',') | | grades_reader = csv.reader(tsvfile, delimiter='\t') |
| for row in grades_reader: | | for row in grades_reader: |
t | mystring=str(row) | t | row_count += 1 |
| csvlist=list(mystring.split('\\t')) | | midterm1_avg += int(row[2]) |
| csv1=str(csvlist[0]) | | midterm2_avg += int(row[3]) |
| cvs4=str(csvlist[4]) | | final_avg += int(row[4]) |
| csv1s=csv1.strip("['") | | grade = (int(row[2])+int(row[3])+int(row[4]))/3 |
| cvs4s=cvs4.strip("']") | | |
| newlist1=[] | | |
| newlist1.append(csv1s) | | |
| newlist1.append(csvlist[1]) | | |
| newlist1.append(int(csvlist[2])) | | |
| newlist1.append(int(csvlist[3])) | | |
| newlist1.append(int(cvs4s)) | | |
| numgrade=((newlist1[2]+newlist1[3]+newlist1[4])/(3)) | | |
| if numgrade>=90: | | if grade >= 90: |
| numgrade='A' | | grade_letter = 'A' |
| elif numgrade>=80: | | elif grade < 90 and grade >= 80: |
| numgrade='B' | | grade_letter = 'B' |
| elif numgrade>=70: | | elif grade < 80 and grade >= 70: |
| numgrade='C' | | grade_letter = 'C' |
| elif numgrade>=60: | | elif grade < 70 and grade >= 60: |
| numgrade='D' | | grade_letter = 'D' |
| elif numgrade<60: | | else: |
| numgrade='F' | | grade_letter = 'F' |
| newlist1.append(numgrade) | | row.append(grade_letter) |
| count+=1 | | grade_list.append(row[0]) |
| midterm1tot=newlist1[2]+midterm1tot | | grade_list.append(row[1]) |
| midterm2tot=newlist1[3]+midterm2tot | | grade_list.append(row[2]) |
| finaltot=newlist1[4]+finaltot | | grade_list.append(row[3]) |
| newstring1=str(f'{newlist1[0]}\t{newlist1[1]}\t{newlist1[2]}\t{newlist1[ | | grade_list.append(row[4]) |
| 3]}\t{newlist1[4]}\t{newlist1[5]}') | | |
| print(newstring1) | | grade_list.append(row[5]) |
| f=open('report.txt', 'a+') | | midterm1_avg /= row_count |
| f.write(newstring1) | | midterm2_avg /= row_count |
| f.write('\n') | | final_avg /= row_count |
| f.close() | | |
| midterm1=midterm1tot/count | | |
| midterm2=midterm2tot/count | | |
| final=finaltot/count | | |
| print('\n') | | |
| print(f'Averages: midterm1 {midterm1:.2f}, midterm2 {midterm2:.2f}, final {f | | |
| inal:.2f}') | | |
| avgline=(f'Averages: midterm1 {midterm1:.2f}, midterm2 {midterm2:.2f}, final | | |
| {final:.2f}') | | |
| f=open('report.txt', 'a') | | final_file = open('report.txt', 'w') |
| | | for word in grade_list: |
| | | final_file.write(word) |
| | | iteration_count +=1 |
| | | if iteration_count == 6: |
| | | final_file.write('\n') |
| | | iteration_count = 0 |
| | | else: |
| | | final_file.write('\t') |
| | | midterm1_avg = "{:.2f}".format(midterm1_avg) |
| | | midterm2_avg = "{:.2f}".format(midterm2_avg) |
| | | final_avg = "{:.2f}".format(final_avg) |
| f.write('\n') | | final_file.write('\n') |
| f.write(avgline) | | final_file.write(f'Averages: midterm1 {midterm1_avg}, midterm2 {midterm2_avg |
| | | }, final {final_avg}') |
| f.write('\n') | | final_file.write('\n') |
| f.close() | | final_file.close() |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|
Page 85
Student ID: 55, P-Value: 8.97e-01
Nearest Neighbor ID: 152
Student (left) and Nearest Neighbor (right).
f | import random | f | import random |
| def randomGen(): | | def randomGen(): |
n | randomList = [] | n | result = str(random.randint(0,9)) |
| randomStr = "" | | for x in range(4): |
| | | result += ","+str(random.randint(0,9)) |
| | | return result |
| | | try: |
| | | out = open('randomNums.txt', "w") |
| | | line = "" |
| for x in range(5): | | for i in range(5): |
| value = str(random.randint(0,9)) | | out.write(randomGen()+"\n") |
| randomList.append(value) | | out.close() |
| randomStr = ','.join(randomList) | | except Exception: |
| return randomStr | | print("File not found") import csv |
| if __name__ == "__main__": | | input1 = input() |
| output = randomGen() | | with open(input1, 'r') as wordsfile: |
| file = open('randomNums.txt','w') | | words_reader = csv.reader(wordsfile) |
| for number in range(0,len(output),2): | | for row in words_reader: |
| file.write(output[number]) | | list_of_words = row |
| file.close()import csv | | no_duplicates_in_list = list(dict.fromkeys(list_of_words)) |
| | | listlength = len(no_duplicates_in_list) |
| | | for i in range(listlength): |
| | | print(no_duplicates_in_list[i], list_of_words.count(no_duplicates_in_list[i] |
| | | ))import csv |
| fileInput = input() | | file_input = input() |
| with open(fileInput, newline='') as csvfile: | | with open(file_input, 'r') as csvfile: |
| occurDict = {} | | |
| myList = None | | |
| file = csv.reader(csvfile, delimiter=' ', quotechar='|') | | reader = csv.reader(csvfile, delimiter='\t') |
| | | students = [] |
| | | totals = [0,0,0] |
| for row in file: | | for row in reader: |
| myList = ','.join(row) | | final_grade = (int(row[2])+int(row[3])+int(row[4]))/3 |
| myList = myList.split(',') | | if final_grade >= 90: |
| for x in myList: | | final_letter = "A" |
| if x not in occurDict: | | elif final_grade >= 80: |
| occurDict[str(x)] = 1 | | final_letter = "B" |
| | | elif final_grade >= 70: |
| | | final_letter = "C" |
| | | elif final_grade >= 60: |
| | | final_letter = "D" |
| else: | | else: |
t | occurDict[str(x)] = occurDict.get(str(x))+1 | t | final_letter = "F" |
| for key,value in occurDict.items(): | | row.append(final_letter) |
| print(key, value) | | totals[0] += int(row[2]) |
| import csv | | totals[1] += int(row[3]) |
| userInputFile = input() | | totals[2] += int(row[4]) |
| gradingDict = { | | students.append(row) |
| "A": range(90,101), | | averages = [i/len(students) for i in totals] |
| "B":range(80,90), | | |
| "C":range(70,80), | | |
| "D":range(60,70), | | |
| "F":range(0,60) | | |
| } | | |
| studentGrades = {} | | |
| inputFile = open(userInputFile) | | |
| file = csv.reader(inputFile, delimiter="\t") | | |
| for row in file: | | |
| key = f'{row[0]}\t{row[1]}' | | |
| value = [] | | |
| lower = row.index(row[2]) | | |
| upper = row.index(row[-1]) | | |
| for grade in range(lower,upper+1): | | |
| value.append(row[grade]) | | |
| studentGrades[key] = value | | |
| inputFile.close() | | |
| totalPoints = 0 | | |
| averages = list() | | |
| for key,value in studentGrades.items(): | | |
| totalPoints += int(value[0]) | | |
| averages.append(totalPoints/len(studentGrades)) | | |
| totalPoints = 0 | | |
| for key,value in studentGrades.items(): | | |
| totalPoints += int(value[1]) | | |
| averages.append(totalPoints/len(studentGrades)) | | |
| totalPoints = 0 | | |
| for key,value in studentGrades.items(): | | |
| totalPoints += int(value[2]) | | |
| averages.append(totalPoints/len(studentGrades)) | | |
| print(averages) | | |
| for person,value in studentGrades.items(): | | |
| average = int() | | |
| for grade in value: | | |
| average += int(grade) | | |
| average /= len(value) | | |
| average = int(average) | | |
| for letter in gradingDict: | | |
| if average in gradingDict.get(letter): | | |
| value += letter | | |
| outputFile = open("report.txt","w") | | f = open("report.txt","w") |
| for key,value in studentGrades.items(): | | for i in students: |
| values = '\t'.join(value) | | f.write("\t".join(i)+"\n") |
| outputFile.write(f'{key}\t{values}') | | |
| outputFile.write('\n') | | |
| outputFile.write('\n') | | |
| outputFile.write(f'Averages: midterm1 {averages[0]:.2f}, midterm2 {averages[1]:. | | f.write(f"\nAverages: midterm1 {averages[0]:.2f}, midterm2 {averages[1]:.2f} |
| 2f}, final {averages[2]:.2f}\n') | | , final {averages[2]:.2f}\n") |
Legends |
Colors |
Added |
Changed |
Deleted |
|
Links |
(f)irst change |
(n)ext change |
(t)op |
|