0518 - SecvZero - Revision history

Monica Dragos: /* Explicație rezolvare */

2023-05-14T19:44:59Z

Explicație rezolvare

← Older revision		Revision as of 19:44, 14 May 2023
Line 79:		Line 79:
	Funcția lungime_maxima_secventa_nula primește ca parametru un vector și returnează lungimea și poziția celei mai lungi secvențe de elemente nule din vector. Pentru a face acest lucru, parcurgem vectorul și căutăm secvențe de elemente nule. Dacă găsim o secvență mai lungă decât cea găsită până acum, actualizăm lungimea maximă și poziția. Funcția folosește o buclă while pentru a permite căutarea secvențelor de elemente nule care se întind pe mai mult de un element.		Funcția lungime_maxima_secventa_nula primește ca parametru un vector și returnează lungimea și poziția celei mai lungi secvențe de elemente nule din vector. Pentru a face acest lucru, parcurgem vectorul și căutăm secvențe de elemente nule. Dacă găsim o secvență mai lungă decât cea găsită până acum, actualizăm lungimea maximă și poziția. Funcția folosește o buclă while pentru a permite căutarea secvențelor de elemente nule care se întind pe mai mult de un element.
	Funcția validare_date_intrare primește ca parametri numărul de elemente și vectorul și returnează True dacă datele de intrare respectă restricțiile impuse și False altfel. În acest caz, verificăm dacă numărul de elemente este între 1 și 1000, dacă toate elementele vectorului sunt între 0 și 999 și dacă vectorul conține cel puțin un element nul.		Funcția validare_date_intrare primește ca parametri numărul de elemente și vectorul și returnează True dacă datele de intrare respectă restricțiile impuse și False altfel. În acest caz, verificăm dacă numărul de elemente este între 1 și 1000, dacă toate elementele vectorului sunt între 0 și 999 și dacă vectorul conține cel puțin un element nul.
	În funcția if __name__ == "__main__", ~~citim~~		În funcția if __name__ == "__main__", întâi se citește de la tastatură un număr întreg, n, și un vector de n numere întregi, vector, separate prin spațiu.
			Apoi se apelează funcția validare_date_intrare cu parametrii n și vector pentru a verifica dacă datele introduse sunt valide.
			Dacă datele introduse sunt valide, se afișează mesajul "Datele sunt introduse corect".
			Se apelează funcția lungime_maxima_secventa_nula cu parametrul vector pentru a găsi lungimea și poziția primei secvențe nule din vector.
			Se afișează lungimea și poziția găsite anterior.
			Dacă datele introduse nu sunt valide, se afișează mesajul "Datele nu corespund restricțiilor impuse".

Flaviu at 19:34, 14 May 2023

2023-05-14T19:34:16Z

← Older revision		Revision as of 19:34, 14 May 2023
Line 27:		Line 27:
	; Ieșire		; Ieșire
	: Datele nu corespund restricțiilor impuse.		: Datele nu corespund restricțiilor impuse.
	~~: 2 5~~

	== Rezolvare ==		== Rezolvare ==
Line 34:		Line 34:
	# 0518 - SecvZero		# 0518 - SecvZero

	def ~~gaseste_secventa_maxima~~(vector):		def lungime_maxima_secventa_nula(vector):
			n = len(vector)
	lungime_maxima = 0		lungime_maxima = 0
	~~pozitie_start~~ = -1		pozitie = -1
	~~lungime_curenta~~ = 0		i = 0
			while i < n:
	~~for~~ i~~, element in enumerate(vector)~~:		if vector[i] == 0:
	if ~~element~~ == 0:		j = i + 1
	~~lungime_curenta~~ += 1		while j < n and vector[j] == 0:
	~~else:~~		j += 1
			lungime_curenta = j - i
	if lungime_curenta > lungime_maxima:		if lungime_curenta > lungime_maxima:
	lungime_maxima = lungime_curenta		lungime_maxima = lungime_curenta
	~~pozitie_start~~ = i ~~- lungime_maxima~~		pozitie = i
	~~lungime_curenta~~ = 0		i = j
			else:
			i += 1
			return lungime_maxima, pozitie

	if ~~lungime_curenta > lungime_maxima~~:		def validare_date_intrare(n, vector):
	~~lungime_maxima~~ = ~~lungime_curenta~~		if not (1 <= n <= 1000):
	~~pozitie_start~~ = ~~len(~~vector) ~~- lungime_maxima~~		return False
			if not all(0 <= x < 1000 for x in vector):
			return False
			if not any(x == 0 for x in vector):
			return False
			return True

	~~return (lungime_maxima, pozitie_start)~~


	~~# functia main~~
	if __name__ == "__main__":		if __name__ == "__main__":
	n = int(input())		n = int(input())
	vector = input().split()		vector = list(map(int, input().split()))
			if validare_date_intrare(n, vector):
	~~# validare date de intrare~~		print("Datele sunt introduse corect.")
	if n <= ~~0 or n > 1000 or len~~(vector) ~~!= n~~:		lungime, pozitie = lungime_maxima_secventa_nula(vector)
			print(lungime, pozitie)
			else:
	print("Datele nu corespund restricțiilor impuse.")		print("Datele nu corespund restricțiilor impuse.")
	~~else:~~
	~~try:~~
	~~vector = [int(elem) for elem in vector]~~
	~~except ValueError:~~
	~~print("Datele nu corespund restricțiilor impuse.")~~
	~~exit(0)~~

	~~if max(vector) >= 1000:~~
	~~print("Datele nu corespund restricțiilor impuse.")~~
	~~else:~~
	~~lungime_maxima, pozitie_start = gaseste_secventa_maxima(vector)~~
	~~print("Datele sunt introduse corect.")~~
	~~print(lungime_maxima, pozitie_start)~~


Line 82:		Line 77:
	== Explicație rezolvare==		== Explicație rezolvare==

	Funcția validate_input verifică dacă datele introduse de utilizator corespund cerințelor problemei, adică dacă numărul n este în intervalul [1, 1000], toate numerele citite sunt mai mici decât 1000 și vectorul conține cel puțin un element nul. Dacă datele sunt valide, funcția returnează True, altfel returnează False.		Funcția lungime_maxima_secventa_nula primește ca parametru un vector și returnează lungimea și poziția celei mai lungi secvențe de elemente nule din vector. Pentru a face acest lucru, parcurgem vectorul și căutăm secvențe de elemente nule. Dacă găsim o secvență mai lungă decât cea găsită până acum, actualizăm lungimea maximă și poziția. Funcția folosește o buclă while pentru a permite căutarea secvențelor de elemente nule care se întind pe mai mult de un element.
			Funcția validare_date_intrare primește ca parametri numărul de elemente și vectorul și returnează True dacă datele de intrare respectă restricțiile impuse și False altfel. În acest caz, verificăm dacă numărul de elemente este între 1 și 1000, dacă toate elementele vectorului sunt între 0 și 999 și dacă vectorul conține cel puțin un element nul.
	~~Funcția find_longest_sequence_of_zeros~~ primește ca ~~argument vectorul citit~~ și returnează ~~două numere:~~ lungimea celei mai lungi secvențe de elemente nule din vector ~~și poziția de început a acestei secvențe~~. Pentru a ~~găsi aceste valori~~, ~~funcția parcurge~~ vectorul și ~~numără lungimea fiecărei~~ secvențe de elemente nule ~~întâlnite~~. ~~De fiecare dată când găsește~~ o secvență ~~de elemente nule~~ mai lungă decât cea găsită ~~anterior~~, ~~funcția actualizează~~ lungimea maximă și poziția de ~~început a acestei secvențe~~.		În funcția if __name__ == "__main__", citim

	~~În main, se citesc~~ datele de intrare de ~~la tastatură, se validează~~ și ~~se apelează funcția find_longest_sequence_of_zeros. Dacă datele introduse sunt valide~~, ~~se afișează mesajul "Datele~~ sunt ~~introduse corect."~~ și ~~rezultatul returnat de funcția find_longest_sequence_of_zeros~~. În ~~caz contrar, se afișează mesajul~~ "~~Datele nu corespund restricțiilor impuse.~~".

Flaviu at 20:53, 13 May 2023

2023-05-13T20:53:59Z

← Older revision		Revision as of 20:53, 13 May 2023
Line 34:		Line 34:
	# 0518 - SecvZero		# 0518 - SecvZero

	def ~~validate_input~~(~~n, v~~):		def gaseste_secventa_maxima(vector):
	~~if n < 1 or n > 1000:~~		lungime_maxima = 0
	~~print("n nu respecta restricțiile impuse")~~		pozitie_start = -1
	~~return False~~		lungime_curenta = 0
	~~if all(elem~~ =~~= 0 for elem in v):~~
	~~print("vectorul nu poate contine doar elemente nule")~~
	~~return False~~
	~~for i in range(n):~~
	~~if v[i] <~~ 0 ~~or v[i] > 1000000:~~
	~~print("valorile din v trebuie sa fie in intervalul [0, 1000000]")~~
	~~return False~~
	~~return True~~

	~~def find_longest_sequence~~(~~n, v~~):		for i, element in enumerate(vector):
	~~max_len = 0~~		if element == 0:
	~~start = -1~~		lungime_curenta += 1
	~~end = -1~~
	~~i = 0~~
	~~while i < n~~:
	if ~~v[i]~~ == 0:
	i += 1
	else:		else:
	~~j = i~~		if lungime_curenta > lungime_maxima:
	~~while j < n and v[j] != 0:~~		lungime_maxima = lungime_curenta
	~~j += 1~~		pozitie_start = i - lungime_maxima
	if ~~j - i~~ > ~~max_len~~:		lungime_curenta = 0
	~~max_len~~ = ~~j - i~~
	~~start~~ = i
	~~end = j~~-1
	i = j
	~~return (start+1, end+1)~~

	~~def read_input~~():		if lungime_curenta > lungime_maxima:
	~~try~~:		lungime_maxima = lungime_curenta
	n = int(input(~~"Introduceti valoarea lui n: "~~))		pozitie_start = len(vector) - lungime_maxima
	v = ~~list(map(int,~~ input(~~"Introduceti valorile vectorului, separate prin spatiu: "~~).split()))
	~~if not validate_input~~(~~n, v~~):		return (lungime_maxima, pozitie_start)


			# functia main
			if __name__ == "__main__":
			n = int(input())
			vector = input().split()

			# validare date de intrare
			if n <= 0 or n > 1000 or len(vector) != n:
			print("Datele nu corespund restricțiilor impuse.")
			else:
			try:
			vector = [int(elem) for elem in vector]
			except ValueError:
	print("Datele nu corespund restricțiilor impuse.")		print("Datele nu corespund restricțiilor impuse.")
	~~return None, None~~		exit(0)
	~~print~~(~~"Datele sunt introduse corect."~~)
	~~return n, v~~
	~~except ValueError:~~
	~~print("Datele nu corespund formatului așteptat.")~~
	~~return None, None~~

	if ~~__name__ =~~= ~~'__main__'~~:		if max(vector) >= 1000:
	~~n, v = read_input~~()		print("Datele nu corespund restricțiilor impuse.")
	~~if n is not None and v is not None~~:		else:
	~~start~~, ~~end~~ = ~~find_longest_sequence~~(~~n, v~~)		lungime_maxima, pozitie_start = gaseste_secventa_maxima(vector)
	print(~~start~~, ~~end~~)		print("Datele sunt introduse corect.")
			print(lungime_maxima, pozitie_start)


Line 90:		Line 82:
	== Explicație rezolvare==		== Explicație rezolvare==

	validate_input~~(n, v) valideaza~~ datele de ~~intrare. Se verifica daca~~ n este in intervalul ~~permis~~, ~~daca fiecare element din v este~~ mai ~~mic decat~~ 1000 ~~si daca~~ vectorul ~~contine~~ cel ~~putin~~ un element 0. ~~Daca una dintre aceste conditii nu este indeplinita~~, ~~se afiseaza un mesaj de eroare si se returneaza~~ False.		Funcția validate_input verifică dacă datele introduse de utilizator corespund cerințelor problemei, adică dacă numărul n este în intervalul [1, 1000], toate numerele citite sunt mai mici decât 1000 și vectorul conține cel puțin un element nul. Dacă datele sunt valide, funcția returnează True, altfel returnează False.
	~~find_longest_sequence(n, v) determina cea~~ mai ~~lunga secventa~~ de elemente nule din vector. ~~Se foloseste o metoda de tip "sliding window"~~, ~~unde se~~ parcurge vectorul~~, se identifica toate secventele~~ de elemente nule ~~si se retine cea~~ mai ~~lunga si pozitia ei de inceput. Deoarece dorim sa identificam~~ cea ~~mai din stanga secventa de lungime maxima~~, ~~pozitia~~ de ~~inceput~~ a ~~secventei se retine prin variabila start~~. ~~Se returneaza o pereche de indici~~, ~~reprezentand capetele secventei.~~
	~~read_input() citeste~~ datele de intrare ~~si le valideaza cu ajutorul functiei validate_input()~~. ~~Daca~~ datele sunt valide, ~~functia returneaza n si v~~.		Funcția find_longest_sequence_of_zeros primește ca argument vectorul citit și returnează două numere: lungimea celei mai lungi secvențe de elemente nule din vector și poziția de început a acestei secvențe. Pentru a găsi aceste valori, funcția parcurge vectorul și numără lungimea fiecărei secvențe de elemente nule întâlnite. De fiecare dată când găsește o secvență de elemente nule mai lungă decât cea găsită anterior, funcția actualizează lungimea maximă și poziția de început a acestei secvențe.
	~~In if __name__ == '__main__' se citesc datele~~ de ~~intrare cu ajutorul functiei read_input() si~~ se ~~apeleaza functia find_longest_sequence(), care determina cea mai lunga secventa de elemente nule din vector~~. ~~Indicii capetelor secventei se afiseaza cu ajutorul functiei print()~~.
			În main, se citesc datele de intrare de la tastatură, se validează și se apelează funcția find_longest_sequence_of_zeros. Dacă datele introduse sunt valide, se afișează mesajul "Datele sunt introduse corect." și rezultatul returnat de funcția find_longest_sequence_of_zeros. În caz contrar, se afișează mesajul "Datele nu corespund restricțiilor impuse.".

Flaviu at 07:16, 3 May 2023

2023-05-03T07:16:54Z

← Older revision		Revision as of 07:16, 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 numărul de perechi care îndeplinesc condițiile cerute''', 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 ==
Line 14:		Line 14:
	* indicii elementelor vectorului sunt cuprinși între 1 și n		* indicii elementelor vectorului sunt cuprinși între 1 și n
	* vectorul va conține cel puțin un element nul		* vectorul va conține cel puțin un element nul
	== Exemplu ==		== Exemplu 1 ==
	; Intrare		; Intrare
	: 10		: 10
	: 0 1 0 0 0 5 0 0 0 2		: 0 1 0 0 0 5 0 0 0 2
			; Ieșire
			: Datele sunt introduse correct.
			: 3 5
			== Exemplu 2 ==
			; Intrare
			: 2
			: 2 1 1 0 0 3 4
	; Ieșire		; Ieșire
	: Datele nu corespund restricțiilor impuse.		: Datele nu corespund restricțiilor impuse.
	: 3 5		: 2 5

	== Rezolvare ==		== Rezolvare ==

Flaviu at 17:37, 27 April 2023

2023-04-27T17:37:19Z

← Older revision		Revision as of 17:37, 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 17:		Line 19:
	: 0 1 0 0 0 5 0 0 0 2		: 0 1 0 0 0 5 0 0 0 2
	; Ieșire		; Ieșire
			: Datele nu corespund restricțiilor impuse.
	: 3 5		: 3 5

Line 26:		Line 29:
	def validate_input(n, v):		def validate_input(n, v):
	if n < 1 or n > 1000:		if n < 1 or n > 1000:
	print("n nu respecta ~~restrictiile~~ impuse")		print("n nu respecta restricțiile impuse")
			return False
			if all(elem == 0 for elem in v):
			print("vectorul nu poate contine doar elemente nule")
	return False		return False
	for i in range(n):		for i in range(n):
	if v[i] >~~= 1000~~:		if v[i] < 0 or v[i] > 1000000:
	print("~~elementul"~~, ~~i+1, "nu respecta restrictiile impuse~~")		print("valorile din v trebuie sa fie in intervalul [0, 1000000]")
	return False		return False
	~~if all(elem != 0 for elem in v):~~
	~~print("vectorul nu contine elemente nule")~~
	~~return False~~
	return True		return True

	def find_longest_sequence(n, v):		def find_longest_sequence(n, v):
	max_len = 0		max_len = 0
	start = 0		start = -1
			end = -1
	i = 0		i = 0
	while i < n:		while i < n:
	if v[i] != 0:		if v[i] == 0:
	i += 1		i += 1
	else:		else:
	j = i		j = i
	while j < n and v[j] == 0:		while j < n and v[j] != 0:
	j += 1		j += 1
	if j - i > max_len:		if j - i > max_len:
	max_len = j - i		max_len = j - i
	start = i		start = i
			end = j-1
	i = j		i = j
	return (start+1, ~~start~~+~~max_len~~)		return (start+1, end+1)

	def read_input():		def read_input():
	n = int(input())		try:
	v = list(map(int, input().split()))		n = int(input("Introduceti valoarea lui n: "))
	if not validate_input(n, v):		v = list(map(int, input("Introduceti valorile vectorului, separate prin spatiu: ").split()))
	~~exit~~()		if not validate_input(n, v):
	return n, v		print("Datele nu corespund restricțiilor impuse.")
			return None, None
			print("Datele sunt introduse corect.")
			return n, v
			except ValueError:
			print("Datele nu corespund formatului așteptat.")
			return None, None

	if __name__ == '__main__':		if __name__ == '__main__':
	n, v = read_input()		n, v = read_input()
	start, end = find_longest_sequence(n, v)		if n is not None and v is not None:
	print(start, end)		start, end = find_longest_sequence(n, v)
			print(start, end)

Flaviu at 19:43, 17 April 2023

2023-04-17T19:43:50Z

← Older revision		Revision as of 19:43, 17 April 2023
Line 24:		Line 24:
	# 0518 - SecvZero		# 0518 - SecvZero

	n ~~= int(input~~("~~Introduceți numărul de elemente din vector:~~ "))		def validate_input(n, v):
	v = ~~list~~(~~map(int~~, ~~input(~~"~~Introduceți elementele vectorului:~~ ")~~.split~~()))		if n < 1 or n > 1000:
			print("n nu respecta restrictiile impuse")
			return False
			for i in range(n):
			if v[i] >= 1000:
			print("elementul", i+1, "nu respecta restrictiile impuse")
			return False
			if all(elem != 0 for elem in v):
			print("vectorul nu contine elemente nule")
			return False
			return True

	start = -1 ~~# indexul de start al secvenței de elemente nule~~		def find_longest_sequence(n, v):
	~~end~~ = ~~-1 # indexul de sfârșit al secvenței de elemente nule~~		max_len = 0
	~~max_length~~ = 0 ~~# lungimea maximă a secvenței de elemente nule~~		start = 0
	~~current_start~~ = -~~1 # indexul de~~ start ~~al secvenței curente de elemente nule~~		i = 0
	~~current_length~~ = ~~0 # lungimea curentă a secvenței de elemente nule~~		while i < n:
			if v[i] != 0:
			i += 1
			else:
			j = i
			while j < n and v[j] == 0:
			j += 1
			if j - i > max_len:
			max_len = j - i
			start = i
			i = j
			return (start+1, start+max_len)

	~~for i in range~~(n):		def read_input():
	if v~~[i]~~ =~~= 0: # dacă am găsit un element nul~~		n = int(input())
	if ~~current_start == -1~~: ~~# dacă nu eram deja într-o secvență de elemente nule~~		v = list(map(int, input().split()))
	~~current_start = i # începem o secvență nouă~~		if not validate_input(n, v):
	~~current_length += 1 # creștem lungimea curentă a secvenței~~		exit()
	~~else: # dacă am găsit un element nenul~~		return n, v
	if ~~current_length > max_length~~: ~~# dacă secvența curentă este mai lungă decât maximul anterior~~
	~~start~~ = ~~current_start # actualizăm indexul de~~ start ~~al secvenței maxime~~		if __name__ == '__main__':
	end = ~~i - 1 # actualizăm indexul de sfârșit al secvenței maxime~~		n, v = read_input()
	~~max_length = current_length # actualizăm lungimea maximă~~		start, end = find_longest_sequence(n, v)
	~~current_start = -1 # resetăm indexul de~~ start ~~al secvenței curente~~		print(start, end)
	~~current_length = 0 # resetăm lungimea curentă a secvenței~~

	~~# Afisăm indicii de start și sfârșit ai secvenței de elemente nule~~
	~~print(start, end)~~

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

			validate_input(n, v) valideaza datele de intrare. Se verifica daca n este in intervalul permis, daca fiecare element din v este mai mic decat 1000 si daca vectorul contine cel putin un element 0. Daca una dintre aceste conditii nu este indeplinita, se afiseaza un mesaj de eroare si se returneaza False.
			find_longest_sequence(n, v) determina cea mai lunga secventa de elemente nule din vector. Se foloseste o metoda de tip "sliding window", unde se parcurge vectorul, se identifica toate secventele de elemente nule si se retine cea mai lunga si pozitia ei de inceput. Deoarece dorim sa identificam cea mai din stanga secventa de lungime maxima, pozitia de inceput a secventei se retine prin variabila start. Se returneaza o pereche de indici, reprezentand capetele secventei.
			read_input() citeste datele de intrare si le valideaza cu ajutorul functiei validate_input(). Daca datele sunt valide, functia returneaza n si v.
			In if __name__ == '__main__' se citesc datele de intrare cu ajutorul functiei read_input() si se apeleaza functia find_longest_sequence(), care determina cea mai lunga secventa de elemente nule din vector. Indicii capetelor secventei se afiseaza cu ajutorul functiei print().

Flaviu: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/4265/perechiab 0518 - SecvZero] ---- == Cerinţa == Se dă un vector cu n elemente numere naturale. Determinați cea mai lungă secvență de elemente nule din vector. Dacă în vector există mai multe secvențe de elemente nule 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 =...

2023-03-21T20:57:03Z

Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/4265/perechiab 0518 - SecvZero] ---- == Cerinţa == Se dă un vector cu n elemente numere naturale. Determinați cea mai lungă secvență de elemente nule din vector. Dacă în vector există mai multe secvențe de elemente nule 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 =...

New page

Sursa: [https://www.pbinfo.ro/probleme/4265/perechiab 0518 - SecvZero]
----
== Cerinţa ==
Se dă un vector cu n elemente numere naturale. Determinați cea mai lungă secvență de elemente nule din vector. Dacă în vector există mai multe secvențe de elemente nule 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 1000
* indicii elementelor vectorului sunt cuprinși între 1 și n
* vectorul va conține cel puțin un element nul
== Exemplu ==
; Intrare
: 10
: 0 1 0 0 0 5 0 0 0 2
; Ieșire
: 3 5

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0518 - SecvZero

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

start = -1 # indexul de start al secvenței de elemente nule
end = -1 # indexul de sfârșit al secvenței de elemente nule
max_length = 0 # lungimea maximă a secvenței de elemente nule
current_start = -1 # indexul de start al secvenței curente de elemente nule
current_length = 0 # lungimea curentă a secvenței de elemente nule

for i in range(n):
if v[i] == 0: # dacă am găsit un element nul
if current_start == -1: # dacă nu eram deja într-o secvență de elemente nule
current_start = i # începem o secvență nouă
current_length += 1 # creștem lungimea curentă a secvenței
else: # dacă am găsit un element nenul
if current_length > max_length: # dacă secvența curentă este mai lungă decât maximul anterior
start = current_start # actualizăm indexul de start al secvenței maxime
end = i - 1 # actualizăm indexul de sfârșit al secvenței maxime
max_length = current_length # actualizăm lungimea maximă
current_start = -1 # resetăm indexul de start al secvenței curente
current_length = 0 # resetăm lungimea curentă a secvenței

# Afisăm indicii de start și sfârșit ai secvenței de elemente nule
print(start, end)

</syntaxhighlight>