1610 - Colier: Difference between revisions

From Bitnami MediaWiki
Sinn Erich (talk | contribs)
Sinn Erich (talk | contribs)
 
(11 intermediate revisions by the same user not shown)
Line 15: Line 15:
Dacă valoarea lui '''T''' este 2, se va rezolva numai punctul 2) din cerințe. În acest caz, programul va conține pe prima linie un număr natural reprezentând răspunsul la cerinţa 2).
Dacă valoarea lui '''T''' este 2, se va rezolva numai punctul 2) din cerințe. În acest caz, programul va conține pe prima linie un număr natural reprezentând răspunsul la cerinţa 2).


Dacă datele sunt introduse corect, programul va rula.
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cerintele de mai sus.
 
În cazul în care datele nu respectă restricțiile, se va afișa pe ecran: ''' "Datele nu corespund restricțiilor impuse.".'''
În caz contrar, se va afișa pe ecran: "Datele nu corespund restricțiilor impuse."


== Restricţii şi precizări ==
== Restricţii şi precizări ==
Line 37: Line 37:


== Exemplul 1 ==
== Exemplul 1 ==
; Intrare
; Datele de intrare
: T:
: 1
: 1
: N:
: 5
: 5
:Margele:
: 12 678 312 24 938
: 12 678 312 24 938
; Ieșire
; Datele de ieșire
: Datele sunt introduse corect.
: 3
: 3
<br>
<br>
Line 47: Line 51:
== Exemplul 2 ==
== Exemplul 2 ==
; Intrare
; Intrare
: T:
: 2
: 2
: N:
: 5
: 5
:Margele:
: 12 678 312 24 938
: 12 678 312 24 938
; Ieșire
; Ieșire
: Datele sunt introduse corect.
: 4
: 4
<br>
<br>
Line 57: Line 65:
<syntaxhighlight lang="python" line>
<syntaxhighlight lang="python" line>
#1610
#1610
T = int(input("n:"))
def solve(t, n, margele):
N = int(input("m:"))
    tip1 = []
margele = list(map(int, input().split()))
    tip2 = []
 
    for m in margele:
 
        if m % 10 > m // 10:
# determinăm mărgelele de tipul 1 și 2
            tip2.append(m)
tip1 = []
         else:
tip2 = []
            tip1.append(m)
for m in margele:
 
    if m % 10 > m // 10:
         tip2.append(m)


     else:
     if t == 1:
        return len(tip1)
    elif t == 2:
        num_margele = len(margele)
        max_margele = 0
        for i in range(num_margele):
            num = 1
            last_tip = 1 if margele[i] in tip1 else 2
            for j in range(i + 1, num_margele + i):
                index = j % num_margele
                if margele[index] in tip1:
                    tip = 1
                else:
                    tip = 2
                if tip != last_tip:
                    num += 1
                    last_tip = tip
            if num > max_margele:
                max_margele = num


         tip1.append(m)
         return max_margele


if T == 1:
    print("Datele introduse sunt corecte")
    print(len(tip1))
elif T == 2:
    # determinăm numărul maxim de mărgele în colier
    num_margele = len(margele)
    max_margele = 0
    for i in range(num_margele):
        # determinăm numărul maxim de mărgele pornind de la i
        num = 1
        last_tip = 1 if margele[i] in tip1 else 2
        for j in range(i + 1, num_margele + i):
            index = j % num_margele
            if margele[index] in tip1:
                tip = 1
            else:
                tip = 2
            if tip != last_tip:
                num += 1
                last_tip = tip
        if num > max_margele:
            max_margele = num


    print(max_margele)
def validare_input(t, n, margele):
def validare_input(t, n, margele):
     # verificăm restricțiile pentru T
     # verificăm restricțiile pentru T
Line 113: Line 112:
             return False
             return False
     return True
     return True
if __name__ == '__main__':
if __name__ == '__main__':
     t = int(input())
     t = int(input("T: "))
     n = int(input())
     n = int(input("N: "))
     margele = list(map(int, input().split()))
     margele = list(map(int, input("Margele: ").split()))


     if not validare_input(t, n, margele):
     if not validare_input(t, n, margele):
         print( "Datele nu corespund restricțiilor impuse.")
         print("Datele nu corespund restricțiilor impuse.")
     else:
     else:
 
         print(solve(t, n, margele))
         tip1 = []
        tip2 = []
        for m in margele:
            if m % 10 > m // 10:
                tip2.append(m)
            else:
                tip1.append(m)
 
        if t == 1:
            print(len(tip1))
        elif t == 2:
            num_margele = len(margele)
            max_margele = 0
            for i in range(num_margele):
                num = 1
                last_tip = 1 if margele[i] in tip1 else 2
                for j in range(i + 1, num_margele + i):
                    index = j % num_margele
                    if margele[index] in tip1:
                        tip = 1
                    else:
                        tip = 2
                    if tip != last_tip:
                        num += 1
                        last_tip = tip
                if num > max_margele:
 
                    max_margele = num
 
            print(max_margele)





Latest revision as of 23:03, 27 April 2023

Sursa: [1]

Cerinţa[edit | edit source]

Maria are în camera sa N mărgele așezate una lângă alta. Pe fiecare dintre ele este scris un număr natural format din cifre nenule distincte. Pentru fiecare mărgea, Maria șterge numărul și în locul său scrie altul, având doar două cifre, respectiv cifra minimă și cifra maximă din numărul scris inițial, în ordinea în care aceste cifre apăreau înainte de ștergere. Acum Maria consideră că mărgelele sunt de două tipuri, în funcție de numărul de două cifre scris pe ele: tipul 1 (cele care au cifra zecilor mai mică decât cifra unităților) și tipul 2 (celelalte). Folosind mărgelele, fetița dorește ca prin eliminarea unora dintre ele (dar fără să le schimbe ordinea celorlalte) să obțină un colier circular cât mai lung care să respecte proprietatea că oricare două mărgele vecine ale sale sunt de tipuri diferite. În colierul format cu mărgelele rămase după eliminare se consideră că prima mărgea este vecină cu ultima.


1) determinați numărul de mărgele de tipul 1;

2) determinați numărul maxim de mărgele pe care le poate avea colierul;

Date de intrare[edit | edit source]

Programul conține pe prima linie un număr natural T. Pe linia a doua se găsește un număr natural N. Pe linia a treia sunt N numere naturale ce reprezintă, în ordine, valorile scrise inițial pe mărgele. Aceste numere sunt separate prin câte un spațiu.

Date de ieșire[edit | edit source]

Dacă valoarea lui T este 1, se va rezolva numai punctul 1) din cerințe. În acest caz, programul va conține pe prima linie un număr natural reprezentând răspunsul la cerinţa 1). Dacă valoarea lui T este 2, se va rezolva numai punctul 2) din cerințe. În acest caz, programul va conține pe prima linie un număr natural reprezentând răspunsul la cerinţa 2).

Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt introduse corect.", apoi pe un rând nou afișează cerintele de mai sus.

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

Restricţii şi precizări[edit | edit source]

1 ≤ N ≤ 50 000;

Numerele scrise inițial pe mărgele au cifrele distincte, nu conțin cifra 0 și sunt cuprinse între 12 și 987654321;

T va fi 1 sau 2;

Pentru obținerea colierului, Maria poate decide să nu elimine nicio mărgea;

Colierul obținut poate fi format și dintr-o singură mărgea;

Pentru teste în valoare de 20 de puncte avem T = 1 și toate numerele scrise inițial pe mărgele au două cifre;

Pentru teste în valoare de 30 de puncte avem T= 1 și dintre numerele scrise inițial pe mărgele sunt și unele cu mai mult de două cifre;

Pentru teste în valoare de 50 de puncte avem T = 2.

Exemplul 1[edit | edit source]

Datele de intrare
T:
1
N:
5
Margele:
12 678 312 24 938
Datele de ieșire
Datele sunt introduse corect.
3


Exemplul 2[edit | edit source]

Intrare
T:
2
N:
5
Margele:
12 678 312 24 938
Ieșire
Datele sunt introduse corect.
4


Rezolvare[edit | edit source]

<syntaxhighlight lang="python" line>

  1. 1610

def solve(t, n, margele):

   tip1 = []
   tip2 = []
   for m in margele:
       if m % 10 > m // 10:
           tip2.append(m)
       else:
           tip1.append(m)
   if t == 1:
       return len(tip1)
   elif t == 2:
       num_margele = len(margele)
       max_margele = 0
       for i in range(num_margele):
           num = 1
           last_tip = 1 if margele[i] in tip1 else 2
           for j in range(i + 1, num_margele + i):
               index = j % num_margele
               if margele[index] in tip1:
                   tip = 1
               else:
                   tip = 2
               if tip != last_tip:
                   num += 1
                   last_tip = tip
           if num > max_margele:
               max_margele = num
       return max_margele


def validare_input(t, n, margele):

   # verificăm restricțiile pentru T
   if t not in [1, 2]:
       return False
   # verificăm restricțiile pentru N
   if n < 1 or n > 50000:
       return False
   # verificăm restricțiile pentru mărgele
   for m in margele:
       if m < 12 or m > 987654321:
           return False
       digits = set(str(m))
       if len(digits) != len(str(m)) or '0' in digits:
           return False
   return True


if __name__ == '__main__':

   t = int(input("T: "))
   n = int(input("N: "))
   margele = list(map(int, input("Margele: ").split()))
   if not validare_input(t, n, margele):
       print("Datele nu corespund restricțiilor impuse.")
   else:
       print(solve(t, n, margele))


</syntaxhighlight>

Explicatie cod:

Acest cod calculează numărul de mărgele de tipul 1 și 2 și determină numărul maxim de mărgele consecutive de tipuri diferite care pot fi utilizate într-un colier, în funcție de cerințele date.

La început, se citește valoarea lui T (tipul cerinței) și numărul N de mărgele din colier. Apoi, se citesc cele N mărgele. Pentru a valida inputul, se verifică dacă T este 1 sau 2, dacă N este între 1 și 50000 și dacă mărgelele sunt între 12 și 987654321, nu conțin cifra 0 și nu au cifre repetate.

După validarea inputului, se determină mărgelele de tipul 1 și 2 prin verificarea dacă ultima cifră a unei mărgele este mai mare decât prima cifră. Pentru fiecare tip de cerință (T), se calculează răspunsul cerut.

Dacă T este 1, se afișează numărul de mărgele de tipul 1. Dacă T este 2, se determină numărul maxim de mărgele consecutive de tipuri diferite care pot fi utilizate într-un colier. Pentru a face acest lucru, se parcurge lista de mărgele și se determină numărul maxim de mărgele consecutive de tipuri diferite care încep cu fiecare mărgea. Se compară aceste numere pentru a găsi numărul maxim de mărgele consecutive de tipuri diferite care pot fi utilizate în colier.

În cazul în care inputul nu este valid, se afișează un mesaj de eroare.