Editing 0953 - DeeDee

Sursă: [https://www.pbinfo.ro/probleme/953/deedee]
== Enunt ==
Deedee a descoperit în parc un şotron triunghiular construit din '''N*(N+1)/2''' dale de piatră dintre care '''K''' au culoarea gri iar restul sunt albe. Dalele sunt numerotate cu numerele distincte de la '''1''' la '''N*(N+1)/2''' şi sunt dispuse pe '''N''' rânduri, una lângă alta, ca în desenul de mai jos realizat pentru un şotron cu '''N=6''' şi '''K=5''', astfel:
: -pe rândul '''1''', dala cu numărul '''1'''
: -pe rândul '''2''', dalele cu numerele: '''2''' şi '''3'''
: -pe rândul '''3, dalele cu numerele: '''4''', '''5''' şi '''6'''
: …………..
: -pe rândul '''N''', dalele cu numerele: '''N*(N-1)/2+1, N*(N-1)/2+2 , … , N*(N+1)/2'''
Pornind de pe dala iniţială, adică dala cu numărul '''1''', sărind din dală în dală, Deedee trebuie să ajungă pe dala finală, adică dala cu numărul '''N*(N+1)/2''', respectând regula următoare: de pe dala curentă, numerotată cu '''X''' şi situată pe rândul '''Y''', ea poate să sară doar pe o dală albă situată pe rândul '''Y''' şi numerotată cu '''X+1''' (dacă aceasta există) sau pe rândul '''Y+1''' pe aceeaşi coloană cu dala curentă.
Nefiind o bună sportivă, Deedee vrea să descopere mai întâi dalele pe care ar trebui să sară pornind de la dala iniţială astfel încât să execute un număr minim de sărituri până la dala finală, respectând la fiecare săritură regula.
== Cerință ==
Scrieţi un program care să determine:
: a) numărul '''R''' al rândului care conţine cele mai multe dale gri, iar dacă sunt mai multe rânduri cu această proprietate atunci '''R''' va fi egal cu numărul cel mai mic al unui astfel de rând;
: b) numărul minim '''D''' de dale pe care trebuie să sară Deedee pornind de la dala iniţială astfel încât să ajungă pe dala finală, respectând la fiecare săritură regula din enunţ.
== Date de intrare ==
Programul citește de la tastatură numerele naturale '''N''' şi '''K''', cu semnificaţia din enunţ, apoi '''K''' numere naturale nenule, ordonate strict crescător, reprezentând numerele dalelor de culoare gri din şotron.
== Date de ieșire == 
Dacă datele sunt introduse corect, pe ecran se va afișa: "Datele sunt corecte.". Programul va afișa pe ecran numărul '''R''' și '''D''', în această ordine. În caz contrar, se va afișa pe ecran: "Datele nu sunt comform restricțiilor impuse.".
== Restricții și precizări ==
* '''3 ≤ N  ≤ 100000; 1 ≤ K < 100000''';
* dalele au formă pătratică, cu latura de aceeaşi lungime
* dala iniţială şi dala finală sunt de culoare albă
* pentru datele de test există întotdeauna soluţie
* pentru rezolvarea corectă a cerinţei a) se acordă '''60%''' din punctaj, iar pentru rezolvarea corectă a ambelor cerinţe se acordă '''100%''' din punctaj
== Exemple ==
=== Exemplu 1 ===
; Date de intrare
: 6 5 
: 4 6 7 18 19
; Date de ieșire
: 3 
: 10
==== Explicatie ====
Rândurile '''3''' şi '''6''' au numărul maxim de dale gri ('''2'''), deci '''R=3'''.

Deedee poate ajunge pe dala finală efectuând minimum '''D=10''' sărituri. De exemplu, poate urma traseul:
'''1 → 2 → 3 → 5 → 8 → 9 → 13 → 14 → 15 → 20 → 21'''.
== Rezolvare ==
<syntaxhighlight lang="python" line="1">
import math

def citeste_n_k():
    while True:
        try:
            n = int(input("Introduceti numarul n: "))
            k = int(input("Introduceti numarul de valori: "))
            if 3 <= n <= 100000 and 1 <= k <= 100000:
                print("Datele sunt corecte.")
                return n, k
            else:
                print("Datele nu sunt conform restricțiilor impuse.")
        except ValueError:
            print("Trebuie introduse doar numere intregi.")


def citeste_valori(k):
    valori = []
    for i in range(k):
        while True:
            try:
                valoare = int(input("Introduceti o valoare: "))
                if 1 <= valoare <= 1000000000:
                    print("Datele sunt corecte.")
                    valori.append(valoare)
                    break
                else:
                    print("Datele nu sunt conform restricțiilor impuse.")
            except ValueError:
                print("Trebuie introduse doar valori intregi cu cel mult 10 cifre.")
    return valori

def deedee(valori, n):
    r = 0
    d = 0
    ultimul_gri = 0
    gri_in_rand = 0
    for i in range(len(valori)):
        row = math.ceil((math.sqrt(8*valori[i] + 1) - 1)/2)
        if row > r:
            r = row
            gri_in_rand = 1
        elif row == r:
            gri_in_rand += 1
        if valori[i] == 1:
            ultimul_gri = 1
        else:
            if valori[i] == ultimul_gri + 1 or valori[i] == ultimul_gri + r + 1:
                ultimul_gri = valori[i]
            else:
                salturi = math.ceil((valori[i] - ultimul_gri) / r)
                ultimul_gri += salturi * r
                if valori[i] == ultimul_gri + 1 or valori[i] == ultimul_gri + r + 1:
                    ultimul_gri = valori[i]
                else: ultimul_gri+= r
                d += salturi + 1
    d += math.ceil((n*(n+1)//2 - ultimul_gri) / r)
    return r, d


if _name_ == '_main_':
    n, k = citeste_n_k()
    valori = citeste_valori(k)
    x, y = deedee(valori, n)
    print("Valorile cerute sunt:", x, "și", y)
</syntaxhighlight>
== Explicatie ==
 Acesta este un program Python care primește două numere de la utilizator - n și k - și o listă de k valori, apoi calculează două valori - r și d - și le afișează. 
 Valoarea r reprezintă numărul de griuri necesare pentru a acoperi toată grilă de dimensiune n x n, iar d reprezintă numărul de salturi necesare pentru a trece de la un gri la altul în ordinea dată de valorile introduse în listă.

 Funcția "citeste_n_k()" primește de la utilizator valorile n și k și le validează, astfel încât n să fie între 3 și 100000, iar k între 1 și 100000. Dacă valorile nu sunt valide, se va cere reintroducerea lor până la introducerea unor valori valide.

 Funcția "citeste_valori(k)" primește o valoare k și cere utilizatorului să introducă k valori, pe care le validează. Fiecare valoare trebuie să fie între 1 și 1000000000 și să aibă cel mult 10 cifre. Dacă valorile nu sunt valide, se va cere reintroducerea lor până la introducerea unor valori valide.
 
 Funcția "deedee(valori, n)" primește o listă de valori și o valoare n și calculează r și d. Pentru fiecare valoare din listă, se calculează pe ce rând din grilă se află griul cu acea valoare (utilizând formula pentru calculul rândului unui gri dat în funcție de valoarea acestuia). Pe măsură ce se calculează rândurile, se actualizează valoarea lui r și numărul de griuri în același rând. Se calculează apoi numărul de salturi necesare pentru a ajunge la următorul gri în ordinea dată de valorile din listă. Dacă se găsește un salt către un gri care nu urmează în mod corect după ultimul gri, atunci se adaugă încă un salt pentru a ajunge la următorul gri corect. În cele din urmă, se calculează numărul de salturi necesare pentru a ajunge la toate griurile care nu au fost deja parcurse în lista de valori introdusă.

 Funcția "main" apelează celelalte funcții pentru a obține valorile r și d și le afișează utilizatorului.