0524 - SecvEgale1 - Revision history

Flaviu at 20:04, 14 May 2023

2023-05-14T20:04:26Z

← Older revision		Revision as of 20:04, 14 May 2023
Line 26:		Line 26:
	; Ieșire		; Ieșire
	: Datele nu corespund restricțiilor impuse.		: Datele nu corespund restricțiilor impuse.
	~~: 2 3 4~~
	== Rezolvare ==		== Rezolvare ==
	=== Rezolvare ver. 1 ===		=== Rezolvare ver. 1 ===
Line 32:		Line 32:
	# 0524 - SecvEgale1		# 0524 - SecvEgale1

	def ~~gaseste_secventa_identica~~(n, v):		def validate_input(n, v):
	~~secventa~~ = ~~None~~		if not (isinstance(n, int) and n >= 1 and n <= 1000):
	~~max_lungime~~ = 0		return False
			if not all(isinstance(x, int) and x >= 0 and x < 1000000000 for x in v):
			return False
			return True


			def find_identical_sequence(n, v):
			max_len = 0
			seq_start = None
			seq_end = None

	for i in range(n):		for i in range(n):
	for j in range(i, n):		for j in range(i+1, n+1):
	if v[i] == v[j]:		if v[i:j] == v[i:j][::-1] and j-i > max_len:
	~~lungime~~ = ~~j -~~ i + 1		seq_start = i+1
	if ~~lungime~~ > ~~max_lungime~~:		seq_end = j
	~~max_lungime = lungime~~		max_len = j-i
	~~secventa =~~ (~~i+1~~, ~~j+1~~)
			if max_len > 0:
	return ~~secventa~~		return (seq_start, seq_end)
			else:
			return None


	if __name__ == "__main__":		if __name__ == "__main__":
	n = int(input())		n = int(input())
	v = list(map(int, input().split()))		v = list(map(int, input().split()))

	if ~~not~~ (~~isinstance~~(n, ~~int~~) ~~and n >=~~ 1 ~~and n <= 1000~~):		if validate_input(n, v):
			result = find_identical_sequence(n, v)
			if result:
			print("Datele sunt introduse corect.")
			print(result[0], result[1])
			else:
			print("Nu exista secventa identica.")
			else:
	print("Datele nu corespund restricțiilor impuse.")		print("Datele nu corespund restricțiilor impuse.")
	~~exit()~~

	~~if not all(isinstance(x, int) and x >= 0 and x < 1000000000 for x in v):~~
	~~print("Datele nu corespund restricțiilor impuse.")~~
	~~exit()~~

	~~rezultat = gaseste_secventa_identica(n, v)~~

	~~if rezultat is None:~~
	~~print("Datele nu corespund restricțiilor impuse.")~~
	~~else:~~
	~~print("Datele sunt introduse corect.")~~
	~~print(rezultat[0], rezultat[1])~~


Line 70:		Line 77:
	</syntaxhighlight>		</syntaxhighlight>
	== Explicatie Rezolvare ==		== Explicatie Rezolvare ==
	Funcția ~~gaseste_secventa_identica~~ primește ~~ca argumente lungimea listei~~ și ~~lista însăși~~ și returnează ~~o tuplă de forma (i~~, ~~j) reprezentând indicii începutului~~ și ~~sfârșitului celei~~ mai ~~lungi secvențe~~ de ~~elemente egale din listă~~.		Funcția validate_input primește n și v și verifică dacă n se află în intervalul [1, 1000] și dacă fiecare element al listei v se află în intervalul [0, 1000000000]. Dacă datele sunt valide, funcția returnează True, altfel returnează False.

			Funcția find_identical_sequence primește n și v și parcurge fiecare posibilă subsecvență a lui v. Dacă subsecvența este identică cu inversul ei și este mai mare decât lungimea maximă găsită până acum, actualizează lungimea maximă și poziția de început și sfârșit a secvenței. Dacă nu se găsește o secvență identică, funcția returnează None.

	~~Blocul~~ if __name__ == "__main__"~~: citește~~ datele ~~de intrare~~, ~~validează datele~~ și ~~apelează funcția gaseste_secventa_identica pentru a obține rezultatul~~, ~~pe care îl afișează pe ecran~~.		În funcția if __name__ == "__main__", citim n și v și verificăm dacă datele sunt valide. Dacă sunt, apelăm find_identical_sequence și afișăm secvența identică dacă există. Altfel, afișăm un mesaj de eroare corespunzător.

Flaviu at 21:21, 13 May 2023

2023-05-13T21:21:39Z

← Older revision		Revision as of 21:21, 13 May 2023
Line 32:		Line 32:
	# 0524 - SecvEgale1		# 0524 - SecvEgale1

	def ~~citeste_date_intrare~~():		def gaseste_secventa_identica(n, v):
			secventa = None
			max_lungime = 0

			for i in range(n):
			for j in range(i, n):
			if v[i] == v[j]:
			lungime = j - i + 1
			if lungime > max_lungime:
			max_lungime = lungime
			secventa = (i+1, j+1)

			return secventa

			if __name__ == "__main__":
	n = int(input())		n = int(input())
	v = list(map(int, input().split()))		v = list(map(int, input().split()))
	~~return n, v~~
			if not (isinstance(n, int) and n >= 1 and n <= 1000):
			print("Datele nu corespund restricțiilor impuse.")
	~~def determina_secventa_maxima~~(n, v):		exit()
	~~st, dr~~ = ~~-1, -~~1
	~~for i in range~~(n):		if not all(isinstance(x, int) and x >= 0 and x < 1000000000 for x in v):
	if ~~v[i] =~~= v[0]:		print("Datele nu corespund restricțiilor impuse.")
	~~j = i~~		exit()
	~~while j~~ < ~~n and~~ v~~[j] == v[i]~~:
	~~j += 1~~		rezultat = gaseste_secventa_identica(n, v)
	~~if j - i > dr - st:~~
	~~st, dr~~ = i, ~~j - 1~~		if rezultat is None:
	~~return st, dr~~		print("Datele nu corespund restricțiilor impuse.")
			else:
			print("Datele sunt introduse corect.")
	~~def valideaza_datele_intrare~~(~~n, v~~):		print(rezultat[0], rezultat[1])
	~~return len~~(v) ~~== n and n >~~ 0 ~~and n <= 1000 and max(v~~) ~~< 1000~~


	~~if __name__ == '__main__':~~
	~~n, v = citeste_date_intrare()~~
	~~if valideaza_datele_intrare(n, v):~~
	~~st, dr = determina_secventa_maxima(n, v)~~
	~~if st == -1 and dr == -1:~~
	~~print("NU")~~
	~~else:~~
	~~print(st + 1, dr + 1)~~
	~~else:~~
	~~print("Datele nu corespund restricțiilor impuse.")~~


	</syntaxhighlight>		</syntaxhighlight>
	== Explicatie Rezolvare ==		== Explicatie Rezolvare ==
	Funcția ~~citeste_date_intrare citește de la tastatură numerele n~~ și ~~elementele vectorului v~~ și le returnează ca o ~~listă~~ de ~~întregi.~~		Funcția gaseste_secventa_identica primește ca argumente lungimea listei și lista însăși și returnează o tuplă de forma (i, j) reprezentând indicii începutului și sfârșitului celei mai lungi secvențe de elemente egale din listă.

	~~Funcția determina_secventa_maxima primește vectorul v și returnează~~ indicii ~~st și dr ai capetelor secvenței determinate.~~

	~~Funcția valideaza_datele_intrare primește vectorul v~~ și ~~returnează True dacă datele~~ de ~~intrare sunt valide și False altfel. În acest caz, verificăm doar dacă vectorul nu este gol~~.

	~~În funcția main, mai întâi citim~~ datele de intrare ~~și verificăm dacă sunt valide. Apoi~~, ~~determinăm secvența maximă~~ și ~~afișăm indicii capetelor secvenței sau mesajul "NU"~~, ~~dacă nu există nicio secvență~~.		Blocul if __name__ == "__main__": citește datele de intrare, validează datele și apelează funcția gaseste_secventa_identica pentru a obține rezultatul, pe care îl afișează pe ecran.

Flaviu at 07:23, 3 May 2023

2023-05-03T07:23:51Z

← Older revision		Revision as of 07:23, 3 May 2023
Line 7:		Line 7:
	== Date de ieșire ==		== Date de ieșire ==
	Dacă datele sunt introduse corect, pe ecran se va afișa:		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."'''.		'''"Datele sunt introduse corect."''', apoi pe un rând nou '''va afișa pe ecran indicii st dr ai capetelor secvenței determinate, separați printr-un spațiu''', 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
	* cele n numere citite vor fi mai mici decât 1.000.000.000		* cele n numere citite vor fi mai mici decât 1.000.000.000
	* indexarea elementelor vectorului începe de la 1.		* indexarea elementelor vectorului începe de la 1.
	== Exemplu ==		== Exemplu 1 ==
	; Intrare		; Intrare
	: 12		: 12
	: 6 6 8 3 6 6 3 8 4 3 3 4		: 6 6 8 3 6 6 3 8 4 3 3 4
	; Ieșire		; Ieșire
	: Datele ~~nu corespund restricțiilor impuse~~.		: Datele sunt introduse corect..
	: 4 11		: 4 11

			== Exemplu 2 ==
			; Intrare
			: 11
			: 6 2 8 3 3 6 3 8 4 1 3 4
			; Ieșire
			: Datele nu corespund restricțiilor impuse.
			: 2 3 4
	== Rezolvare ==		== Rezolvare ==
	=== Rezolvare ver. 1 ===		=== Rezolvare ver. 1 ===

Flaviu at 18:11, 27 April 2023

2023-04-27T18:11:00Z

← Older revision		Revision as of 18:11, 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:
	: 6 6 8 3 6 6 3 8 4 3 3 4		: 6 6 8 3 6 6 3 8 4 3 3 4
	; Ieșire		; Ieșire
			: Datele nu corespund restricțiilor impuse.
	: 4 11		: 4 11

Line 26:		Line 28:
	n = int(input())		n = int(input())
	v = list(map(int, input().split()))		v = list(map(int, input().split()))
	return v		return n, v


	def determina_secventa_maxima(v):		def determina_secventa_maxima(n, v):
	st, dr = -1, -1		st, dr = -1, -1
	for i in range(n):		for i in range(n):
Line 41:		Line 43:


	def valideaza_datele_intrare(v):		def valideaza_datele_intrare(n, v):
	return len(v) > 0		return len(v) == n and n > 0 and n <= 1000 and max(v) < 1000


	if __name__ == '__main__':		if __name__ == '__main__':
	v = citeste_date_intrare()		n, v = citeste_date_intrare()
	if valideaza_datele_intrare(v):		if valideaza_datele_intrare(n, v):
	~~n = len(v)~~		st, dr = determina_secventa_maxima(n, v)
	st, dr = determina_secventa_maxima(v)
	if st == -1 and dr == -1:		if st == -1 and dr == -1:
	print("NU")		print("NU")
Line 55:		Line 56:
	print(st + 1, dr + 1)		print(st + 1, dr + 1)
	else:		else:
	print("~~Date de intrare invalide~~.")		print("Datele nu corespund restricțiilor impuse.")

Flaviu at 19:55, 17 April 2023

2023-04-17T19:55:16Z

← Older revision		Revision as of 19:55, 17 April 2023
Line 67:		Line 67:

	În funcția main, mai întâi citim datele de intrare și verificăm dacă sunt valide. Apoi, determinăm secvența maximă și afișăm indicii capetelor secvenței sau mesajul "NU", dacă nu există nicio secvență.		În funcția main, mai întâi citim datele de intrare și verificăm dacă sunt valide. Apoi, determinăm secvența maximă și afișăm indicii capetelor secvenței sau mesajul "NU", dacă nu există nicio secvență.




	~~Regenerate response~~

Flaviu at 19:55, 17 April 2023

2023-04-17T19:55:02Z

← Older revision		Revision as of 19:55, 17 April 2023
Line 23:		Line 23:
	# 0524 - SecvEgale1		# 0524 - SecvEgale1

	n = int(input())		def citeste_date_intrare():
	v = list(map(int, input().split()))		n = int(input())
			v = list(map(int, input().split()))
			return v

	~~max_len = 0~~
	~~start_pos = end_pos = -1~~

	~~for i in range~~(n):		def determina_secventa_maxima(v):
	for j in range(n~~-1, i, -1~~):		st, dr = -1, -1
	if v[i] == v[j]:		for i in range(n):
	~~length~~ = j-i+1		if v[i] == v[0]:
	if ~~length~~ > ~~max_len~~:		j = i
	~~max_len = length~~		while j < n and v[j] == v[i]:
	~~start_pos~~ = i		j += 1
	~~end_pos =~~ j		if j - i > dr - st:
	~~break~~		st, dr = i, j - 1
			return st, dr

	~~if max_len~~ > 0:
	print(~~start_pos~~+1, ~~end_pos~~+1)		def valideaza_datele_intrare(v):
	else:		return len(v) > 0
	print("~~Secventa nu exista~~")

			if __name__ == '__main__':
			v = citeste_date_intrare()
			if valideaza_datele_intrare(v):
			n = len(v)
			st, dr = determina_secventa_maxima(v)
			if st == -1 and dr == -1:
			print("NU")
			else:
			print(st + 1, dr + 1)
			else:
			print("Date de intrare invalide.")


	</syntaxhighlight>		</syntaxhighlight>
			== Explicatie Rezolvare ==
			Funcția citeste_date_intrare citește de la tastatură numerele n și elementele vectorului v și le returnează ca o listă de întregi.

			Funcția determina_secventa_maxima primește vectorul v și returnează indicii st și dr ai capetelor secvenței determinate.

			Funcția valideaza_datele_intrare primește vectorul v și returnează True dacă datele de intrare sunt valide și False altfel. În acest caz, verificăm doar dacă vectorul nu este gol.

			În funcția main, mai întâi citim datele de intrare și verificăm dacă sunt valide. Apoi, determinăm secvența maximă și afișăm indicii capetelor secvenței sau mesajul "NU", dacă nu există nicio secvență.




			Regenerate response

Flaviu: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/524/secvegale1 0524 - SecvEgale1] ---- == Cerinţa == Se dă un vector cu n elemente, numere naturale. Determinați cea mai lungă secvență de elemente din vector care începe și se termină cu aceeași valoare. Dacă în vector există mai multe secvențe corecte de lungime maximă se va determina cea mai din stânga. == Date de intrare == Programul citește de la tastatură numărul n, iar apoi n numere naturale, reprezentând eleme...

2023-03-21T21:26:46Z

Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/524/secvegale1 0524 - SecvEgale1] ---- == Cerinţa == Se dă un vector cu n elemente, numere naturale. Determinați cea mai lungă secvență de elemente din vector care începe și se termină cu aceeași valoare. Dacă în vector există mai multe secvențe corecte de lungime maximă se va determina cea mai din stânga. == Date de intrare == Programul citește de la tastatură numărul n, iar apoi n numere naturale, reprezentând eleme...

New page

Sursa: [https://www.pbinfo.ro/probleme/524/secvegale1 0524 - SecvEgale1]
----
== Cerinţa ==
Se dă un vector cu n elemente, numere naturale. Determinați cea mai lungă secvență de elemente din vector care începe și se termină cu aceeași valoare. Dacă în vector există mai multe secvențe corecte de lungime maximă se va determina cea mai din stânga.
== 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 1.000.000.000
* indexarea elementelor vectorului începe de la 1.
== Exemplu ==
; Intrare
: 12
: 6 6 8 3 6 6 3 8 4 3 3 4
; Ieșire
: 4 11

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0524 - SecvEgale1

n = int(input())
v = list(map(int, input().split()))

max_len = 0
start_pos = end_pos = -1

for i in range(n):
for j in range(n-1, i, -1):
if v[i] == v[j]:
length = j-i+1
if length > max_len:
max_len = length
start_pos = i
end_pos = j
break

if max_len > 0:
print(start_pos+1, end_pos+1)
else:
print("Secventa nu exista")

</syntaxhighlight>