0521 - kSecventa: Diferență între versiuni

De la Universitas MediaWiki
Fără descriere a modificării
Fără descriere a modificării
 
(Nu s-au afișat 6 versiuni intermediare efectuate de alți 2 utilizatori)
Linia 6: Linia 6:
Programul citește de la tastatură numerele n și k, iar apoi n numere naturale, reprezentând elementele vectorului.
Programul citește de la tastatură numerele n și k, iar apoi n numere naturale, reprezentând elementele vectorului.
== Date de ieșire ==  
== Date de ieșire ==  
Programul va afișa pe ecran numerele i j, i < j reprezentând numerele de ordine a două secvențe identice, dacă există două astfel de secvențe, sau mesajul NU, dacă nu există două astfel de secvențe.
Dacă datele sunt introduse corect, pe ecran se va afișa:
Dacă există mai multe perechi de secvențe identice se vor considera cele cu numerele de ordine minime.
'''"Datele sunt introduse corect."''', apoi pe un rând nou '''se va afișa pe ecran numerele i j, i < j reprezentând numerele de ordine a două secvențe identice, dacă există două astfel de secvențe, sau mesajul NU, dacă nu există două astfel de secvențe, dacă există mai multe perechi de secvențe identice se vor considera cele cu numerele de ordine minime''', 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 ≤ k < n ≤ 1000, k este divizor al lui n
* 1 ≤ k < n ≤ 1000, k este divizor al lui n
* cele n numere citite vor fi mai mici decât 1000
* cele n numere citite vor fi mai mici decât 1000
== Exemplu ==
== Exemplu 1 ==
; Intrare
; Intrare
: 15 5
: 15 5
: 3 6 4 7 6 6 6 4 6 7 6 6 4 4 5  
: 3 6 4 7 6 6 6 4 6 7 6 6 4 4 5  
; Ieșire
; Ieșire
: Datele sunt introduse corect.
: 2 4
: 2 4
== Exemplu 2 ==
; Intrare
: 3 2
: 1 1 2 3 2 6 7 8 2 4 1 1 2 3
; Ieșire
: Datele nu corespund restricțiilor impuse.


== Rezolvare ==  
== Rezolvare ==  
Linia 23: Linia 32:
# 0521 - kSecventa
# 0521 - kSecventa


def citeste_date_intrare():
def validate_input(n, k, arr):
     n, k = map(int, input().split())
     if k >= n:
     x = list(map(int, input().split()))
        return False
    return n, k, x
    if n % k != 0:
        return False
    if max(arr) > 1000:
        return False
    return True
 
 
def find_identical_sequences(n, k, arr):
     if not validate_input(n, k, arr):
        print("Datele nu corespund restricțiilor impuse.")
        return


def gaseste_secvente_identice(n, k, x):
    l = n // k
     seq_dict = {}
     seq_dict = {}
     for i in range(1, k+1):
     for i in range(n // k):
         seq = tuple(x[(i-1)*l:i*l])
         seq = tuple(arr[i * k: (i + 1) * k])
         if seq not in seq_dict:
         if seq in seq_dict:
             seq_dict[seq] = 1
             print(seq_dict[seq], i + 1)
            return
         else:
         else:
             seq_dict[seq] += 1
             seq_dict[seq] = i + 1
        if seq_dict[seq] == 2:
 
            for j in range(1, i):
     print("NU")
                if seq == tuple(x[(j-1)*l:j*l]):
 
                    return j, i
     return "NU"


def valideaza_datele_de_intrare(n, k, x):
if __name__ == "__main__":
     assert 1 <= k < n <= 1000 and n % k == 0, "Datele de intrare sunt incorecte!"
    n, k = map(int, input().split())
    assert max(x) < 1000, "Datele de intrare sunt incorecte!"
     arr = list(map(int, input().split()))


if __name__ == '__main__':
    if validate_input(n, k, arr):
    n, k, x = citeste_date_intrare()
        print("Datele sunt introduse corect.")
    valideaza_datele_de_intrare(n, k, x)
        find_identical_sequences(n, k, arr)
    rezultat = gaseste_secvente_identice(n, k, x)
     else:
     print(rezultat)
        print("Datele nu corespund restricțiilor impuse.")




</syntaxhighlight>
</syntaxhighlight>
== Explicatie Rezolvare ==  
== Explicatie Rezolvare ==  
Citim datele de intrare (n, k și vectorul x).
Funcția validate_input(n, k, arr) verifică dacă intrarea este validă și întoarce un rezultat boolean care indică dacă intrarea este validă sau nu. Mai exact, verifică dacă k este mai mic decât n, dacă n este divizibil cu k, iar dacă toate elementele din vectorul arr sunt mai mici sau egale cu 1000.
Calculăm lungimea fiecărei secvențe (l), care este egală cu n/k.
 
Inițializăm un dicționar (seq_dict) în care vom stoca fiecare secvență și numărul de apariții a acesteia.
Funcția find_identical_sequences(n, k, arr) caută și afișează pe ecran două secvențe identice de lungime k din vectorul arr, dacă există. Pentru a face acest lucru, împarte vectorul în sub-secvențe de lungime k, creând o secvență din fiecare sub-secvență și verificând dacă secvența respectivă există deja într-un dicționar. Dacă secvența există deja în dicționar, înseamnă că am găsit două secvențe identice și le afișăm pozițiile. Dacă ajungem la sfârșitul vectorului și nu găsim nicio pereche de secvențe identice, afișăm mesajul "NU".
Iterăm prin fiecare secvență (de la 1 la k) și:
 
a. Extragem secvența corespunzătoare.
Funcția principală if __name__ == "__main__" citește datele de intrare și, dacă acestea sunt valide, afișează mesajul "Datele sunt introduse corect." și apelează funcția find_identical_sequences(n, k, arr) pentru a căuta secvențele identice. Dacă datele de intrare nu sunt valide, se afișează mesajul "Datele nu corespund restricțiilor impuse."
b. Dacă secvența nu există deja în dicționar, o adăugăm cu valoarea 1.
c. Dacă secvența există deja în dicționar, o incrementăm cu 1.
d. Verificăm dacă secvența a fost întâlnită de două ori și, dacă da, afișăm index-urile secvențelor identice și ieșim din program.
Dacă nu am găsit două secvențe identice, afișăm "NU".

Versiunea curentă din 14 mai 2023 20:01

Sursa: 0521 - kSecventa


Cerinţa

Se dă un vector cu n elemente, numere naturale, și un număr k, divizor al lui n. Se împarte vectorul în k secvențe disjuncte, numerotate de la 1 la k. Să se stabilească dacă există două secvențe identice.

Date de intrare

Programul citește de la tastatură numerele n și k, 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 se va afișa pe ecran numerele i j, i < j reprezentând numerele de ordine a două secvențe identice, dacă există două astfel de secvențe, sau mesajul NU, dacă nu există două astfel de secvențe, dacă există mai multe perechi de secvențe identice se vor considera cele cu numerele de ordine minime, 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 ≤ k < n ≤ 1000, k este divizor al lui n
  • cele n numere citite vor fi mai mici decât 1000

Exemplu 1

Intrare
15 5
3 6 4 7 6 6 6 4 6 7 6 6 4 4 5
Ieșire
Datele sunt introduse corect.
2 4

Exemplu 2

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


Rezolvare

Rezolvare ver. 1

# 0521 - kSecventa

def validate_input(n, k, arr):
    if k >= n:
        return False
    if n % k != 0:
        return False
    if max(arr) > 1000:
        return False
    return True


def find_identical_sequences(n, k, arr):
    if not validate_input(n, k, arr):
        print("Datele nu corespund restricțiilor impuse.")
        return

    seq_dict = {}
    for i in range(n // k):
        seq = tuple(arr[i * k: (i + 1) * k])
        if seq in seq_dict:
            print(seq_dict[seq], i + 1)
            return
        else:
            seq_dict[seq] = i + 1

    print("NU")


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

    if validate_input(n, k, arr):
        print("Datele sunt introduse corect.")
        find_identical_sequences(n, k, arr)
    else:
        print("Datele nu corespund restricțiilor impuse.")

Explicatie Rezolvare

Funcția validate_input(n, k, arr) verifică dacă intrarea este validă și întoarce un rezultat boolean care indică dacă intrarea este validă sau nu. Mai exact, verifică dacă k este mai mic decât n, dacă n este divizibil cu k, iar dacă toate elementele din vectorul arr sunt mai mici sau egale cu 1000.

Funcția find_identical_sequences(n, k, arr) caută și afișează pe ecran două secvențe identice de lungime k din vectorul arr, dacă există. Pentru a face acest lucru, împarte vectorul în sub-secvențe de lungime k, creând o secvență din fiecare sub-secvență și verificând dacă secvența respectivă există deja într-un dicționar. Dacă secvența există deja în dicționar, înseamnă că am găsit două secvențe identice și le afișăm pozițiile. Dacă ajungem la sfârșitul vectorului și nu găsim nicio pereche de secvențe identice, afișăm mesajul "NU".

Funcția principală if __name__ == "__main__" citește datele de intrare și, dacă acestea sunt valide, afișează mesajul "Datele sunt introduse corect." și apelează funcția find_identical_sequences(n, k, arr) pentru a căuta secvențele identice. Dacă datele de intrare nu sunt valide, se afișează mesajul "Datele nu corespund restricțiilor impuse."