Zadatak predstavlja simulaciju kretanja lopova i policajca kroz tržni centar koji je predstavljen matricom.

Tržni centar ima:

• 10 redova ( spratovi )

• 20 kolona ( radnje i stepenice )

Matrica sadrži:

• R → radnja

• S → stepenice

• E → izlaz

Formiranje matrice

Matrica se formira tako da:

• prva i poslednja kolona predstavljaju stepenice

• u poslednjem redu se na tim pozicijama nalaze izlazi

• sva ostala polja predstavljaju radnje

Primer:

• (i,0) i (i,19) → S

• (9,0) i (9,19) → E

• ostala polja → R

Kretanje lopova

Lopov:

1. pljačka radnju u kojoj se nalazi

2. označava je simbolom -

3. ide ka strani gde ima više radnji

4. kada dođe do stepenica, preko stepenica prelazi na drugi sprat (ispod)

Kretanje po sledećem spratu

Ako postoji radnja desno kreće desno, a u suprotnom ide levo

Kretanje policajca

Policajac ima dva režima rada.

1. Lopov je na istom spratu

Ako su:

• Xp == Xl

policajac ide direktno ka lopovu po 2 polja u jednom potezu

2. Lopov nije na istom spratu

Policajac ide do najbližih stepenica, menja sprat i pokušava da dođe na sprat lopova

Završetak simulacije

Simulacija se završava kada:

• policajac uhvati lopova ili

• lopov opljačka sve radnje

Hvatanje lopova

Ako su koordinate iste:

Xp == Xl && Yp == Yl

lopov je uhvaćen.

Polje se označava simbolom:

• X

Uspešnost pljačke

Uspešnost predstavlja procenat opljačkanih radnji, tako što se izbroje sve opljačkane radnje (ne računa se radnja u kojoj s+je uhvaćen) - znači L i -.

To se podeli sa početnim brojem radnji (10*18=180), a onda pomnoži sa 100 da bi se dobili procenti.

Pseudokod

POCETAK

KREIRAJ matricu 10x20

ZA svaki red i kolonu
    AKO je prva ili poslednja kolona
        AKO je poslednji red
            postavi E
        INACE
            postavi S
    INACE
        postavi R

UCITAJ poziciju policajca
UCITAJ poziciju lopova

PRIKAZI matricu

POSTAVI policajca i lopova

DOK traje simulacija

    OBELEZI trenutnu poziciju lopova sa '-'

    POMERI lopova

    AKO su sve radnje opljackane
        PREKINI

    POMERI policajca

    AKO policajac i lopov imaju iste koordinate
        POSTAVI X
        PREKINI

KRAJ DOK

PRIKAZI matricu

AKO je lopov uhvacen
    ISPISI koordinate hvatanja
INACE
    ISPISI poruku o bekstvu

IZRACUNAJ procenat uspesnosti

ISPISI procenat

KRAJ

U nastavku su rešenja kojima se poklapaju razultati kao u test primeru: to znači da je lopov "glupav" i NE BEŽI od policajca

Rešenje u C#

using System;

class Program
{
    const int rows = 10;
    const int cols = 20;

    // Formiranje matrice
    static char[,] InitializeMall()
    {
        char[,] mall = new char[rows, cols];

        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                // Stepenice i izlazi
                if (j == 0 || j == cols - 1)
                {
                    if (i == rows - 1)
                        mall[i, j] = 'E';
                    else
                        mall[i, j] = 'S';
                }
                else
                {
                    mall[i, j] = 'R';
                }
            }
        }

        return mall;
    }

    // Ispis matrice
    static void PrintMall(char[,] mall)
    {
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                Console.Write(mall[i, j] + " ");
            }

            Console.WriteLine();
        }

        Console.WriteLine();
    }

    // Kretanje lopova
    static void MoveThief(char[,] mall, ref int Xl, ref int Yl)
    {
        // Oznaci opljackanu radnju
        if (mall[Xl, Yl] == 'R')
        {
            mall[Xl, Yl] = '-';
        }

        // Kretanje desno
        if (Yl < cols - 2 && mall[Xl, Yl + 1] == 'R')
        {
            Yl++;
        }
        // Kretanje levo
        else if (Yl > 1 && mall[Xl, Yl - 1] == 'R')
        {
            Yl--;
        }
        // Kretanje po stepenicama
        else if (Yl == 0 || Yl == cols - 1)
        {
            if (Xl < rows - 1)
            {
                Xl++;
            }
            else if (Xl > 0)
            {
                Xl--;
            }
        }
        else
        {
            // Odlazak do stepenica
            if (Yl < cols / 2)
                Yl--;
            else
                Yl++;
        }
    }

    // Kretanje policajca
    static void MovePolice(ref int Xp, ref int Yp,
                           int Xl, int Yl)
    {
        // Ako su na istom spratu
        if (Xp == Xl)
        {
            if (Yp < Yl)
                Yp += 2;
            else if (Yp > Yl)
                Yp -= 2;
        }
        else
        {
            // Odlazak do stepenica
            if (Yp != 0 && Yp != cols - 1)
            {
                if (Yp < cols / 2)
                    Yp = 0;
                else
                    Yp = cols - 1;
            }
            else
            {
                // Promena sprata
                if (Xp < Xl)
                    Xp++;
                else if (Xp > Xl)
                    Xp--;
            }
        }

        // Ogranicenja
        if (Xp < 0) Xp = 0;
        if (Xp >= rows) Xp = rows - 1;

        if (Yp < 0) Yp = 0;
        if (Yp >= cols) Yp = cols - 1;
    }

    // Provera da li postoje radnje
    static bool AllShopsRobbed(char[,] mall)
    {
        for (int i = 0; i < rows; i++)
        {
            for (int j = 1; j < cols - 1; j++)
            {
                if (mall[i, j] == 'R')
                    return false;
            }
        }

        return true;
    }

    // Brojanje opljackanih radnji
    static int CountRobbedShops(char[,] mall)
    {
        int count = 0;

        for (int i = 0; i < rows; i++)
        {
            for (int j = 1; j < cols - 1; j++)
            {
                if (mall[i, j] == '-')
                    count++;
            }
        }

        return count;
    }

    static void Main()
    {
        int Xp, Yp;
        int Xl, Yl;

        Console.WriteLine("Unesite poziciju policajca:");
        string[] p = Console.ReadLine().Split(',');

        Xp = int.Parse(p[0]);
        Yp = int.Parse(p[1]);

        Console.WriteLine("Unesite poziciju lopova:");
        string[] l = Console.ReadLine().Split(',');

        Xl = int.Parse(l[0]);
        Yl = int.Parse(l[1]);

        int Xu = -1;
        int Yu = -1;

        char[,] mall = InitializeMall();

        Console.WriteLine("*************** Izlaz 3.1 ***************");
        PrintMall(mall);

        mall[Xp, Yp] = 'P';
        mall[Xl, Yl] = 'L';

        Console.WriteLine("*************** Izlaz 3.2 ***************");
        PrintMall(mall);

        while (true)
        {
            MoveThief(mall, ref Xl, ref Yl);

            // Provera svih opljackanih radnji
            if (AllShopsRobbed(mall))
            {
                break;
            }

            MovePolice(ref Xp, ref Yp, Xl, Yl);

            // Hvatanje lopova
            if (Xp == Xl && Yp == Yl)
            {
                mall[Xp, Yp] = 'X';

                Xu = Xp;
                Yu = Yp;

                break;
            }
        }

        Console.WriteLine("*************** Izlaz 3.3 ***************");
        PrintMall(mall);

        Console.WriteLine("*************** Izlaz 3.4 ***************");

        if (Xu != -1 && Yu != -1)
        {
            Console.WriteLine(
                "Policajac je uhvatio lopova na poziciji: "
                + Xu + ", " + Yu);
        }
        else
        {
            Console.WriteLine(
                "Lopov je uspeo da opljacka sve radnje.");
        }

        Console.WriteLine("*************** Izlaz 3.5 ***************");

        int countRobbed = CountRobbedShops(mall) + 1;

        double percent =
            (double)countRobbed / (rows * (cols - 2)) * 100;

        Console.WriteLine(
            "Uspesnost pljacke je {0:F2} %",
            percent);

        Console.ReadKey();
    }
}

Rešenje u C++

#include <iostream>
#include <iomanip>

using namespace std;

const int rows = 10;
const int cols = 20;

// Formiranje matrice trznog centra
char** InitializeMall()
{
    // Dinamicka alokacija redova
    char** mall = new char*[rows];

    for (int i = 0; i < rows; i++)
    {
        mall[i] = new char[cols];

        for (int j = 0; j < cols; j++)
        {
            // Stepenice i izlazi
            if (j == 0 || j == cols - 1)
            {
                // Poslednji red sadrzi izlaze
                if (i == rows - 1)
                    mall[i][j] = 'E';
                else
                    mall[i][j] = 'S';
            }
            else
            {
                // Radnje
                mall[i][j] = 'R';
            }
        }
    }

    return mall;
}

// Ispis matrice
void PrintMall(char** mall)
{
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            cout << mall[i][j] << " ";
        }

        cout << endl;
    }

    cout << endl;
}

// Kretanje lopova
void MoveThief(char** mall, int& Xl, int& Yl)
{
    // Oznaci opljackanu radnju
    if (mall[Xl][Yl] == 'R')
    {
        mall[Xl][Yl] = '-';
    }

    // Kretanje desno
    if (Yl < cols - 2 && mall[Xl][Yl + 1] == 'R')
    {
        Yl++;
    }
    // Kretanje levo
    else if (Yl > 1 && mall[Xl][Yl - 1] == 'R')
    {
        Yl--;
    }
    // Kretanje po stepenicama
    else if (Yl == 0 || Yl == cols - 1)
    {
        if (Xl < rows - 1)
            Xl++;
        else if (Xl > 0)
            Xl--;
    }
    else
    {
        // Odlazak ka stepenicama
        if (Yl < cols / 2)
            Yl--;
        else
            Yl++;
    }
}

// Kretanje policajca
void MovePolice(int& Xp, int& Yp, int Xl, int Yl)
{
    // Ako su na istom spratu
    if (Xp == Xl)
    {
        if (Yp < Yl)
            Yp += 2;
        else if (Yp > Yl)
            Yp -= 2;
    }
    else
    {
        // Policajac ide ka stepenicama
        if (Yp != 0 && Yp != cols - 1)
        {
            if (Yp < cols / 2)
                Yp = 0;
            else
                Yp = cols - 1;
        }
        else
        {
            // Menja sprat
            if (Xp < Xl)
                Xp++;
            else if (Xp > Xl)
                Xp--;
        }
    }

    // Ogranicenja matrice
    if (Xp < 0) Xp = 0;
    if (Xp >= rows) Xp = rows - 1;

    if (Yp < 0) Yp = 0;
    if (Yp >= cols) Yp = cols - 1;
}

// Provera da li su sve radnje opljackane
bool AllShopsRobbed(char** mall)
{
    for (int i = 0; i < rows; i++)
    {
        for (int j = 1; j < cols - 1; j++)
        {
            if (mall[i][j] == 'R')
                return false;
        }
    }

    return true;
}

// Brojanje opljackanih radnji
int CountRobbedShops(char** mall)
{
    int count = 0;

    for (int i = 0; i < rows; i++)
    {
        for (int j = 1; j < cols - 1; j++)
        {
            if (mall[i][j] == '-')
                count++;
        }
    }

    return count;
}

int main()
{
    int Xp, Yp;
    int Xl, Yl;

    cout << "Unesite poziciju policajca (Xp,Yp): "<<endl;
    cin >> Xp;
    cin.ignore(1, ',');
    cin >> Yp;

    cout << "Unesite poziciju lopova (Xl,Yl): "<<endl;
    cin >> Xl;
    cin.ignore(1, ',');
    cin >> Yl;

    int Xu = -1;
    int Yu = -1;

    // Formiranje matrice
    char** mall = InitializeMall();

    cout << "\n*************** Izlaz 3.1 ***************\n";
    PrintMall(mall);

    // Pocetne pozicije
    mall[Xp][Yp] = 'P';
    mall[Xl][Yl] = 'L';

    cout << "*************** Izlaz 3.2 ***************\n";
    PrintMall(mall);

    // Simulacija
    while (true)
    {
        MoveThief(mall, Xl, Yl);

        // Provera svih opljackanih radnji
        if (AllShopsRobbed(mall))
            break;

        MovePolice(Xp, Yp, Xl, Yl);

        // Hvatanje lopova
        if (Xp == Xl && Yp == Yl)
        {
            mall[Xp][Yp] = 'X';

            Xu = Xp;
            Yu = Yp;

            break;
        }
    }

    cout << "*************** Izlaz 3.3 ***************\n";
    PrintMall(mall);

    cout << "*************** Izlaz 3.4 ***************\n";

    if (Xu != -1 && Yu != -1)
    {
        cout << "Policajac je uhvatio lopova na poziciji: ";
        cout << Xu << ", " << Yu << endl;
    }
    else
    {
        cout << "Lopov je opljackao sve radnje." << endl;
    }

    cout << "*************** Izlaz 3.5 ***************\n";

    int countRobbed = CountRobbedShops(mall) + 1;

    double percent =
        (double)countRobbed / (rows * (cols - 2)) * 100;

    cout << fixed << setprecision(2);

    cout << "Uspesnost pljacke je ";
    cout << percent << " %" << endl;

    // Oslobadjanje memorije
    for (int i = 0; i < rows; i++)
    {
        delete[] mall[i];
    }

    delete[] mall;

    return 0;
}

Rešenje u Python-u

ROWS = 10
COLS = 20

# Formiranje matrice
def initialize_mall():

    mall = []

    for i in range(ROWS):

        row = []

        for j in range(COLS):

            # Stepenice i izlazi
            if j == 0 or j == COLS - 1:

                # Poslednji red sadrzi izlaze
                if i == ROWS - 1:
                    row.append('E')
                else:
                    row.append('S')

            else:
                # Radnje
                row.append('R')

        mall.append(row)

    return mall


# Ispis matrice
def print_mall(mall):

    for i in range(ROWS):

        for j in range(COLS):

            print(mall[i][j], end=' ')

        print()

    print()


# Kretanje lopova
def move_thief(mall, xl, yl):

    # Oznacavanje opljackane radnje
    if mall[xl][yl] == 'R':
        mall[xl][yl] = '-'

    # Kretanje desno
    if yl < COLS - 2 and mall[xl][yl + 1] == 'R':
        yl += 1

    # Kretanje levo
    elif yl > 1 and mall[xl][yl - 1] == 'R':
        yl -= 1

    # Kretanje po stepenicama
    elif yl == 0 or yl == COLS - 1:

        if xl < ROWS - 1:
            xl += 1

        elif xl > 0:
            xl -= 1

    else:

        # Odlazak ka stepenicama
        if yl < COLS // 2:
            yl -= 1
        else:
            yl += 1

    return xl, yl


# Kretanje policajca
def move_police(xp, yp, xl, yl):

    # Ako su na istom spratu
    if xp == xl:

        if yp < yl:
            yp += 2

        elif yp > yl:
            yp -= 2

    else:

        # Odlazak do stepenica
        if yp != 0 and yp != COLS - 1:

            if yp < COLS // 2:
                yp = 0
            else:
                yp = COLS - 1

        else:

            # Menjanje sprata
            if xp < xl:
                xp += 1

            elif xp > xl:
                xp -= 1

    # Ogranicenja matrice
    xp = max(0, min(xp, ROWS - 1))
    yp = max(0, min(yp, COLS - 1))

    return xp, yp


# Provera svih opljackanih radnji
def all_shops_robbed(mall):

    for i in range(ROWS):

        for j in range(1, COLS - 1):

            if mall[i][j] == 'R':
                return False

    return True


# Brojanje opljackanih radnji
def count_robbed_shops(mall):

    count = 0

    for i in range(ROWS):

        for j in range(1, COLS - 1):

            if mall[i][j] == '-':
                count += 1

    return count


# Glavni program

xp, yp = map(int, input(
    "Unesite poziciju policajca (Xp,Yp): "
).split(','))

xl, yl = map(int, input(
    "Unesite poziciju lopova (Xl,Yl): "
).split(','))

xu = -1
yu = -1

# Formiranje matrice
mall = initialize_mall()

print("\n*************** Izlaz 3.1 ***************")
print_mall(mall)

# Pocetne pozicije
mall[xp][yp] = 'P'
mall[xl][yl] = 'L'

print("*************** Izlaz 3.2 ***************")
print_mall(mall)

# Simulacija
while True:

    xl, yl = move_thief(mall, xl, yl)

    # Provera svih opljackanih radnji
    if all_shops_robbed(mall):
        break

    xp, yp = move_police(xp, yp, xl, yl)

    # Hvatanje lopova
    if xp == xl and yp == yl:

        mall[xp][yp] = 'X'

        xu = xp
        yu = yp

        break

print("*************** Izlaz 3.3 ***************")
print_mall(mall)

print("*************** Izlaz 3.4 ***************")

if xu != -1 and yu != -1:

    print("Policajac je uhvatio lopova na poziciji:",
          xu, yu)

else:

    print("Lopov je opljackao sve radnje.")

print("*************** Izlaz 3.5 ***************")

count_robbed = count_robbed_shops(mall) + 1

percent = count_robbed / (ROWS * (COLS - 2)) * 100

print("Uspesnost pljacke je {:.2f} %".format(percent))