0524 - SecvEgale1: Diferență între versiuni

De la Universitas MediaWiki
Fără descriere a modificării
Fără descriere a modificării
 
(Nu s-a afișat o versiune intermediară efectuată de același utilizator)
Linia 26: Linia 26:
; Ieșire
; Ieșire
: Datele nu corespund restricțiilor impuse.
: Datele nu corespund restricțiilor impuse.
: 2 3 4
 
== Rezolvare ==  
== Rezolvare ==  
=== Rezolvare ver. 1 ===
=== Rezolvare ver. 1 ===
Linia 32: Linia 32:
# 0524 - SecvEgale1
# 0524 - SecvEgale1


def citeste_date_intrare():
def validate_input(n, v):
     n = int(input())
     if not (isinstance(n, int) and n >= 1 and n <= 1000):
     v = list(map(int, input().split()))
        return False
     return n, v
     if not all(isinstance(x, int) and x >= 0 and x < 1000000000 for x in v):
        return False
     return True
 


def find_identical_sequence(n, v):
    max_len = 0
    seq_start = None
    seq_end = None


def determina_secventa_maxima(n, v):
    st, dr = -1, -1
     for i in range(n):
     for i in range(n):
         if v[i] == v[0]:
         for j in range(i+1, n+1):
             j = i
             if v[i:j] == v[i:j][::-1] and j-i > max_len:
            while j < n and v[j] == v[i]:
                 seq_start = i+1
                j += 1
                seq_end = j
            if j - i > dr - st:
                max_len = j-i
                 st, dr = i, j - 1
    return st, dr


    if max_len > 0:
        return (seq_start, seq_end)
    else:
        return None


def valideaza_datele_intrare(n, v):
    return len(v) == n and n > 0 and n <= 1000 and max(v) < 1000


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


if __name__ == '__main__':
     if validate_input(n, v):
    n, v = citeste_date_intrare()
         result = find_identical_sequence(n, v)
     if valideaza_datele_intrare(n, v):
         if result:
         st, dr = determina_secventa_maxima(n, v)
             print("Datele sunt introduse corect.")
         if st == -1 and dr == -1:
            print(result[0], result[1])
             print("NU")
         else:
         else:
             print(st + 1, dr + 1)
             print("Nu exista secventa identica.")
     else:
     else:
         print("Datele nu corespund restricțiilor impuse.")  
         print("Datele nu corespund restricțiilor impuse.")
 
 




</syntaxhighlight>
</syntaxhighlight>
== Explicatie Rezolvare ==
== Explicatie Rezolvare ==
Funcția citeste_date_intrare citește de la tastatură numerele n și elementele vectorului v și le returnează ca o listă de întregi.
Funcția validate_input primește n și v și verifică dacă n se află în intervalul [1, 1000] și dacă fiecare element al listei v se află în intervalul [0, 1000000000]. Dacă datele sunt valide, funcția returnează True, altfel returnează False.
 
Funcția determina_secventa_maxima primește vectorul v și returnează indicii st și dr ai capetelor secvenței determinate.


Funcția valideaza_datele_intrare primește vectorul v și returnează True dacă datele de intrare sunt valide și False altfel. În acest caz, verificăm doar dacă vectorul nu este gol.
Funcția find_identical_sequence primește n și v și parcurge fiecare posibilă subsecvență a lui v. Dacă subsecvența este identică cu inversul ei și este mai mare decât lungimea maximă găsită până acum, actualizează lungimea maximă și poziția de început și sfârșit a secvenței. Dacă nu se găsește o secvență identică, funcția returnează None.


În funcția main, mai întâi citim datele de intrare și verificăm dacă sunt valide. Apoi, determinăm secvența maximă și afișăm indicii capetelor secvenței sau mesajul "NU", dacă nu există nicio secvență.
În funcția if __name__ == "__main__", citim n și v și verificăm dacă datele sunt valide. Dacă sunt, apelăm find_identical_sequence și afișăm secvența identică dacă există. Altfel, afișăm un mesaj de eroare corespunzător.

Versiunea curentă din 14 mai 2023 20:04

Sursa: 0524 - SecvEgale1


Cerinţa

Se dă un vector cu n elemente, numere naturale. Determinați cea mai lungă secvență de elemente din vector care începe și se termină cu aceeași valoare. Dacă în vector există mai multe secvențe corecte 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

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 ≤ 1000
  • cele n numere citite vor fi mai mici decât 1.000.000.000
  • indexarea elementelor vectorului începe de la 1.

Exemplu 1

Intrare
12
6 6 8 3 6 6 3 8 4 3 3 4
Ieșire
Datele sunt introduse corect..
4 11

Exemplu 2

Intrare
11
6 2 8 3 3 6 3 8 4 1 3 4
Ieșire
Datele nu corespund restricțiilor impuse.

Rezolvare

Rezolvare ver. 1

# 0524 - SecvEgale1

def validate_input(n, v):
    if not (isinstance(n, int) and n >= 1 and n <= 1000):
        return False
    if not all(isinstance(x, int) and x >= 0 and x < 1000000000 for x in v):
        return False
    return True


def find_identical_sequence(n, v):
    max_len = 0
    seq_start = None
    seq_end = None

    for i in range(n):
        for j in range(i+1, n+1):
            if v[i:j] == v[i:j][::-1] and j-i > max_len:
                seq_start = i+1
                seq_end = j
                max_len = j-i

    if max_len > 0:
        return (seq_start, seq_end)
    else:
        return None


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

    if validate_input(n, v):
        result = find_identical_sequence(n, v)
        if result:
            print("Datele sunt introduse corect.")
            print(result[0], result[1])
        else:
            print("Nu exista secventa identica.")
    else:
        print("Datele nu corespund restricțiilor impuse.")

Explicatie Rezolvare

Funcția validate_input primește n și v și verifică dacă n se află în intervalul [1, 1000] și dacă fiecare element al listei v se află în intervalul [0, 1000000000]. Dacă datele sunt valide, funcția returnează True, altfel returnează False.

Funcția find_identical_sequence primește n și v și parcurge fiecare posibilă subsecvență a lui v. Dacă subsecvența este identică cu inversul ei și este mai mare decât lungimea maximă găsită până acum, actualizează lungimea maximă și poziția de început și sfârșit a secvenței. Dacă nu se găsește o secvență identică, funcția returnează None.

În funcția if __name__ == "__main__", citim n și v și verificăm dacă datele sunt valide. Dacă sunt, apelăm find_identical_sequence și afișăm secvența identică dacă există. Altfel, afișăm un mesaj de eroare corespunzător.