1846 - OrdonareSecvF REC: Difference between revisions

From Bitnami MediaWiki
No edit summary
No edit summary
 
(One intermediate revision by the same user not shown)
Line 7: Line 7:


==Date de ieșire==
==Date de ieșire==
Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".
În cazul în care datele introduse de la tastatură nu îndeplinesc cerințele enunțate, pe ecran se va afișa mesajul "Datele de intrare nu corespund restricțiilor impuse.".


==Restricţii şi precizări==
==Restricţii şi precizări==
0 < n <= 1000
*0 < n <= 1000
numele subprogramului cerut este ordonare
*numele subprogramului cerut este ordonare
parametrii sunt, în această ordine: a, n, st, dr
*parametrii sunt, în această ordine: a, n, st, dr
0≤st≤dr<n
*0≤st≤dr<n
elementele tabloului a sunt indexate de la zero
*elementele tabloului a sunt indexate de la zero
se recomandă realizarea unei soluții recursive
*se recomandă realizarea unei soluții recursive


==Exemplu==
==Exemplu==
Dacă n=6, a=(63,273,9,83,93,123), st=1 și dr=3 după apelul subprogramului tabloul a devine (63,9,83,273,93,123).
===Exemplu 1===
:Intrare:
;Introduceti numarul de elemente: 6
;Introduceti cele 6 numere separate prin spatiu: 63 273 9 83 93 123
;Introduceti indexul stanga: 1
;Introduceti indexul dreapta: 3
:Iesire:
[63, 9, 83, 273, 93, 123]
 
===Exemplu 2===
:Intrare:
;Introduceti numarul de elemente: 1001
:Iesire:
;Datele de intrare nu corespund cerinței.


==Important==
==Important==
Line 25: Line 37:


==Rezolvare==
==Rezolvare==
<syntaxhighlight lang="python" line="1">
def validare_numar(numar):
    if not numar.isdigit():
        return False
    n = int(numar)
    if n < 1 or n > 1000:
        return False
    return True


Funcția de validare
def validare_index(index, n):
Pentru a valida datele de intrare vom verifica dacă valorile sunt numere naturale mai mici decât 1.000.000.000 și dacă valorile indiciilor st și dr sunt în intervalul [0, n), unde n este lungimea tabloului a.
     if not index.isdigit():
 
 
def validare(n: int, st: int, dr: int) -> bool:
     if not (0 < n <= 1000):
         return False
         return False
     if not (0 <= st <= dr < n):
    i = int(index)
     if i < 0 or i >= n:
         return False
         return False
     return True
     return True
Funcția de rezolvare
Pentru a ordona crescător elementele tabloului a cu indici între st și dr, inclusiv aceștia, vom folosi o implementare a algoritmului quicksort.


 
def ordonare(a, n, st, dr):
def ordonare(a: List[int], n: int, st: int, dr: int) -> None:
     if st < dr:
     if st < dr:
         pivot = partition(a, st, dr)
         pivot = a[dr]
        ordonare(a, n, st, pivot - 1)
        i = st - 1
        ordonare(a, n, pivot + 1, dr)
        for j in range(st, dr):
 
            if a[j] < pivot:
 
                i += 1
def partition(a: List[int], st: int, dr: int) -> int:
                a[i], a[j] = a[j], a[i]
    pivot = a[dr]
        i += 1
    i = st - 1
        a[i], a[dr] = a[dr], a[i]
    for j in range(st, dr):
        ordonare(a, n, st, i - 1)
        if a[j] <= pivot:
        ordonare(a, n, i + 1, dr)
            i += 1
            a[i], a[j] = a[j], a[i]
    a[i + 1], a[dr] = a[dr], a[i + 1]
    return i + 1
Funcția partition este implementarea unei etape a algoritmului quicksort, care selectează un element pivot și împarte tabloul în două subtablouri, astfel încât elementele mai mici decât pivot sunt înaintea sa, iar cele mai mari sunt după. Funcția întoarce indicele poziției pivot după ce tabloul a fost partitionat.
 
Funcția ordonare este implementarea recursivă a algoritmului quicksort pentru a ordona crescător elementele tabloului a cu indici între st și dr, inclusiv aceștia. Pe baza valorii pivotului returnate de partition, subtabloul din stânga pivotului și cel din dreapta pivotului sunt ordonate recursiv cu apeluri recursive la ordonare.
 
Funcția main
Funcția main va citi datele de intrare, le va valida și, în cazul în care acestea sunt corecte, va apela funcția ordonare pentru a ordona elementele tabloului a. Dacă datele de intrare nu corespund restricțiilor impuse, va afișa un mesaj corespunzător.


numar_elemente = input("Introduceti numarul de elemente: ")
if not validare_numar(numar_elemente):
    print("Datele de intrare nu corespund cerinței.")
else:
    n = int(numar_elemente)
    a = input("Introduceti cele " + str(n) + " numere separate prin spatiu: ").split()
    if len(a) != n or not all(map(str.isdigit, a)):
        print("Datele de intrare nu corespund cerinței.")
    else:
        a = [int(x) for x in a]
        st = input("Introduceti indexul stanga: ")
        if not validare_index(st, n):
            print("Datele de intrare nu corespund cerinței.")
        else:
            st = int(st)
            dr = input("Introduceti indexul dreapta: ")
            if not validare_index(dr, n):
                print("Datele de intrare nu corespund cerinței.")
            else:
                dr = int(dr)
                ordonare(a, n, st, dr)
                print(a)
</syntaxhighlight>


def main() -> None:
==Explicații==
    n = int(input())
În funcția validare_input, se validează datele de intrare. Se verifică dacă numărul de elemente n este un număr natural mai mic sau egal cu 1000, iar indicele stanga st și cel dreapta dr sunt numere naturale, st mai mic decât dr și n mai mare decât dr.
    a = list(map(int, input().split()))
    st, dr = map(int, input().split())


    if not validare(n, st, dr):
Funcția ordonare este implementată recursiv, astfel încât să divizeze tabloul în două subtablouri, să le sorteze individual și apoi să le combine într-un tablou sortat. Dacă subtabloul are un singur element sau niciun element, atunci subtabloul este deja sortat. Altfel, se calculează mijlocul subtabloului, se sortează subtabloul stâng și subtaboul drept și apoi se combină cele două subtablouri sortate.
        print("Datele de intrare nu corespund restricțiilor impuse.")
        return


    ordonare(a, n, st, dr)
În funcția main, se citesc datele de intrare și se validează folosind funcția validare_input. Dacă datele de intrare sunt valide, atunci se completează tabloul și se apelează funcția ordonare pentru a sorta elementele între indicii stanga și dreapta. În final, se afișează tabloul sortat.
    print("Datele de intrare co

Latest revision as of 21:59, 14 May 2023

Cerinţa[edit | edit source]

Scrieţi definiția completă a subprogramului recursiv ordonare care are 4 parametri: a, prin care primeşte un tablou unidimensional cu maximum 1000 de numere naturale mai mici decât 1.000.000.000 și n, numărul efectiv de elemente ale tabloului și doi indici st dr. Subprogramul ordonează crescător elementele tabloului a cu indici între st și dr, inclusiv aceștia,fără a modifica celelalte elemente ale tabloului.

Date de intrare[edit | edit source]

Se va introduce de la tastatură un număr natural care va fi transmis ca perimetru

Date de ieșire[edit | edit source]

Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".

Restricţii şi precizări[edit | edit source]

  • 0 < n <= 1000
  • numele subprogramului cerut este ordonare
  • parametrii sunt, în această ordine: a, n, st, dr
  • 0≤st≤dr<n
  • elementele tabloului a sunt indexate de la zero
  • se recomandă realizarea unei soluții recursive

Exemplu[edit | edit source]

Exemplu 1[edit | edit source]

Intrare:
Introduceti numarul de elemente
6
Introduceti cele 6 numere separate prin spatiu
63 273 9 83 93 123
Introduceti indexul stanga
1
Introduceti indexul dreapta
3
Iesire:

[63, 9, 83, 273, 93, 123]

Exemplu 2[edit | edit source]

Intrare:
Introduceti numarul de elemente
1001
Iesire:
Datele de intrare nu corespund cerinței.

Important[edit | edit source]

Soluţia propusă va conţine doar definiţia subprogramului cerut. Prezenţa în soluţie a altor instrucţiuni poate duce erori de compilare sau de execuţie care vor avea ca efect depunctarea soluţiei.

Rezolvare[edit | edit source]

<syntaxhighlight lang="python" line="1"> def validare_numar(numar):

   if not numar.isdigit():
       return False
   n = int(numar)
   if n < 1 or n > 1000:
       return False
   return True

def validare_index(index, n):

   if not index.isdigit():
       return False
   i = int(index)
   if i < 0 or i >= n:
       return False
   return True

def ordonare(a, n, st, dr):

   if st < dr:
       pivot = a[dr]
       i = st - 1
       for j in range(st, dr):
           if a[j] < pivot:
               i += 1
               a[i], a[j] = a[j], a[i]
       i += 1
       a[i], a[dr] = a[dr], a[i]
       ordonare(a, n, st, i - 1)
       ordonare(a, n, i + 1, dr)

numar_elemente = input("Introduceti numarul de elemente: ") if not validare_numar(numar_elemente):

   print("Datele de intrare nu corespund cerinței.")

else:

   n = int(numar_elemente)
   a = input("Introduceti cele " + str(n) + " numere separate prin spatiu: ").split()
   if len(a) != n or not all(map(str.isdigit, a)):
       print("Datele de intrare nu corespund cerinței.")
   else:
       a = [int(x) for x in a]
       st = input("Introduceti indexul stanga: ")
       if not validare_index(st, n):
           print("Datele de intrare nu corespund cerinței.")
       else:
           st = int(st)
           dr = input("Introduceti indexul dreapta: ")
           if not validare_index(dr, n):
               print("Datele de intrare nu corespund cerinței.")
           else:
               dr = int(dr)
               ordonare(a, n, st, dr)
               print(a)

</syntaxhighlight>

Explicații[edit | edit source]

În funcția validare_input, se validează datele de intrare. Se verifică dacă numărul de elemente n este un număr natural mai mic sau egal cu 1000, iar indicele stanga st și cel dreapta dr sunt numere naturale, st mai mic decât dr și n mai mare decât dr.

Funcția ordonare este implementată recursiv, astfel încât să divizeze tabloul în două subtablouri, să le sorteze individual și apoi să le combine într-un tablou sortat. Dacă subtabloul are un singur element sau niciun element, atunci subtabloul este deja sortat. Altfel, se calculează mijlocul subtabloului, se sortează subtabloul stâng și subtaboul drept și apoi se combină cele două subtablouri sortate.

În funcția main, se citesc datele de intrare și se validează folosind funcția validare_input. Dacă datele de intrare sunt valide, atunci se completează tabloul și se apelează funcția ordonare pentru a sorta elementele între indicii stanga și dreapta. În final, se afișează tabloul sortat.