2148 - ADN: Difference between revisions

From Bitnami MediaWiki
No edit summary
No edit summary
 
(3 intermediate revisions by the same user not shown)
Line 31: Line 31:
:6
:6
;Ieșire
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:16
:16


Line 42: Line 43:
:19
:19
;Ieșire
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:88
:88


Line 48: Line 50:
:38
:38
;Ieșire
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:251
:251


Line 54: Line 57:
:99
:99
;Ieșire
;Ieșire
:Datele de intrare corespund restricțiilor impuse.
:961
:961


Line 60: Line 64:
:0
:0
;Ieșire
;Ieșire
:Date de intrare gresite!
:Datele de intrare nu corespund restricțiilor impuse.


==Rezolvare==
==Rezolvare==
Line 69: Line 73:




def nr_perechi_adn(n):
def ADN(n):
     martieni_adn = {}
     martieni_adn = {}
     nr_perechi = 0
     nr_perechi = 0


    # Inițializăm un dicționar cu cheile de la 1 la n și valorile 1
     for i in range(1, n + 1):
     for i in range(1, n + 1):
         martieni_adn[i] = 1
         martieni_adn[i] = 1
    # Folosim Ciurul lui Eratostene pentru a calcula factorizarea în numere prime a fiecărui număr de la 2 la n
     for i in range(2, n + 1):
     for i in range(2, n + 1):
        # Dacă martieni_adn[i] == 1, atunci i este un număr prim
         if martieni_adn[i] == 1:
         if martieni_adn[i] == 1:
            # Setăm factorizarea în numere prime a lui martieni_adn[i] să fie pasul i
             martieni_adn[i] = i
             martieni_adn[i] = i
            # Folosind algoritmul Ciurului lui Eratostene, marcam toți multiplii lui i cu factorul prim i
             j = 2
             j = 2
             while j * i <= n:
             while j * i <= n:
                 martieni_adn[i * j] = martieni_adn[i * j] * i
                 martieni_adn[i * j] = martieni_adn[i * j] * i
                # Incrementăm j pentru a considera următorul multiplu al lui i
                 j += 1
                 j += 1
    # Calculăm numărul de perechi de marțieni cu ADN-e distincte
     for i in range(1, n + 1):
     for i in range(1, n + 1):
         nr_perechi += int(n / martieni_adn[i])
         nr_perechi += int(n / martieni_adn[i])


     return nr_perechi
     print(nr_perechi)




def main():
if __name__ == "__main__":
     n = int(input())
     n = int(input())


     if not conditii(n):
     if not conditii(n):
         return print("Datele de intrare nu corespund restricțiilor impuse.")
         print("Datele de intrare nu corespund restricțiilor impuse.")
     print("Datele de intrare corespund restricțiilor impuse.")
     else:
 
        print("Datele de intrare corespund restricțiilor impuse.")
    print(nr_perechi_adn(n))
        ADN(n)
 
 
if __name__ == "__main__":
    main()


</syntaxhighlight>
</syntaxhighlight>

Latest revision as of 15:26, 6 May 2023

Cerința[edit | edit source]

Pe Marte s-au descoperit N marțieni, identificați de către oamenii de știință de pe Pământ prin numerele de la 1 la N. Cercetările au dovedit că ADN-ul oricărui marțian X este format din mulțimea factorilor primi din descompunerea lui X. De exemplu ADN(6)={2,3}.

Se știe că marțianul cu numărul de ordine Y îl moștenește pe marțianul cu numărul de ordine X dacă ADN(X) este inclus în ADN(Y), adică mulțimea factorilor primi ai lui X este inclusă în mulțimea factorilor primi ai lui Y.

De exemplu, marțianul 6 îl moștenește pe marțianul 3 deoarece ADN(3)={3} este inclus în ADN(6)={2,3}.

Trebuie să specificăm că se pot întâlni situații extreme în care X îl moștenește pe Y dar și Y îl moștenește pe X, atunci când cei doi marțieni au ADN-urile egale. Este situația marțianului 12 care îl moștenește pe 6 dar și 6 îl moștenește pe 12.

Realizați un program care, considerând mulțimea celor N marțieni, determină numărul de perechi de marțieni (Y, X) pentru care Y îl moștenește pe X, unde 1 ≤ X ≤ N și 1 ≤ Y ≤ N.

Date de intrare[edit | edit source]

Fișierul de intrare adn.in conține pe prima linie numărul N, reprezentând numărul de marțieni.

Date de ieșire[edit | edit source]

Pe ecran se va afișa mesajul: "Datele de intrare corespund restricțiilor impuse."

Pe următorul rând se va afișa numărul de perechi determinat.

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

  • 1 ≤ N ≤ 5 000 000
  • Pe planeta Marte orice marțian X îl moștenește pe X.
  • Orice marțian îl moștenește pe marțianul 1 deoarece ADN(1)={}, adică mulțimea vidă, care se consideră inclusă în orice mulțime nevidă.
  • Se garantează că numărul de perechi determinat are cel mult nouă cifre.

Exemplu 1[edit | edit source]

Intrare
6
Ieșire
Datele de intrare corespund restricțiilor impuse.
16

Explicație[edit | edit source]

ADN(1)={}, ADN(2)={2}, ADN(3)={3}, ADN(4)={2}, ADN(5)={5}, ADN(6)={2,3}.

Perechile de marțieni determinate sunt (1,1); (2,2); (3,3); (4,4); (5,5); (6,6); (4,2); (2,4); (6,2); (6,3); (6,4); (2,1) ; (3,1); (4,1); (5,1); (6,1).

Exemplu 2[edit | edit source]

Intrare
19
Ieșire
Datele de intrare corespund restricțiilor impuse.
88

Exemplu 3[edit | edit source]

Intrare
38
Ieșire
Datele de intrare corespund restricțiilor impuse.
251

Exemplu 4[edit | edit source]

Intrare
99
Ieșire
Datele de intrare corespund restricțiilor impuse.
961

Exemplu 5[edit | edit source]

Intrare
0
Ieșire
Datele de intrare nu corespund restricțiilor impuse.

Rezolvare[edit | edit source]

<syntaxhighlight lang="python" line="1">

  1. 2148 ADN

def conditii(n):

   return 1 <= n <= 5_000_000


def ADN(n):

   martieni_adn = {}
   nr_perechi = 0
   # Inițializăm un dicționar cu cheile de la 1 la n și valorile 1
   for i in range(1, n + 1):
       martieni_adn[i] = 1
   # Folosim Ciurul lui Eratostene pentru a calcula factorizarea în numere prime a fiecărui număr de la 2 la n
   for i in range(2, n + 1):
       # Dacă martieni_adn[i] == 1, atunci i este un număr prim
       if martieni_adn[i] == 1:
           # Setăm factorizarea în numere prime a lui martieni_adn[i] să fie pasul i
           martieni_adn[i] = i
           # Folosind algoritmul Ciurului lui Eratostene, marcam toți multiplii lui i cu factorul prim i
           j = 2
           while j * i <= n:
               martieni_adn[i * j] = martieni_adn[i * j] * i
               # Incrementăm j pentru a considera următorul multiplu al lui i
               j += 1
   # Calculăm numărul de perechi de marțieni cu ADN-e distincte
   for i in range(1, n + 1):
       nr_perechi += int(n / martieni_adn[i])
   print(nr_perechi)


if __name__ == "__main__":

   n = int(input())
   if not conditii(n):
       print("Datele de intrare nu corespund restricțiilor impuse.")
   else:
       print("Datele de intrare corespund restricțiilor impuse.")
       ADN(n)

</syntaxhighlight>