Editing 1056 - Unific

== Enunt == 

Se consideră un şir <code>A=(A1, A2, ..., AN)</code>, format din <code>N</code> numere naturale nenule. Două numere se consideră vecine dacă se află pe poziţii alăturate (<code>Ai</code> are ca vecini pe <code>Ai-1</code> şi <code>Ai+1</code>, pentru orice <code>1<i<N</code>, <code>A1</code> are ca vecin doar pe <code>A2</code>, iar <code>AN</code> are ca vecin doar pe <code>AN-1</code>).

Dacă două elemente vecine <code>Ai</code>, <code>Ai+1</code> (<code>1≤i<N</code>) au cel puţin o cifră comună, ele se pot unifica. Procedeul de unificare constă în eliminarea din numerele <code>Ai</code> şi <code>Ai+1</code> a tuturor cifrelor comune şi adăugarea prin alipirea numărului obţinut din <code>Ai+1</code> la numărul obţinut din <code>Ai</code>, formându-se astfel un nou număr. Numărul <code>Ai</code> va fi înlocuit cu noul număr, iar numărul <code>Ai+1</code> va fi eliminat din şir.

De exemplu, numerele <code>Ai=23814</code> şi <code>Ai+1=40273</code> au cifrele <code>2</code>, <code>3</code>, <code>4</code> comune, după unificare obţinem <code>Ai=817</code>, iar <code>Ai+1</code> este eliminat; observaţi că dacă după eliminarea cifrelor comune, numerele încep cu zerouri nesemnificative, acestea vor fi eliminate, apoi se realizează alipirea.

Dacă în urma eliminării cifrelor comune, unul dintre numere nu mai are cifre, atunci numărul rezultat va avea cifrele rămase în celălalt. Dacă în urma eliminării cifrelor comune atât <code>Ai</code> cât şi <code>Ai+1</code> nu mai au cifre, atunci ambele numere vor fi eliminate din şir, fără a fi înlocuite cu o altă valoare.

Ordinea în care se fac unificările în şir este importantă: la fiecare pas se alege prima pereche de elemente vecine <code>Ai</code> <code>Ai+1</code> care poate fi unificată, considerând şirul parcurs de la stânga la dreapta. (De exemplu, considerând <code>Ai=123</code>, <code>Ai+1=234</code>, <code>Ai+2=235</code>, se unifică <code>Ai</code> cu <code>Ai+1</code> => <code>Ai=14</code>, iar unificarea cu următorul număr nu mai este posibilă).

= Cerinţă =
Cunoscându-se şirul celor <code>N</code> numere naturale, să se determine:

a) cifra care apare cel mai frecvent în scrierea tuturor celor <code>N</code> numere; dacă există mai multe cifre cu aceeaşi frecvenţă de apariţie maximă, se va reţine cea mai mică cifră.

b) şirul obţinut prin efectuarea unui număr maxim de unificări, după regulile descrise în enunţ.

= Date de intrare =
Fișierul de intrare <code>unificIN.txt</code> conține pe prima linie o valoare naturală <code>N</code>, iar pe următoarele <code>N</code> linii, în ordine, cele <code>N</code> numere naturale din şirul <code>A</code>, câte un număr pe o linie.

= Date de ieșire =
Fișierul de ieșire <code>unificOUT.txt</code> va conține pe prima linie un număr natural c reprezentând cifra care apare cel mai frecvent în scrierea celor <code>N</code> numere naturale. Pe cea de a doua linie un număr natural <code>Nr</code> reprezentând numărul de numere naturale rămase în şir după efectuarea unui număr maxim de unificări. Pe cea de a treia linie se vor scrie cele <code>Nr</code> numere naturale rămase, în ordinea din şir, separate prin câte un spaţiu.

Dacă în urma procedeului de unificare, toate numerele vor fi eliminate, fişierul de ieşire va conţine o singură linie, pe care se va scrie cifra care apare cel mai frecvent în scrierea celor <code>N</code> numere naturale. În cazul în care restricțiile nu sunt îndeplinite, se va afișa mesajul "Datele nu corespund restrictiilor impuse".

= Restricții și precizări =

* <code>1 ≤ N ≤ 100 000</code>
* Numerele din şirul iniţial, precum şi numerele obţinute în urma unificărilor, nu vor depăşi <code>1018</code>
* Pentru datele de test şirul obţinut în urma unificărilor este nevid.
* Pentru 30% dintre teste <code>N ≤ 1000</code>
* Pentru 70% dintre teste numere naturale din şir au cifrele nenule.
* Pentru determinarea corectă a primei cerinţe se acordă 10% din punctajul pe test. Punctajul integral se acordă pe ambele cerinţe rezolvate corect.

= Exemplul 1: =
<code>unificIN.txt</code>
 10
 6
 47
 67
 40
 123
 231
 1238
 331
 2035
 50007
<code>unificOUT.txt</code>
 3
 2
 0 837

= Explicație =
Cifra care apare cel mai frecvent este <code>3</code> (de <code>6</code> ori).

Se unifică: <code>47</code> cu <code>67  => 46</code>. Şirul rămas: <code>6 46 40 123 231 1238 331 2035 50007</code>

Se unifică: <code>6</code> cu <code>46  => 4</code>. Şirul rămas: <code>4 40 123 231 1238 331 2035 50007</code>

Se unifică: <code>4</code> cu <code>40 => 0</code>. Şirul rămas: <code>0 123 231 1238 331 2035 50007</code>

Se unifică: <code>123</code> cu <code>231</code>, ambele numere rămân fără cifre, deci vor fi ambele eliminate. Şirul rămas: <code>0 1238 331 2035 50007</code>

Se unifică: <code>1238</code> cu <code>331 => 28</code>. Şirul rămas: <code>0 28 2035 50007</code>

Se unifică: <code>28</code> cu <code>2035 => 835</code>. Şirul rămas: <code>0 835 50007</code>

Se unifică: <code>835</code> cu <code>50007 => 837</code>. Şirul rămas: <code>0 837</code>

== Exemplul 1: ==
<code>unificIN.txt</code>
 100001
 6
 47
 67
 40
 123
 231
 1238
 331
 2035
 50007
<code>unificOUT.txt</code>
 Datele nu corespund restrictiilor impuse

== Rezolvare ==
<syntaxhighlight lang="python3" line="1">
def verifica_restrictii(n, numere):
    if not (1 <= n <= 100000):
        return False

    for numar in numere:
        if not (0 <= numar <= 10**18):
            return False

    return True

def main():
    with open("unificIN.txt", "r") as fin, open("unificOUT.txt", "w") as fout:
        n = int(fin.readline().strip())
        numere = []

        for _ in range(n):
            line = fin.readline().strip()
            if line:
                numere.append(int(line))

        if not verifica_restrictii(n, numere):
            fout.write("Datele nu corespund restrictiilor impuse")
            return

        frec = [0] * 11
        st = []


        def cifre(x):
            while x:
                frec[x % 10] += 1
                x //= 10

        def verif(poz):
            aux1 = [0] * 11
            x = st[poz - 1]
            if x == 0:
                aux1[0] += 1

            while x:
                aux1[x % 10] += 1
                x //= 10

            y = st[poz]
            if y == 0 and aux1[0] != 0:
                return 1

            while y:
                if aux1[y % 10] != 0:
                    return 1
                y //= 10
            return 0

        def getnum(dr):
            f = [0] * 21
            unu = [0] * 21
            doi = [0] * 21
            cif1, cif2 = 0, 0
            x, y = st[dr - 1], st[dr]
            st_num, drr = 0, 0
            concatenate = False
            ok = False

            if x == 0:
                f[0] += 1
                unu[cif1] = 0
                cif1 += 1
            if y == 0:
                f[0] += 1
                doi[cif2] = 0
                cif2 += 1
            while x:
                cif1 += 1
                unu[cif1] = x % 10
                f[x % 10] += 1
                x //= 10
            while y:
                if f[y % 10] != 0:
                    f[y % 10] = -1
                cif2 += 1
                doi[cif2] = y % 10
                y //= 10

            for i in range(cif1, 0, -1):
                if f[unu[i]] != -1:
                    st_num = 10 * st_num + unu[i]
                    ok = True
            for i in range(cif2, 0, -1):
                if f[doi[i]] != -1:
                    drr = 10 * drr + doi[i]
                    ok = True
                    concatenate = True

            if not ok:
                return -1

            if concatenate:
                p = 10
                while drr >= p:
                    p *= 10
                return st_num * p + drr

            return st_num

        for numar in numere:
            cifre(numar) 
            st.append(numar)  

            while len(st) >= 2 and verif(len(st) - 1):
                x = getnum(len(st) - 1)
                if x != -1:
                    st[-2] = x
                    st.pop()
                else:
                    st.pop()
                    st.pop()

        maxi, afis = max((val, idx) for idx, val in enumerate(frec))

        fout.write(f'{afis}\n')
        fout.write(f'{len(st)}\n')
        for numar in st:
            fout.write(f'{numar} ')

if __name__ == "__main__":
    main()

</syntaxhighlight>