2649 - reactii: Diferență între versiuni

De la Universitas MediaWiki
(Pagină nouă: == Cerința == Într-un laborator de chimie, cercetătorii monitorizează o serie de reacții chimice reprezentate prin stive de reacții. Fiecare reacție poate adăuga un nou element pe stivă sau poate elimina elementul de la vârful stivei. Sarcina ta este să implementezi un program care să simuleze aceste operațiuni asupra unei stive de reacții chimice. == Date de intrare == Programul citește de la tastatură: Un număr întreg n reprezentând numărul de operațiu...)
 
 
(Nu s-au afișat 3 versiuni intermediare efectuate de același utilizator)
Linia 1: Linia 1:
== Cerința ==
== Cerința ==
Într-un laborator de chimie, cercetătorii monitorizează o serie de reacții chimice reprezentate prin stive de reacții. Fiecare reacție poate adăuga un nou element pe stivă sau poate elimina elementul de la vârful stivei. Sarcina ta este implementezi un program care să simuleze aceste operațiuni asupra unei stive de reacții chimice.
Să considerăm o secvenţă de n substanţe chimice s=s1,s2,…,sn
. Substanţele sunt numerotate distinct de la 1 la n şi fiecare substanţă apare în secvenţa s o singură dată.
 
Să considerăm o subsecvenţă si,j=si,si+1,…,sj şi notăm cu mini,jşi maxi,j cel mai mic, respectiv cel mai mare număr din subsecvenţă. Subsecvenţa respectivă constituie un interval dacă ea conţine toate numerele naturale cuprinse între mini,jşi maxi,j.
 
Cu substanţele din secvenţa s se vor efectua diferite experimente. În timpul unui experiment pot reacţiona două substanţe alăturate si şi si+1 doar dacă numerele lor de ordine sunt consecutive. În urma reacţiei se obţine o nouă substanţă, formată din substanţele care au reacţionat, notată ( si, si+1). Mai mult, substanţele obţinute pot reacţiona dacă ele sunt alăturate, iar prin reunirea subsecvenţelor de substanţe ce le compun se obţine un interval.
 
Experimentul este declarat reuşit dacă în final, urmând regulile de mai sus, se obţine o singură substanţă formată din toate cele n substanţe din secvenţa s, aceasta fiind declarată stabilă.
Nu din orice secvenţă de substanţe se poate obţine în urma reacţiilor o substanţă finală stabilă.
Determinaţi pentru o secvenţă dată de substanţe, dacă în urma reacţiilor ce se pot produce conform regulilor din enunţ rezultă o substanţă stabilă.
 
== Date de intrare ==
== Date de intrare ==
Programul citește de la tastatură:
Fişierul de intrare reactii.in conţine pe prima linie numărul natural n, numărul de substanţe. Pe cea de a doua linie se află un număr natural m, reprezentând numărul de secvenţe de n substanţe din fişierul de intrare. Fiecare dintre următoarele m linii conţine câte n numere naturale distincte, separate prin câte un spaţiu, reprezentând o secvenţă de n substanţe.
 
Un număr întreg n reprezentând numărul de operațiuni.
O listă de n operațiuni, fiecare operațiune fiind de forma "PUSH X" (unde X este un element chimic) sau "POP".
== Date de ieșire ==
== Date de ieșire ==
Pe ecran se va afișa stiva rezultată după efectuarea tuturor operațiunilor. Dacă o operațiune "POP" este efectuată pe o stivă goală, se va afișa mesajul "Eroare: stivă goală".
Fişierul de ieşire reactii.out conţine, pentru fiecare secvenţă de substanţe din fişierul de intrare, câte o linie, pe care este afişată valoarea 1 dacă pentru secvenţa respectivă se poate obţine o substanţă stabilă sau valoarea 0 în caz contrar.
== Restricții și precizări ==
== Restricții și precizări ==
*1 ⩽ '''n''' ⩽ 100
*2 <= n <= 15000
* 'x' este întotdeauna un tip de bloc reprezentat printr-un șir de caractere.
*1 <= m <= 20
*La un moment dat pot reacţiona doar două substanţe.
== Exemplu 1 ==
== Exemplu 1 ==
;Intrare
;Intrare
5<br>
6<br>
PUSH H<br>
PUSH O<br>
POP<br>
PUSH N<br>
PUSH C
 
;Iesire
['H', 'N', 'C']
 
== Exemplu 2 ==
;Intrare
4<br>
4<br>
PUSH Na<br>
6 3 2 1 5 4<br>
POP<br>
3 4 1 6 5 2<br>
POP<br>
2 3 1 5 4 6<br>
PUSH Cl<br>
6 2 3 1 4 5


;Iesire
;Iesire
Eroare: stivă goală<br>
0<br>
['Cl']
0<br>
1<br>
0


Datele de intrare nu corespund restricțiilor impuse.
== Rezolvare ==
== Rezolvare ==
<syntaxhighlight lang="python" line>
<syntaxhighlight lang="python" line>
def citeste_date():
def verifica_substanta_stabila(substante):
     try:
     n = len(substante)
        n = int(input("Introduceți numărul de operațiuni (n): "))
    schimbat = True
        operatiuni = []
     while schimbat and n > 1:
        for _ in range(n):
         schimbat = False
            operatiune = input().strip()
         i = 0
            operatiuni.append(operatiune)
         while i < n - 1:
        return n, operatiuni
             min_substanta = min(substante[i], substante[i + 1])
     except ValueError:
             max_substanta = max(substante[i], substante[i + 1])
        return None, None
            if substante[i] == min_substanta and substante[i + 1] == max_substanta:
 
                substante = substante[:i] + [max_substanta] + substante[i + 2:]
def valideaza_date(n, operatiuni):
                n -= 1
    if not (1 <= n <= 100):
                schimbat = True
         return False
                 break
    for operatiune in operatiuni:
             i += 1
         if not (operatiune.startswith("PUSH ") or operatiune == "POP"):
     return 1 if n == 1 else 0
            return False
         if operatiune.startswith("PUSH ") and len(operatiune.split()) != 2:
             return False
        if operatiune.startswith("PUSH ") and not operatiune.split()[1].isalpha():
             return False
    return True
 
def proceseaza_operatiuni(n, operatiuni):
    stiva = []
    for operatiune in operatiuni:
        if operatiune.startswith("PUSH "):
            _, element = operatiune.split()
            stiva.append(element)
        elif operatiune == "POP":
            if stiva:
                 stiva.pop()
             else:
                print("Eroare: stivă goală")
     return stiva


def main():
def main():
     n, operatiuni = citeste_date()
     with open("reactii.in", "r") as f:
        n = int(f.readline().strip())
        m = int(f.readline().strip())
       
        assert 2 <= n <= 15000, "n trebuie să fie între 2 și 15000"
        assert 1 <= m <= 20, "m trebuie să fie între 1 și 20"
       
        secvente = []
        for _ in range(m):
            secventa = list(map(int, f.readline().strip().split()))
            assert len(secventa) == n, f"Fiecare secvență trebuie să conțină exact {n} substanțe"
            assert all(1 <= x <= n for x in secventa), f"Fiecare substanță trebuie să fie între 1 și {n}"
            secvente.append(secventa)
      
      
     if n is None or operatiuni is None or not valideaza_date(n, operatiuni):
     rezultate = []
         print("Datele de intrare nu corespund restricțiilor impuse.")
    for secventa in secvente:
        return
         rezultate.append(verifica_substanta_stabila(secventa))
      
      
     print("Datele de intrare corespund restricțiilor impuse.")
     with open("reactii.out", "w") as f:
    rezultat = proceseaza_operatiuni(n, operatiuni)
        for rezultat in rezultate:
    print(rezultat)
            f.write(f"{rezultat}\n")


if __name__ == "__main__":
if __name__ == "__main__":
     main()
     main()


</syntaxhighlight>
</syntaxhighlight>

Versiunea curentă din 2 iunie 2024 23:05

Cerința

Să considerăm o secvenţă de n substanţe chimice s=s1,s2,…,sn . Substanţele sunt numerotate distinct de la 1 la n şi fiecare substanţă apare în secvenţa s o singură dată.

Să considerăm o subsecvenţă si,j=si,si+1,…,sj şi să notăm cu mini,jşi maxi,j cel mai mic, respectiv cel mai mare număr din subsecvenţă. Subsecvenţa respectivă constituie un interval dacă ea conţine toate numerele naturale cuprinse între mini,jşi maxi,j.

Cu substanţele din secvenţa s se vor efectua diferite experimente. În timpul unui experiment pot reacţiona două substanţe alăturate si şi si+1 doar dacă numerele lor de ordine sunt consecutive. În urma reacţiei se obţine o nouă substanţă, formată din substanţele care au reacţionat, notată ( si, si+1). Mai mult, substanţele obţinute pot reacţiona dacă ele sunt alăturate, iar prin reunirea subsecvenţelor de substanţe ce le compun se obţine un interval.

Experimentul este declarat reuşit dacă în final, urmând regulile de mai sus, se obţine o singură substanţă formată din toate cele n substanţe din secvenţa s, aceasta fiind declarată stabilă. Nu din orice secvenţă de substanţe se poate obţine în urma reacţiilor o substanţă finală stabilă. Determinaţi pentru o secvenţă dată de substanţe, dacă în urma reacţiilor ce se pot produce conform regulilor din enunţ rezultă o substanţă stabilă.

Date de intrare

Fişierul de intrare reactii.in conţine pe prima linie numărul natural n, numărul de substanţe. Pe cea de a doua linie se află un număr natural m, reprezentând numărul de secvenţe de n substanţe din fişierul de intrare. Fiecare dintre următoarele m linii conţine câte n numere naturale distincte, separate prin câte un spaţiu, reprezentând o secvenţă de n substanţe.

Date de ieșire

Fişierul de ieşire reactii.out conţine, pentru fiecare secvenţă de substanţe din fişierul de intrare, câte o linie, pe care este afişată valoarea 1 dacă pentru secvenţa respectivă se poate obţine o substanţă stabilă sau valoarea 0 în caz contrar.

Restricții și precizări

  • 2 <= n <= 15000
  • 1 <= m <= 20
  • La un moment dat pot reacţiona doar două substanţe.

Exemplu 1

Intrare

6
4
6 3 2 1 5 4
3 4 1 6 5 2
2 3 1 5 4 6
6 2 3 1 4 5

Iesire

0
0
1
0

Rezolvare

def verifica_substanta_stabila(substante):
    n = len(substante)
    schimbat = True
    while schimbat and n > 1:
        schimbat = False
        i = 0
        while i < n - 1:
            min_substanta = min(substante[i], substante[i + 1])
            max_substanta = max(substante[i], substante[i + 1])
            if substante[i] == min_substanta and substante[i + 1] == max_substanta:
                substante = substante[:i] + [max_substanta] + substante[i + 2:]
                n -= 1
                schimbat = True
                break
            i += 1
    return 1 if n == 1 else 0

def main():
    with open("reactii.in", "r") as f:
        n = int(f.readline().strip())
        m = int(f.readline().strip())
        
        assert 2 <= n <= 15000, "n trebuie să fie între 2 și 15000"
        assert 1 <= m <= 20, "m trebuie să fie între 1 și 20"
        
        secvente = []
        for _ in range(m):
            secventa = list(map(int, f.readline().strip().split()))
            assert len(secventa) == n, f"Fiecare secvență trebuie să conțină exact {n} substanțe"
            assert all(1 <= x <= n for x in secventa), f"Fiecare substanță trebuie să fie între 1 și {n}"
            secvente.append(secventa)
    
    rezultate = []
    for secventa in secvente:
        rezultate.append(verifica_substanta_stabila(secventa))
    
    with open("reactii.out", "w") as f:
        for rezultat in rezultate:
            f.write(f"{rezultat}\n")

if __name__ == "__main__":
    main()