0523 - SecvEgale: Difference between revisions

From Bitnami MediaWiki
Flaviu (talk | contribs)
Pagină nouă: Sursa: [https://www.pbinfo.ro/probleme/523/secvegale 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șir...
 
Flaviu (talk | contribs)
No edit summary
 
(3 intermediate revisions by the same user not shown)
Line 6: Line 6:
Programul citește de la tastatură numărul n, iar apoi n numere naturale, reprezentând elementele vectorului.
Programul citește de la tastatură numărul n, iar apoi n numere naturale, reprezentând elementele vectorului.
== Date de ieșire ==  
== Date de ieșire ==  
Programul va afișa pe ecran indicii st dr ai capetelor secvenței determinate, separați printr-un spațiu.
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 ≤ 1000
* 1 ≤ n ≤ 1000
Line 16: Line 17:
: 5 5 1 1 1 1 2 2 2 2  
: 5 5 1 1 1 1 2 2 2 2  
; Ieșire
; Ieșire
: 7 10
: Datele nu corespund restricțiilor impuse.
 


== Rezolvare ==  
== Rezolvare ==  
Line 23: Line 25:
# 0523 - SecvEgale
# 0523 - SecvEgale


n = int(input("Introduceți numărul de elemente din vector: "))
def validare(n, v):
v = list(map(int, input("Introduceți elementele vectorului: ").split()))
    if n < 1 or n > 1000:
        return False
    for x in v:
        if x < 0 or x >= 1000:
            return False
    return True
 
 
def rezolvare(n, v):
    if not validare(n, v):
        return "Datele nu corespund restricțiilor impuse."
 
    maxim = 1
    poz = n - 1
    for i in range(n - 1, 0, -1):
        lungime = 1
        while i > 0 and v[i] == v[i - 1]:
            lungime += 1
            i -= 1
        if lungime > maxim:
            maxim = lungime
            poz = i
 
    return maxim
 


# Initializăm variabilele pentru secvența maximă
if __name__ == "__main__":
max_len = 1
    n = int(input())
max_start = 0
    v = list(map(int, input().split()))
max_end = 0


# Parcurgem vectorul incepand de la elementul 1
     rez = rezolvare(n, v)
i = 1
    if isinstance(rez, str):
while i < n:
         print(rez)
    # Daca elementul curent este egal cu cel anterior
     if v[i] == v[i-1]:
        # Determinăm lungimea secvenței curente
        len_seq = 2
        j = i + 1
        while j < n and v[j] == v[j-1]:
            len_seq += 1
            j += 1
        # Verificăm dacă secvența curentă este mai lungă decât cea maximă
        if len_seq > max_len:
            max_len = len_seq
            max_start = i - 1
            max_end = j - 1
         # Daca există mai multe secvențe de aceeași lungime maximă
        # Alegem secvența mai din dreapta
        elif len_seq == max_len and j - 1 > max_end:
            max_start = i - 1
            max_end = j - 1
        i = j
     else:
     else:
         i += 1
         print("Datele sunt introduse corect.")
        print(rez)


# Afisăm capetele secvenței maximale
</syntaxhighlight>
print(max_start, max_end)
== Explicație rezolvare==


</syntaxhighlight>
Funcția validare primește numărul de elemente n și vectorul v și returnează True dacă acestea corespund restricțiilor impuse și False în caz contrar. Mai precis, verifică dacă n este între 1 și 1000 și dacă toate elementele din v sunt numere naturale mai mici decât 1000.
Funcția rezolvare primește numărul de elemente n și vectorul v și returnează lungimea celei mai lungi secvențe de elemente egale din vector. Mai precis, parcurge vectorul de la dreapta la stânga și pentru fiecare element verifică cât de lungă este secvența de elemente egale care începe cu el. Dacă lungimea acestei secvențe este mai mare decât lungimea celei mai lungi secvențe găsite până acum, atunci actualizează variabila maxim și variabila poz care reține poziția primei apariții a celei mai lungi secvențe de elemente egale.
În funcția rezolvare se folosește și funcția validare pentru a verifica dacă datele de intrare sunt corecte.
În funcția rezolvare se consideră că dacă în vector există mai multe secvențe de elemente egale de lungime maximă, atunci se determină cea mai din dreapta.
În funcția rezolvare se folosește funcția isinstance pentru a verifica dacă rezultatul este un șir de caractere (adică mesajul de eroare) sau un număr (adică lungimea celei mai lungi secvențe de elemente egale).
Citirea datelor de intrare și afișarea rezultatului se fac în funcția main.

Latest revision as of 19:35, 14 May 2023

Sursa: 0523 - SecvEgale


Cerinţa[edit | edit source]

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[edit | edit source]

Programul citește de la tastatură numărul n, iar apoi n numere naturale, reprezentând elementele vectorului.

Date de ieșire[edit | edit source]

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[edit | edit source]

  • 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[edit | edit source]

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


Rezolvare[edit | edit source]

Rezolvare ver. 1[edit | edit source]

<syntaxhighlight lang="python" line>

  1. 0523 - SecvEgale

def validare(n, v):

   if n < 1 or n > 1000:
       return False
   for x in v:
       if x < 0 or x >= 1000:
           return False
   return True


def rezolvare(n, v):

   if not validare(n, v):
       return "Datele nu corespund restricțiilor impuse."
   maxim = 1
   poz = n - 1
   for i in range(n - 1, 0, -1):
       lungime = 1
       while i > 0 and v[i] == v[i - 1]:
           lungime += 1
           i -= 1
       if lungime > maxim:
           maxim = lungime
           poz = i
   return maxim


if __name__ == "__main__":

   n = int(input())
   v = list(map(int, input().split()))
   rez = rezolvare(n, v)
   if isinstance(rez, str):
       print(rez)
   else:
       print("Datele sunt introduse corect.")
       print(rez)

</syntaxhighlight>

Explicație rezolvare[edit | edit source]

Funcția validare primește numărul de elemente n și vectorul v și returnează True dacă acestea corespund restricțiilor impuse și False în caz contrar. Mai precis, verifică dacă n este între 1 și 1000 și dacă toate elementele din v sunt numere naturale mai mici decât 1000. Funcția rezolvare primește numărul de elemente n și vectorul v și returnează lungimea celei mai lungi secvențe de elemente egale din vector. Mai precis, parcurge vectorul de la dreapta la stânga și pentru fiecare element verifică cât de lungă este secvența de elemente egale care începe cu el. Dacă lungimea acestei secvențe este mai mare decât lungimea celei mai lungi secvențe găsite până acum, atunci actualizează variabila maxim și variabila poz care reține poziția primei apariții a celei mai lungi secvențe de elemente egale. În funcția rezolvare se folosește și funcția validare pentru a verifica dacă datele de intrare sunt corecte. În funcția rezolvare se consideră că dacă în vector există mai multe secvențe de elemente egale de lungime maximă, atunci se determină cea mai din dreapta. În funcția rezolvare se folosește funcția isinstance pentru a verifica dacă rezultatul este un șir de caractere (adică mesajul de eroare) sau un număr (adică lungimea celei mai lungi secvențe de elemente egale). Citirea datelor de intrare și afișarea rezultatului se fac în funcția main.