Editing 3924 - Cripto 1

== Enunt ==
Se dă un limbaj format din N cuvinte și un text criptat format din M cuvinte. Spunem că un cuvânt se permută după un șir x1,x2,…,xK dacă prima literă se permută cu x1, a doua cu x2, …, iar ultima cu xK.
De exemplu, după șirul 1 5 6, “abc” devine “bgi”. Permutarea se face în ordinea literelor mici din alfabetul englez. Dacă o literă ar trece de finalul alfabetului, aceasta îl reia și apoi permută și litera următoare cu 1.
În cazul în care ultima literă trece de finalul alfabetului, atunci cuvântul devine invalid. De exemplu, “zza” permutat după șirul 1 2 3, devine “ace”. (adunarea se face cu transport pornind de la stânga). Dacă “zzz” s-ar permuta după șirul 1 2 3, ar deveni invalid. Cele mai “semnificative” litere sunt de la dreapta la stânga.
Vrem să decriptăm textul, folosind mai multe variante de șiruri pe care le considerăm valabile. Cel mai bun șir de decriptare este acela pentru care numărul de cuvinte din textul criptat care se găsesc, după operație, în limbaj, este maximal.
== Cerinţa ==
Să se determine șirul cel mai bun de decriptare, dintre cele date. În cazul în care există mai multe astfel de șiruri, se va afișa cel cu indicele cel mai mic.
== Date de intrare ==
Pe prima linie din fișierul cripto1.in se află patru numere naturale N, M, K, Q.
Pe următoarea linie, se găsește limbajul, format din cele N cuvinte de lungime K.
Pe a treia linie se găsesc cele M cuvinte.
În final, se găsesc cele Q șiruri, de câte K numere fiecare pe câte o linie.
== Date de ieșire ==
Fişierul de ieşire cripto1.out va conţine pe prima linie, indicele celui mai bun șir, și similitudinea acestuia.
== Restricţii şi precizări ==
* N, M, Q ≤ 105, M * Q ≤ 107
*  Valorile din șiruri sunt strict mai mici decât 26.
* Pentru 30% din tese N, M, Q ≤ 100.
* K ≤ 12. Pentru alte 20% din teste K ≤ 3.
== Exemplul 1 ==
; cripto1.in

  6 3 4 2 
  info olte niaa este inva lcea 
  hlck njqa hlcj 
  1 2 3 5  
  1 2 3 4 
; cripto1.out

  2 2
== Explicație ==
Se permută cuvintele de pe a doua linie, după fiecare șir, din cele două.
Răspunsul este al doilea șir, 1 2 3 4, pentru că input-ul devine info olte infn.
Astfel, 2 dintre cuvinte se găsesc în primul limbaj.
Dacă am folosi primul șir, rezultatul ar fi 1: infp oltf info.
<br>


== Rezolvare ==
<syntaxhighlight lang="python" line>
def decrypt_text(language, encrypted_text, permutation):
    decrypted_text = []
    for word in encrypted_text:
        decrypted_word = ""
        for i in range(len(word)):
            decrypted_word += language[word[i] - 1]
        decrypted_text.append(decrypted_word)
    decrypted_text_permuted = []
    for word in decrypted_text:
        permuted_word = ""
        for i in range(len(word)):
            permuted_word += word[permutation[i] - 1]
        decrypted_text_permuted.append(permuted_word)
    return decrypted_text_permuted

def similarity(language, decrypted_text):
    count = 0
    for word in decrypted_text:
        if word in language:
            count += 1
    return count

def read_input(file_name):
    with open(file_name, 'r') as file:
        N, M, K, Q = map(int, file.readline().split())
        language = file.readline().split()
        encrypted_text = [file.readline().split()[0] for _ in range(M)]
        permutations = [list(map(int, file.readline().split())) for _ in range(Q)]
    return N, M, K, Q, language, encrypted_text, permutations

def write_output(file_name, result):
    with open(file_name, 'w') as file:
        file.write(str(result[0]) + ' ' + str(result[1]))

def find_best_decryption(N, M, K, Q, language, encrypted_text, permutations):
    max_similarity = -1
    best_permutation_index = -1
    for i in range(Q):
        decrypted_text = decrypt_text(language, encrypted_text, permutations[i])
        current_similarity = similarity(language, decrypted_text)
        if current_similarity > max_similarity:
            max_similarity = current_similarity
            best_permutation_index = i + 1
    return best_permutation_index, max_similarity

def main():
    N, M, K, Q, language, encrypted_text, permutations = read_input("cripto1.in")
    result = find_best_decryption(N, M, K, Q, language, encrypted_text, permutations)
    write_output("cripto1.out", result)

if __name__ == "__main__":
    main()

</syntaxhighlight>