Segítségek, tanácsok ebben a C++ -ban megírandó programra?

Igazából két dolgot tehetsz. Érdekel téged egyáltalán a programozás?

Ha azt válaszoltad, hogy "igen, érdekel", akkor kezdd el csinálni, ha elakadsz, gebedj felette órákon át, guglizz, olvasd át az órán tanultakat. Szopasd vele magad, és egyszer majd megvilágosodsz. Ha elakadsz valahol, akkor pedig tanulj meg egy értelmes kérdést feltenni, amely tartalmazza, hogy

- mi a feladat (ez eddig megvan)

- mi a mostani kódod

- mit csinál a mostani kódod

- mit kellene csinálnia a kódnak (miért nem jó az, amit most csinál)

Ha viszont leszarod a programozást (ahogy az a jelen kérdésedből is következtethető), akkor írj ide egy árat, hogy mennyit ér meg neked az, hogy valaki megcsinálja helyetted.

A dinamikus tömbökről:

[link]

mivel egészről van szó, használhatsz egy mátrixot (két dimenziós tömb), amiben az elem mellett azt is tárolod, hogy mennyi van belőle. Ha a darabszám nulla, akkor az utolsó elemmel és darabszámával felülírod, és ha tudod, akkor rövidíted.

A feladat ezen részét nem értem:

" valamint két zsák metszetét (a közös elemek a kisebb előfordulási számmal maradnak meg"

Ez mit jelent?

Sokféleképpen meg lehet valósítani, ez lényegében egy lecsupaszított vektor.

Így első nekifutásra: (de jobban jársz ha egy normális vector implementációt tanulmányozól, és abból legózod össze)

#include <iostream>

#include <string>

#include <algorithm>

#include <assert.h>

template<typename T>

class zsak {

public:

using value_type = T;

using size_type = std::size_t;

using iterator = T*;

using const_iterator = const T*;

zsak() : m_size{0}, m_capacity{0}, m_data{nullptr} {}

void beteves(const T& value);

void kivetel(const T& value, const bool all = true);

void kiiras() const;

size_type size() const noexcept { return m_size; }

size_type capacity() const noexcept { return m_capacity; }

bool empty() const noexcept { return m_size == 0; }

iterator begin() noexcept { return m_data; }

iterator end() noexcept { return m_data + m_size; }

const_iterator begin() const noexcept { return m_data; }

const_iterator end() const noexcept { return m_data + m_size; }

const_iterator cbegin() const noexcept { return m_data; }

const_iterator cend() const noexcept { return m_data + m_size; }

private:

size_type m_size;

size_type m_capacity;

T* m_data;

};

template<typename T>

void zsak<T>::beteves(const T& value) {

if(m_size == m_capacity) {

m_capacity = m_capacity == 0 ? 2 : m_capacity * 2;

T* new_data = new T[m_capacity];

std::copy(m_data, m_data + m_size, new_data);

delete[] m_data;

m_data = new_data;

}

m_data[m_size] = value;

++m_size;

}

template<typename T>

void zsak<T>::kivetel(const T& value, const bool all /*=true*/) {

if(empty()) { return; }

if(all) {

assert(false);

} else {

iterator it = std::find(begin(), end(), value);

if(it != end()) {

for(; it != end() - 1; ++it) {

*it = *(it + 1);

}

--m_size;

}

}

}

template<typename T>

void zsak<T>::kiiras() const {

if(empty()) {

std::cout << "ures\n";

} else {

for(const auto& i : *this) {

std::cout << i << ' ';

}

std::cout << '\n';

}

}

int main() {

zsak<int> egesz_szamok;

egesz_szamok.beteves(1);

egesz_szamok.beteves(2);

egesz_szamok.beteves(3);

egesz_szamok.beteves(4);

egesz_szamok.beteves(5);

egesz_szamok.kiiras();

egesz_szamok.kivetel(4, false);

egesz_szamok.kivetel(1, false);

egesz_szamok.kiiras();

egesz_szamok.kivetel(5, false);

egesz_szamok.kivetel(3, false);

egesz_szamok.kiiras();

egesz_szamok.kivetel(2, false);

egesz_szamok.kiiras();

}