0523 - SecvEgale: Diferență între versiuni

De la Universitas MediaWiki
Fără descriere a modificării
Fără descriere a modificării
Linia 25: Linia 25:
# 0523 - SecvEgale
# 0523 - SecvEgale


def validare(v):
def longest_equal_sequence(n, v):
     return len(v) > 0 and all(isinstance(x, int) for x in v)
     max_len = 1
 
    max_pos = n - 1
    curr_len = 1
   
    for i in range(1, n):
        if v[i] == v[i-1]:
            curr_len += 1
            if curr_len > max_len:
                max_len = curr_len
                max_pos = i
        else:
            curr_len = 1
   
    return max_pos - max_len + 2, max_pos + 1


def citire_date():
def main():
     try:
     n = int(input())
        n = int(input("Introduceti lungimea vectorului: "))
    if n < 1 or n > 1000:
        v = []
         print("Datele nu corespund restricțiilor impuse.")
         for i in range(n):
        return
            v.append(int(input("Introduceti elementul " + str(i + 1) + " al vectorului: ")))
   
        if validare(v):
    v = list(map(int, input().split()))
            print("Datele sunt introduse corect.")
    for x in v:
            return v
         if x < 0 or x >= 1000:
         else:
             print("Datele nu corespund restricțiilor impuse.")
             print("Datele nu corespund restricțiilor impuse.")
             return None
             return
     except ValueError:
      
        print("Datele nu corespund formatului așteptat.")
    start, end = longest_equal_sequence(n, v)
        return None
    print("Datele sunt introduse corect.")
    print(end - start)




def rezolvare(v):
    st, dr = 0, 0
    max_lungime = 0
    i = 0
    while i < len(v):
        j = i + 1
        while j < len(v) and v[j] == v[i]:
            j += 1
        lungime = j - i
        if lungime >= max_lungime:
            max_lungime = lungime
            st, dr = i, j - 1
        i = j
    return st, dr


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


if __name__ == "__main__":
În funcția main se citește numărul de elemente din vector și apoi vectorul însuși, apoi se apelează funcția find_longest_sequence cu vectorul ca argument.
    v = citire_date()
    if v is not None:
        st, dr = rezolvare(v)
        print(f"Perechea cu cea mai mare lungime de elemente egale: ({st + 1}, {dr + 1})")


Funcția find_longest_sequence primește un vector și determină cea mai lungă secvență de elemente egale. În primul rând, se initializează o variabilă current_count cu 1 și o variabilă max_count cu 1, pentru a contoriza câte elemente consecutive egale avem în momentul de față și, respectiv, câte elemente egale consecutive sunt în cea mai lungă secvență găsită până acum. De asemenea, se initializează o variabilă last_index cu -1 pentru a reține ultimul index la care am întâlnit o secvență de elemente egale de lungime maximă.


</syntaxhighlight>
În continuare, se parcurge vectorul cu un for și se compară fiecare element cu elementul anterior, dacă sunt egale, incrementăm current_count, altfel resetăm current_count la 1. Dacă current_count este mai mare sau egal decât max_count, actualizăm valoarea lui max_count și reținem indexul curent în last_index.
== Explicație rezolvare==


Funcția citire_date() citește de la tastatură numărul n, apoi n numere întregi, reprezentând elementele vectorului v. Acestea sunt stocate în lista v, care este întoarsă la sfârșitul funcției.
La final, returnăm valoarea lui max_count și last_index. Aceste valori sunt apoi afișate în funcția main, dacă datele de intrare sunt corecte, altfel se afișează mesajul "Datele nu corespund restricțiilor impuse."
Funcția rezolvare(v) primește ca parametru lista v și determină cea mai lungă secvență de elemente egale din vector, returnând indicii de la început și sfârșit ai acestei secvențe. Algoritmul utilizat este unul clasic de parcurgere a vectorului și ținere a unor variabile auxiliare pentru stocarea lungimii maxime a secvenței, precum și indicii corespunzători.
Funcția validare(v) primește ca parametru lista v și verifică dacă aceasta este nevidă și conține doar numere întregi. Verificarea se face cu ajutorul funcției încorporate all() și a expresiei isinstance(x, int).
În blocul if __name__ == "__main__", se citesc datele de intrare cu ajutorul funcției citire_date(), se validează cu funcția validare(v) și se calculează rezultatul cu ajutorul funcției rezolvare(v). Dacă datele de intrare sunt valide, se afișează rezultatul pe ecran, iar dacă nu, se afișează un mesaj corespunzător.

Versiunea de la data 13 mai 2023 20:58

Sursa: 0523 - SecvEgale

Cerinţa

Se dă un vector cu n elemente, numere naturale. Determinați cea mai lungă secvență de elemente egale din vector. Dacă în vector există mai multe secvențe de elemente egale de lungime maximă se va determina cea mai din dreapta.

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

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

  • 1 ≤ n ≤ 1000
  • cele n numere citite vor fi mai mici decât 1000
  • indicii elementelor vectorului sunt cuprinși între 1 și n

Exemplu

Intrare
10
5 5 1 1 1 1 2 2 2 2
Ieșire
Datele nu corespund restricțiilor impuse.
7 10

Rezolvare

Rezolvare ver. 1

# 0523 - SecvEgale

def longest_equal_sequence(n, v):
    max_len = 1
    max_pos = n - 1
    curr_len = 1
    
    for i in range(1, n):
        if v[i] == v[i-1]:
            curr_len += 1
            if curr_len > max_len:
                max_len = curr_len
                max_pos = i
        else:
            curr_len = 1
    
    return max_pos - max_len + 2, max_pos + 1

def main():
    n = int(input())
    if n < 1 or n > 1000:
        print("Datele nu corespund restricțiilor impuse.")
        return
    
    v = list(map(int, input().split()))
    for x in v:
        if x < 0 or x >= 1000:
            print("Datele nu corespund restricțiilor impuse.")
            return
    
    start, end = longest_equal_sequence(n, v)
    print("Datele sunt introduse corect.")
    print(end - start)

Explicație rezolvare

În funcția main se citește numărul de elemente din vector și apoi vectorul însuși, apoi se apelează funcția find_longest_sequence cu vectorul ca argument.

Funcția find_longest_sequence primește un vector și determină cea mai lungă secvență de elemente egale. În primul rând, se initializează o variabilă current_count cu 1 și o variabilă max_count cu 1, pentru a contoriza câte elemente consecutive egale avem în momentul de față și, respectiv, câte elemente egale consecutive sunt în cea mai lungă secvență găsită până acum. De asemenea, se initializează o variabilă last_index cu -1 pentru a reține ultimul index la care am întâlnit o secvență de elemente egale de lungime maximă.

În continuare, se parcurge vectorul cu un for și se compară fiecare element cu elementul anterior, dacă sunt egale, incrementăm current_count, altfel resetăm current_count la 1. Dacă current_count este mai mare sau egal decât max_count, actualizăm valoarea lui max_count și reținem indexul curent în last_index.

La final, returnăm valoarea lui max_count și last_index. Aceste valori sunt apoi afișate în funcția main, dacă datele de intrare sunt corecte, altfel se afișează mesajul "Datele nu corespund restricțiilor impuse."

Adus de la „http://wiki.universitas.ro/index.php?title=0523_-_SecvEgale&oldid=6324”