0524 - SecvEgale1: Difference between revisions

From Bitnami MediaWiki
Flaviu (talk | contribs)
No edit summary
Flaviu (talk | contribs)
No edit summary
 
Line 26: Line 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 ===
Line 32: Line 32:
# 0524 - SecvEgale1
# 0524 - SecvEgale1


def gaseste_secventa_identica(n, v):
def validate_input(n, v):
     secventa = None
     if not (isinstance(n, int) and n >= 1 and n <= 1000):
     max_lungime = 0
        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 i in range(n):
         for j in range(i, n):
         for j in range(i+1, n+1):
             if v[i] == v[j]:
             if v[i:j] == v[i:j][::-1] and j-i > max_len:
                 lungime = j - i + 1
                 seq_start = i+1
                 if lungime > max_lungime:
                 seq_end = j
                    max_lungime = lungime
                max_len = j-i
                    secventa = (i+1, j+1)
 
      
    if max_len > 0:
    return secventa
        return (seq_start, seq_end)
     else:
        return None
 


if __name__ == "__main__":
if __name__ == "__main__":
     n = int(input())
     n = int(input())
     v = list(map(int, input().split()))
     v = list(map(int, input().split()))
   
 
     if not (isinstance(n, int) and n >= 1 and n <= 1000):
     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.")
         print("Datele nu corespund restricțiilor impuse.")
        exit()
 
   
    if not all(isinstance(x, int) and x >= 0 and x < 1000000000 for x in v):
        print("Datele nu corespund restricțiilor impuse.")
        exit()
       
    rezultat = gaseste_secventa_identica(n, v)
   
    if rezultat is None:
        print("Datele nu corespund restricțiilor impuse.")
    else:
        print("Datele sunt introduse corect.")
        print(rezultat[0], rezultat[1])




Line 70: Line 77:
</syntaxhighlight>
</syntaxhighlight>
== Explicatie Rezolvare ==
== Explicatie Rezolvare ==
Funcția gaseste_secventa_identica primește ca argumente lungimea listei și lista însăși și returnează o tuplă de forma (i, j) reprezentând indicii începutului și sfârșitului celei mai lungi secvențe de elemente egale din listă.
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.


Blocul if __name__ == "__main__": citește datele de intrare, validează datele și apelează funcția gaseste_secventa_identica pentru a obține rezultatul, pe care îl afișează pe ecran.
Î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.

Latest revision as of 20:04, 14 May 2023

Sursa: 0524 - SecvEgale1


Cerinţa[edit | edit source]

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

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

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

Exemplu 2[edit | edit source]

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

Rezolvare[edit | edit source]

Rezolvare ver. 1[edit | edit source]

<syntaxhighlight lang="python" line>

  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.")



</syntaxhighlight>

Explicatie Rezolvare[edit | edit source]

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.