0981 - secventa11 - Revision history

Flaviu at 19:40, 14 May 2023

2023-05-14T19:40:56Z

← Older revision		Revision as of 19:40, 14 May 2023
Line 26:		Line 26:
	; Ieșire		; Ieșire
	: Datele nu corespund restricțiilor impuse.		: Datele nu corespund restricțiilor impuse.
	~~: 9~~

	== Rezolvare ==		== Rezolvare ==
Line 33:		Line 33:
	# 0981 - secventa11		# 0981 - secventa11

	def ~~is_binary_string~~(~~num~~):		def validate_input(n, lst):
	~~"""Verifică dacă un număr dat în baza 10 poate fi scris în baza 2 doar cu cifrele 1."""~~		for i in range(n):
	~~binary_str = bin~~(~~num~~)[2:~~] # conversia în binar elimină prefixul "0b"~~		if lst[i] < 0 or lst[i] > 1000000:
	return ~~set(binary_str) == {'1'}~~		return False
			return True

			def get_max_ones(n, lst):
	def ~~max_length_of_ones_sequence~~(~~numbers~~):		if not validate_input(n, lst):
	""~~"Determină lungimea maximă a unei secvențe de numere din șir cu proprietatea că în scrierea binară~~		print("Datele nu corespund restricțiilor impuse.")
	~~sunt formate doar din cifre de 1."""~~		return 0
	~~max_len~~ = 0		max_ones = 0
	~~cur_len~~ = 0		current_ones = 0
			for i in range(n):
	for ~~num~~ in ~~numbers~~:		binary = bin(lst[i])[2:] # convertim numarul in baza 2 si eliminam prefixul "0b"
	if ~~is_binary_string~~(~~num~~):		if all(digit == '1' for digit in binary):
	~~cur_len~~ += 1		current_ones += 1
	~~max_len = max(max_len, cur_len)~~
	else:		else:
	~~cur_len~~ = 0		if current_ones > max_ones:
			max_ones = current_ones
			current_ones = 0
			if current_ones > max_ones: # verificam din nou pentru ultima secventa de 1-uri
			max_ones = current_ones
			print("Datele sunt introduse corect.")
			return max_ones

	~~return max_len~~		if __name__ == "__main__":


	~~def main()~~:
	n = int(input())		n = int(input())
	~~vector~~ = input().split()		lst = list(map(int, input().split()))
			print(get_max_ones(n, lst))

	~~# 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.")~~
	~~exit(0)~~

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

	~~if __name__ == "__main__":~~		Functia `validate_data` are rolul de a valida datele de intrare citite de la tastatura. In cazul in care datele nu corespund restrictiilor impuse de problema, se va afisa un mesaj de eroare si se va returna valoarea `False`. In caz contrar, se va returna valoarea `True`.
	~~main()~~

	~~</syntaxhighlight>~~		Functia `max_length_binary_sequence` primeste ca parametru un vector de numere naturale si returneaza lungimea maxima a unei secvente de numere din vector care sunt formate doar din cifre de 1 in scrierea lor binara. Mai intai se parcurge vectorul si se trece prin fiecare element. Pentru fiecare element se verifica daca acesta este format doar din cifre de 1 in scrierea binara. Daca da, se incrementeaza contorul curent de secventa. Daca nu, se verifica daca contorul curent este mai mare decat lungimea maxima a secventei gasite pana in acel moment. Daca da, se actualizeaza lungimea maxima a secventei. La final, se returneaza lungimea maxima a secventei gasita.
	~~== Explicatie Rezolvare ==~~

	~~Funcția is_binary_string primește un număr natural num și returnează True dacă reprezentarea binară a acestuia conține doar cifra 1~~, ~~False în caz contrar.~~		În interiorul condiției if __name__ == "__main__", se citesc datele de intrare, apoi se apelează funcția validare() pentru a verifica dacă datele de intrare corespund restricțiilor cerinței. Dacă datele corespund restricțiilor, se afișează mesajul "Datele sunt introduse corect." și se apelează funcția rezolvare() pentru a calcula răspunsul problemei. Dacă datele nu corespund restricțiilor, se afișează mesajul "Datele nu corespund restricțiilor impuse.".
	Funcția max_length_of_ones_sequence primește o listă de numere naturale și returnează lungimea maximă a unei secvențe de numere din această listă cu proprietatea că reprezentarea binară a fiecărui număr este formată doar din cifra 1. Algoritmul este implementat astfel: se ~~parcurg numerele din listă și se ține evidența lungimii secvenței curente~~ de ~~numere cu proprietatea dată. Dacă numărul curent respectă proprietatea~~, ~~lungimea secvenței curente~~ se ~~mărește cu 1 și se actualizează lungimea maximă găsită până în acel moment. În caz contrar, secvența curentă se întrerupe.~~
	~~Funcția main citește~~ datele de intrare ~~și validează restricțiile impuse de problemă~~. Dacă datele sunt introduse corect, se apelează funcția ~~max_length_of_ones_sequence și se afișează rezultatul.~~
	~~Functia def main~~() ~~este incapsulata in functia if __name__ == "__main__~~ pentru ~~că funcția gaseste_secventa_maxima~~ nu ~~este definită și nici~~ nu ~~poate fi definită în acest mod~~. ~~Prin urmare, funcția main() trebuie păstrată~~.

Flaviu at 21:03, 13 May 2023

2023-05-13T21:03:30Z

← Older revision		Revision as of 21:03, 13 May 2023
Line 33:		Line 33:
	# 0981 - secventa11		# 0981 - secventa11

	def ~~read_input~~():		def is_binary_string(num):
	~~try:~~		"""Verifică dacă un număr dat în baza 10 poate fi scris în baza 2 doar cu cifrele 1."""
	~~n = int(input(~~"~~Introduceți numărul de numere din lista:~~ "))		binary_str = bin(num)[2:] # conversia în binar elimină prefixul "0b"
	~~numbers = list(map(int, input(~~"~~Introduceți numerele din lista, separate prin spațiu:~~ "~~).split()))~~		return set(binary_str) == {'1'}
	~~if not validate_input~~(~~numbers~~):
	~~print(~~"~~Datele introduse nu respectă restricțiile impuse.~~")
	return ~~None~~
	~~return numbers~~
	~~except ValueError:~~
	~~print~~(~~"Datele introduse nu respectă formatul așteptat."~~)
	~~return None~~

	~~def validate_input(numbers):~~
	~~for num in numbers:~~
	~~if num < 0 or num > 10**9:~~
	~~return False~~
	~~return True~~

	def ~~find_longest_binary_ones~~(numbers):		def max_length_of_ones_sequence(numbers):
			"""Determină lungimea maximă a unei secvențe de numere din șir cu proprietatea că în scrierea binară
			sunt formate doar din cifre de 1."""
	max_len = 0		max_len = 0
	~~current_len~~ = 0		cur_len = 0

	for num in numbers:		for num in numbers:
	~~binary_num = bin~~(num)[2:]		if is_binary_string(num):
	~~if all(digit~~ =~~= '~~1~~' for digit in binary_num):~~		cur_len += 1
	~~current_len +~~= 1		max_len = max(max_len, cur_len)
	else:		else:
	~~max_len = max(max_len, current_len)~~		cur_len = 0
	~~current_len~~ = 0
	~~max_len = max(max_len, current_len)~~
	return max_len		return max_len

	def ~~validate_output~~(~~result~~):
	if ~~result~~ >= 1:		def main():
	print(~~result~~)		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:		else:
	print(0)		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)

	if __name__ == '__main__':		if __name__ == "__main__":
	~~numbers = read_input~~()		main()
	~~if numbers is not None:~~
	~~result = find_longest_binary_ones(numbers)~~
	~~validate_output(result~~)

	</syntaxhighlight>		</syntaxhighlight>
	== Explicatie Rezolvare ==		== Explicatie Rezolvare ==

	Funcția ~~read_input() citește numerele de la tastatură~~ și le returnează ~~sub forma unei liste de întregi.~~		Funcția is_binary_string primește un număr natural num și returnează True dacă reprezentarea binară a acestuia conține doar cifra 1, False în caz contrar.
	~~Am adăugat o funcție de validare a intrării validate_input pentru a verifica~~ dacă ~~fiecare număr din listă este între 0 și 10^9. Am schimbat funcția read_input pentru~~ a ~~folosi această funcție de validare și pentru a afișa un mesaj adecvat în cazul~~ în ~~care datele introduse nu sunt valide sau nu respectă restricțiile impuse~~.		Funcția max_length_of_ones_sequence primește o listă de numere naturale și returnează lungimea maximă a unei secvențe de numere din această listă cu proprietatea că reprezentarea binară a fiecărui număr este formată doar din cifra 1. Algoritmul este implementat astfel: se parcurg numerele din listă și se ține evidența lungimii secvenței curente de numere cu proprietatea dată. Dacă numărul curent respectă proprietatea, lungimea secvenței curente se mărește cu 1 și se actualizează lungimea maximă găsită până în acel moment. În caz contrar, secvența curentă se întrerupe.
			Funcția main citește datele de intrare și validează restricțiile impuse de problemă. Dacă datele sunt introduse corect, se apelează funcția max_length_of_ones_sequence și se afișează rezultatul.
	Funcția ~~find_longest_binary_ones(numbers)~~ primește ~~lista~~ de numere și ~~calculează~~ lungimea ~~celei mai lungi~~ secvențe de numere din ~~șir~~ cu proprietatea că ~~în scrierea~~ binară ~~sunt formate~~ doar din ~~cifre de~~ 1. ~~Pentru fiecare număr~~ din listă~~, se transformă în baza 2~~ și se ~~verifică dacă toate cifrele sunt 1~~. Dacă da, ~~se adaugă la~~ lungimea ~~curentă a~~ secvenței~~, altfel~~ se ~~compară lungimea curentă~~ cu ~~lungimea maximă~~ și se ~~resetează~~ lungimea ~~curentă~~. ~~La final~~, ~~se mai compară o dată lungimea~~ curentă ~~cu lungimea maximă și~~ se ~~returnează lungimea maximă~~.		Functia def main() este incapsulata in functia if __name__ == "__main__ pentru că funcția gaseste_secventa_maxima nu este definită și nici nu poate fi definită în acest mod. Prin urmare, funcția main() trebuie păstrată.

	Funcția ~~validate_output(result) primește rezultatul~~ și îl validează. Dacă ~~rezultatul este mai mare sau egal cu 1~~, se ~~afișează pe ecran. Altfel,~~ se afișează 0.

	În if __name__ == '__main__~~':, citim datele de intrare, apoi apelăm~~ funcția ~~find_longest_binary_ones()~~ și ~~validăm rezultatul apelând~~ funcția ~~validate_output~~().

Flaviu at 07:17, 3 May 2023

2023-05-03T07:17:54Z

← Older revision		Revision as of 07:17, 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 L, reprezentând lungimea maximă a unei secvenţe de elemente din şir cu proprietatea dată''', 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 ≤ 300.000		* 1 ≤ n ≤ 300.000
	* cele n numere citite vor fi mai mici decât 1.000.000		* cele n numere citite vor fi mai mici decât 1.000.000
	* dacă în șir nu sunt numere formate numai din cifre de 1 în baza 2, se va afișa 0		* dacă în șir nu sunt numere formate numai din cifre de 1 în baza 2, se va afișa 0
	== Exemplu ==		== Exemplu 1 ==
	; Intrare		; Intrare
	: 5		: 5
	: 4 6 7 15 88		: 4 6 7 15 88
			; Ieșire
			: Datele sunt introduse correct.
			: 2

			== Exemplu 2 ==
			; Intrare
			: 1
			: 2 4 13 25
	; Ieșire		; Ieșire
	: Datele nu corespund restricțiilor impuse.		: Datele nu corespund restricțiilor impuse.
	: 2		: 9

	== Rezolvare ==		== Rezolvare ==

Flaviu at 17:44, 27 April 2023

2023-04-27T17:44:09Z

← Older revision		Revision as of 17:44, 27 April 2023
Line 6:		Line 6:
	Programul citește de la tastatură numărul n, iar apoi n numere naturale, separate prin spații.		Programul citește de la tastatură numărul n, iar apoi n numere naturale, separate prin spații.
	== Date de ieșire ==		== Date de ieșire ==
	~~Programul~~ va afișa pe ~~ecran~~ numărul L, reprezentând ~~lungimea maximă a unei secvenţe de elemente din şir cu proprietatea dată~~.		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 ≤ 300.000		* 1 ≤ n ≤ 300.000
Line 16:		Line 17:
	: 4 6 7 15 88		: 4 6 7 15 88
	; Ieșire		; Ieșire
			: Datele nu corespund restricțiilor impuse.
	: 2		: 2

Line 24:		Line 26:

	def read_input():		def read_input():
	n = int(input())		try:
	numbers = list(map(int, input().split()))		n = int(input("Introduceți numărul de numere din lista: "))
	return numbers		numbers = list(map(int, input("Introduceți numerele din lista, separate prin spațiu: ").split()))
			if not validate_input(numbers):
			print("Datele introduse nu respectă restricțiile impuse.")
			return None
			return numbers
			except ValueError:
			print("Datele introduse nu respectă formatul așteptat.")
			return None

			def validate_input(numbers):
			for num in numbers:
			if num < 0 or num > 10**9:
			return False
			return True

	def find_longest_binary_ones(numbers):		def find_longest_binary_ones(numbers):
Line 49:		Line 64:
	if __name__ == '__main__':		if __name__ == '__main__':
	numbers = read_input()		numbers = read_input()
	result = find_longest_binary_ones(numbers)		if numbers is not None:
	validate_output(result)		result = find_longest_binary_ones(numbers)
			validate_output(result)

	</syntaxhighlight>		</syntaxhighlight>
Line 57:		Line 72:

	Funcția read_input() citește numerele de la tastatură și le returnează sub forma unei liste de întregi.		Funcția read_input() citește numerele de la tastatură și le returnează sub forma unei liste de întregi.
			Am adăugat o funcție de validare a intrării validate_input pentru a verifica dacă fiecare număr din listă este între 0 și 10^9. Am schimbat funcția read_input pentru a folosi această funcție de validare și pentru a afișa un mesaj adecvat în cazul în care datele introduse nu sunt valide sau nu respectă restricțiile impuse.

	Funcția find_longest_binary_ones(numbers) primește lista de numere și calculează lungimea celei mai lungi secvențe de numere din șir cu proprietatea că în scrierea binară sunt formate doar din cifre de 1. Pentru fiecare număr din listă, se transformă în baza 2 și se verifică dacă toate cifrele sunt 1. Dacă da, se adaugă la lungimea curentă a secvenței, altfel se compară lungimea curentă cu lungimea maximă și se resetează lungimea curentă. La final, se mai compară o dată lungimea curentă cu lungimea maximă și se returnează lungimea maximă.		Funcția find_longest_binary_ones(numbers) primește lista de numere și calculează lungimea celei mai lungi secvențe de numere din șir cu proprietatea că în scrierea binară sunt formate doar din cifre de 1. Pentru fiecare număr din listă, se transformă în baza 2 și se verifică dacă toate cifrele sunt 1. Dacă da, se adaugă la lungimea curentă a secvenței, altfel se compară lungimea curentă cu lungimea maximă și se resetează lungimea curentă. La final, se mai compară o dată lungimea curentă cu lungimea maximă și se returnează lungimea maximă.

Flaviu at 19:47, 17 April 2023

2023-04-17T19:47:01Z

← Older revision		Revision as of 19:47, 17 April 2023
Line 23:		Line 23:
	# 0981 - secventa11		# 0981 - secventa11

	n = int(input())		def read_input():
	numbers = input().split()		n = int(input())
			numbers = list(map(int, input().split()))
			return numbers

	~~# lungimea maxima a secventei~~		def find_longest_binary_ones(numbers):
	max_len = 0		max_len = 0
	~~# lungimea curenta a secventei~~		current_len = 0
	~~curr_len~~ = 0		for num in numbers:
			binary_num = bin(num)[2:]
			if all(digit == '1' for digit in binary_num):
			current_len += 1
			else:
			max_len = max(max_len, current_len)
			current_len = 0
			max_len = max(max_len, current_len)
			return max_len

	~~for num in numbers:~~		def validate_output(result):
	~~# convertim numarul la reprezentarea sa binara~~		if result >= 1:
	~~binary_num = bin(int~~(~~num)~~)[2:]		print(result)
	~~# verificam daca reprezentarea binara contine doar cifre de 1~~
	if ~~set(binary_num) =~~= {'1'}:
	~~curr_len += 1~~
	~~# actualizam lungimea maxima~~
	~~if curr_len > max_len:~~
	~~max_len = curr_len~~
	else:		else:
	~~# resetam contorul~~		print(0)
	~~curr_len~~ = 0
			if __name__ == '__main__':
			numbers = read_input()
			result = find_longest_binary_ones(numbers)
			validate_output(result)

	~~print(max_len)~~

	</syntaxhighlight>		</syntaxhighlight>
			== Explicatie Rezolvare ==

			Funcția read_input() citește numerele de la tastatură și le returnează sub forma unei liste de întregi.

			Funcția find_longest_binary_ones(numbers) primește lista de numere și calculează lungimea celei mai lungi secvențe de numere din șir cu proprietatea că în scrierea binară sunt formate doar din cifre de 1. Pentru fiecare număr din listă, se transformă în baza 2 și se verifică dacă toate cifrele sunt 1. Dacă da, se adaugă la lungimea curentă a secvenței, altfel se compară lungimea curentă cu lungimea maximă și se resetează lungimea curentă. La final, se mai compară o dată lungimea curentă cu lungimea maximă și se returnează lungimea maximă.

			Funcția validate_output(result) primește rezultatul și îl validează. Dacă rezultatul este mai mare sau egal cu 1, se afișează pe ecran. Altfel, se afișează 0.

			În if __name__ == '__main__':, citim datele de intrare, apoi apelăm funcția find_longest_binary_ones() și validăm rezultatul apelând funcția validate_output().

Flaviu: Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/981/secventa11 0981 - secventa11] ---- == Cerinţa == Se dau n numere naturale. Determinaţi lungimea maximă a unei secvenţe de numere din şir cu proprietatea că în scrierea binară sunt formate doar din cifre de 1. == Date de intrare == Programul citește de la tastatură numărul n, iar apoi n numere naturale, separate prin spații. == Date de ieșire == Programul va afișa pe ecran numărul L, reprezentând lungimea maximă a un...

2023-03-21T21:02:31Z

Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/981/secventa11 0981 - secventa11] ---- == Cerinţa == Se dau n numere naturale. Determinaţi lungimea maximă a unei secvenţe de numere din şir cu proprietatea că în scrierea binară sunt formate doar din cifre de 1. == Date de intrare == Programul citește de la tastatură numărul n, iar apoi n numere naturale, separate prin spații. == Date de ieșire == Programul va afișa pe ecran numărul L, reprezentând lungimea maximă a un...

New page

Sursa: [https://www.pbinfo.ro/probleme/981/secventa11 0981 - secventa11]
----
== Cerinţa ==
Se dau n numere naturale. Determinaţi lungimea maximă a unei secvenţe de numere din şir cu proprietatea că în scrierea binară sunt formate doar din cifre de 1.
== Date de intrare ==
Programul citește de la tastatură numărul n, iar apoi n numere naturale, separate prin spații.
== Date de ieșire ==
Programul va afișa pe ecran numărul L, reprezentând lungimea maximă a unei secvenţe de elemente din şir cu proprietatea dată.
== Restricţii şi precizări ==
* 1 ≤ n ≤ 300.000
* cele n numere citite vor fi mai mici decât 1.000.000
* dacă în șir nu sunt numere formate numai din cifre de 1 în baza 2, se va afișa 0
== Exemplu ==
; Intrare
: 5
: 4 6 7 15 88
; Ieșire
: 2

== Rezolvare ==
=== Rezolvare ver. 1 ===
<syntaxhighlight lang="python" line>
# 0981 - secventa11

n = int(input())
numbers = input().split()

# lungimea maxima a secventei
max_len = 0
# lungimea curenta a secventei
curr_len = 0

for num in numbers:
# convertim numarul la reprezentarea sa binara
binary_num = bin(int(num))[2:]
# verificam daca reprezentarea binara contine doar cifre de 1
if set(binary_num) == {'1'}:
curr_len += 1
# actualizam lungimea maxima
if curr_len > max_len:
max_len = curr_len
else:
# resetam contorul
curr_len = 0

print(max_len)

</syntaxhighlight>