1839 - Memory006: Difference between revisions

From Bitnami MediaWiki
Flaviu (talk | contribs)
No edit summary
Flaviu (talk | contribs)
No edit summary
 
(2 intermediate revisions by one other user not shown)
Line 9: Line 9:


== Date de ieșire ==  
== Date de ieșire ==  
Fișierul de ieșire memory006.out va conține:
 
Dacă datele sunt introduse corect, pe ecran se va afișa:  
Dacă datele sunt introduse corect, pe ecran se va afișa:  
'''"Datele sunt introduse corect."''', apoi pe un rând nou '''numărul S, reprezentând numărul secvenţelor din şir care au produsul elementelor egal cu 2k.''', reprezentând valoarea cerută. În cazul contrar, se va afișa pe ecran: '''"Datele nu corespund restricțiilor impuse."'''.
'''"Datele sunt introduse corect."''', apoi fișierul memory006.out va conține '''numărul S, reprezentând numărul secvenţelor din şir care au produsul elementelor egal cu 2k.''', 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 ==
Line 34: Line 34:
; Ieșire
; Ieșire
: Datele nu corespund restricțiilor impuse.
: Datele nu corespund restricțiilor impuse.
: memory006.out
 
: Datele nu corespund restricțiilor impuse


== Rezolvare ==  
== Rezolvare ==  
Line 42: Line 41:
# 1839 - Memory006
# 1839 - Memory006


def count_subarrays(n, k, arr):
def validate_input(n, k, arr):
     count = 0
     if not(1 <= n <= 500000 and 1 <= k <= 10000 and len(arr) == n):
        print("Datele nu corespund restricțiilor impuse.")
        return False
    for num in arr:
        if not(1 <= num <= 10**18):
            print("Datele nu corespund restricțiilor impuse.")
            return False
    print("Datele sunt introduse corect.")
    return True
 
def calculate_sequences(n, k, arr):
    if not validate_input(n, k, arr):
        return
 
    sequences_count = 0
     prod = 1
     prod = 1
    left = 0
     for i in range(n):
   
         prod *= arr[i]
     for right in range(n):
         while prod % 2 == 0:
         prod *= arr[right]
             prod //= 2
       
             if prod == 2 ** k:
         while prod > (2 ** 64) / 2 ** k:
                sequences_count += 1
             prod //= arr[left]
             left += 1
       
        if prod == 2 ** k:
            count += right - left + 1
   
    return count
 
if __name__ == '__main__':
    with open('memory006.in', 'r') as f_in:
        n, k = map(int, f_in.readline().split())
        arr = list(map(int, f_in.readline().split()))


     if max(arr) > 10 ** 18 or min(arr) < 1 or k > 10000 or n > 500000:
     with open("memory006.out", "w") as fout:
        print("Datele nu corespund restricțiilor impuse.")
         fout.write(str(sequences_count))
    else:
         print("Datele sunt introduse corect.")
        print(count_subarrays(n, k, arr))


if __name__ == "__main__":
    with open("memory006.in", "r") as fin:
        n, k = map(int, fin.readline().split())
        arr = list(map(int, fin.readline().split()))
    calculate_sequences(n, k, arr)




Line 75: Line 78:
</syntaxhighlight>
</syntaxhighlight>
== Explicatie Rezolvare ==
== Explicatie Rezolvare ==
Funcția count_subarrays primește ca argumente lungimea șirului n, numărul natural k și șirul de numere naturale nenule arr. Returnează numărul de subșiruri ale șirului arr care au produsul elementelor egal cu 2^k.
Functia validate_input verifica daca datele de intrare sunt valide, in functie de restrictiile impuse. Daca toate valorile sunt valide, functia returneaza True, altfel returneaza False si afiseaza un mesaj de eroare.
 
În cadrul funcției, inițializăm count la 0, prod la 1 și left la 0. Parcurgem șirul arr cu un indice right și actualizăm prod înmulțind cu fiecare element arr[right]. În timp ce prod depășește o anumită valoare calculată cu ajutorul lui k, actualizăm prod împărțind cu elementele de la începutul subșirului până când prod este mai mic sau egal cu acea valoare.


Dacă prod este egal cu 2^k, incrementăm count cu numărul de elemente din subșirul curent.
Functia calculate_sequences primeste ca parametri n - numarul de elemente din sir, k - numarul dat si arr - sirul de numere date. Daca datele de intrare sunt valide, functia calculeaza numarul de secvente din sir care au produsul elementelor egal cu 2^k si il scrie in fisierul de iesire "memory006.out". Algoritmul este de a parcurge sirul si de a calcula produsul elementelor din secvente succesive, impartind la 2 pana cand produsul devine egal cu 2^k. Cand acest lucru se intampla, numarul de secvente creste cu 1.


În funcția main, citim datele de intrare din fișierul memory006.in și verificăm dacă acestea corespund restricțiilor impuse în enunțul problemei. Dacă datele sunt valide, apelăm funcția count_subarrays și afișăm rezultatul. Dacă datele nu sunt valide, afișăm un mesaj corespunzător.
In __main__ se face citirea din fisierul de intrare "memory006.in" si se apeleaza functia calculate_sequences.

Latest revision as of 20:51, 14 May 2023

Sursa: - Memory006


Cerinţa[edit | edit source]

Se dă un şir format din n numere naturale nenule. Să se afle numărul secvenţelor din şir care au produsul elementelor egal cu 2k, unde k este un număr natural dat.


Date de intrare[edit | edit source]

Fișierul de intrare memory006.in conține pe prima linie numerele n şi k, iar pe a doua linie n numere naturale nenule, separate prin spații.

Date de ieșire[edit | edit source]

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi fișierul memory006.out va conține numărul S, reprezentând numărul secvenţelor din şir care au produsul elementelor egal cu 2k., 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 ≤ 500.000
  • 1 ≤ k ≤ 10.000
  • numerele de pe a doua linie a fișierului de intrare vor fi mai mari decât 1 şi mai mici decât 10^18

Exemplu 1[edit | edit source]

Intrare
memory006.in
5 3
7 4 2 4 5
Ieșire
Datele sunt introduse correct
memory006.out
2

Exemplu 2[edit | edit source]

Intrare
memory006.in
5 15000
7 4 2 4 5
Ieșire
Datele nu corespund restricțiilor impuse.


Rezolvare[edit | edit source]

Rezolvare ver. 1[edit | edit source]

<syntaxhighlight lang="python" line>

  1. 1839 - Memory006

def validate_input(n, k, arr):

   if not(1 <= n <= 500000 and 1 <= k <= 10000 and len(arr) == n):
       print("Datele nu corespund restricțiilor impuse.")
       return False
   for num in arr:
       if not(1 <= num <= 10**18):
           print("Datele nu corespund restricțiilor impuse.")
           return False
   print("Datele sunt introduse corect.")
   return True

def calculate_sequences(n, k, arr):

   if not validate_input(n, k, arr):
       return
   sequences_count = 0
   prod = 1
   for i in range(n):
       prod *= arr[i]
       while prod % 2 == 0:
           prod //= 2
           if prod == 2 ** k:
               sequences_count += 1
   with open("memory006.out", "w") as fout:
       fout.write(str(sequences_count))

if __name__ == "__main__":

   with open("memory006.in", "r") as fin:
       n, k = map(int, fin.readline().split())
       arr = list(map(int, fin.readline().split()))
   calculate_sequences(n, k, arr)


</syntaxhighlight>

Explicatie Rezolvare[edit | edit source]

Functia validate_input verifica daca datele de intrare sunt valide, in functie de restrictiile impuse. Daca toate valorile sunt valide, functia returneaza True, altfel returneaza False si afiseaza un mesaj de eroare.

Functia calculate_sequences primeste ca parametri n - numarul de elemente din sir, k - numarul dat si arr - sirul de numere date. Daca datele de intrare sunt valide, functia calculeaza numarul de secvente din sir care au produsul elementelor egal cu 2^k si il scrie in fisierul de iesire "memory006.out". Algoritmul este de a parcurge sirul si de a calcula produsul elementelor din secvente succesive, impartind la 2 pana cand produsul devine egal cu 2^k. Cand acest lucru se intampla, numarul de secvente creste cu 1.

In __main__ se face citirea din fisierul de intrare "memory006.in" si se apeleaza functia calculate_sequences.