1992 - PlatouAT - Revision history

Cata at 06:37, 3 May 2023

2023-05-03T06:37:37Z

← Older revision		Revision as of 06:37, 3 May 2023
Line 102:		Line 102:
	print("Input invalid")		print("Input invalid")

	~~def main()~~:		if __name__ == '__main__':
	n = int(input())		n = int(input())
	lmax = 0		lmax = 0
Line 131:		Line 131:
	print("NU EXISTA")		print("NU EXISTA")

	~~if __name__ == '__main__':~~
	~~main()~~

	</syntaxhighlight>		</syntaxhighlight>
Line 145:		Line 143:
	Funcția process_input(n) primește un întreg n și citește n valori întregi de la utilizator. Pentru fiecare valoare, se verifică dacă aceasta îndeplinește condițiile necesare și, în caz afirmativ, se calculează secvența și cadranul corespunzătoare, și se returnează o secvență de trei valori: x, secv și c.		Funcția process_input(n) primește un întreg n și citește n valori întregi de la utilizator. Pentru fiecare valoare, se verifică dacă aceasta îndeplinește condițiile necesare și, în caz afirmativ, se calculează secvența și cadranul corespunzătoare, și se returnează o secvență de trei valori: x, secv și c.

	~~Funcția main()~~ primește un întreg n și apelează funcția process_input(n) pentru a procesa valorile introduse. Pentru fiecare valoare x, se aplică anumite transformări și se calculează lungimea celei mai lungi secvențe continue de caractere 'T' în codul ASCII obținut. Lungimea maximă a secvenței este afișată la sfârșitul funcției.		Blocul __main__ primește un întreg n și apelează funcția process_input(n) pentru a procesa valorile introduse. Pentru fiecare valoare x, se aplică anumite transformări și se calculează lungimea celei mai lungi secvențe continue de caractere 'T' în codul ASCII obținut. Lungimea maximă a secvenței este afișată la sfârșitul funcției.

	În general, codul este folosit pentru a procesa și transforma date și pentru a calcula anumite valori specifice, cum ar fi lungimea celei mai lungi secvențe de caractere.		În general, codul este folosit pentru a procesa și transforma date și pentru a calcula anumite valori specifice, cum ar fi lungimea celei mai lungi secvențe de caractere.

Cata at 06:33, 3 May 2023

2023-05-03T06:33:51Z

← Older revision		Revision as of 06:33, 3 May 2023
Line 1:		Line 1:
			==Cerința==
	Se definește operația AT un procedeu prin care se schimbă caracterul 'A' în 'T' și caracterul 'T' în 'A'. Operația poate fi modelată ca o funcție astfel: AT(A) = T și AT(T) = A. Operația se generalizează pentru orice secvență de caractere formată din literele A și T. De exemplu, dacă se aplică operația AT pentru secvența AAATTA, se va obține TTTAAT. Notăm AT(AAATTA) = TTTAAT.		Se definește operația AT un procedeu prin care se schimbă caracterul 'A' în 'T' și caracterul 'T' în 'A'. Operația poate fi modelată ca o funcție astfel: AT(A) = T și AT(T) = A. Operația se generalizează pentru orice secvență de caractere formată din literele A și T. De exemplu, dacă se aplică operația AT pentru secvența AAATTA, se va obține TTTAAT. Notăm AT(AAATTA) = TTTAAT.

Line 8:		Line 9:
	În general: S<sub>n</sub> = S<sub>n-1</sub> AT(S<sub>n-1</sub> ) AT(S<sub>n-1</sub> ) S<sub>n-1</sub> .		În general: S<sub>n</sub> = S<sub>n-1</sub> AT(S<sub>n-1</sub> ) AT(S<sub>n-1</sub> ) S<sub>n-1</sub> .

	~~==Cerința==~~
	Se dau n numere naturale: k<sub>1</sub> , k<sub>2</sub> , k<sub>3</sub> ... k<sub>n</sub>. Pentru fiecare număr k<sub>i</sub> se determină caracterul de pe poziția k<sub>i</sub> dintr-un element al șirului S care are cel puțin k<sub>i</sub> caractere. Cu aceste caractere se construiește un nou șir V.		Se dau n numere naturale: k<sub>1</sub> , k<sub>2</sub> , k<sub>3</sub> ... k<sub>n</sub>. Pentru fiecare număr k<sub>i</sub> se determină caracterul de pe poziția k<sub>i</sub> dintr-un element al șirului S care are cel puțin k<sub>i</sub> caractere. Cu aceste caractere se construiește un nou șir V.

Line 17:		Line 17:

	==Date de ieșire==		==Date de ieșire==
	Programul va afișa pe ecran numărul L cerut sau mesajul NU EXISTA, alături de un mesaj de confirmare a datelor.		Programul va afișa pe ecran numărul L cerut sau mesajul NU EXISTA, alături de un mesaj de confirmare a datelor ("Input valid" sau "Input invalid" după caz).

	==Restricții și precizări==		==Restricții și precizări==
Line 31:		Line 31:
	: 1 2 2 2 1		: 1 2 2 2 1
	;Ieșire		;Ieșire
	: ~~Valid input~~		: Input valid
	: 3		: 3
	Explicație		Explicație
Line 41:		Line 41:
	: 1 2 1 2 2 2 1 2 2 2 2 2 2 2 1 1 1 1 1 1		: 1 2 1 2 2 2 1 2 2 2 2 2 2 2 1 1 1 1 1 1
	;Ieșire		;Ieșire
	: ~~Valid input~~		: Input valid
	: 7		: 7
	Explicație		Explicație
Line 51:		Line 51:
	: 1 2 3 2 3 1		: 1 2 3 2 3 1
	; Ieșire		; Ieșire
	: ~~Valid input~~		: Input valid
	: NU EXISTA		: NU EXISTA
	Explicație		Explicație
Line 61:		Line 61:
	: 6 3 2 3 4 3 3 2 3 2 2 3 2 1 1		: 6 3 2 3 4 3 3 2 3 2 2 3 2 1 1
	; Ieșire		; Ieșire
	: ~~Valid input~~		: Input valid
	: 3		: 3
	Explicație		Explicație
Line 95:		Line 95:
	x = int(input())		x = int(input())
	if validate_input(x):		if validate_input(x):
	print("~~Valid input~~")		print("Input valid")
	secv = get_secv(x)		secv = get_secv(x)
	x, c = reduce_to_first_cadran(x, secv)		x, c = reduce_to_first_cadran(x, secv)
	yield x, secv, c		yield x, secv, c
			else:
			print("Input invalid")

	def main():		def main():

Cata at 07:40, 28 April 2023

2023-04-28T07:40:47Z

← Older revision		Revision as of 07:40, 28 April 2023
Line 17:		Line 17:

	==Date de ieșire==		==Date de ieșire==
	Programul va afișa pe ecran numărul L cerut sau mesajul NU EXISTA.		Programul va afișa pe ecran numărul L cerut sau mesajul NU EXISTA, alături de un mesaj de confirmare a datelor.

	==Restricții și precizări==		==Restricții și precizări==
Line 27:		Line 27:
	==Exemple==		==Exemple==
	===Exemplul 1:===		===Exemplul 1:===
	Intrare		; Intrare
			: 5
	5		: 1 2 2 2 1
	1 2 2 2 1		;Ieșire
	Ieșire		: Valid input
			: 3
	3
	Explicație		Explicație
	S-a format șirul V : ATTTA, cea mai lunga secvență de elemente T are lungimea 3, iar 3 este un număr cu toți biții setați.		S-a format șirul V : ATTTA, cea mai lunga secvență de elemente T are lungimea 3, iar 3 este un număr cu toți biții setați.

	===Exemplul 2:===		===Exemplul 2:===
	Intrare		;Intrare
			: 20
	20		: 1 2 1 2 2 2 1 2 2 2 2 2 2 2 1 1 1 1 1 1
	1 2 1 2 2 2 1 2 2 2 2 2 2 2 1 1 1 1 1 1		;Ieșire
	Ieșire		: Valid input
			: 7
	7
	Explicație		Explicație
	S-a format șirul V : ATATTTATTTTTTTAAAAAA, lungimile secvențelor sunt : 1, 3, 7, toate aceste numere au biții setați, însă, cea mai lungă secvență este de 7 T-uri.		S-a format șirul V : ATATTTATTTTTTTAAAAAA, lungimile secvențelor sunt : 1, 3, 7, toate aceste numere au biții setați, însă, cea mai lungă secvență este de 7 T-uri.

	===Exemplul 3:===		===Exemplul 3:===
	Intrare		;Intrare
			: 6
	6		: 1 2 3 2 3 1
	1 2 3 2 3 1		; Ieșire
	Ieșire		: Valid input
			: NU EXISTA
	NU EXISTA
	Explicație		Explicație
	S-a format șirul V : ATTTTA, cea mai lungă secvență de elemente T are lungimea 4, iar 4 NU este un număr cu toți biții setați.		S-a format șirul V : ATTTTA, cea mai lungă secvență de elemente T are lungimea 4, iar 4 NU este un număr cu toți biții setați.

	===Exemplul 4:===		===Exemplul 4:===
	Intrare		; Intrare
			: 15
	15		: 6 3 2 3 4 3 3 2 3 2 2 3 2 1 1
	6 3 2 3 4 3 3 2 3 2 2 3 2 1 1		; Ieșire
	Ieșire		: Valid input
			: 3
	3
	Explicație		Explicație
	S-a format șirul V : ATTTATTTTTTTTAA, cea mai lungă secvență de elemente T are lungimea 8, dar 8 NU este un număr cu toți biții setați. Cea mai lungă secvență de elemente T, de lungime L, L fiind un număr cu toți biții setați, este TTT și are lungime 3.		S-a format șirul V : ATTTATTTTTTTTAA, cea mai lungă secvență de elemente T are lungimea 8, dar 8 NU este un număr cu toți biții setați. Cea mai lungă secvență de elemente T, de lungime L, L fiind un număr cu toți biții setați, este TTT și are lungime 3.
Line 99:		Line 95:
	x = int(input())		x = int(input())
	if validate_input(x):		if validate_input(x):
			print("Valid input")
	secv = get_secv(x)		secv = get_secv(x)
	x, c = reduce_to_first_cadran(x, secv)		x, c = reduce_to_first_cadran(x, secv)

Cata: Pagină nouă: Se definește operația AT un procedeu prin care se schimbă caracterul 'A' în 'T' și caracterul 'T' în 'A'. Operația poate fi modelată ca o funcție astfel: AT(A) = T și AT(T) = A. Operația se generalizează pentru orice secvență de caractere formată din literele A și T. De exemplu, dacă se aplică operația AT pentru secvența AAATTA, se va obține TTTAAT. Notăm AT(AAATTA) = TTTAAT. Considerăm șirul infinit S, definit după următoarea regulă: * S1 = ATTA...

2023-04-20T16:51:37Z

Pagină nouă: Se definește operația AT un procedeu prin care se schimbă caracterul 'A' în 'T' și caracterul 'T' în 'A'. Operația poate fi modelată ca o funcție astfel: AT(A) = T și AT(T) = A. Operația se generalizează pentru orice secvență de caractere formată din literele A și T. De exemplu, dacă se aplică operația AT pentru secvența AAATTA, se va obține TTTAAT. Notăm AT(AAATTA) = TTTAAT. Considerăm șirul infinit S, definit după următoarea regulă: * S1 = ATTA...

New page

Se definește operația AT un procedeu prin care se schimbă caracterul 'A' în 'T' și caracterul 'T' în 'A'. Operația poate fi modelată ca o funcție astfel: AT(A) = T și AT(T) = A. Operația se generalizează pentru orice secvență de caractere formată din literele A și T. De exemplu, dacă se aplică operația AT pentru secvența AAATTA, se va obține TTTAAT. Notăm AT(AAATTA) = TTTAAT.

Considerăm șirul infinit S, definit după următoarea regulă:

* S1 = ATTA
* S2 = ATTATAATTAATATTA
* S3 = ATTATAATTAATATTATAATATTAATTATAATTAATATTAATTATAATATTATAATTAATATTA
În general: Sn = Sn-1 AT(Sn-1 ) AT(Sn-1 ) Sn-1 .

==Cerința==
Se dau n numere naturale: k1 , k2 , k3 ... kn. Pentru fiecare număr ki se determină caracterul de pe poziția ki dintr-un element al șirului S care are cel puțin ki caractere. Cu aceste caractere se construiește un nou șir V.

Să se determine un număr L cu toți biții setați, reprezentând lungimea maximă a unei secvențe maximale de caractere 'T' din șirul V. Dacă în șirul V nu există nicio astfel de secvență se va afișa mesajul NU EXISTA.

==Date de intrare==
Programul citește de la tastatură numărul n, iar apoi cele n numere naturale de forma ki, separate prin spații.

==Date de ieșire==
Programul va afișa pe ecran numărul L cerut sau mesajul NU EXISTA.

==Restricții și precizări==
* L &les; N &les; 1.111.111;
* cele n numere citite vor fi mai mici decât 261;
* un număr natural are toți biții setați dacă reprezentarea sa binară conține numai cifre 1;
* pentru un șir dat, o secvență de elemente cu o anumită proprietate este maximală dacă la secvență nu se mai pot adăuga elemente cu acea proprietatea. De exemplu, în șirul qweauaiopaert secvența de vocale eauaio este maximală, dar secvența eaua nu este maximală pentru că la ea se mai pot adăuga alte vocale.

==Exemple==
===Exemplul 1:===
Intrare

5
1 2 2 2 1
Ieșire

3
Explicație
S-a format șirul V : ATTTA, cea mai lunga secvență de elemente T are lungimea 3, iar 3 este un număr cu toți biții setați.

===Exemplul 2:===
Intrare

20
1 2 1 2 2 2 1 2 2 2 2 2 2 2 1 1 1 1 1 1
Ieșire

7
Explicație
S-a format șirul V : ATATTTATTTTTTTAAAAAA, lungimile secvențelor sunt : 1, 3, 7, toate aceste numere au biții setați, însă, cea mai lungă secvență este de 7 T-uri.

===Exemplul 3:===
Intrare

6
1 2 3 2 3 1
Ieșire

NU EXISTA
Explicație
S-a format șirul V : ATTTTA, cea mai lungă secvență de elemente T are lungimea 4, iar 4 NU este un număr cu toți biții setați.

===Exemplul 4:===
Intrare

15
6 3 2 3 4 3 3 2 3 2 2 3 2 1 1
Ieșire

3
Explicație
S-a format șirul V : ATTTATTTTTTTTAA, cea mai lungă secvență de elemente T are lungimea 8, dar 8 NU este un număr cu toți biții setați. Cea mai lungă secvență de elemente T, de lungime L, L fiind un număr cu toți biții setați, este TTT și are lungime 3.

==Rezolvare==
<syntaxhighlight lang="python">
def all_bits(x):
return (x and not (x & (x-1))) # verifica daca toate bitii lui x sunt setati la 1

def validate_input(x):
return x < 2**61 and all_bits(x)

def get_secv(x):
secv = 1
while secv < x: # caut lungimea sirului, putere de 4, care cuprinde pozitia x
secv <<= 2
return secv

def reduce_to_first_cadran(x, secv):
cadran = x // secv + (x % secv != 0) # aflu "cadranul" in care ma aflu, raportat la lungimea secventelor
if cadran == 1:
return x, 65 # cazul de baza, nu sufera transformari
elif cadran == 2 or cadran == 3:
x -= (cadran - 1) * secv # reduc x ul in primul cadran
return x, 149 - 65 # se schimba valoarea
else:
x -= 3 * secv # reduc x ul in primul cadran
return x, 65

def process_input(n):
for i in range(n):
x = int(input())
if validate_input(x):
secv = get_secv(x)
x, c = reduce_to_first_cadran(x, secv)
yield x, secv, c

def main():
n = int(input())
lmax = 0
l = 0
start = False

for x, secv, c in process_input(n):
if x == 2 or x == 3:
c = 149 - c
if c == ord('T'):
if not start:
start = True
l = 1
else:
l += 1
else:
if all_bits(l + 1):
lmax = max(lmax, l)
l = 0
start = False

if all_bits(l + 1):
lmax = max(lmax, l)

if lmax:
print(lmax)
else:
print("NU EXISTA")

if __name__ == '__main__':
main()

</syntaxhighlight>

==Explicație cod==
Acest cod implementează o funcționalitate care primește un număr n și n valori întregi de la utilizator. Funcția verifică dacă fiecare valoare îndeplinește anumite condiții și, dacă da, efectuează anumite transformări și calculează lungimea celei mai lungi secvențe continue de caractere 'T' în codul ASCII obținut în urma transformărilor.

Funcția all_bits(x) primește un întreg și verifică dacă toți biții sunt setați la 1. Funcția validate_input(x) verifică dacă valoarea introdusă x este mai mică decât 2^61 și toți biții sunt setați la 1. Funcția get_secv(x) calculează cea mai mare putere de 4 mai mică decât valoarea introdusă x.

Funcția reduce_to_first_cadran(x, secv) primește două valori, o valoare întreagă x și o valoare secv și calculează în ce cadran se află x raportat la secv, reducând x la valoarea sa din primul cadran (între 0 și secv). Funcția returnează valoarea x și c, care este un număr în funcție de cadranul în care se află x.

Funcția process_input(n) primește un întreg n și citește n valori întregi de la utilizator. Pentru fiecare valoare, se verifică dacă aceasta îndeplinește condițiile necesare și, în caz afirmativ, se calculează secvența și cadranul corespunzătoare, și se returnează o secvență de trei valori: x, secv și c.

Funcția main() primește un întreg n și apelează funcția process_input(n) pentru a procesa valorile introduse. Pentru fiecare valoare x, se aplică anumite transformări și se calculează lungimea celei mai lungi secvențe continue de caractere 'T' în codul ASCII obținut. Lungimea maximă a secvenței este afișată la sfârșitul funcției.

În general, codul este folosit pentru a procesa și transforma date și pentru a calcula anumite valori specifice, cum ar fi lungimea celei mai lungi secvențe de caractere.