0578 - SecvEgale2: Diferență între versiuni

De la Universitas MediaWiki
Fără descriere a modificării
Fără descriere a modificării
 
(Nu s-au afișat 4 versiuni intermediare efectuate de același utilizator)
Linia 27: Linia 27:
: 4 3 3 3 5
: 4 3 3 3 5
; Ieșire
; Ieșire
: Datele nu corespund restricțiilor impuse.
: Datele nu corespund restrictiilor inpuse.
: 3
 


== Rezolvare ==  
== Rezolvare ==  
Linia 35: Linia 35:
# 0578 - SecvEgale2
# 0578 - SecvEgale2


def read_input():
def validate_input(n, arr):
     n = int(input())
     if not 1 <= n <= 100000:
     v = list(map(int, input().split()))
        return False
    return v
    if not all(0 <= x < 1000000000 for x in arr):
        return False
    return True
 
 
def longest_equal_seq(n, arr):
     if not validate_input(n, arr):
        print("Datele nu corespund restricțiilor impuse.")
        return


def count_equal_sequences(v):
     count = 1
     cnt = 0
     max_count = 1
     last = None
 
    seq_len = 0
     for i in range(1, n):
   
         if arr[i] == arr[i - 1]:
     for i in range(len(v)):
             count += 1
         if v[i] != last:
             if seq_len >= 2:
                cnt += 1
            seq_len = 1
            last = v[i]
         else:
         else:
             seq_len += 1
             max_count = max(max_count, count)
              
             count = 1
    if seq_len >= 2:
        cnt += 1
       
    return cnt


def validate_output(expected, actual):
    max_count = max(max_count, count)
     return expected == actual
    print("Datele sunt introduse corect.")
     print(max_count)


if __name__ == '__main__':
    v = read_input()
    result = count_equal_sequences(v)
    expected = int(input())
    if validate_output(expected, result):
        print("Datele sunt introduse corect.")
    else:
        print("Datele nu corespund restricțiilor impuse.")
    if validate_output(expected, result):
        print("Raspunsul este: ", result)


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




Linia 78: Linia 72:


== Explicatie Rezolvare ==
== Explicatie Rezolvare ==
arr -> vine de la lista


read_input(): Aceasta functie citeste de la tastatura numarul de elemente al listei si apoi elementele listei, separate prin spatii. Aceasta returneaza lista citita.
validate_input(n: int, arr: list[int]) -> bool: Această funcție primește doi parametri: numărul n și vectorul arr. Funcția verifică dacă numărul n respectă restricțiile impuse de problema (adica 1 ≤ n ≤ 100.000) și dacă toate elementele din vectorul arr sunt mai mici decât 1.000.000.000. Dacă restricțiile sunt respectate, funcția returnează True, altfel returnează False.
 
count_equal_sequences(v): Aceasta functie primeste o lista v ca si argument si calculeaza numarul de secvente consecutive formate din cel putin doua elemente egale. Pentru asta, parcurgem lista si incrementam un contor atunci cand gasim o secventa valida.


validate_output(expected, actual): Aceasta functie primeste doua argumente: valoarea asteptata (expected) si valoarea reala (actual) a rezultatului. Aceasta verifica daca cele doua valori sunt egale si returneaza True daca da si False altfel.
find_longest_equal_seq(n: int, arr: list[int]) -> None: Această funcție primește doi parametri: numărul n și vectorul arr. Funcția verifica dacă datele sunt introduse corect folosind funcția validate_input și, în caz afirmativ, găsește lungimea celei mai lungi secvențe a vectorului arr care conține elemente egale și afișează indicii capetelor acestei secvențe.


In ceea ce priveste blocul if __name__ == '__main__':, acesta verifica daca programul este executat ca si script (adica nu este importat ca modul) si, in caz afirmativ, citeste datele de intrare, apeleaza functia count_equal_sequences() cu aceste date, citeste rezultatul asteptat de la tastatura, si verifica daca rezultatul real si cel asteptat sunt egale cu ajutorul functiei validate_output(). In functie de rezultatul acestei verificari, este afisat un mesaj corespunzator.
In if __name__ == "__main__"itim numărul n și vectorul arr folosind input de la utilizator. Apoi, apelăm funcția find_longest_equal_seq și afișăm rezultatul.

Versiunea curentă din 14 mai 2023 20:31

Sursa: 0578 - SecvEgale2

Cerinţa

Se dă un vector cu n elemente, numere naturale. Determinați câte secvențe ale vectorului au toate elementele egale.

Date de intrare

Programul citește de la tastatură numărul n, apoi cele n elemente ale vectorului.

Date de ieșire

Dacă datele sunt introduse corect, pe ecran se va afișa: "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

  • 1 ≤ n ≤ 100.000
  • elementele vectorului vor fi mai mici decât 1.000.000.000

Exemplu 1

Intrare
5
4 3 3 3 5
Ieșire
Datele sunt introduse corect.
8

Exemplu 2

Intrare
5
4 3 3 3 5
Ieșire
Datele nu corespund restrictiilor inpuse.


Rezolvare

Rezolvare ver. 1

# 0578 - SecvEgale2

def validate_input(n, arr):
    if not 1 <= n <= 100000:
        return False
    if not all(0 <= x < 1000000000 for x in arr):
        return False
    return True


def longest_equal_seq(n, arr):
    if not validate_input(n, arr):
        print("Datele nu corespund restricțiilor impuse.")
        return

    count = 1
    max_count = 1

    for i in range(1, n):
        if arr[i] == arr[i - 1]:
            count += 1
        else:
            max_count = max(max_count, count)
            count = 1

    max_count = max(max_count, count)
    print("Datele sunt introduse corect.")
    print(max_count)


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

Explicatie Rezolvare

arr -> vine de la lista

validate_input(n: int, arr: list[int]) -> bool: Această funcție primește doi parametri: numărul n și vectorul arr. Funcția verifică dacă numărul n respectă restricțiile impuse de problema (adica 1 ≤ n ≤ 100.000) și dacă toate elementele din vectorul arr sunt mai mici decât 1.000.000.000. Dacă restricțiile sunt respectate, funcția returnează True, altfel returnează False.

find_longest_equal_seq(n: int, arr: list[int]) -> None: Această funcție primește doi parametri: numărul n și vectorul arr. Funcția verifica dacă datele sunt introduse corect folosind funcția validate_input și, în caz afirmativ, găsește lungimea celei mai lungi secvențe a vectorului arr care conține elemente egale și afișează indicii capetelor acestei secvențe.

In if __name__ == "__main__"itim numărul n și vectorul arr folosind input de la utilizator. Apoi, apelăm funcția find_longest_equal_seq și afișăm rezultatul.

Adus de la „http://wiki.universitas.ro/index.php?title=0578_-_SecvEgale2&oldid=6443”