2279 - Concurs Perf - Revision history

Paul Ungur at 17:52, 15 May 2023

2023-05-15T17:52:22Z

← Older revision		Revision as of 17:52, 15 May 2023
Line 90:		Line 90:
	print("nu")		print("nu")
	</syntaxhighlight>		</syntaxhighlight>
			==Explicatie cod:==
			validare(num_teste, nr_probleme, punctaj_maxim, probleme): Această funcție primește ca parametri numărul de teste (num_teste), numărul de probleme (nr_probleme), punctajul maxim (punctaj_maxim) și o listă de punctaje pentru fiecare problemă (probleme). Scopul funcției este de a valida datele de intrare pentru un set de teste. Verificările includ asigurarea că numărul de teste, numărul de probleme și punctajul maxim sunt mai mari decât zero și că lungimea listei probleme este egală cu numărul de probleme. De asemenea, se verifică ca fiecare punctaj să fie cuprins între 1 și punctajul maxim inclusiv. Funcția returnează True dacă datele de intrare sunt valide și False în caz contrar.
			citeste_input(): Această funcție nu primește niciun argument. Scopul ei este să citească datele de intrare și să construiască o listă de teste. Întâi se citește numărul total de teste (num_teste). Apoi, pentru fiecare test, se citește numărul de probleme (nr_probleme), punctajul maxim (punctaj_maxim) și lista de punctaje pentru fiecare problemă (probleme). După fiecare citire, se validează datele apelând funcția validare() și se verifică dacă rezultatul validării este False. Dacă datele de intrare sunt invalide, funcția returnează None. În caz contrar, se adaugă un tuplu format din numărul de probleme, punctajul maxim și lista de punctaje în lista test_cases. La final, funcția returnează lista de teste test_cases.
			este_balansata(nr_probleme, punctaj_maxim, probleme): Această funcție primește numărul de probleme (nr_probleme), punctajul maxim (punctaj_maxim) și lista de punctaje pentru fiecare problemă (probleme) pentru un test specific. Scopul funcției este de a determina dacă distribuția punctajelor este echilibrată în funcție de cerințele urmărite. Se parcurge lista de punctaje și se numără de câte ori un punctaj este mai mare decât jumătate din punctajul maxim (usor) și de câte ori este mai mic sau egal cu un zecime din punctajul maxim (greu). Funcția returnează True dacă există exact o problemă ușoară (cu punctaj mai mare decât jumătate din punctajul maxim) și exact două probleme grele (cu punctaj mai mic sau egal cu un zecime din punctajul maxim). În caz contrar, funcția returnează False.

Paul Ungur at 16:22, 26 April 2023

2023-04-26T16:22:20Z

← Older revision		Revision as of 16:22, 26 April 2023
Line 46:		Line 46:
	==Rezolvare==		==Rezolvare==
	<syntaxhighlight lang="python" line>		<syntaxhighlight lang="python" line>
	def ~~validate~~(t, n, p, ~~problems~~):		def validare(num_teste, nr_probleme, punctaj_maxim, probleme):
	if t <= 0 or n <= 0 or p <= 0:		if num_teste <= 0 or nr_probleme <= 0 or punctaj_maxim <= 0:
	return False		return False
	if len(~~problems~~) != n:		if len(probleme) != nr_probleme:
	return False		return False
	if not all(1 <= x <= p for x in ~~problems~~):		if not all(1 <= x <= punctaj_maxim for x in probleme):
	return False		return False
	return True		return True

	def ~~read_input~~():
	t = int(input())		def citeste_input():
			num_teste = int(input())
	test_cases = []		test_cases = []
	for i in range(t):		for i in range(num_teste):
	n, p = map(int, input().split())		nr_probleme, punctaj_maxim = map(int, input().split())
	~~problems~~ = list(map(int, input().split()))		probleme = list(map(int, input().split()))
	if not ~~validate~~(t, n, p, ~~problems~~):		if not validare(i+1, nr_probleme, punctaj_maxim, probleme):
	return None		return None
	test_cases.append((n, p, ~~problems~~))		test_cases.append((nr_probleme, punctaj_maxim, probleme))
	return test_cases		return test_cases

	~~def is_balanced(n, p, problems):~~
	~~easy = 0~~
	~~hard = 0~~
	~~for i in range(n):~~
	~~if problems[i] > p // 2:~~
	~~easy += 1~~
	~~elif problems[i] <= p // 10:~~
	~~hard += 1~~
	~~return easy == 1 and hard == 2~~

	def ~~main~~():		def este_balansata(nr_probleme, punctaj_maxim, probleme):
	~~test_cases~~ = ~~read_input~~()		usor = 0
	if ~~test_cases~~ is None:		greu = 0
	print("~~Invalid input~~")		for i in range(nr_probleme):
	~~return~~		if probleme[i] > punctaj_maxim // 2:
	for ~~case~~ in ~~test_cases~~:		usor += 1
	n, p, ~~problems~~ = ~~case~~		elif probleme[i] <= punctaj_maxim // 10:
	if ~~is_balanced~~(n, p, ~~problems~~):		greu += 1
			return usor == 1 and greu == 2


			if __name__ == '__main__':
			teste = citeste_input()
			if teste is None:
			print("Input invalid")
			for test in teste:
			nr_probleme, punctaj_maxim, probleme = test
			if este_balansata(nr_probleme, punctaj_maxim, probleme):
	print("da")		print("da")
	else:		else:
	print("nu")		print("nu")

	~~if __name__ == '__main__':~~
	~~main()~~
	</syntaxhighlight>		</syntaxhighlight>

	~~==Explicatie==~~
	~~În funcția validate, verificăm dacă datele de intrare sunt valide, adică dacă numerele sunt în intervalul specificat și dacă lista problemelor are dimensiunea corectă.~~

	~~În funcția read_input, citim datele de intrare pentru fiecare caz de testare și le validăm folosind funcția validate.~~

	~~În funcția is_balanced, verificăm dacă un anumit caz de testare respectă condițiile problemei, adică dacă există o singură problemă ușoară și două probleme grele.~~

	~~În funcția main, citim datele de intrare pentru fiecare caz de testare și le procesăm folosind funcția is_balanced.~~

Paul Ungur: Pagină nouă: ==Cerința== Chef vrea să organizeze un concurs. Previziunea nivelurilor de dificultate a problemelor poate fi o sarcină descurajantă. Chef vrea să echilibreze nivelurile de dificultate ale problemelor. Să presupunem că un concurs a avut P participanți în total. O problemă care a fost rezolvată de cel puțin jumătate dintre participanți (adică P/2) este...

2023-04-22T10:21:59Z

Pagină nouă: ==Cerința== Chef vrea să organizeze un concurs. Previziunea nivelurilor de dificultate a problemelor poate fi o sarcină descurajantă. Chef vrea să echilibreze nivelurile de dificultate ale problemelor. Să presupunem că un concurs a avut P participanți în total. O problemă care a fost rezolvată de cel puțin jumătate dintre participanți (adică P/2) este...

New page

==Cerința==
Chef vrea să organizeze un concurs. Previziunea nivelurilor de dificultate a problemelor poate fi o sarcină descurajantă. Chef vrea să echilibreze nivelurile de dificultate ale problemelor.

Să presupunem că un concurs a avut P participanți în total. O problemă care a fost rezolvată de cel puțin jumătate dintre participanți (adică P/2) este considerată ușoară. O problemă rezolvată de participanții de cel mult P/10 este considerată dificilă.

Chef vrea echilibru. Potrivit lui, un concurs echilibrat trebuie să aibă exact 1 problemă ușoară și exact 2 probleme grele. Vi se oferă descrierea problemelor N și numărul de participanți care rezolvă aceste probleme. Puteți spune dacă concursul a fost echilibrat sau nu?

==Date de intrare==
Primul rând conține un număr întreg T care indică numărul de cazuri de testare.
Prima linie a fiecărui caz de testat conține două numere întregi N și P indicând numărul de probleme, respectiv numărul de participanți.
Cea de-a doua linie conține N numere întregi, separate prin spațiu, al căror număr indică numărul de participanți care rezolvă problema cu numărul de ordine i.

==Date de ieșire==
Pentru fiecare caz, afișati da, dacă concursul este echilibrat, sau nu.

==Restricții și precizări==
 1 ≤ T, N ≤ 500
1 ≤ P ≤ 10^8^
1 ≤ numărul de participanți care rezolvă o problemă ≤ P

==Exemplu:==
Intrare
6
3 100
10 1 100
3 100
11 1 100
3 100
10 1 10
3 100
10 1 50
4 100
50 50 50 50
4 100
1 1 1 1

Ieșire
da
nu
nu
da
nu
nu

==Rezolvare==
<syntaxhighlight lang="python" line>
def validate(t, n, p, problems):
if t <= 0 or n <= 0 or p <= 0:
return False
if len(problems) != n:
return False
if not all(1 <= x <= p for x in problems):
return False
return True

def read_input():
t = int(input())
test_cases = []
for i in range(t):
n, p = map(int, input().split())
problems = list(map(int, input().split()))
if not validate(t, n, p, problems):
return None
test_cases.append((n, p, problems))
return test_cases

def is_balanced(n, p, problems):
easy = 0
hard = 0
for i in range(n):
if problems[i] > p // 2:
easy += 1
elif problems[i] <= p // 10:
hard += 1
return easy == 1 and hard == 2

def main():
test_cases = read_input()
if test_cases is None:
print("Invalid input")
return
for case in test_cases:
n, p, problems = case
if is_balanced(n, p, problems):
print("da")
else:
print("nu")

if __name__ == '__main__':
main()
</syntaxhighlight>

==Explicatie==
În funcția validate, verificăm dacă datele de intrare sunt valide, adică dacă numerele sunt în intervalul specificat și dacă lista problemelor are dimensiunea corectă.

În funcția read_input, citim datele de intrare pentru fiecare caz de testare și le validăm folosind funcția validate.

În funcția is_balanced, verificăm dacă un anumit caz de testare respectă condițiile problemei, adică dacă există o singură problemă ușoară și două probleme grele.

În funcția main, citim datele de intrare pentru fiecare caz de testare și le procesăm folosind funcția is_balanced.