Vissza

Mutatók  II.

Megoldott feladatok:
1. Vizsgáljuk meg két véletlenszerű elemekkel inicializált kétdimenziós tömbről, hogy egyformák-e? ( Forráskód )
2. Határozzuk meg két kétdimenziós tömb szorzatát, ahol az elemeket állományból olvassuk ki. ( Forráskód )
3. Fűzzünk egymás után két egydimenziós tömböt, rekurzív algoritmust írva. ( Forráskód )
4. Függvényt írva, töltsünk fel egy kétdimenziós tömböt 'llom'nyban levő értékekkel, majd írjuk ki az elemeit a képernyőre. ( Forráskód )

Forráskódok:
1.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int same(int ** m1, int **m2, int n, int m);

int main()
{
    int **mat1 ;
    int **mat2;
    int n, m, i, j, e;
    n = 3;
    m = 4;
    // az elso tombnek szukseges memoria zona lefoglalasa
    mat1 = (int**) malloc (n* sizeof (int *));
    for (i = 0; i < n; ++i)
        mat1[i] = (int*)malloc(m * sizeof(int));
   
    srand(time(NULL));
    for (i = 0; i < n; ++i) {
        for (j = 0; j < m; ++j) {
            mat1[i][j] = rand()%2;
            printf("%4i", mat1[i][j]);
        }
        printf("\n");
    }
    printf("\n");

    // a második tombnek szukseges memoria zona lefoglalasa
    mat2 = (int**) malloc (n* sizeof (int *));
    for (i = 0; i < n; ++i)
        mat2[i] = (int*)malloc(m * sizeof(int));
   
    for (i = 0; i < n; ++i)
    {
        for (j = 0; j < m; ++j)
        {
            mat2[i][j] = rand()%2;
            printf("%4i", mat2[i][j]);
        }
        printf("\n");
    }

    e = same(mat1, mat2, n, m);
    if(e) printf("egyformak\n");
    else printf("nem egyformak\n");
    for (i = 0; i < n; ++i)
    {
        free (mat1[i]);
        free (mat2[i]);
    }
    free (mat1);
    free (mat2);
    return 0;
}

// a ket tomb egyenloseget megvizsgalo fuggveny
int same(int ** m1, int **m2, int n, int m)
{
    int i, j;
    for (i = 0; i < n; i++)
        for (j = 0; j < m; j++)
            if (m1[i][j] != m2[i][j]) return 0;
    return 1;
}

Vissza

2. A szamok.txt állomány tartalma legyen a következő:
3 4

1 2 3 4
1 1 1 1
12 3 4 5

4 2

1 1
1 2
1 0
1 2

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int ** multiply(int ** m1, int **m2, int n, int m, int p);

int main()
{
    // a ket tombot konstans ertekekkel inicializaljuk
    int **mat1;
    int **mat2;
    int **e;
    int n, m, p, i, j;

    FILE * F;
    F = fopen ("szamok.txt", "r");
    fscanf(F, "%i", &n);
    fscanf(F, "%i", &m);
    mat1 = (int**) malloc (n* sizeof (int *));
    for (i = 0; i < n; ++i){
        mat1[i] = (int*)malloc(m * sizeof(int));
        for (j = 0; j < m; ++j){
            fscanf(F, "%i", &mat1[i][j]);
            printf("%4i", mat1[i][j]);
        }
        printf("\n");
    }
   
    printf("\n");
    fscanf(F, "%i", &m);
    fscanf(F, "%i", &p);
    mat2 = (int**) malloc (m* sizeof (int *));
    for (i = 0; i < m; ++i){
        mat2[i] = (int*)malloc(p * sizeof(int));
        for (j = 0; j < p; ++j){
            fscanf(F, "%i", &mat2[i][j]);
            printf("%4i", mat2[i][j]);
        }
        printf("\n");
    }
    fclose(F);
    printf("\nA szorzat: \n");
    e = multiply(mat1, mat2, n, m, p);
    for (i = 0; i < n; ++i)
    {
        for (j = 0; j < p; ++j)
            printf("%4i", e[i][j]);
        printf("\n");
    }
    for (i = 0; i < n; ++i)
        free(mat1[i]);
    free(mat1);
    for (i = 0; i < m; ++i)
        free(mat2[i]);
    free(mat2);
    for (i = 0; i < n; ++i)
        free(e[i]);
    free(e);
    return 0;
}

// a két tomb osszeszorzasat megvalosito fuggveny
int ** multiply(int ** m1, int **m2, int n, int m, int p)
{
    int i, j, k, osz;
    int ** newm = (int**) malloc (n * sizeof (int *));
    for (i = 0; i < n; ++i)
        newm[i] = (int*) malloc (p * sizeof(int));

    for (i = 0; i < n; ++i)
        for (j = 0; j < p; j++)
        {
            osz = 0;
            for (k = 0; k < m; ++k)
                osz += m1[i][k] * m2[k][j];
            newm[i][j] = osz;
        }
    return newm;
}
Vissza

3.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int * fuz(int * m1, int *m2, int n1, int n2, int *n);

main()
{
    //a ket tombot konstans ertekekkel inicializaljuk
    int tomb1[] = {1,2,3,4,5,6,7,8,9} ;
    int tomb2[] = {17,18,19};
    int n1 = sizeof(tomb1) / sizeof(tomb1[0]);
    int n2 = sizeof(tomb2) / sizeof(tomb2[0]);
    int n, i;
    int *newt;

    // az osszefuzest megvalosito fuggveny meghivasa, az uj tomb elemszamat cim szerinti
    // parameteratadassal hatarozzuk meg, az uj tomb pedig a fuggveny visszatertesi erteke lesz
    newt = fuz(tomb1, tomb2, n1, n2-1, &n);
    for(i = 0; i < n; ++i)
            printf("%4i", newt[i]);
    printf("\n");
    free (newt);
}

int * fuz(int * m1, int *m2, int n1, int n2, int *n)
{
    int *newt, i;
    if (n2 < 0)
    {
        //atmasoljuk az elso tomb elemeit az uj tombe, melynek dinamiksan foglalunk le helyet
        newt = (int*)malloc(n1*sizeof(int));
        for (i = 0; i < n1; ++i)
            newt[i] = m1[i];
        (*n) = i;
        return newt;
    }
    //a rekurziv hivas utan fuzzuk hozza a a masodik tomb elemet az uj tombhoz
    newt = fuz (m1, m2, n1, n2-1, n);
 
    newt = (int*) realloc (newt, ((*n) + 1)* sizeof(int));
    newt[*n] = m2[n2];
    (*n) ++;
    return newt;
}
Vissza

4.
#include <stdio.h>
#include <stdlib.h>

void beolvas(int ***tomb,int*n,int *m);
void kiir(int **tomb,int n,int m);

void main()
{
    int **tomb;
    int n, m;
    beolvas (&tomb, &n, &m);
    kiir (tomb, n, m);
    for( i = 0; i < n; ++i)
        free(tomb[i]);
    free(tomb);
}

void beolvas(int ***tomb, int*n, int *m)
{
    int i,j;
    FILE *F;
    F = fopen ("szamok.txt", "r");
    fscanf(F, "%i", n);
    fscanf(F, "%i", m);
    *tomb = (int**)malloc((*n)*sizeof(int));
    for (i = 0; i < (*n); i++)
        *((*tomb) + i) = (int*) calloc( (*m), sizeof(int));
      
    for (i = 0; i < (*n); i++)
        for (j = 0; j < (*m); j++)
            fscanf(F,"%d", *((*tomb) + i) + j );
    fclose(F);
}

void kiir(int **tomb,int n,int m)
{
    int i,j;
    for (i = 0; i < n; ++i){
        for (j = 0; j < m; j++)
            printf("%4d", *(*(tomb + i) + j));
        printf("\n");
    }
}


Vissza