Vissza

Tömbök, mutatók

Házi feladatok:
1. Egy dinamikusan kezelt tömb elemeihez rendeljük hozzá az első n négyzetszámot.
2. Definiáljunk konstansként egy valós típusú tömb elemeit, majd egy pointer típusú változó segítségével írassuk ki a páros sorszámú elemeket.
3. Definiáljunk konstansként egy egész típusú tömb elemeit, majd egy pointer típusú változó segítségével írassuk ki prímszámokat, a prímtesztelésre használjuk függvényt.
4. Definiáljunk konstansként egy karakterlánc típusú tömb elemeit, majd egy pointer típusú változó segítségével írassuk ki az magánhangzóval kezdődő szavakat.
5. Definiáljunk konstansként egy karakterlánc típusú tömb elemeit, majd egy pointer típusú változó segítségével írassuk ki a nagybetűvel kezdődő szavakat.

Megoldott feladatok:

1. Rendezési algoritmusok:
//sortarea bubble sort - buborek rendezes
//sortarea prin insertie - beszuras rendezes
//sortarea prin selectie - kivalsztas rendezes
//sortarea prin numerare - szamlalas rendezes

#include <iostream>
using namespace std;

void buborekRend(int tomb[], int n);
void csere(int &a, int &b);
void beszurasRend(int tomb[], int n);
void kivalasztasRend(int tomb[], int n);
void szamlalasRend (int tomb[], int n);
int szamol(int elem, int tomb[], int n);

int main(){
    int tomb[] = {80, 23, 45, 6, 21, 3, 4, 22, 90, 89, 7, 56, 78, 2, 77, 1, 0, 100};
    int n = sizeof(tomb)/sizeof(tomb[0]);

    buborekRend(tomb, n);
    //beszurasRend(tomb, n);
    //kivalasztasRend(tomb, n);
    //szamlalasRend (tomb, n);

    for (int i = 0; i < n; ++i)
        cout << tomb[i] << " ";
    cout << endl;
    return 0;
}

void buborekRend(int tomb[], int n){
    int ok;
    do{
        ok = 1;
        for (int i = 0; i < n - 1; ++i)
            if (tomb[i] > tomb[i+1]){
                csere(tomb[i], tomb[i+1]);
                ok = 0;
            }
    }while (ok == 0);
}

void csere(int &a, int &b){
    int temp;
    temp = a;
    a = b;
    b = temp;
}

void beszurasRend(int tomb[], int n){
    int temp, j;
    for (int i = 1; i < n; ++i){
            if (tomb[i] < tomb[i-1]){
                temp = tomb[i];
                j = i - 1;
                while (tomb[j] > temp && j >=0){
                    tomb[j+1] = tomb[j];
                    j --;
                }
                tomb[j+1] = temp;
            }
    }
}

void kivalasztasRend(int tomb[], int n){
    for (int i = 0; i < n; ++i)
        for(int j = i + 1; j < n; ++j)
            if (tomb[i] > tomb[j]) csere (tomb[i], tomb[j]);
}

void szamlalasRend (int tomb[], int n){
    int *tempTomb = new int[n];
    int *szamTomb = new int[n];
    int i, k;
    for (i=0; i < n; ++i){
        tempTomb[i] = tomb[i];
        k = szamol (tomb[i], tomb, n);
        szamTomb[i] = k;
    }

    for (i=0; i < n; ++i)
            tomb[szamTomb[i]] = tempTomb[i];

    delete(szamTomb);
    delete(tempTomb);
}

int szamol(int elem, int tomb[], int n){
    int db = 0;
    for (int i = 0; i < n; ++i)
        if (elem > tomb[i]) db += 1;
    return db;
}
2. Egy dinamikusan kezelt tömb elemeihez rendeljük hozzá az első n Fibonacci számot.
#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
    long long n, i;
    long long *tomb;
    cout << "hany fibonacci szamot akarsz:? ";
    cin >> n;
    tomb = new long long[n];

    tomb[0] = 1;
    tomb[1] = 1;
    for (i = 2; i < n; i++)
        tomb[i] = tomb[i-1] + tomb[i-2];

    for (i = 0; i < n; i++)
        cout << setw(10) << tomb[i];
    delete (tomb);
    return 0;
}

#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
    int n, i;
    int *tomb;
    cout << "hany fibonacci szamot akarsz:? ";
    cin >> n;
    tomb = new int[n];

    *tomb = 1;
    *(tomb + 1) = 1;
    for (i = 2; i < n; i++)
        *(tomb+i) = *(tomb+i-1) + *(tomb+i-2);

    for (i = 0; i < n; i++)
        cout << setw(8) << *(tomb+i);
    delete (tomb);
    return 0;
}

 3. Definiáljunk konstansként egy egész típusú tömb elemeit, majd egy pointer típusú változó segítségével írassuk ki az elemeket.
Megjegyzések:
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
    int x[] = {0,1,2,3,4,5,6,7,8,9};
    int i, n;
    int *p = x;

    cout << "a p altal azonositott memoriacim:";
    cout << p << endl;
    cout << "az x altal azonositott memoriacim: ";
    cout << x;

    n = sizeof(x) / sizeof(x[0]);
    cout << endl << endl;

    cout << "Az elemek memoriacimei: " << endl;
    for (i = 0; i < n; i++)
        cout << setw(10) << (p + i);
    cout << endl << endl;

    cout << "Az elemek:" << endl;
    for (i = 0; i < n; i++)
        cout << setw(5) << *(p + i);
    cout << endl << endl;
    return 0;
}

4. Definiáljunk konstansként egy karakter típusú tömb elemeit, majd egy pointer típusú változó segítségével írassuk ki az elemeket.
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
    char x[] = {'a','b','c','d','e','f'};
    int i, n;
    char *p = x;
    n = sizeof(x) / sizeof(x[0]);
    cout << "az elemek: " << endl;
    for (i = 0; i < n; i++)
    {
        cout << setw(5) << *p;
        p++;
    }
    cout << endl << endl;
    return 0;
}

5. Definiáljunk konstansként egy karakterlánc típusú tömb elemeit, majd egy pointer típusú változó segítségével írassuk ki az elemeket.
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
    char x[][10] = {"alma","korte","barack","dio","mogyoro"};
    int i,n;
    char *p;
    n = sizeof(x) / sizeof(x[0]);
    cout << "az elemek: " << endl;
    for (i = 0; i < n; i++)
    {
        p = x[i];
        cout << setw(10) << p;
    }
    cout << endl << endl;
    return 0;
}

A fenti feladatok standard C író/olvasó függvényekkel
1. Definiáljunk konstansként egy egész típusú tömb elemeit, majd egy pointer típusú változó segítségével írassuk ki az elemeket.
Megjegyzések:
#include <stdio.h>
int main()
{
    int x[] = {0,1,2,3,4,5,6,7,8,9};
    int i, n;
    int *p = x;

    printf("a p altal azonositott memoriacim: %p\n", p);
    printf("az x altal azonositott memoriacim: %p\n\n", x);
   
    n = sizeof(x) / sizeof(x[0]);
    printf("Az elemek memoria cimei:\n");

    for (i = 0; i < n; i++)
        printf("%10p", (p + i));
    printf("\n\n");

    printf("Az elemek:\n");
    for (i = 0; i < n; i++)
        printf("%5i", *(p + i));
    printf("\n\n");
    return 0;
}

2. Definiáljunk konstansként egy karakter típusú tömb elemeit, majd egy pointer típusú változó segítségével írassuk ki az elemeket.

#include <stdio.h>
int main()
{
    char x[] = {'a','b','c','d','e','f'};
    int i, n;
    char *p = x;
    n = sizeof(x) / sizeof(x[0]);
    printf("az elemek:\n");
    for (i = 0; i < n; i++)
    {
        //kiiratjuk a p memoriacimen levo erteket
        printf("%5c", *p);
        //valtoztatjuk a p memoriacimet
        p++;
    }
printf("\n\n");
return 0;
}

3. Definiáljunk konstansként egy karakterlánc típusú tömb elemeit, majd egy pointer típusú változó segítségével írassuk ki az elemeket.

#include <stdio.h>
int main()
{
    char x[][10]={"alma","korte","barack","dio","mogyoro"};
    int i, n;
    char *p;
    n = sizeof(x)/sizeof(x[0]);
    for (i = 0; i < n; i++)
    {
        p = x[i];
        printf("%10s", p);
    }
printf("\n\n");
return 0;
}

4. Egy dinamikusan kezelt tömb elemeihez rendeljük hozzá az első n Fibonacci számot.

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int n, i;
    int *tomb;
    printf("hany fibonacci szamot akarsz:?");
    scanf("%i", &n);
    tomb = (int*) malloc(n * sizeof(int));

    *tomb = 1;
    *(tomb + 1) = 1;
    for (i = 2; i < n; i++)
        *(tomb+i) = *(tomb+i-1) + *(tomb+i-2);
        //vagy: tomb[i]= tomb[i-1]+tomb[i-2];

    for (i = 0; i < n; i++)
        printf("%i\n", *(tomb+i));
    free (tomb);
    return 0;
}