Sekcija iz Programiranja

 REŠENJE za Python  

# Funkcija za računanje zbira cifara broja
def zbir_cifara(broj):
    zbir = 0                     # promenljiva u kojoj skupljamo zbir cifara
    while broj != 0:             # petlja radi dok broj ne postane 0
        zbir += broj % 10        # izdvajamo poslednju cifru i dodajemo na zbir
        broj //= 10              # uklanjamo poslednju cifru (celobrojno deljenje)
    return zbir                  # vraćamo rezultat

# Funkcija za računanje proizvoda cifara broja
def proizvod_cifara(broj):
    if broj == 0:                # ako je broj 0 → proizvod je 0
        return 0
    proizvod = 1                 # početna vrednost (množenje kreće od 1)
    while broj != 0:             # dok ima cifara
        proizvod *= broj % 10    # množimo sa poslednjom cifrom
        broj //= 10              # uklanjamo cifru
    return proizvod              # vraćamo rezultat

# Funkcija koja proverava da li je broj prost
def prost(broj):
    if broj <= 1:                # brojevi <= 1 nisu prosti
        return False
    for i in range(2, broj // 2 + 1):  # proveravamo delioce
        if broj % i == 0:        # ako postoji delilac
            return False         # broj nije prost
    return True                  # ako nema delilaca → prost je

# =========================
# KORAK 1 – unos n
# =========================

while True:                                      # beskonačna petlja
    n = int(input("Unesite broj elemenata niza N\n"))  # unos broja n

    if 5 <= n < 15:                              # provera uslova
        break                                    # izlaz iz petlje ako je ispravno
    else:
        print("Broj nije u opsegu")              # poruka ako nije ispravno

# =========================
# KORAK 2 – unos niza A
# =========================

A = []                                           # pravimo prazan niz

print("Unesite elemente niza A:")

for i in range(n):                               # unosimo n elemenata
    broj = int(input())                          # učitavamo jedan broj
    A.append(broj)                               # dodajemo u niz

# =========================
# ODGOVOR 1
# =========================

print("************** Odgovor 1 **************")

zbir = 0                                         # zbir elemenata niza

for x in A:                                      # prolazimo kroz niz
    print(x, end=" ")                            # ispis elementa
    zbir += x                                    # sabiramo elemente
print()                                          # novi red

srednja = zbir / n                               # računamo srednju vrednost
print("Srednja vrednost niza:", srednja)

brojac = 0                                       # brojač elemenata

for x in A:
    if x % 3 == 0 and x > srednja:               # uslov iz zadatka
        brojac += 1                              # povećavamo brojač

print("Broj elemenata koji su deljivi sa 3 i veci su od srednje vrednosti niza:", brojac)

# =========================
# ODGOVOR 2 – niz B
# =========================

print("************** Odgovor 2 **************")

B = []                                           # novi niz

for x in A:
    if x > 0:                                    # pozitivan broj
        B.append(zbir_cifara(x))                 # upisujemo zbir cifara
    elif x < 0:                                  # negativan broj
        B.append(abs(x))                         # apsolutna vrednost
    else:                                        # nula
        B.append(0)

for x in B:
    print(x, end=" ")
print()

# =========================
# ODGOVOR 3 – niz C
# =========================

print("************** Odgovor 3 **************")

C = []                                           # novi niz

for x in B:
    if prost(x):                                 # ako je broj prost
        C.append(x * x)                          # kvadrat broja
    else:
        C.append(proizvod_cifara(x))             # proizvod cifara

for x in C:
    print(x, end=" ")
print()

# =========================
# ODGOVOR 4 – matrica M
# =========================

print("************** Odgovor 4 **************")

m = 1                                            # početna dimenzija

while m * m < n:                                 # tražimo najmanje m
    m += 1

M = []                                           # matrica (lista lista)
k = 0                                            # indeks za niz C

for i in range(m):
    red = []                                     # jedan red matrice
    for j in range(m):
        red.append(C[k])                         # upisujemo element
        k += 1                                   # prelazimo na sledeći

        if k == n:                               # ako smo došli do kraja niza
            k = 0                                # vraćamo se na početak

    M.append(red)                                # dodajemo red u matricu

# ispis matrice
for red in M:
    for x in red:
        print(x, end=" ")
    print()

# =========================
# ODGOVOR 5 – matrica D
# =========================

print("************** Odgovor 5 **************")

D = []                                           # nova matrica

for i in range(m):
    red = []
    for j in range(m):

        suma_reda = 0                            # zbir reda
        suma_kolone = 0                          # zbir kolone

        for t in range(m):
            suma_reda += M[i][t]                 # sabiramo red
            suma_kolone += M[t][j]               # sabiramo kolonu

        vrednost = suma_reda + suma_kolone - M[i][j]  # formula
        red.append(vrednost)

    D.append(red)

# ispis matrice D
for red in D:
    for x in red:
        print(x, end=" ")
    print()
 

REŠENJE za C#

using System;                          // omogućava rad sa konzolom i osnovnim funkcijama

class Program
{
    // Funkcija za računanje zbira cifara broja
    static int ZbirCifara(int broj)
    {
        int zbir = 0;                  // promenljiva za zbir cifara

        while (broj != 0)              // dok broj ima cifre
        {
            zbir += broj % 10;         // uzimamo poslednju cifru i dodajemo je
            broj /= 10;                // uklanjamo poslednju cifru
        }

        return zbir;                   // vraćamo rezultat
    }

    // Funkcija za računanje proizvoda cifara
    static int ProizvodCifara(int broj)
    {
        if (broj == 0)                // ako je broj 0
            return 0;                 // proizvod je 0

        int proizvod = 1;             // početna vrednost za množenje

        while (broj != 0)             // dok ima cifara
        {
            proizvod *= broj % 10;    // množimo sa poslednjom cifrom
            broj /= 10;               // uklanjamo cifru
        }

        return proizvod;              // vraćamo rezultat
    }

    // Funkcija za proveru prostog broja
    static bool Prost(int broj)
    {
        if (broj <= 1)               // brojevi <= 1 nisu prosti
            return false;

        for (int i = 2; i <= broj / 2; i++)   // proveravamo delioce
        {
            if (broj % i == 0)      // ako postoji delilac
                return false;       // broj nije prost
        }

        return true;                // ako nema delilaca → prost je
    }

    static void Main()
    {
        int n;                      // broj elemenata niza

        // =========================
        // KORAK 1 – unos n
        // =========================

        do
        {
            Console.WriteLine("Unesite broj elemenata niza N");
            n = int.Parse(Console.ReadLine());   // unos broja

            if (n < 5 || n >= 15)               // provera uslova
                Console.WriteLine("Broj nije u opsegu");

        } while (n < 5 || n >= 15);             // ponavljanje dok nije ispravno

        // =========================
        // KORAK 2 – unos niza A
        // =========================

        int[] A = new int[n];                  // kreiranje niza

        Console.WriteLine("Unesite elemente niza A:");

        for (int i = 0; i < n; i++)            // unos elemenata
        {
            A[i] = int.Parse(Console.ReadLine());
        }

        // =========================
        // ODGOVOR 1
        // =========================

        Console.WriteLine("************** Odgovor 1 **************");

        int zbir = 0;                          // zbir elemenata

        for (int i = 0; i < n; i++)
        {
            Console.Write(A[i] + " ");         // ispis elementa
            zbir += A[i];                      // sabiranje
        }
        Console.WriteLine();

        double srednja = (double)zbir / n;     // srednja vrednost (realan broj)
        Console.WriteLine("Srednja vrednost niza: " + srednja);

        int brojac = 0;                        // brojač

        for (int i = 0; i < n; i++)
        {
            if (A[i] % 3 == 0 && A[i] > srednja)   // uslov iz zadatka
                brojac++;
        }

        Console.WriteLine("Broj elemenata koji su deljivi sa 3 i veci su od srednje vrednosti niza: " + brojac);

        // =========================
        // ODGOVOR 2 – niz B
        // =========================

        Console.WriteLine("************** Odgovor 2 **************");

        int[] B = new int[n];                 // novi niz

        for (int i = 0; i < n; i++)
        {
            if (A[i] > 0)                    // pozitivan broj
                B[i] = ZbirCifara(A[i]);     // zbir cifara
            else if (A[i] < 0)               // negativan broj
                B[i] = Math.Abs(A[i]);       // apsolutna vrednost
            else
                B[i] = 0;                    // nula ostaje 0

            Console.Write(B[i] + " ");       // ispis
        }
        Console.WriteLine();

        // =========================
        // ODGOVOR 3 – niz C
        // =========================

        Console.WriteLine("************** Odgovor 3 **************");

        int[] C = new int[n];                // novi niz

        for (int i = 0; i < n; i++)
        {
            if (Prost(B[i]))                // ako je broj prost
                C[i] = B[i] * B[i];         // kvadrat
            else
                C[i] = ProizvodCifara(B[i]); // proizvod cifara

            Console.Write(C[i] + " ");
        }
        Console.WriteLine();

        // =========================
        // ODGOVOR 4 – matrica M
        // =========================

        Console.WriteLine("************** Odgovor 4 **************");

        int m = 1;                          // dimenzija matrice

        while (m * m < n)                   // tražimo najmanje m
            m++;

        int[,] M = new int[m, m];           // kreiranje matrice
        int k = 0;                          // indeks za niz C

        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < m; j++)
            {
                M[i, j] = C[k];            // upis elementa
                k++;                       // sledeći element

                if (k == n)                // ako smo došli do kraja niza
                    k = 0;                // vraćamo se na početak

                Console.Write(M[i, j] + " ");
            }
            Console.WriteLine();
        }

        // =========================
        // ODGOVOR 5 – matrica D
        // =========================

        Console.WriteLine("************** Odgovor 5 **************");

        int[,] D = new int[m, m];          // nova matrica

        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < m; j++)
            {
                int sumaReda = 0;          // zbir reda
                int sumaKolone = 0;        // zbir kolone

                for (int t = 0; t < m; t++)
                {
                    sumaReda += M[i, t];   // sabiranje reda
                    sumaKolone += M[t, j]; // sabiranje kolone
                }

                D[i, j] = sumaReda + sumaKolone - M[i, j]; // formula

                Console.Write(D[i, j] + " ");
            }
            Console.WriteLine();
        }
    }
}
 

 REŠENJE za C  

#include <stdio.h>      // omogućava rad sa ulazom i izlazom (printf, scanf)
#include <stdlib.h>     // omogućava funkciju abs (apsolutna vrednost)
#include <stdbool.h>    // omogućava tip bool (true/false)

// Funkcija za računanje zbira cifara
int zbirCifara(int broj) {
    int zbir = 0;                   // promenljiva za zbir cifara

    while (broj != 0) {             // dok broj ima cifre
        zbir += broj % 10;          // izdvajamo poslednju cifru i dodajemo je
        broj /= 10;                 // uklanjamo poslednju cifru
    }

    return zbir;                    // vraćamo zbir cifara
}

// Funkcija za računanje proizvoda cifara
int proizvodCifara(int broj) {
    if (broj == 0) return 0;        // ako je broj 0 → proizvod je 0

    int proizvod = 1;               // početna vrednost za množenje

    while (broj != 0) {             // dok ima cifara
        proizvod *= broj % 10;      // množimo sa poslednjom cifrom
        broj /= 10;                 // uklanjamo cifru
    }

    return proizvod;                // vraćamo rezultat
}

// Funkcija za proveru da li je broj prost
bool prost(int broj) {
    if (broj <= 1) return false;    // brojevi <= 1 nisu prosti

    for (int i = 2; i <= broj / 2; i++) { // proveravamo moguće delioce
        if (broj % i == 0)          // ako postoji delilac
            return false;           // broj nije prost
    }

    return true;                    // ako nema delilaca → broj je prost
}

int main() {
    int n;                          // broj elemenata niza

    // =========================
    // KORAK 1 – unos n
    // =========================

    do {
        printf("Unesite broj elemenata niza N\n");
        scanf("%d", &n);            // unos broja

        if (n < 5 || n >= 15)       // provera uslova
            printf("Broj nije u opsegu\n");

    } while (n < 5 || n >= 15);     // ponavljanje dok uslov nije ispunjen

    // =========================
    // KORAK 2 – unos niza A
    // =========================

    int A[100];                     // niz dovoljno velik (maks 14 elemenata)

    printf("Unesite elemente niza A:\n");

    for (int i = 0; i < n; i++) {   // unos elemenata
        scanf("%d", &A[i]);
    }

    // =========================
    // ODGOVOR 1
    // =========================

    printf("************** Odgovor 1 **************\n");

    int zbir = 0;                   // zbir elemenata

    for (int i = 0; i < n; i++) {
        printf("%d ", A[i]);        // ispis elementa
        zbir += A[i];               // sabiranje
    }
    printf("\n");

    double srednja = (double)zbir / n;   // srednja vrednost (realan broj)
    printf("Srednja vrednost niza: %.2lf\n", srednja);

    int brojac = 0;                 // brojač

    for (int i = 0; i < n; i++) {
        if (A[i] % 3 == 0 && A[i] > srednja) // uslov iz zadatka
            brojac++;
    }

    printf("Broj elemenata koji su deljivi sa 3 i veci su od srednje vrednosti niza: %d\n", brojac);

    // =========================
    // ODGOVOR 2 – niz B
    // =========================

    printf("************** Odgovor 2 **************\n");

    int B[100];                     // novi niz

    for (int i = 0; i < n; i++) {
        if (A[i] > 0)               // pozitivan broj
            B[i] = zbirCifara(A[i]);
        else if (A[i] < 0)          // negativan broj
            B[i] = abs(A[i]);
        else
            B[i] = 0;

        printf("%d ", B[i]);        // ispis
    }
    printf("\n");

    // =========================
    // ODGOVOR 3 – niz C
    // =========================

    printf("************** Odgovor 3 **************\n");

    int C[100];                     // novi niz

    for (int i = 0; i < n; i++) {
        if (prost(B[i]))            // ako je broj prost
            C[i] = B[i] * B[i];     // kvadrat
        else
            C[i] = proizvodCifara(B[i]); // proizvod cifara

        printf("%d ", C[i]);
    }
    printf("\n");

    // =========================
    // ODGOVOR 4 – matrica M
    // =========================

    printf("************** Odgovor 4 **************\n");

    int m = 1;                      // dimenzija matrice

    while (m * m < n)               // tražimo najmanje m
        m++;

    int M[10][10];                  // matrica (maks 4x4 dovoljno)
    int k = 0;                      // indeks za niz C

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < m; j++) {
            M[i][j] = C[k];         // upis elementa
            k++;                    // prelazak na sledeći

            if (k == n)             // ako smo došli do kraja niza
                k = 0;              // vraćamo se na početak

            printf("%d ", M[i][j]);
        }
        printf("\n");
    }

    // =========================
    // ODGOVOR 5 – matrica D
    // =========================

    printf("************** Odgovor 5 **************\n");

    int D[10][10];                  // nova matrica

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < m; j++) {
            int sumaReda = 0;       // zbir reda
            int sumaKolone = 0;     // zbir kolone

            for (int t = 0; t < m; t++) {
                sumaReda += M[i][t];   // sabiranje reda
                sumaKolone += M[t][j]; // sabiranje kolone
            }

            D[i][j] = sumaReda + sumaKolone - M[i][j]; // formula

            printf("%d ", D[i][j]);
        }
        printf("\n");
    }

    return 0;                       // kraj programa
}

 REŠENJE za C++  

#include <iostream>   // omogućava rad sa ulazom i izlazom (cin, cout)
#include <cmath>      // omogućava abs funkciju
using namespace std;

// Funkcija za zbir cifara
int zbirCifara(int broj) {
    int zbir = 0;                 // promenljiva za zbir

    while (broj != 0) {
        zbir += broj % 10;        // uzimamo poslednju cifru
        broj /= 10;               // uklanjamo cifru
    }

    return zbir;
}

// Funkcija za proizvod cifara
int proizvodCifara(int broj) {
    if (broj == 0) return 0;      // ako je broj 0

    int proizvod = 1;

    while (broj != 0) {
        proizvod *= broj % 10;    // množimo cifre
        broj /= 10;
    }

    return proizvod;
}

// Funkcija za proveru prostog broja
bool prost(int broj) {
    if (broj <= 1) return false;

    for (int i = 2; i <= broj / 2; i++) {
        if (broj % i == 0)
            return false;
    }

    return true;
}

int main() {
    int n;

    // =========================
    // KORAK 1 – unos n
    // =========================

    do {
        cout << "Unesite broj elemenata niza N" << endl;
        cin >> n;

        if (n < 5 || n >= 15)
            cout << "Broj nije u opsegu" << endl;

    } while (n < 5 || n >= 15);

    // =========================
    // KORAK 2 – unos niza A
    // =========================

    int A[100];

    cout << "Unesite elemente niza A:" << endl;

    for (int i = 0; i < n; i++) {
        cin >> A[i];
    }

    // =========================
    // ODGOVOR 1
    // =========================

    cout << "************** Odgovor 1 **************" << endl;

    int zbir = 0;

    for (int i = 0; i < n; i++) {
        cout << A[i] << " ";
        zbir += A[i];
    }
    cout << endl;

    double srednja = (double)zbir / n;
    cout << "Srednja vrednost niza: " << srednja << endl;

    int brojac = 0;

    for (int i = 0; i < n; i++) {
        if (A[i] % 3 == 0 && A[i] > srednja)
            brojac++;
    }

    cout << "Broj elemenata koji su deljivi sa 3 i veci su od srednje vrednosti niza: " << brojac << endl;

    // =========================
    // ODGOVOR 2 – niz B
    // =========================

    cout << "************** Odgovor 2 **************" << endl;

    int B[100];

    for (int i = 0; i < n; i++) {
        if (A[i] > 0)
            B[i] = zbirCifara(A[i]);
        else if (A[i] < 0)
            B[i] = abs(A[i]);
        else
            B[i] = 0;

        cout << B[i] << " ";
    }
    cout << endl;

    // =========================
    // ODGOVOR 3 – niz C
    // =========================

    cout << "************** Odgovor 3 **************" << endl;

    int C[100];

    for (int i = 0; i < n; i++) {
        if (prost(B[i]))
            C[i] = B[i] * B[i];
        else
            C[i] = proizvodCifara(B[i]);

        cout << C[i] << " ";
    }
    cout << endl;

    // =========================
    // ODGOVOR 4 – matrica M
    // =========================

    cout << "************** Odgovor 4 **************" << endl;

    int m = 1;

    while (m * m < n)
        m++;

    int M[10][10];
    int k = 0;

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < m; j++) {
            M[i][j] = C[k];
            k++;

            if (k == n)
                k = 0;

            cout << M[i][j] << " ";
        }
        cout << endl;
    }

    // =========================
    // ODGOVOR 5 – matrica D
    // =========================

    cout << "************** Odgovor 5 **************" << endl;

    int D[10][10];

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < m; j++) {
            int sumaReda = 0;
            int sumaKolone = 0;

            for (int t = 0; t < m; t++) {
                sumaReda += M[i][t];
                sumaKolone += M[t][j];
            }

            D[i][j] = sumaReda + sumaKolone - M[i][j];

            cout << D[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}