0523 - SecvEgale - Revision history

Flaviu at 19:35, 14 May 2023

2023-05-14T19:35:53Z

← Older revision		Revision as of 19:35, 14 May 2023
Line 18:		Line 18:
	; Ieșire		; Ieșire
	: Datele nu corespund restricțiilor impuse.		: Datele nu corespund restricțiilor impuse.
	~~: 7 10~~

	== Rezolvare ==		== Rezolvare ==
Line 25:		Line 25:
	# 0523 - SecvEgale		# 0523 - SecvEgale

	def ~~longest_equal_sequence~~(n, v):		def validare(n, v):
	~~max_len = 1~~
	~~max_pos = n - 1~~
	~~curr_len = 1~~

	~~for i in range(1, n):~~
	~~if v[i] == v[i-1]:~~
	~~curr_len += 1~~
	~~if curr_len > max_len:~~
	~~max_len = curr_len~~
	~~max_pos = i~~
	~~else:~~
	~~curr_len = 1~~

	~~return max_pos - max_len + 2, max_pos + 1~~

	~~def main():~~
	~~n = int(input())~~
	if n < 1 or n > 1000:		if n < 1 or n > 1000:
	~~print("Datele nu corespund restricțiilor impuse.")~~		return False
	return

	~~v = list(map(int, input().split()))~~
	for x in v:		for x in v:
	if x < 0 or x >= 1000:		if x < 0 or x >= 1000:
	~~print("Datele nu corespund restricțiilor impuse.")~~		return False
	return		return True

	~~start, end = longest_equal_sequence~~(n, v)
	~~print~~("Datele ~~sunt introduse corect~~.")		def rezolvare(n, v):
	~~print(end - start)~~		if not validare(n, v):
			return "Datele nu corespund restricțiilor impuse."

			maxim = 1
			poz = n - 1
			for i in range(n - 1, 0, -1):
			lungime = 1
			while i > 0 and v[i] == v[i - 1]:
			lungime += 1
			i -= 1
			if lungime > maxim:
			maxim = lungime
			poz = i

			return maxim

	~~</syntaxhighlight>~~
	~~== Explicație rezolvare==~~

	~~În funcția main se citește numărul de elemente din vector și apoi vectorul însuși~~, ~~apoi se apelează funcția find_longest_sequence cu vectorul ca argument~~.		if __name__ == "__main__":
			n = int(input())
			v = list(map(int, input().split()))

	~~Funcția find_longest_sequence primește un vector și determină cea mai lungă secvență de elemente egale. În primul rând~~, ~~se initializează o variabilă current_count cu 1 și o variabilă max_count cu 1~~, ~~pentru a contoriza câte elemente consecutive egale avem în momentul de față și, respectiv, câte elemente egale consecutive~~ sunt în cea mai lungă secvență găsită până acum. De asemenea, se initializează o variabilă last_index cu -1 pentru a reține ultimul index la care am întâlnit o secvență de elemente egale de lungime maximă.		rez = rezolvare(n, v)
			if isinstance(rez, str):
			print(rez)
			else:
			print("Datele sunt introduse corect.")
			print(rez)

	În continuare, se parcurge vectorul cu un for și se compară fiecare element cu elementul anterior, dacă sunt egale, incrementăm current_count, altfel resetăm current_count la 1. Dacă current_count este mai mare sau egal decât max_count, actualizăm valoarea lui max_count și reținem indexul curent în last_index.		</syntaxhighlight>
			== Explicație rezolvare==

	~~La final~~, ~~returnăm valoarea lui max_count~~ și ~~last_index~~. ~~Aceste valori sunt apoi afișate în~~ funcția ~~main,~~ dacă datele de intrare sunt corecte, ~~altfel~~ se ~~afișează~~ mesajul ~~"Datele nu corespund restricțiilor impuse~~."		Funcția validare primește numărul de elemente n și vectorul v și returnează True dacă acestea corespund restricțiilor impuse și False în caz contrar. Mai precis, verifică dacă n este între 1 și 1000 și dacă toate elementele din v sunt numere naturale mai mici decât 1000.
			Funcția rezolvare primește numărul de elemente n și vectorul v și returnează lungimea celei mai lungi secvențe de elemente egale din vector. Mai precis, parcurge vectorul de la dreapta la stânga și pentru fiecare element verifică cât de lungă este secvența de elemente egale care începe cu el. Dacă lungimea acestei secvențe este mai mare decât lungimea celei mai lungi secvențe găsite până acum, atunci actualizează variabila maxim și variabila poz care reține poziția primei apariții a celei mai lungi secvențe de elemente egale.
			În funcția rezolvare se folosește și funcția validare pentru a verifica dacă datele de intrare sunt corecte.
			În funcția rezolvare se consideră că dacă în vector există mai multe secvențe de elemente egale de lungime maximă, atunci se determină cea mai din dreapta.
			În funcția rezolvare se folosește funcția isinstance pentru a verifica dacă rezultatul este un șir de caractere (adică mesajul de eroare) sau un număr (adică lungimea celei mai lungi secvențe de elemente egale).
			Citirea datelor de intrare și afișarea rezultatului se fac în funcția main.

Flaviu at 20:58, 13 May 2023

2023-05-13T20:58:34Z

← Older revision		Revision as of 20:58, 13 May 2023
Line 25:		Line 25:
	# 0523 - SecvEgale		# 0523 - SecvEgale

	def ~~validare~~(v):		def longest_equal_sequence(n, v):
	~~return len~~(~~v) > 0 and all(isinstance(x~~, ~~int~~) ~~for x in~~ v)		max_len = 1
			max_pos = n - 1
			curr_len = 1

			for i in range(1, n):
			if v[i] == v[i-1]:
			curr_len += 1
			if curr_len > max_len:
			max_len = curr_len
			max_pos = i
			else:
			curr_len = 1

			return max_pos - max_len + 2, max_pos + 1

	def ~~citire_date~~():		def main():
	~~try:~~		n = int(input())
	n = int(input(~~"Introduceti lungimea vectorului: "~~))		if n < 1 or n > 1000:
	~~v = []~~		print("Datele nu corespund restricțiilor impuse.")
	~~for i in range~~(n):		return
	v~~.append~~(int(input(~~"Introduceti elementul " + str~~(~~i + 1) + " al vectorului: "~~)))
	~~if validare(~~v):		v = list(map(int, input().split()))
	~~print("Datele sunt introduse corect.")~~		for x in v:
	~~return v~~		if x < 0 or x >= 1000:
	~~else~~:
	print("Datele nu corespund restricțiilor impuse.")		print("Datele nu corespund restricțiilor impuse.")
	return ~~None~~		return
	~~except ValueError:~~
	print("Datele ~~nu corespund formatului așteptat~~.")		start, end = longest_equal_sequence(n, v)
	~~return None~~		print("Datele sunt introduse corect.")
			print(end - start)


	~~def rezolvare(v):~~
	~~st, dr = 0, 0~~
	~~max_lungime = 0~~
	~~i = 0~~
	~~while i < len(v):~~
	~~j = i + 1~~
	~~while j < len(v) and v[j] == v[i]:~~
	~~j += 1~~
	~~lungime = j - i~~
	~~if lungime >= max_lungime:~~
	~~max_lungime = lungime~~
	~~st, dr = i, j - 1~~
	~~i = j~~
	~~return st, dr~~

			</syntaxhighlight>
			== Explicație rezolvare==

	~~if __name__ == "__main__":~~		În funcția main se citește numărul de elemente din vector și apoi vectorul însuși, apoi se apelează funcția find_longest_sequence cu vectorul ca argument.
	~~v = citire_date()~~
	~~if v is not None:~~
	~~st, dr = rezolvare(v)~~
	~~print(f"Perechea cu cea mai mare lungime~~ de elemente ~~egale: ({st + 1}~~, ~~{dr + 1})")~~

			Funcția find_longest_sequence primește un vector și determină cea mai lungă secvență de elemente egale. În primul rând, se initializează o variabilă current_count cu 1 și o variabilă max_count cu 1, pentru a contoriza câte elemente consecutive egale avem în momentul de față și, respectiv, câte elemente egale consecutive sunt în cea mai lungă secvență găsită până acum. De asemenea, se initializează o variabilă last_index cu -1 pentru a reține ultimul index la care am întâlnit o secvență de elemente egale de lungime maximă.

	~~</syntaxhighlight>~~		În continuare, se parcurge vectorul cu un for și se compară fiecare element cu elementul anterior, dacă sunt egale, incrementăm current_count, altfel resetăm current_count la 1. Dacă current_count este mai mare sau egal decât max_count, actualizăm valoarea lui max_count și reținem indexul curent în last_index.
	~~== Explicație rezolvare==~~

	~~Funcția citire_date() citește de la tastatură numărul n~~, ~~apoi n numere întregi, reprezentând elementele vectorului v~~. ~~Acestea~~ sunt ~~stocate~~ în ~~lista v, care este întoarsă la sfârșitul funcției.~~		La final, returnăm valoarea lui max_count și last_index. Aceste valori sunt apoi afișate în funcția main, dacă datele de intrare sunt corecte, altfel se afișează mesajul "Datele nu corespund restricțiilor impuse."
	~~Funcția rezolvare(v) primește ca parametru lista v și determină cea mai lungă secvență de elemente egale din vector~~, returnând indicii de la început și sfârșit ai acestei secvențe. Algoritmul utilizat este unul clasic de parcurgere a vectorului și ținere a unor variabile auxiliare pentru stocarea lungimii maxime a secvenței, precum și indicii corespunzători.
	~~Funcția validare(v) primește ca parametru lista v și verifică~~ dacă ~~aceasta este nevidă și conține doar numere întregi. Verificarea se face cu ajutorul funcției încorporate all() și a expresiei isinstance(x, int).~~
	În blocul if __name__ == "__main__", se citesc datele de intrare cu ajutorul funcției citire_date(), se validează cu funcția validare(v) și se calculează rezultatul cu ajutorul funcției rezolvare(v). Dacă datele de intrare sunt ~~valide~~, se afișează ~~rezultatul pe ecran, iar dacă~~ nu~~, se afișează un mesaj corespunzător~~.

Flaviu at 17:41, 27 April 2023

2023-04-27T17:41:45Z

← Older revision		Revision as of 17:41, 27 April 2023
Line 6:		Line 6:
	Programul citește de la tastatură numărul n, iar apoi n numere naturale, reprezentând elementele vectorului.		Programul citește de la tastatură numărul n, iar apoi n numere naturale, reprezentând elementele vectorului.
	== Date de ieșire ==		== Date de ieșire ==
	~~Programul~~ va afișa pe ecran ~~indicii st dr ai capetelor secvenței determinate, separați printr-un spațiu~~.		Dacă datele sunt introduse corect, pe ecran se va afișa:
			'''"Datele sunt introduse corect."''', apoi pe un rând nou '''numărul c''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.
	== Restricţii şi precizări ==		== Restricţii şi precizări ==
	* 1 ≤ n ≤ 1000		* 1 ≤ n ≤ 1000
Line 16:		Line 17:
	: 5 5 1 1 1 1 2 2 2 2		: 5 5 1 1 1 1 2 2 2 2
	; Ieșire		; Ieșire
			: Datele nu corespund restricțiilor impuse.
	: 7 10		: 7 10

Line 22:		Line 24:
	<syntaxhighlight lang="python" line>		<syntaxhighlight lang="python" line>
	# 0523 - SecvEgale		# 0523 - SecvEgale

			def validare(v):
			return len(v) > 0 and all(isinstance(x, int) for x in v)


	def citire_date():		def citire_date():
	n = int(input())		try:
	v = []		n = int(input("Introduceti lungimea vectorului: "))
	for i in range(n):		v = []
	v.append(int(input()))		for i in range(n):
	return v		v.append(int(input("Introduceti elementul " + str(i + 1) + " al vectorului: ")))
			if validare(v):
			print("Datele sunt introduse corect.")
			return v
			else:
			print("Datele nu corespund restricțiilor impuse.")
			return None
			except ValueError:
			print("Datele nu corespund formatului așteptat.")
			return None


Line 45:		Line 60:
	i = j		i = j
	return st, dr		return st, dr


	~~def validare(v):~~
	~~return len(v) > 0 and all(isinstance(x, int) for x in v)~~


	if __name__ == "__main__":		if __name__ == "__main__":
	v = citire_date()		v = citire_date()
	if ~~validare(~~v):		if v is not None:
	st, dr = rezolvare(v)		st, dr = rezolvare(v)
	print(st + 1, dr + 1)		print(f"Perechea cu cea mai mare lungime de elemente egale: ({st + 1}, {dr + 1})")
	~~else:~~
	~~print("Date de intrare invalide.~~")

Flaviu at 19:45, 17 April 2023

2023-04-17T19:45:31Z

← Older revision		Revision as of 19:45, 17 April 2023
Line 23:		Line 23:
	# 0523 - SecvEgale		# 0523 - SecvEgale

	n = int(input(~~"Introduceți numărul de elemente din vector: "~~))		def citire_date():
	v = ~~list~~(~~map~~(int, input~~("Introduceți elementele vectorului: ").split~~()))		n = int(input())
			v = []
			for i in range(n):
			v.append(int(input()))
			return v

	~~# Initializăm variabilele pentru secvența maximă~~
	~~max_len = 1~~
	~~max_start = 0~~
	~~max_end = 0~~

	~~# Parcurgem vectorul incepand de la elementul 1~~		def rezolvare(v):
	i = 1		st, dr = 0, 0
	~~while i < n:~~		max_lungime = 0
	~~# Daca elementul curent este egal cu cel anterior~~		i = 0
	~~if v[~~i~~] ==~~ v~~[i-1]~~:		while i < len(v):
	~~# Determinăm lungimea secvenței curente~~
	~~len_seq = 2~~
	j = i + 1		j = i + 1
	while j < n and v[j] == v[~~j-1~~]:		while j < len(v) and v[j] == v[i]:
	~~len_seq += 1~~
	j += 1		j += 1
	~~# Verificăm dacă secvența curentă este mai lungă decât cea maximă~~		lungime = j - i
	~~if len_seq > max_len:~~		if lungime >= max_lungime:
	~~max_len = len_seq~~		max_lungime = lungime
	~~max_start = i - 1~~		st, dr = i, j - 1
	~~max_end~~ = j - 1
	~~# Daca există mai multe secvențe de aceeași~~ lungime ~~maximă~~
	~~# Alegem secvența mai din dreapta~~
	~~elif len_seq~~ =~~= max_len and j - 1 > max_end~~:
	~~max_start~~ = ~~i - 1~~
	~~max_end~~ = j - 1
	i = j		i = j
			return st, dr


			def validare(v):
			return len(v) > 0 and all(isinstance(x, int) for x in v)


			if __name__ == "__main__":
			v = citire_date()
			if validare(v):
			st, dr = rezolvare(v)
			print(st + 1, dr + 1)
	else:		else:
	~~i += 1~~		print("Date de intrare invalide.")

	~~# Afisăm capetele secvenței maximale~~
	~~print(max_start, max_end)~~

	</syntaxhighlight>		</syntaxhighlight>
			== Explicație rezolvare==

			Funcția citire_date() citește de la tastatură numărul n, apoi n numere întregi, reprezentând elementele vectorului v. Acestea sunt stocate în lista v, care este întoarsă la sfârșitul funcției.
			Funcția rezolvare(v) primește ca parametru lista v și determină cea mai lungă secvență de elemente egale din vector, returnând indicii de la început și sfârșit ai acestei secvențe. Algoritmul utilizat este unul clasic de parcurgere a vectorului și ținere a unor variabile auxiliare pentru stocarea lungimii maxime a secvenței, precum și indicii corespunzători.
			Funcția validare(v) primește ca parametru lista v și verifică dacă aceasta este nevidă și conține doar numere întregi. Verificarea se face cu ajutorul funcției încorporate all() și a expresiei isinstance(x, int).
			În blocul if __name__ == "__main__", se citesc datele de intrare cu ajutorul funcției citire_date(), se validează cu funcția validare(v) și se calculează rezultatul cu ajutorul funcției rezolvare(v). Dacă datele de intrare sunt valide, se afișează rezultatul pe ecran, iar dacă nu, se afișează un mesaj corespunzător.

Flaviu: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/523/secvegale 0523 - SecvEgale] ---- == Cerinţa == Se dă un vector cu n elemente, numere naturale. Determinați cea mai lungă secvență de elemente egale din vector. Dacă în vector există mai multe secvențe de elemente egale de lungime maximă se va determina cea mai din dreapta. == Date de intrare == Programul citește de la tastatură numărul n, iar apoi n numere naturale, reprezentând elementele vectorului. == Date de ieșir...

2023-03-21T20:59:39Z

Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/523/secvegale 0523 - SecvEgale] ---- == Cerinţa == Se dă un vector cu n elemente, numere naturale. Determinați cea mai lungă secvență de elemente egale din vector. Dacă în vector există mai multe secvențe de elemente egale de lungime maximă se va determina cea mai din dreapta. == Date de intrare == Programul citește de la tastatură numărul n, iar apoi n numere naturale, reprezentând elementele vectorului. == Date de ieșir...

New page

Sursa: [https://www.pbinfo.ro/probleme/523/secvegale 0523 - SecvEgale]
----
== Cerinţa ==
Se dă un vector cu n elemente, numere naturale. Determinați cea mai lungă secvență de elemente egale din vector. Dacă în vector există mai multe secvențe de elemente egale de lungime maximă se va determina cea mai din dreapta.
== Date de intrare ==
Programul citește de la tastatură numărul n, iar apoi n numere naturale, reprezentând elementele vectorului.
== Date de ieșire ==
Programul va afișa pe ecran indicii st dr ai capetelor secvenței determinate, separați printr-un spațiu.
== Restricţii şi precizări ==
* 1 ≤ n ≤ 1000
* cele n numere citite vor fi mai mici decât 1000
* indicii elementelor vectorului sunt cuprinși între 1 și n
== Exemplu ==
; Intrare
: 10
: 5 5 1 1 1 1 2 2 2 2
; Ieșire
: 7 10

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0523 - SecvEgale

n = int(input("Introduceți numărul de elemente din vector: "))
v = list(map(int, input("Introduceți elementele vectorului: ").split()))

# Initializăm variabilele pentru secvența maximă
max_len = 1
max_start = 0
max_end = 0

# Parcurgem vectorul incepand de la elementul 1
i = 1
while i < n:
# Daca elementul curent este egal cu cel anterior
if v[i] == v[i-1]:
# Determinăm lungimea secvenței curente
len_seq = 2
j = i + 1
while j < n and v[j] == v[j-1]:
len_seq += 1
j += 1
# Verificăm dacă secvența curentă este mai lungă decât cea maximă
if len_seq > max_len:
max_len = len_seq
max_start = i - 1
max_end = j - 1
# Daca există mai multe secvențe de aceeași lungime maximă
# Alegem secvența mai din dreapta
elif len_seq == max_len and j - 1 > max_end:
max_start = i - 1
max_end = j - 1
i = j
else:
i += 1

# Afisăm capetele secvenței maximale
print(max_start, max_end)

</syntaxhighlight>