Cheating Detection Docs

cheating_detection_docs.md

primero definí las variables players, questios, y un array vacío para answers

def  cheating_detection():
	players =  100
	questions =  10000
	answers =  []

luego de eso hice un for en el rango de 0 a 100 (no inclusivo), para poder capturar la entrada por cada player

for player in  range(players):
	answers +=  list(map(int,  (input().strip())))
	questions_right_answers =  []

Hice un for en el que quería averiguar cuantas respuestas correctas tiene cada pregunta. El for fue en el rango de 0 a 10,000(no inclusivo).

Dentro del for definí una variable question_index para poder saltar de 10,000 en 10,000 y sumar las respuestas de la misma pregunta.

También definí una variable llamada correct_answers para sumar el numero de respuestas correctas

Dentro del for escribí otro for, este recorré desde 0 hasta 100(no inclusivo), esto lo hice para poder sumar las respuestás en el rango de los players existentes.

Verifiqué que la respuesta fuese 1, si lo era se sumaría a la variable correct_answers

Luego de eso, se añadiría el número de respuestas por cada player a una lista definida por fuera del for, llamada questions_right_answers

questions_right_answers =  []
for question in  range(questions):
	question_index = question +  1
	sum_correct_answers =  0

	for player in  range(players):
		if answers[question_index -  1]  ==  1:
			sum_correct_answers +=  1
		question_index += questions
	  
	questions_right_answers.append(correct_answers)

Luego de esto hice algo bastante similar con los players para conseguir cuantas preguntas habían respondido correctamente.

Definí una variable llamada players_right_answers, en la que se guardará el número de respuestas correctas por cada player.

Definí una variable llamada player_index para poder recorrer solamente las 10,000 preguntas de cada player.

Establecí un for en el rango de 1 a 100(no inclusivo), dentro de este creé una varible llamada correct_answers, en esta variable se sumaba las respues de cada player. Luego guardé el número de respuestas correctas en la lista player_right_answers. Por último añadí uno al player_index

players_right_answers =  []
player_index =  0
for player in  range(players):
	correct_answers =  sum(
	answers[player_index:  (player_index)  + questions])
	players_right_answers.append(correct_answers)
	player_index += questions

Creé una lista llamada questions_difficulty. Luego creé un for en el rango del número de questions. Por definir la dificultad de cada pregunta usé la siguiente formula:

(questions_right_answers * (-6.00)) / players) + 3.00)

Luego de evaluar la dificultad de cada pregunta la añadí a la lista questions_difficulty.

questions_difficulty =  []
for question in  range(questions):
	difficulty =  round(
	(((questions_right_answers[question]  *  (-6.00))  / players)  +  3.00),  2)
	questions_difficulty.append(difficulty)

Para calcular la habilidad de cada player hice casi lo mismo pero con un pequeño cambio en la formula:

(players_right_answers * 6.00) / questions) - 3.00)

players_skill =  []
for player in  range(players):
	skill =  round(
		(((players_right_answers[player]  *  6.00)  / questions)  -  3.00),  2)
	players_skill.append(skill)

Ahora necesitaba encontrar las preguntas más difíciles, para ello creé una lista llamada extreme_question, luego hice un for que recorriera todas las preguntas, dentro del for hice un if que verificara si la pregunta tenía una dificultad de mas de 2.0, y en caso de que fuese así guardaría el índice de exta pregunta en la lista extreme_questions

extreme_questions =  []
for question in  range(questions):
	if questions_difficulty[question]  >  2.0:
		extreme_questions.append(question)

Luego de tener las preguntas más difíciles y la habilidad del jugador, pensé en calcular cuantas preguntas más difíciles tenía la probabilidad de responder cada jugador según su habilidad, luego de eso obtener cuantas preguntas difíciles había respondido. Luego podía restar la cantidad de preguntas difíciles posibles menos la cantidad de preguntas dificiles respondidas, esto nos daría una diferencia de cada jugador con respecto a sí mismo, y el que tuviese una mayor diferencia sería el tramposo. Esto lo hice de la siguiente manera:

Creé una variable llamada question_per_player que me permitiría recorrer las preguntas por cada player.

Creé una lista llamada players_difference, en la que almacenaría la diferencia de cada uno de los players.

creé las variables difference, question_difficulty, player_skill

calculé la probabilidad de respuestas dificiles de cada player, luego lo almacené en una variable llamada probability_of_right_answer. Lo hice con la siguiente formula:

1/(1 + 2.718 ^ -(player_skill - question_difficulty)) (Sigmoid)

Luego de eso calculé la posible cantidad de respuestas correctas por jugador multiplicando la probabilidad por el umero de respuestas extremas. Recuerda que la probabilidad es el porcentaje de respuestás que podría responder, por eso lo multiplicamos con el número de preguntas.

Luego en un for, por cada pregunta difícil revisamos si el player la respondió bien, si fué así, sumamos 1 a player_right_extreme_answers.

Luego de esto calculamos la diferencia restando el número de respuestas correctas de player menos la cantidad de posibles respuestas. Añadimos la diferencia a la lista players_difference.

Sumamos la cantidad de preguntas a question_per_player, para pasar al set de preguntas del otro player.

question_per_player =  0
players_difference =  []
for player in  range(players):
	difference =  0
	question_difficulty =  2.0
	player_skill = players_skill[player]
	probability_of_right_answer =  round(
	1/(1  +  2.718  **  -(player_skill - question_difficulty)),  2)
	  
	quantity_of_extreme_questions =  len(extreme_questions)
	quantity_of_player_posible_right_extreme_answers = quantity_of_extreme_questions * probability_of_right_answer
	player_right_extreme_answers =  0

	for answer in  range(len(extreme_questions)):
		player_answer = answers[int(extreme_questions[answer])  + question_per_player]

		if player_answer ==  1:
		player_right_extreme_answers +=  1 

	difference = player_right_extreme_answers - quantity_of_player_posible_right_extreme_answers
	players_difference.append(difference)
	question_per_player += questions

Como dijimos que el cheater iba a ser el que tuviese la mayor diferencia buscamos eso con el método max, lo ponemos dentro del método index para coseguirlo y sumamos uno. Esto lo guardamos en una variable llamada cheater y la retornamos.

cheater = players_difference.index(max(players_difference))  +  1
return(cheater)

Por último creamos nuestro punto de entrada. Primero pedimos nuestros test_cases, luego p que sería el nivel de accuracy que necesitamos para pasarl el test_case, y creamos un for que por cada test_case invoque nuestra función cheating_detection y devuelva el output.

if __name__ ==  '__main__':
	test_cases =  int(input())
	p =  int(input())
	for test_case in  range(1, test_cases +  1):
		print(f"Case #{test_case}: {cheating_detection()}")