Editing 4087 - vecine

== Enunt ==
Se dă un șir de n cifre c1, c2, …, cn, adică 0 ≤ ci ≤ 9. Dintr-un șir de cifre se poate obține un șir de 1 ≤ m ≤ n numere a1, a2, …, am astfel:

* Inițial considerăm fiecare cifră un număr și obținem șirul de n numere ai = c1
* Un număr nou poate fi obținut prin lipirea unei secvențe de două sau mai multe numere vecine din șirul original. Două elemente dintr-un șir se numesc vecine dacă acestea se regăsesc în șir pe poziții alăturate.
* Operația de lipire de două sau mai multe numere se poate realiza de oricâte ori atât timp cât numărul obținut este mai mic sau egal cu 2.000.000.000, nu începe cu cifra 0 și există cel puțin două numere în șir.
* De exemplu șirul [3, 5, 0, 2, 7, 3] poate deveni [35, 0, 2, 73] prin lipirea numerelor 3, 5 → 35 și 7, 3 → 73, care ulterior poate deveni [3502, 73] prin lipirea numerelor 35, 0, 2 → 3502. Dar nu putem crea șirul [35, 02, 73], deoarece am avea un număr care începe cu 0.
Două numere vecine sunt consecutive dacă primul este cu 1 mai mic decât al doilea.
== Cerinţa ==
Cunoscându-se șirul de cifre inițial, să se obțină următoarele rezultate:

* Presupunând că nu se face nici o lipire de cifre, fiecare cifră devenind un număr în șir, adică ai = c1, să se determine câte perechi de numere vecine consecutive există în șir;
* Să se determine o modalitate de lipire a cifrelor astfel încât să se obțină cele mai mari două numere vecine consecutive și să se afișeze primul dintre aceste numere.
== Date de intrare ==
Fișierul de intrare vecine.in conține pe prima linie două numere p și n, p reprezentând cerința 1 sau 2, iar pe linia următoare cele n cifre, despărțite prin câte un spațiu.
== Date de ieșire ==
În fișierul de ieșire vecine.out se va afla un singur număr natural. Dacă p = 1, acesta va reprezenta răspunsul pentru cerința 1. Dacă p = 2, acesta va reprezenta răspunsul pentru cerința 2.
== Restricţii şi precizări ==
* Pentru cerința 2 se garantează că numerele ce se pot obține nu vor depăși valoarea 2.000.000.000
* Tot pentru cerința 2 se garantează existența a cel puțin o pereche de numere vecine consecutive
* Cifra 0 poate forma singură doar numărul 0.
* Două numere vecine sunt consecutive dacă primul este cu 1 mai mic decât al doilea.
* Pentru 20 de puncte p = 1 și 3 ≤ n ≤ 100.000
* Pentru 80 de puncte p = 2 și 3 ≤ n ≤ 100.000
== Exemplul 1 ==
; vecine.in
 1 18
 3 2 1 2 1 0 6 3 0 5 6 3 0 6 9 2 9 3
; vecine.out
 2
<br>

== Explicație ==
Există două perechi de numere vecine consecutive formate dintr-o singură cifră: 1, 2 și 5, 6
== Exemplul 2 ==
; vecine.in
 2 18
 3 2 1 2 1 0 6 3 0 5 6 3 0 6 9 2 9 3
; vecine.out
 6305
<br>

== Explicație ==
Perechea cu cele mai mari două numere vecine consecutive este 6305 și 6306. Conform cerinței s-a scris în fișier doar primul număr din pereche.
== Rezolvare ==
<syntaxhighlight lang="python" line>
def count_consecutive_pairs(arr):
    count = 0
    for i in range(len(arr) - 1):
        if abs(arr[i] - arr[i+1]) == 1:
            count += 1
    return count

def find_largest_consecutive_pair(arr):
    max_num = arr[0]
    second_max_num = arr[1]
    
    for i in range(1, len(arr) - 1):
        if abs(arr[i] - arr[i+1]) == 1:
            if arr[i] > max_num:
                second_max_num = max_num
                max_num = arr[i]
            elif arr[i] > second_max_num:
                second_max_num = arr[i]
    
    return max_num

def main():
    p, n = map(int, input().split())
    digits = list(map(int, input().split()))

    if p == 1:
        result = count_consecutive_pairs(digits)
        print(result)
    elif p == 2:
        result = find_largest_consecutive_pair(digits)
        print(result)

if __name__ == "__main__":
    main()

</syntaxhighlight>