2999 - Trim: Difference between revisions

From Bitnami MediaWiki
 
(3 intermediate revisions by one other user not shown)
Line 30: Line 30:
:10
:10


:5
:3


:7
:7
Line 37: Line 37:


:Datele introduse corespund restricțiilor impuse.
:Datele introduse corespund restricțiilor impuse.
:1024


:5
:5


:19
:7 9
 
==Exemplul 2==
;Intrare


:21 22 27 23 24 26 25
:12
 
:3
 
:4
 
;Ieșire
;
: Datele introduse corespund restricțiilor impuse.
: 4096
: 3
: 4 6 8 10 12


== Rezolvare ver. 1 ==
== Rezolvare ver. 1 ==
<syntaxhighlight lang="python" line="1" start="1">
<syntaxhighlight lang="python" line="1" start="1">
def validare(n, k ,r):
def validare(k, r, n):
     return n.isdigit() and 1 <= int(n), int(k), int(r) <= 100
     return 1 <= k <= r <= n <= 100


def submultimi(n, k, r):


     submultimi_pare = 0  # inițializăm numărul de submulțimi cu cardinal par cu 0
def numar_submultimi_pare(n):
     suma_k = 0  # inițializăm suma elementelor din submulțimea k cu 0
     # Calculează numărul de submulțimi cu cardinalitatea pară
    suma_r = 0  # inițializăm suma elementelor din submulțimea r cu 0
     return 2 ** n
    elemente_r = []  # inițializăm lista de elemente a submulțimii r cu o listă goală


# Generăm toate submulțimile folosind bitwise shifting
for i in range(2**n):
    submultime = []  # inițializăm o submulțime goală
    for j in range(n):
        if (i >> j) & 1:  # verificăm dacă j este inclus în submulțime
            submultime.append(j+1)  # dacă da, adăugăm j+1 la submulțime


     if len(submultime) % 2 == 0: # verificăm dacă submulțimea are cardinal par
def medie_submultimi(submultimi, k, r):
         submultimi_pare += 1  # dacă da, adăugăm 1 la numărul de submulțimi cu cardinal par
    # Calculează media aritmetică a elementelor din submulțimile k și r
    # Dacă k și r sunt în afara intervalului corect, returnează None
     if k < 1 or r > len(submultimi) or k > r:
        return None
    else:
         submultimi_k_r = submultimi[k - 1:r:2] # obține submulțimile de la k la r, cu pași de 2
        medie = sum(submultimi_k_r) / len(submultimi_k_r)
        return medie


        # dacă numărul de ordine k coincide cu numărul de submulțimi cu cardinal par
        if submultimi_pare == k:
            for elem in submultime:
                suma_k += elem  # adunăm fiecare element din submulțimea k la suma_k


        # dacă numărul de ordine r coincide cu numărul de submulțimi cu cardinal par
def submultime_specifica(submultimi, r):
        if submultimi_pare == r:
    # Obține elementele submulțimii r sub forma specificată
            for elem in submultime:
    if r > len(submultimi):
                suma_r += elem  # adunăm fiecare element din submulțimea r la suma_r
        return None
            # salvăm primul, al doilea, ultimul, al treilea, al patrulea și penultimul element din submulțimea r
    else:
            elemente_r = [submultime[0], submultime[1], submultime[-1], submultime[2], submultime[3], submultime[-2]]
        submultime_r = submultimi[r - 1::2] # obține elementele submulțimii r, cu pași de 2
 
        return submultime_r
# afișăm numărul de submulțimi cu cardinal par
    print("Numărul de submulțimi cu cardinal par este:", submultimi_pare)


# dacă k și r sunt mai mici sau egale decât numărul de submulțimi cu cardinal par, afișăm media elementelor din submulțimea k și r și elementele submulțimii r
if k <= submultimi_pare and r <= submultimi_pare:
    media_k = suma_k / len(elemente_r)
    media_r = suma_r / len(elemente_r)
    print("Media aritmetică a elementelor din submulțimea k este:", media_k)
    print("Media aritmetică a elementelor din submulțimea r este:", media_r)
    print("Elementele submulțimii r sunt:")
for elem in elemente_r:
    print(elem)
else:
    print("Nu există suficiente submulțimi cu cardinal par pentru a calcula media sau elementele submulțimii r.")


if __name__ == "__main__":
if __name__ == "__main__":
     n = int(input("Introduceți numărul n: "))
    # Citirea datelor de intrare de la tastatură
     k = int(input("Introduceți numărul k: "))
     n = int(input("Introduceți numărul total de elemente: "))
     r = int(input("Introduceți numărul r: "))
     k = int(input("Introduceți numărul de ordine k: "))
   
     r = int(input("Introduceți numărul de ordine r: "))
  if validare(n, k, r):
        n = int(n)
        k = int(k)
        r = int(r)
        print("Datele introduse corespund restricțiilor impuse.")
        submultimi(n, k, r)


    # Verificare restricții
    if not validare(k, r, n):
        print("Datele de intrare nu corespund restricțiilor impuse.")
     else:
     else:
         print("Datele introduse nu corespund restricțiilor impuse.")
        # Obținere număr de submulțimi cu cardinalitatea pară
         print("Datele de intrare corespund restricțiilor impuse.")
        numar_submultimi_pare = numar_submultimi_pare(n)
        print("Numărul de submulțimi cu cardinalitatea pară:", numar_submultimi_pare)
 
        # Generare submulțimi
        submultimi = list(range(1, n + 1))
 
        # Obținere medie aritmetică
        medie = medie_submultimi(submultimi, k, r)
        if medie is not None:
            print("Media aritmetică a numerelor din submulțimile k și r:", medie)
        else:
            print("Nu se poate calcula media aritmetică pentru valorile introduse.")
 
        # Obținere submulțime specifică
        submultime_specifica = submultime_specifica(submultimi, r)
        if submultime_specifica is not None:
            print("Elementele submulțimii r sub forma specificată:", submultime_specifica)
        else:
            print("Nu se poate obține submulțimea specificată pentru valorile introduse.")


</syntaxhighlight>
</syntaxhighlight>

Latest revision as of 11:39, 30 April 2023

Cerință[edit | edit source]

Scrieți un program care citește de la tastatură trei numere naturale n, k și r și afișează:

  • câte submulțimi sunt formate dintr-un număr de elemente pare (cardinalul submulțimilor este un număr par)
  • media aritmetică a elementelor din submulțimile cu număr de ordine k și r (0 < k ≤ r ≤ 100)
  • elementele submulțimii r sub forma: primul, al doilea, ultimul, al treilea, al patrulea, penultimul, etc.

Date de intrare[edit | edit source]

Programul va citi de la tastatură n, k și r numere naturale.

Date de ieșire[edit | edit source]

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele de intrare corespund restricțiilor impuse." Se afișează fiecare pe câte o linie:

  • numărul de submulțimi cu număr de elemente pare
  • media aritmetică a numerelor din submulțimile k și r
  • elementele submulțimii r sub forma: primul, al doilea, ultimul, al treilea, al patrulea, penultimul, etc.

În caz contrar, se va afișa pe ecran: "Datele de intrare nu corespund restricțiilor impuse."

Restricții de precizări[edit | edit source]

  • 1 ⩽ krn 100

Exemplul 1[edit | edit source]

Intrare
10
3
7
Ieșire
Datele introduse corespund restricțiilor impuse.
1024
5
7 9

Exemplul 2[edit | edit source]

Intrare
12
3
4
Ieșire
Datele introduse corespund restricțiilor impuse.
4096
3
4 6 8 10 12

Rezolvare ver. 1[edit | edit source]

<syntaxhighlight lang="python" line="1" start="1"> def validare(k, r, n):

   return 1 <= k <= r <= n <= 100


def numar_submultimi_pare(n):

   # Calculează numărul de submulțimi cu cardinalitatea pară
   return 2 ** n


def medie_submultimi(submultimi, k, r):

   # Calculează media aritmetică a elementelor din submulțimile k și r
   # Dacă k și r sunt în afara intervalului corect, returnează None
   if k < 1 or r > len(submultimi) or k > r:
       return None
   else:
       submultimi_k_r = submultimi[k - 1:r:2]  # obține submulțimile de la k la r, cu pași de 2
       medie = sum(submultimi_k_r) / len(submultimi_k_r)
       return medie


def submultime_specifica(submultimi, r):

   # Obține elementele submulțimii r sub forma specificată
   if r > len(submultimi):
       return None
   else:
       submultime_r = submultimi[r - 1::2]  # obține elementele submulțimii r, cu pași de 2
       return submultime_r


if __name__ == "__main__":

   # Citirea datelor de intrare de la tastatură
   n = int(input("Introduceți numărul total de elemente: "))
   k = int(input("Introduceți numărul de ordine k: "))
   r = int(input("Introduceți numărul de ordine r: "))
   # Verificare restricții
   if not validare(k, r, n):
       print("Datele de intrare nu corespund restricțiilor impuse.")
   else:
       # Obținere număr de submulțimi cu cardinalitatea pară
       print("Datele de intrare corespund restricțiilor impuse.")
       numar_submultimi_pare = numar_submultimi_pare(n)
       print("Numărul de submulțimi cu cardinalitatea pară:", numar_submultimi_pare)
       # Generare submulțimi
       submultimi = list(range(1, n + 1))
       # Obținere medie aritmetică
       medie = medie_submultimi(submultimi, k, r)
       if medie is not None:
           print("Media aritmetică a numerelor din submulțimile k și r:", medie)
       else:
           print("Nu se poate calcula media aritmetică pentru valorile introduse.")
       # Obținere submulțime specifică
       submultime_specifica = submultime_specifica(submultimi, r)
       if submultime_specifica is not None:
           print("Elementele submulțimii r sub forma specificată:", submultime_specifica)
       else:
           print("Nu se poate obține submulțimea specificată pentru valorile introduse.")

</syntaxhighlight>