Editing 1699 - Robotel (section)

=== Explicație ===
Nu există perechi blocante pe tablă care ar putea opri roboţelul.

<syntaxhighlight lang="python" line="1">
def find_blocking_pairs(R, semnalizatori):
    # Găsirea perechilor blocante
    perechi_blocante = []
    
    # Parcurgerea liniilor pentru perechi E-V
    for i in range(R):
        e_index = -1
        for j in range(R):
            if (i, j) in semnalizatori and semnalizatori[(i, j)] == 'E':
                e_index = j
            elif (i, j) in semnalizatori and semnalizatori[(i, j)] == 'V':
                if e_index != -1:
                    perechi_blocante.append(((i, e_index), (i, j)))
                    e_index = -1  # Resetăm indexul pentru următoarea pereche

    # Parcurgerea coloanelor pentru perechi S-N
    for j in range(R):
        s_index = -1
        for i in range(R):
            if (i, j) in semnalizatori and semnalizatori[(i, j)] == 'S':
                s_index = i
            elif (i, j) in semnalizatori and semnalizatori[(i, j)] == 'N':
                if s_index != -1:
                    perechi_blocante.append(((s_index, j), (i, j)))
                    s_index = -1  # Resetăm indexul pentru următoarea pereche
    
    return perechi_blocante

def simulate_robot(R, semnalizatori, perechi_blocante):
    # Direcțiile Nord, Est, Sud, Vest
    directions = {'N': (-1, 0), 'E': (0, 1), 'S': (1, 0), 'V': (0, -1)}
    steps_count = {'N': 0, 'E': 0, 'S': 0, 'V': 0}
    
    # Poziția inițială și direcția inițială
    x, y = 0, 0
    direction = 'E'
    
    visited = set()
    
    while True:
        # Marcați poziția curentă ca vizitată
        visited.add((x, y))
        
        # Verificați dacă poziția curentă este o căsuță semnalizator
        if (x, y) in semnalizatori:
            direction = semnalizatori[(x, y)]
        
        # Calculați următoarea poziție
        dx, dy = directions[direction]
        new_x, new_y = x + dx, y + dy
        
        # Verificați dacă următoarea poziție este în afara grilei
        if not (0 <= new_x < R and 0 <= new_y < R):
            break
        
        # Verificați dacă se întâlnește o pereche blocantă
        for (ax, ay), (bx, by) in perechi_blocante:
            if (x, y) == (ax, ay) and (new_x, new_y) == (bx, by):
                x, y = bx, by
                break
            elif (x, y) == (bx, by) and (new_x, new_y) == (ax, ay):
                x, y = ax, ay
                break
        else:
            # Dacă nu se întâlnește o pereche blocantă, actualizați poziția
            x, y = new_x, new_y
        
        # Incrementați contorul de pași pentru direcția curentă
        steps_count[direction] += 1
    
    return steps_count

# Exemplu de utilizare
R = 5
semnalizatori = {
    (0, 1): 'E', (4, 1): 'V',  # Pereche blocantă (0,1) (4,1)
    (1, 2): 'S', (1, 4): 'N',  # Pereche blocantă (1,2) (1,4)
    (3, 2): 'N', (4, 2): 'S',  # Nu formează pereche blocantă
}
perechi_blocante = find_blocking_pairs(R, semnalizatori)
steps_count = simulate_robot(R, semnalizatori, perechi_blocante)

print(f"Perechi blocante: {perechi_blocante}")
print(f"Numărul de pași în fiecare direcție: {steps_count}")
</syntaxhighlight>