QUEST 1 – Energia lanternei lui Py-Bot

Py-Bot și-a upgradat lanterna cu un sistem „smart” de gestionare a bateriilor. Fiecare cheie din dicționarul baterii corespunde unui compartiment al lanternei, iar lista asociată conține valorile măsurate ale bateriilor introduse în acel compartiment. Valorile pozitive indică baterii funcționale, în timp ce valorile zero sau negative marchează baterii defecte, care vor fi ignorate în calcul.

Py-Bot are și un mic bonus de calibrare pentru fiecare compartiment, stocat în dicționarul bonus. Pentru fiecare compartiment:

• se păstrează doar bateriile cu energie strict pozitivă,
• se calculează suma valorilor rămase,
• se adaugă bonusul corespunzător din dicționarul bonus,
• dacă în compartiment au rămas cel puțin 2 baterii valide, energia acelui compartiment se adună la energie_totala.

baterii = {
    "A": [5, -1, 3],
    "B": [2, 2],
    "C": [4, 0, 1]
}

bonus = {
    "A": 1,
    "B": 2,
    "C": 0
}

energie_totala = 0

for compartiment, valori in baterii.items():
    valide = [v for v in valori if v > 0]
    energie_compartiment = sum(valide) + bonus[compartiment]
    if len(valide) >= 2:
        energie_totala = energie_totala + energie_compartiment

print(energie_totala)

Sarcină: Fără a rula codul, calculează valoarea variabilei energie_totala după execuția buclei. Acest număr este primul cod de acces al echipei.

Scrie în formular codul de acces (energia totală).

QUEST 2 – Escape Room

Py-Bot este blocat din nou într-un escape room, dar de data aceasta are patru uși: ALFA, BETA, GAMA și DELTA. Fiecare ușă are 3 senzori de siguranță, reprezentați prin numere întregi, iar ușile sunt plasate în camere diferite.

Programul de mai jos folosește două dicționare:

• usi – asociază fiecărei uși o listă de valori ale senzorilor;
• camere – indică în ce cameră se află fiecare ușă.

O ușă este considerată sigură și poate intra în lista usi_sigure doar dacă:

• toți senzorii au valori strict pozitive;
• există cel puțin un senzor cu valoarea cel puțin 5;
• suma valorilor senzorilor este un număr par;
• ușa nu se află în camera "B".

După ce toate ușile sunt verificate, numele ușilor sigure sunt sortate alfabetic,
apoi unite într-un singur șir, despărțite prin caracterul -. Acest șir reprezintă
„parola de ieșire” generată de Py-Bot.

usi = {
    "ALFA":  [4, 3, 5],
    "BETA":  [6, -1, 8],
    "GAMA":  [3, 4, 4],
    "DELTA": [5, 5, 2]
}

camere = {
    "ALFA": "A",
    "BETA": "B",
    "GAMA": "A",
    "DELTA": "C"
}

usi_sigure = []

for nume, senzori in usi.items():
    total = sum(senzori)
    numai_pozitive = all(x > 0 for x in senzori)
    are_senzor_puternic = max(senzori) >= 5

    if numai_pozitive and are_senzor_puternic and total % 2 == 0 and camere[nume] != "B":
        usi_sigure.append(nume)

parola = "-".join(sorted(usi_sigure))

print(parola)

Sarcină: Analizează cu atenție logica programului și determină exact ce șir de caractere este stocat în variabila parola. Acest șir este „parola de ieșire” din escape room.

Scrie în formular exact parola de ieșire produsă de program (cu litere mari și cratime, exact ca în afișare).

QUEST 3 – Registrul de artefacte

În camera comorii există un registru digital de artefacte. Fiecare artefact are un cod scris cu litere mari.
Py-Bot vrea să afle câte dintre artefacte par a fi artefacte antice, adică au codul care:

• începe cu litera A, și
• are lungimea strict mai mare decât 3 caractere.

Se consideră următorul program:

artefacte = [
    "RING_VIANU",
    "MAP_DP",
    "AMULET_ALGORITHM",
    "AXIOM_AI",
    "BITSET_IOI",
    "ANCIENT_ASSEMBLY"
]
numar_antice = 0

for item in artefacte:
    if item.startswith("A") and len(item) > 3:
        numar_antice = numar_antice + 1

print(numar_antice)

Sarcină: Analizează codul și determină câte artefacte sunt considerate „antice” conform condițiilor din program. Numărul obținut reprezintă nivelul de raritate al colecției.

Scrie în formular nivelul de raritate.

QUEST 4 – Mesajul criptat de pe pergament

Py-Bot descoperă un pergament mai complex: mesajul nu mai este scris într-un singur șir, ci este împărțit în mai multe fragmente, corespunzătoare unor nivele diferite ale comorii. Fiecare fragment conține litere mari, dar și diverse simboluri (_, -) care trebuie ignorate, precum și eventual alte caractere irelevante.

Programul de mai jos:

• parcurge fiecare fragment din lista mesaje;
• construiește pentru fiecare fragment un nou șir fragment_curat păstrând doar literele mari, ignorând caracterele din mulțimea ignorat (_, -);
• dacă fragment_curat are cel puțin 3 caractere, este adăugat în lista cuvinte;
• la final, toate cuvintele din lista cuvinte sunt unite într-un singur șir, separate prin spațiu.
  Acest șir reprezintă numele complet al comorii.

mesaje = [
    "T_REA-SU-R_E",
    "M_A-P__",
    "C-OD_E"
]

ignorat = {"_", "-"}

cuvinte = []

for text in mesaje:
    fragment_curat = ""
    for ch in text:
        if ch in ignorat:
            continue
        if ch.isalpha() and ch == ch.upper():
            fragment_curat = fragment_curat + ch
    if len(fragment_curat) >= 3:
        cuvinte.append(fragment_curat)

secret = " ".join(cuvinte)

print(secret)

Sarcină: Urmărește cu atenție algoritmul și stabilește ce șir de caractere se obține în variabila secret după rularea programului. Acest șir este numele complet al comorii.

Scrie în formular numele comorii exact cum este construit în program (cu spații și litere mari).

QUEST BONUS – Bug Hunter

Pentru a deschide comoara, Py-Scanner generează un „cod de activare” dintr-o listă de valori. Fiecărui număr i se adaugă 1, apoi se păstrează doar elementele aflate pe pozițiile cu index par (0, 2, 4, ...). Lista cod obținută la final ar trebui să reprezinte secvența corectă de activare a mecanismului.
Însă, în programul de mai jos s-a strecurat un bug pe linia marcată corespunzător, iar codul de activare nu mai este cel dorit. Misiunea ta este să intri în rolul de bug hunter și să identifici instrucțiunea greșită.

numere = [4, 7, 1, 9, 3]

modificate = [x + 1 for x in numere]
cod = modificate[1:len(modificate):2]   # LINIE CU BUG

print(cod)

Sarcina ta: Analizează programul și corectează linia marcată cu LINIE CU BUG, astfel încât lista cod să conțină doar elementele de pe pozițiile cu index par, așa cum își dorește Py-Scanner.

Scrie în formular varianta corectă a liniei care începe cu cod = ....