Informatika 3 - BME TTK

2. gyakorlat - megoldások

2. feladat. Írjunk függvényt atlag névvel, amely visszaadja a kapott int tömb első n elemének átlagát. Használjuk a static_cast kulcsszót.

Megoldás:

#include <iostream>
using namespace std;

double atlag(int* tomb, int n) {
    if (n <= 0) {
        cerr << "The number of elements must be greater than 0." << endl;
        return 0;
    }

    int sum = 0;
    for (int i = 0; i < n; ++i) {
        sum += tomb[i];
    }

    return static_cast<double>(sum) / n;
}

3. feladat. Írjunk két függvényt, amelyek kiszámolják az F(n) Fibonacci-sorozat k-adik tagját, ahol F(0) = F(1) = 1, n>1 esetén pedig F(n) = F(n-1) + F(n-2). Az egyik függvényben használjunk ciklust, míg a másikban számoljunk rekurzívan. Deklaráljuk a függvényeket a fibonacci.h fejállományban, a függvények definícióját pedig adjuk meg egy külön forrásfájlban. Teszteljük a függvényeket, számoljuk ki mindkettővel az F(20), F(30), F(40) értékeket. Mit tapasztalunk?

Megoldás:

fibonacci.h

#ifndef FIBONACCI_H
#define FIBONACCI_H

long long fibonacci_loop(int n);    //computes the nth element of the Fibonacci sequence using a loop
long long fibonacci_recr(int n);    //computes the nth element of the Fibonacci sequence using recursion

#endif

fibonacci.cpp

#include "fibonacci.h"

long long fibonacci_loop(int n) {
    if ((n == 0) || (n == 1)) {
        return 1;
    }
    else if (n < 0) {
        return 0;
    }

    long long res = 0;
    long long f_pp = 1;
    long long f_p  = 1;
    for (int i = 2; i <= n; ++i) {
        res = f_p + f_pp;
        f_pp = f_p;
        f_p = res;
    }
    return res;
}

long long fibonacci_recr(int n) {
    if (n < 0) {
        return 0;
    }
    else if (n == 0) {
        return 1;
    }
    else {
        return fibonacci_recr(n - 1) + fibonacci_recr(n - 2);
    }
}

4. feladat. Írjunk olyan függvényeket, amelyek közül az egyik egy síkbeli pont Descartes-koordinátáit polárkoordinátákká konvertálja, a másik pedig forítva, polárkoordinátákból számol Descartes-koordinátákat. Deklaráljuk az xy2polar és polar2xy nevű függvényeket a mypolar.h fejállományban, a függvények definícióját pedig adjuk meg egy külön forrásfájlban. Használjuk a cmath fejállományt, és kezeljük azokat az eseteket is, amikor az output nem egyértelmű, ill. mikor az input nem megfelelő.

Megoldás:

mypolar.h

#ifndef MYPOLAR_H
#define MYPOLAR_H

void xy2polar(double x, double y, double& r, double& a);    
int polar2xy(double r, double a, double& x, double& y);

#endif

mypolar.cpp

#define _USE_MATH_DEFINES
#include "mypolar.h"
#include <cmath>

void xy2polar(double x, double y, double& r, double& a) {
    if ((x == .0) && (y == .0)) {
        r = .0;
        t = .0;
        return;
    }
    r = sqrt(x*x+y*y);
    if (y >= .0) {
        t = acos(x/r);
    }
    else {
        t = 2*M_PI- acos(x / r);
    }
}

int polar2xy(double r, double a, double& x, double& y) {
    if (r < .0) {
        return -1;
    }
    x = r * cos(t);
    y = r * sin(t);

    return 0;
}

5. feladat. Írjunk függvényt max névvel, amely visszaadja a kapott double tömb legnagyobb abszolút értékű elemét és az indexét is. A bemenetei:

tomb: a double tömb
hossz: a tömb hossza
Megoldástól függően még lehetnek paraméterek.

Megoldás:

#include<cmath>

void max(double* tomb, int hossz, double& maxval, int& maxidx) {
    double maxAbsValue = abs(tomb[0]);
    int maxIndex = 0;

    for (int i = 1; i < hossz; ++i) {
        if (abs(tomb[i]) > maxAbsValue) {
            maxAbsValue = abs(tomb[i]);
            maxIndex = i;
        }
    }
    maxval = maxAbsValue;
    maxidx = maxIndex;
}

6. feladat. Írjunk függvényt mely kap egy C string-et és egy karaktert (char), és visszaadja, hogy az adott karakter hányszor szerepel a string-ben. Módosítsuk úgy a programot, hogy visszaadja a karakter első előfordulásának címét is, ha pedig a karakter nem fordul elő, akkor adja vissza a null pointert.

Megoldás:

int countCharacterOccurrences(const char* str, char ch) {
    int count = 0;
    for (int i = 0; i < strlen(str); ++i) {
        if (str[i] == ch) {
            ++count;
        }
    }
    return count;
}

const char* countCharacterOccurrences(const char* str, char ch, int& n_of_occ) {
    int n = 0;
    const char* oc = nullptr;
    while (*str != '\0') {
        if (*str == ch) {
            if (oc == nullptr) {
                oc = str;
            }
            ++n;
        }
        ++str;
    }
    n_of_occ = n;

    return oc;
}

7. feladat. Írjunk függvényt, amely kap egy C string-et, és visszaadja az abban található leggyakoribb karaktert.

Megoldás:


char findMostFrequentCharacter(const char* str) {
    if (str == nullptr || *str == '\0') {
        return '\0'; // Return null character if the string is empty
    }

    int frequency[256] = {0}; // Array to store frequency of each character
    const char* ptr = str;

    while (*ptr != '\0') {
        frequency[static_cast<unsigned char>(*ptr)]++;
        ++ptr;
    }

    char mostFrequentChar = '\0';
    int maxFrequency = 0;

    for (int i = 0; i < 256; ++i) {
        if (frequency[i] > maxFrequency) {
            maxFrequency = frequency[i];
            mostFrequentChar = static_cast<char>(i);
        }
    }

    return mostFrequentChar;
}

8. feladat. Írjunk szelet névvel függvényt, mely a kapott C string-et egy paraméterként kapott indextől kezdve egy szintén paraméterként kapott indexű karakterig lemásolja, majd ezt az új C stringet visszaadja. A paraméterek:

str: a string, amiből másolunk, char tömb
bal: az első index, amit másolunk, sima int
jobb: az utolsó index, amit még másolunk, sima int

Megoldás:

#include<iostream>
using namespace std;
 
char* szelet(char s[], int bal, int jobb) {
  int size = jobb - bal + 2;
  char* t = new char[size];
  for(int i = bal; i <= jobb; i++) {
    t[i - bal] = s[i];
  }
  t[size - 1] = '\0';
  return t;
}
 
int main(void) {
  char str[] = "denever";
  char *to_delete = szelet(str, 2, 5);
  cout << to_delete << endl;
  delete[] to_delete;
  return 0;
}

9. feladat. Írjunk függvényt, amely kap két C string-et, és az elsőből törli a másodikban előforduló összes karaktert. Például a "kiskutya", "ky" bementre "isuta"-ra változtatja az eredeti első string-et.

Megoldás:

void removeCharacters(char* str1, const char* str2) {
    bool charSet[256] = { 0 }; // Array to keep track of characters to be removed

    // Mark characters present in str2
    while (*str2 != '\0') {
        charSet[static_cast<unsigned char>(*str2)] = true;
        ++str2;
    }

    // Allocate memory for the result string
    const unsigned char str1_length = strlen(str1) + 1;
    char* result = new char[str1_length];
    int write_idx = 0;

    // Iterate through str1 and copy only those characters not marked for removal
    for (int i = 0; i < str1_length; ++i) {
        if (!charSet[static_cast<unsigned char>(str1[i])]) {
            result[write_idx] = str1[i];
            ++write_idx;
        }
    }

    result[write_idx] = '\0'; // Null-terminate the modified string

    int i = 0;
    do {
        str1[i] = result[i];
    } while (result[i++] != '\0');

    delete[] result;
}