Sekcija iz Programiranja

Analiza - kako do rešenja

Potrebno je realizovati program koji radi sa trodimenzionalnom (3D) matricom celih brojeva dimenzija N x N x N.

Korisnik na početku unosi vrednost N, pri čemu važi uslov:  1 < N < 20

Unos mora biti proveren, što znači da program ne sme nastaviti rad dok se ne unese ispravna vrednost.

Nakon unosa dimenzije:

• formira se 3D matrica,

• svaki element dobija vrednost:  mat[i][j][k] = i + j + k

Indeksiranje počinje od 0.

---

Operacije koje program treba da podrži

Program radi sve dok se ne unese komanda:

QUIT

Komande ne smeju biti osetljive na veličinu slova:

update
UPDATE
UpDaTe

sve mora biti prihvaćeno.

---

1.1 Prikaz matrice

Potrebno je ispisati sve elemente matrice nakon inicijalizacije.

Pošto je matrica 3D, najlakše je prikazati:

• jedan sloj (i)

• unutar njega redove (j)

• i kolone (k)

Primer:

Layer 0
0 1 2
1 2 3
2 3 4

---

1.2 UPDATE operacija

Komanda:

UPDATE 2,2,2 -1

znači:

mat[2][2][2] = -1

Potrebno je:

1. pročitati indekse,

2. pročitati novu vrednost,

3. izmeniti element,

4. ponovo prikazati matricu.

---

1.3 SUM operacija

Komanda:

SUM 1,1,1 3,3,3

znači:

izračunati sumu svih elemenata u opsegu:

i = 1..3
j = 1..3
k = 1..3

uključujući granice.

Potrebno je koristiti tri ugneždene petlje.

---

1.4 NEW operacija

Formira se nova matrica istih dimenzija.

Svaki element nove matrice predstavlja:

• zbir susednih elemenata iz stare matrice.

Susedi su:

• gore/dole

• levo/desno

• napred/nazad

Dijagonale se NE računaju.

---

Ciklično povezivanje (wrap-around)

Ako je element na ivici:

i = 0

njegov sused „iznad“ je:

i = N-1

Isto važi za sve dimenzije.

Ovo je kružna (torusna) matrica.

---

1.5 MOVE operacija

Komanda:

MOVE 1,1,1 0,1,1

znači:

• uzeti elemente u istoj osi,

• pomeriti ih za zadati broj mesta.

Pomeranje može biti:

• pozitivno,

• negativno.

Pošto je matrica ciklična, pomeranje „izlazi“ sa jedne strane i vraća se na drugu.

---

Struktura programa

Program se može podeliti na funkcije:

Funkcija	Opis
InitMatrix	Popunjava matricu
PrintMatrix	Ispisuje matricu
Update	Menja element
SumRange	Računa sumu
CreateNewMatrix	Formira NEW matricu
Move	Vrši pomeranje
ParseCommand	Obrada komandi

C# rešenje (Visual Studio 2010)

using System;

class Program
{ 
    
    static void PrintMatrix(int[,,] mat, int n)
    {
        // prolazak kroz slojeve
        for (int i = 0; i < n; i++)
        {
            // prolazak kroz redove
            for (int j = 0; j < n; j++)
            {
                // prolazak kroz kolone
                for (int k = 0; k < n; k++)
                {
                    Console.Write(mat[i, j, k] + "\t");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }
    }

    static void Main()
    {
        int n;
        do
        {
            Console.WriteLine("Unesite N: ");
            n = int.Parse(Console.ReadLine());
        } while (n < 2 || n > 19);
 
        int[,,] mat = new int[n, n, n];
 
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                for (int k = 0; k < n; k++)
                {
                    mat[i, j, k] = i + j + k;
                }
            }
        }
 
        Console.WriteLine("\n********** Izlaz 1.1 **********");
        PrintMatrix(mat, n);
 
        while (true)
        {
            Console.WriteLine("Naredba: ");
            string input = Console.ReadLine();
 
            string upper = input.ToUpper();
 
            if (upper == "QUIT")
            {
                break;
            }
 
            else if (upper.StartsWith("UPDATE"))
            {
             
                string[] parts = input.Split(' ');
 
                string[] indexes = parts[1].Split(',');
                int i = int.Parse(indexes[0]);
                int j = int.Parse(indexes[1]);
                int k = int.Parse(indexes[2]);
 
                int value = int.Parse(parts[2]);
 
                mat[i, j, k] = value;
                 
                Console.WriteLine("\n********** Izlaz 1.2 **********");
                PrintMatrix(mat, n);
            }
 
            else if (upper.StartsWith("SUM"))
            {
                string[] parts = input.Split(' ');
 
                string[] start = parts[1].Split(',');
 
                string[] end = parts[2].Split(',');

                int i1 = int.Parse(start[0]);
                int j1 = int.Parse(start[1]);
                int k1 = int.Parse(start[2]);

                int i2 = int.Parse(end[0]);
                int j2 = int.Parse(end[1]);
                int k2 = int.Parse(end[2]);

                int sum = 0;
 
                for (int i = i1; i <= i2; i++)
                {
                    for (int j = j1; j <= j2; j++)
                    {
                        for (int k = k1; k <= k2; k++)
                        {
                            sum += mat[i, j, k];
                        }
                    }
                }
               
                Console.WriteLine("\n********** Izlaz 1.3 **********");
                Console.WriteLine( "SUM = " + sum );
            }
 
            else if (upper == "NEW")
            {             
                int[,,] newMat = new int[n, n, n];
                int preX,posleX,preY,posleY,preZ,posleZ, suma;
                
                 for(int i=0;i<n;i++)    
                      for(int j=0;j<n;j++)     
                           for(int k=0;k<n;k++){
                                // indeksi - Susedi
                               preX = (i-1)<0 ? (n-1) : (i-1);
                               posleX = (i+1)>=n ? 0 : (i+1);
                               preY = (j-1)<0 ? (n-1) : (j-1);
                               posleY = (j+1)>=n ? 0 : (j+1);
                               preZ = (k-1)<0 ? (n-1) : (k-1);
                               posleZ = (k+1)>=n ? 0 : (k+1);
                       
                            suma=0;
                               suma += mat[preX,j,k]+mat[posleX,j,k];
                               suma += mat[i,preY,k]+mat[i,posleY,k];
                               suma += mat[i,j,preZ]+mat[i,j,posleZ];
                               
                               newMat[i,j,k] = suma;
                            
                           
                        }
                 Console.WriteLine("\n********** Izlaz  1.4 **********");
                
                PrintMatrix(newMat, n);
            }
 
            else if (upper.StartsWith("MOVE"))
            {
                string[] parts = input.Split(' ');
 
                string[] pos = parts[1].Split(',');
                string[] shift = parts[2].Split(',');
                int x = int.Parse(pos[0]);
                int y = int.Parse(pos[1]);
                int z = int.Parse(pos[2]);

                int dx = int.Parse(shift[0]);
                int dy = int.Parse(shift[1]);
                int dz =  int.Parse(shift[2]);

               // Pomeranje po x osi
                if(dx<0){
                    int pom = mat[0, y, z];
                      for (int p = 0; p < -dx; p++) {
                       for (int i = 0; i < n-1; i++)
                       {
                         mat[i, y, z] = mat[i+1, y, z];
                       }
                       mat[n-1, y, z] = pom;
                    }
                } else if(dx>0){
                    int pom = mat[n - 1,y,z];
                    for (int p = 0; p < dx; p++) {
                      for (int i = n - 1; i > 0; i--) {
                        mat[i,y,z] = mat[i - 1,y,z];
                      }
                      mat[0,y,z] = pom;
                    }
                }

                // Pomeranje po y osi
                if(dz<0){
                     int pom = mat[x, y, 0];
                    for (int p = 0; p < -dz; p++) {
                      for (int i = 0; i < n-1; i++)
                      {
                         mat[x, y, i] = mat[x, y, i+1];
                      }
                      mat[x, y, n-1] = pom;
                    } 
                } else if(dz>0){
                    int pom = mat[x, y, n - 1];
                    for (int p = 0; p < dz; p++) {
                      for (int i = n - 1; i > 0; i--) {
                        mat[x, y, i] = mat[x, y, i - 1];
                        }
                        mat[x, y, 0] = pom;
                    }
                }
                
                // Pomeranje po z osi
                if(dy<0){
                    int pom = mat[x, 0, z];
                    for (int p = 0; p < -dy; p++) {
                      for (int i = 0; i < n-1; i++)
                      {
                         mat[x, i, z] = mat[x, i+1, z];
                      }
                      mat[x, n-1, z] = pom;
                    } 
                } else if(dy>0){
                     int pom = mat[x, n - 1, z];
                    for (int p = 0; p < dy; p++) {
                      for (int i = n - 1; i > 0; i--) {
                        mat[x, i, z] = mat[x, i - 1,z];
                        }
                        mat[x, 0, z] = pom;
                    }
                }
              
                Console.WriteLine("\n********** 1.5 **********");
            
                PrintMatrix(mat, n);
            }
            // Nepoznata komanda
            else
            {
                Console.WriteLine( "Nepoznata komanda." );
            }
        }
    }
}

C++ rešenje

#include <iostream>
#include <string>
#include <cctype>
#include <algorithm>
#include <sstream>
 
using namespace std;
 
 void printMat(int m[][20][20],int N){
     for(int i=0;i<N;i++){    
      for(int j=0;j<N;j++){     
       for(int k=0;k<N;k++)
         cout<<m[i][j][k]<<" ";
       cout<<endl;
        }
        cout<<endl;
    }
    
 }

int main() {
    
    int N,i,j,k,vrednost, sum=0;
    int mat[20][20][20];
    string naredba, komanda;
    string zarez;
    int i1,i2,j1,j2,k1,k2;
    
    do{
        cout<<"Unesite N"<<endl;
        cin>>N;
    }while(N<2 || N>19);

 
    for(i=0;i<N;i++)
      for(j=0;j<N;j++)
       for(k=0;k<N;k++)
         mat[i][j][k] = i+j+k;
         
    cout<<"******** Izlaz 1.1. *********"<<endl;     
    printMat(mat,N);
    cin.ignore();
    
    
     do{
         cout << "Naredba: " << endl;
        getline(cin, naredba);
        
         for(j=0;j<naredba.length();j++)
          naredba[j]= toupper(naredba[j]);
          
         string nazivNaredbe = naredba.substr(0, naredba.find(' '));
          
               
          if(nazivNaredbe=="QUIT") break;
          
         else if(nazivNaredbe=="UPDATE"){
              
             sscanf(naredba.c_str(),"UPDATE %d,%d,%d %d",&i, &j, &k, &vrednost);
              
                   
             mat[i][j][k]=vrednost;
             
             cout<<"\n******** Izlaz 1.2. *********"<<endl;    
             
            printMat(mat,N);
    
                
        } 
        
        else if(nazivNaredbe=="SUM"){              
             sscanf(naredba.c_str(),"SUM %d,%d,%d %d,%d,%d",&i1, &j1, &k1, &i2, &j2, &k2);
             for(i=i1;i<=i2;i++)    
                for(j=j1;j<=j2;j++)     
                   for(k=k1;k<=k2;k++)
                     sum += mat[i][j][k];
               cout<<"\n******** Izlaz 1.3. *********"<<endl;        
             cout<<"Suma = "<<sum<<endl;
         }
         else if(nazivNaredbe=="NEW"){
             int newMat[20][20][20];
             
             int preX,posleX,preY,posleY,preZ,posleZ, suma;
             for(i=0;i<=N;i++)    
                for(j=0;j<=N;j++)     
                   for(k=0;k<=N;k++){
                       preX = (i-1)<0 ? (N-1) : (i-1);
                       posleX = (i+1)>=N ? 0 : (i+1);
                       preY = (j-1)<0 ? (N-1) : (j-1);
                       posleY = (j+1)>=N ? 0 : (j+1);
                       preZ = (k-1)<0 ? (N-1) : (k-1);
                       posleZ = (k+1)>=N ? 0 : (k+1);
                       
                    suma=0;
                       suma += mat[preX][j][k]+mat[posleX][j][k];
                       suma += mat[i][preY][k]+mat[i][posleY][k];
                       suma += mat[i][j][preZ]+mat[i][j][posleZ];
                       newMat[i][j][k] = suma;
                       
                   }
             cout<<"\n******** Izlaz 1.4. *********"<<endl;      
            printMat(newMat,N);     
         
         }
         else if(nazivNaredbe=="MOVE"){
             int x, y, z, x1, y1, z1, pomeraj;
            sscanf(naredba.c_str(), "MOVE %d,%d,%d %d,%d,%d", &x, &y, &z, &i2, &j2, &k2);
            
            pomeraj=i2;// i2 - pomeraj po X osi
            if (pomeraj < 0) {
                for (int p = 0; p < -pomeraj; p++) {
                    int tmp = mat[0][y][z];
                    for (int i = 0; i < N - 1; i++) {
                        mat[i][y][z] = mat[i + 1][y][z];
                    }
                    mat[N - 1][y][z] = tmp;
                }
            } else {
                for (int p = 0; p < pomeraj; p++) {
                    int tmp = mat[N - 1][y][z];
                    for (int i = N - 1; i > 0; i--) {
                        mat[i][y][z] = mat[i - 1][y][z];
                    }
                    mat[0][y][z] = tmp;
                }
            }
            pomeraj=j2;// j2 - pomeraj po Y osi
            if (pomeraj < 0) {
                for (int p = 0; p < -pomeraj; p++) {
                    int tmp = mat[x][0][z];
                    for (int i = 0; i < N - 1; i++) {
                        mat[x][i][z] = mat[x][i + 1][z];
                    }
                    mat[x][N - 1][z] = tmp;
                }
            } else {
                for (int p = 0; p < pomeraj; p++) {
                    int tmp = mat[x][N - 1][z];
                    for (int i = N - 1; i > 0; i--) {
                        mat[x][i][z] = mat[x][i - 1][z];
                    }
                    mat[x][0][z] = tmp;
                }
            }
            
            pomeraj=k2;// k2 - pomeraj po Z osi
             if (pomeraj < 0) {
                for (int p = 0; p < -pomeraj; p++) {
                    int tmp = mat[x][y][0];
                    for (int i = 0; i < N - 1; i++) {
                        mat[x][y][i] = mat[x][y][i + 1];
                    }
                    mat[x][y][N - 1] = tmp;
                }
                } else {
                for (int p = 0; p < pomeraj; p++) {
                    int tmp = mat[x][y][N - 1];
                    for (int i = N - 1; i > 0; i--) {
                        mat[x][y][i] = mat[x][y][i - 1];
                    }
                    mat[x][y][0] = tmp;
                }
            }
            
            printMat(mat,N);
         }
         else cout<<"nepoznata naredba "<<endl;
         
     }while(true);  
       
        return 0;
}

Python rešenje

def print_matrix(mat, n):

    for i in range(n):

        for j in range(n):

            for k in range(n):

                print(mat[i][j][k], end="\t")

            print()

        print()


def mod(x, n):

    return (x % n + n) % n


# unos N
n = 0

while n <= 1 or n >= 20:

    n = int(input("Unesite N: "))


# inicijalizacija
mat = [[[0 for k in range(n)] for j in range(n)] for i in range(n)]

for i in range(n):
    for j in range(n):
        for k in range(n):

            mat[i][j][k] = i + j + k


print_matrix(mat, n)


while True:

    cmd = input("Komanda: ")

    upper = cmd.upper()

    # ---------------------------
    # QUIT
    # ---------------------------
    if upper == "QUIT":
        break

    # ---------------------------
    # UPDATE
    # ---------------------------
    elif upper.startswith("UPDATE"):

        parts = cmd.split()

        idx = parts[1].split(",")

        i = int(idx[0])
        j = int(idx[1])
        k = int(idx[2])

        value = int(parts[2])

        mat[i][j][k] = value

        print("Nakon UPDATE:")
        print_matrix(mat, n)

    # ---------------------------
    # SUM
    # ---------------------------
    elif upper.startswith("SUM"):

        parts = cmd.split()

        start = parts[1].split(",")
        end = parts[2].split(",")

        i1 = int(start[0])
        j1 = int(start[1])
        k1 = int(start[2])

        i2 = int(end[0])
        j2 = int(end[1])
        k2 = int(end[2])

        s = 0

        for i in range(i1, i2 + 1):
            for j in range(j1, j2 + 1):
                for k in range(k1, k2 + 1):

                    s += mat[i][j][k]

        print("SUM =", s)

    # ---------------------------
    # NEW
    # ---------------------------
    elif upper == "NEW":

        new_mat = [[[0 for k in range(n)] for j in range(n)] for i in range(n)]

        for i in range(n):
            for j in range(n):
                for k in range(n):

                    up = mat[mod(i - 1, n)][j][k]
                    down = mat[mod(i + 1, n)][j][k]

                    left = mat[i][mod(j - 1, n)][k]
                    right = mat[i][mod(j + 1, n)][k]

                    front = mat[i][j][mod(k - 1, n)]
                    back = mat[i][j][mod(k + 1, n)]

                    new_mat[i][j][k] = (
                        up + down +
                        left + right +
                        front + back
                    )

        print("NEW matrica:")
        print_matrix(new_mat, n)

    # ---------------------------
    # MOVE
    # ---------------------------
    elif upper.startswith("MOVE"):

        parts = cmd.split()

        idx = parts[1].split(",")
        move = parts[2].split(",")

        x = int(idx[0])
        y = int(idx[1])
        z = int(idx[2])

        dx = int(move[0])
        dy = int(move[1])
        dz = int(move[2])

        temp = [[[mat[i][j][k] for k in range(n)]
                 for j in range(n)]
                 for i in range(n)]

        # pomeranje po x osi
        for i in range(n):

            ni = mod(i + dx, n)

            temp[ni][y][z] = mat[i][y][z]

        # pomeranje po y osi
        for j in range(n):

            nj = mod(j + dy, n)

            temp[x][nj][z] = mat[x][j][z]

        # pomeranje po z osi
        for k in range(n):

            nk = mod(k + dz, n)

            temp[x][y][nk] = mat[x][y][k]

        mat = temp

        print("Nakon MOVE:")
        print_matrix(mat, n)

    else:

        print("Nepoznata komanda.")