0263 - Intervale 2: Difference between revisions

From Bitnami MediaWiki
No edit summary
 
(One intermediate revision by the same user not shown)
Line 40: Line 40:
== Rezolvare ==
== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
<syntaxhighlight lang="python3" line="1">
def intersecare_intervale(intervale):
def intersectare_intervale(intervale):
     # Sortăm intervalele după capătul inferior
     # Sortează intervalele după capătul stâng
     intervale.sort(key=lambda x: x[0])
     intervale.sort(key=lambda x: x[0])
 
   
     # Inițializăm intervalul de intersecție cu primul interval
     # Inițializare intersecție cu primul interval
     intersecție = intervale[0]
     intersecție = intervale[0]


     # Parcurgem celelalte intervale și actualizăm intervalul de intersecție
     # Verificare intersecție cu celelalte intervale
     for interval in intervale[1:]:
     for interval in intervale[1:]:
         intersecție = [max(intersecție[0], interval[0]), min(intersecție[1], interval[1])]
         if interval[0] <= intersecție[1]:
 
            # Există intersecție între intervale
        # Dacă capătul inferior devine mai mare decât capătul superior, intersecția este vidă
            intersecție = [max(interval[0], intersecție[0]), min(interval[1], intersecție[1])]
        if intersecție[0] > intersecție[1]:
        else:
            # Nu există intersecție
             return [0, 0]
             return [0, 0]


     return intersecție
     return intersecție


def main():
# Citirea datelor din fișierul de intrare
    with open("intervale2.txt", "r") as f_in:
with open("intervale2in.txt", "r") as f:
        # Citim numărul de intervale
    n = int(f.readline())
        n = int(f_in.readline())
    intervale = [list(map(int, f.readline().split())) for _ in range(n)]


        # Citim intervalele
# Calculul intervalului de intersecție
        intervale = [list(map(int, f_in.readline().split())) for _ in range(n)]
rezultat = intersectare_intervale(intervale)


    # Determinăm intervalul de intersecție
# Scrierea rezultatului în fișierul de ieșire
     rezultat = intersecare_intervale(intervale)
with open("intervale2out.txt", "w") as g:
     g.write(" ".join(map(str, rezultat)))


    # Scriem rezultatul în fișierul de ieșire
# Verificare restrictii
    with open("intervale2.txt", "w") as f_out:
assert 1 <= n <= 100
        f_out.write(f"{rezultat[0]} {rezultat[1]}\n")
for i in range(n):
    a, b = intervale[i]
    assert -100 <= a <= 100
    assert -100 <= b <= 100


if __name__ == "__main__":
    main()


</syntaxhighlight>
</syntaxhighlight>

Latest revision as of 12:18, 29 December 2023

Cerinta[edit | edit source]

Se dau n intervale [a,b], unde a şi b sunt numere întregi. Să se determine intervalul rezultat prin intersectarea intervalelor date.

Date de intrare[edit | edit source]

Fişierul de intrare intervale2in.txt conţine pe prima linie numărul n, iar pe următoarele n linii câte două numere întregi, separate prin spaţii, reprezentând capetele unui interval.

Date de iesire[edit | edit source]

Fişierul de ieşire intervale2out.txt va conţine pe prima linie cele două numere care reprezintă intervalul intersecție, separate printr-un spațiu, sau valoarea 0, dacă intersecția celor n intervale este mulțimea vidă.

Restrictii si precizari[edit | edit source]

  • 1 ⩽ n ⩽ 100
  • pentru fiecare interval dat [a,b], -100 ⩽ a , b ⩽ 100

Exemplul 1[edit | edit source]

intervale2in.txt
5
-7 10
3 20
-5 5
0 12
-8 30
intervale2out.txt
Datele introduse corespund restrictiilor impuse
3 5

Exemplul 2[edit | edit source]

intervale2in.txt
3
-2.5 1
100 0
6.3 17,2
Datele introduse nu corespund restrictiilor impuse


Rezolvare[edit | edit source]

<syntaxhighlight lang="python3" line="1"> def intersectare_intervale(intervale):

   # Sortează intervalele după capătul stâng
   intervale.sort(key=lambda x: x[0])
   
   # Inițializare intersecție cu primul interval
   intersecție = intervale[0]
   # Verificare intersecție cu celelalte intervale
   for interval in intervale[1:]:
       if interval[0] <= intersecție[1]:
           # Există intersecție între intervale
           intersecție = [max(interval[0], intersecție[0]), min(interval[1], intersecție[1])]
       else:
           # Nu există intersecție
           return [0, 0]
   return intersecție
  1. Citirea datelor din fișierul de intrare

with open("intervale2in.txt", "r") as f:

   n = int(f.readline())
   intervale = [list(map(int, f.readline().split())) for _ in range(n)]
  1. Calculul intervalului de intersecție

rezultat = intersectare_intervale(intervale)

  1. Scrierea rezultatului în fișierul de ieșire

with open("intervale2out.txt", "w") as g:

   g.write(" ".join(map(str, rezultat)))
  1. Verificare restrictii

assert 1 <= n <= 100 for i in range(n):

   a, b = intervale[i]
   assert -100 <= a <= 100
   assert -100 <= b <= 100


</syntaxhighlight>