labs_all+1

Точка
Да се надополни програмата со следните барања:
да се креира структура на точка во тродимензионален простор и да се напише функција која ќе го
пресметува растојанието помеѓу две такви точки.
да се напише функција која како аргумент прима три точки во дводимензионален простор и ќе
проверува дали тие точки лежат на иста права.
#include <stdio.h>
#include <math.h>
typedef struct tocka2D {
double x;
double y;
} tocka2D;
float rastojanie(tocka2D t1, tocka2D t2) {
return sqrt ((t1.x - t2.x) * (t1.x - t2.x) + (t1.y - t2.y) * (t1.y - t2.y));
}
typedef struct tocka3D {
// vasiot kod ovde
 double x;
 double y;
 double z;

} tocka3D ;
float rastojanie3D(tocka3D t1, tocka3D t2) {
// vasiot kod ovde
 return sqrt ((t1.x - t2.x) * (t1.x - t2.x) + (t1.y - t2.y) * (t1.y - t2.y)+(t1.z - t2.z) * (t1.z - t2.z));

}
int ista_prava(tocka2D t1, tocka2D t2, tocka2D t3) {
// vasiot kod ovde
 return (t3.y - t1.y) == ((t2.y - t1.y)*(t3.x-t1.x))/(t2.x-t1.x);
}
int main() {
 float x1, y1, x2, y2;
 scanf("%f %f", &x1, &y1);
scanf("%f %f", &x2, &y2);
tocka2D t1 = { x1, y1 };
tocka2D t2 = { x2, y2 };
printf("%.2f\n", rastojanie(t1, t2));
 float z1, z2;
 scanf("%f %f", &z1, &z2);
 tocka3D t3 = {x1, y1, z1};
 tocka3D t4 = {x2, y2, z2};
 printf("%.2f\n", rastojanie3D(t3, t4));
 tocka2D t5 = {z1, z2};
 printf("%d\n", ista_prava(t1, t2, t5));
return 0;
}
Пресек на отсечки
Да се напише структура која ќе опишува отсечка во дводимензионален простор (две точки). Потоа
да се напише функција која ќе проверува дали две отсечки се сечат.
#include <stdio.h>
typedef struct tocka {
 // vasiot kod ovde
 float x;
 float y;
} tocka;
typedef struct otsecka {
 // vasiot kod ovde
 tocka start;
 tocka end;
} otsecka;
int se_secat(otsecka o1, otsecka o2) {
// vashiot kod ovde
 float a1 = (o1.end.y-o1.start.y)/(o1.end.x-o1.start.x);
 float a2 = (o2.end.y-o2.start.y)/(o2.end.x-o2.start.x);
 float b1 = -1;
 float b2 = -1;
 float c1 = a1*o1.start.x - o1.start.y;
 float c2 = a2*o2.start.x - o2.start.y;
 float xi,yi;

 if (a1 != a2) {
 xi = (c1*b2 - c2*b1)/(a2-a1);
 yi = (a1*c2 - a2*c1)/(a2-a1);
 return (xi >= o1.start.x&&xi <= o1.end.x&&yi >= o1.start.y&&yi <= o1.end.y&&xi >= o2.start.x&&xi
<= o2.end.x&&yi >= o2.start.y && yi <= o2.end.y);
 }

 else return 0;
}
int main() {
 double x1, y1, x2, y2;
 scanf("%f %f %f %f", &x1, &y1, &x2, &y2);
 tocka t1 = { x1, y1 };
 tocka t2 = { x2, y2 };
 otsecka o1 = { t1, t2 };
 scanf("%f %f %f %f", &x1, &y1, &x2, &y2);
 tocka t3 = { x1, y1 };
 tocka t4 = { x2, y2 };
 otsecka o2 = { t3, t4 };
 printf("%d\n", se_secat(o1, o2));
 return 0;
}
Купувачка кошничка
Да се напише програма во која од стандарден влез се вчитува N (бројот на производи), а потоа се
вчитуваат податоците за N производи (име, цена, количина). Програмата треба на стандарден
излез да ја отпечати листата на купени производи и вкупната сума која треба да се плати во
следниот облик (пример):
1. Flips 10.00 x 3 = 30.00
2. CocaCola 75.00 x 2 = 150.00
3. ChokoBanana 5.00 x 10 = 50.00
Total: 230.00
#include <stdio.h>
typedef struct {
 char ime[30];
 float cena;
 float kolicina;
} Proizvod;
int main() {
 Proizvod proizvodi[20];
 int n,i;
 float sum=0.0;
 scanf("%d",&n);
 for (i=0;i<n;i++) {
 scanf("%s %f %f",proizvodi[i].ime,&proizvodi[i].cena,&proizvodi[i].kolicina);
 sum+=proizvodi[i].cena*proizvodi[i].kolicina;
 }

 for (i=0;i<n;i++) {
 printf("%d. %s\t%.2f x %.0f = %.2f\n",i+1,proizvodi[i].ime,proizvodi[i].cena,proizvodi[i].kolicina,
 proizvodi[i].cena*proizvodi[i].kolicina);
 }
 printf("Total: %.2f\n",sum);

 return 0;
}
Агол
Да се дефинира класа Agol, во која се чуваат информации за:
степени, минути и секунди (int)
Во класата да се реализираат:
конструктор по потреба
методи за поставување на вредности на атрибутите на класата (set методи)
метод за пресметување на вредноста на аголот во секунди
Да се дефинира и метод за проверување на тоа дали внесениот агол е валиден, односно дали се
внесени соодветни вредности за атрибутите (во границите кои ги дозволуваат).
#include <iostream>
using namespace std;
class Agol {
 int stepeni;
 int minuti;
 int sekundi;
 public:
 void set_stepeni(int);
 void set_minuti(int);
 void set_sekundi(int);
 int get_stepeni();
 int get_minuti();
 int get_sekundi();
 int to_sekundi();
};
void Agol::set_stepeni(int n)
{
 stepeni=n;
}
void Agol::set_minuti(int n)
{
 minuti=n;
}
void Agol::set_sekundi(int n)
{
 sekundi=n;
}
int Agol::get_stepeni()
{
 return stepeni;
}
int Agol::get_minuti()
{
 return minuti;
}
int Agol::get_sekundi()
{
 return sekundi;
}
int Agol::to_sekundi()
{
 return stepeni*3600 + minuti*60 + sekundi;
}
int proveri(int a, int b, int c)
{
 if(a<=360&&b<60&&c<60)
 {
 return 1;
 }
 else
 {
 cout<<"Nevalidni vrednosti za agol";
 return 0;
 }
}
int main() {

 //da se instancira objekt od klasata Agol
 Agol a1;
 int deg, min, sec;
 cin >> deg >> min >> sec;

 if (proveri(deg, min, sec)) {

 a1.set_stepeni(deg);
 a1.set_minuti(min);
 a1.set_sekundi(sec);
 cout << a1.to_sekundi();

 }

 return 0;
}
Круг
Да се дефинира класа Krug, во која се чуваат информации за:
радиус float
бројот π const float.
Во класата да се реализираат:
default конструктор и конструктор со аргументи
метод за пресметување плоштина
метод за пресметување периметар
метод кој кажува дали плоштината и периметарот на даден круг се еднакви
#include <iostream>
using namespace std;
class Krug {
 float radius;
 static const float pi=3.14;
 public:
 Krug()
 {

 }
 Krug(float rad)
 {
 radius=rad;
 }
 float perimetar()
 {
 return 2*pi*radius;
 }
 float plostina()
 {
 return radius*radius*pi;
 }
 float ednakvi(){
 if(perimetar()==plostina())
 return 1;
 else
 return 0;
 }
};
int main() {
float r;
cin >> r;
 Krug k(r);
//instanciraj objekt od klasata Krug cij radius e vrednosta procitana od tastatura
cout << k.perimetar() << endl;
cout << k.plostina() << endl;
cout << k.ednakvi() <<endl;
 //instanciraj objekt od klasata Krug cij radius ne e definiran
return 0;
}
Филм
Да се дефинира класа Film, во која ќе се чуваат информации за:
име низа од 100 знаци
режисер низа од 50 знаци
жанр низа од 50 знаци
година цел број
Сите променливи треба да бидат приватни. Соодветно во рамките на класата да се дефинираат:
default конструктор и конструктор со аргументи
метод за печатење на информациите за филмот
Дополнително да се реализира надворешна функција:
void pecati_po_godina(Film *f, int n, int godina) која ќе прима аргумент низа од филмови, вкупниот
број на филмови и година, а треба да ги отпечати само филмовите кои се направени во дадената
година.
#include <iostream>
#include <cstring>
using namespace std;
// vashiot kod ovde
class Film {
private:
 char name [100];
 char director [50];
 char type [50];
 int year;
public:
 Film () {}
 Film (char *name, char *director, char *type, int year) {
 strcpy(this->name, name);
 strcpy(this->director, director);
 strcpy(this->type, type);
 this->year = year;
 }
 int getYear () {
 return year;
 }
 void print () {
 cout << "Ime: " << name << endl;
 cout << "Reziser: " << director << endl;
 cout << "Zanr: " << type << endl;
 cout << "Godina: " << year << endl;
 }
};
void printByYear (Film *f, int size, int year) {
 for (int i = 0; i < size; ++i) {
 if (f[i].getYear() == year) {
 f[i].print();
 }
 }
}
int main() {
int n;
cin >> n;
//da se inicijalizira niza od objekti od klasata Film
 Film f[20];
for(int i = 0; i < n; ++i) {
char ime[100];
char reziser[50];
char zanr[50];
int godina;
cin >> ime;
cin >> reziser;
cin >> zanr;
cin >> godina;
//da se kreira soodveten objekt
 f[i] = Film (ime,reziser,zanr,godina);
}
int godina;
cin >> godina;
//da se povika funkcijata pecati_po_godina
 printByYear(f,n,godina);
return 0;
}
Уредување на дом
Во оваа задача е потребно да уредите даден дом со маси. Креирајте класа Masa со следниве
атрибути:
должина (целобројна вредност)
ширина (целобројна вредност)
конструктор со и без параметри и метода pecati().
Креирајте класа Soba која содржи:
маса (објект од класата Маса)
должина на собата (целобројна вредност)
ширина на собата (целобројна вредност)
конструктор со и без параметри и метода pecati() во која се повикува и pecati() за објектот Masa.
Креирајте класа Kukja со атрибути:
соба (објект од класата Soba)
адреса (низа од 50 знаци), и соодветни методи.
конструктор со и без параметри, деструктор и метода pecati() во која се повикува и pecati() за
објектот Soba.
//vasiot kod ovde
#include <iostream>
#include <cstring>
using namespace std;
class Masa{
 private:
 int dolzhina;
 int shirina;
 public:
 Masa(){}
 Masa(int s,int d){
 dolzhina=d; shirina=s;
 }
 void pechatim(){
 cout<<"Masa: "<<shirina<<" "<<dolzhina;
 }
};
class Soba{
 private:
 Masa m;
 int dolzhina;
 int shirina;
 public:
 Soba(){}
 Soba(int s,int d,Masa mas){
 shirina=s; dolzhina=d; m=mas;
 }
 void pechatis(){
 cout<<"Soba: "<<shirina<<" "<<dolzhina<<" "; m.pechatim(); cout<<" ";
 }
};
class Kukja{
 private:
 Soba s;
 char adresa[50];
 public:
 Kukja(){}
 Kukja(Soba sob,char *a){
 strncpy(adresa,a,50);
 s=sob;
 }
 ~Kukja(){}
 void pecati(){
 cout<<"Adresa: "<<adresa<<" "; s.pechatis(); cout<<endl;
 }

};
int main(){
 int n;
 cin>>n;
 for(int i=0;i<n;i++){
 int masaSirina,masaDolzina;
 cin>>masaSirina;
 cin>>masaDolzina;
 Masa m(masaSirina,masaDolzina);
 int sobaSirina,sobaDolzina;
 cin>>sobaSirina;
 cin>>sobaDolzina;
 Soba s(sobaSirina,sobaDolzina,m);
 char adresa[30];
 cin>>adresa;
 Kukja k(s,adresa);
 k.pecati();
}

 return 0;
}
Договор
Да се дефинира класа Potpisuvac во која се чуваат информации за:
име (низа од максимум 20 знаци)
презиме (низа од максимум 20 знаци)
ЕМБГ (низа од максимум 14 знаци)
За класата да се дефинира copy конструктор, default конструктор и конструктор со аргументи.
Да се дефинира класа Dogovor, во која се чуваат информации за:
број на договор (int),
категорија на договор (низа од 50 знаци),
поле од 3 потпишувачи на договорот (објекти од класата Potpisuvac) Во класата да се додаде
метод кој ќе проверува дали постојат два исти потпишувачи (имаат ист ЕМБГ).
#include <iostream>
#include <cstring>
using namespace std;
class Potpisuvac
{
//vasiot kod ovde
 private:
 char ime[20];
 char prezime[20];
 char embg[14];
 public:
 Potpisuvac(const Potpisuvac &p){
 strncpy(ime,p.ime,20);
 strncpy(prezime,p.prezime,20);
 strncpy(embg,p.embg,14);
 }
 Potpisuvac(char *i="no name",char *p="no surname",char *e="no embg"){
 strncpy(ime,i,20);
 strncpy(prezime,p,20);
 strncpy(embg,e,14);
 }
 char* getEmbg(){
 return embg;
 }
};
class Dogovor
{
 //vasiot kod ovde
 private:
 int brNaDog;
 char kategorija[50];
 Potpisuvac potpisuvaci[3];
 public:
 Dogovor(){}
 Dogovor(int br,char *k,Potpisuvac *p){
 brNaDog=br;
 strncpy(kategorija,k,50);
 potpisuvaci[0]=p[0];
 potpisuvaci[1]=p[1];
 potpisuvaci[2]=p[2];
 }
 bool proverka(){
 for(int i=0;i<3;i++){
 for(int j=i+1;j<3;j++){
 if(strcmp(potpisuvaci[i].getEmbg(),potpisuvaci[j].getEmbg())==0){
 return true;
 }
 }
 }
 return false;
 }
};
int main()
{
 char embg[13], ime[20], prezime[20], kategorija[20];
 int broj, n;
 cin >> n;
 for(int i = 0; i < n; i++){
 cin >> embg >> ime >> prezime;
 Potpisuvac p1(ime, prezime, embg);
 cin >> embg >> ime >> prezime;
 Potpisuvac p2(ime, prezime, embg);
 cin >> embg >> ime >> prezime;
 Potpisuvac p3(ime, prezime, embg);
 cin >> broj >> kategorija;
 Potpisuvac p[3];
 p[0] = p1; p[1] = p2; p[2] = p3;
 Dogovor d(broj, kategorija, p);
 cout << "Dogovor " << broj << ":" << endl;
 if(d.proverka() == true)
 cout << "Postojat potpishuvaci so ist EMBG" << endl;
 else
 cout << "Ne postojat potpishuvaci so ist EMBG" << endl;
 }
 return 0;
}
Фабрика
Креирајте класа Rabotnik која во себе содржи:
ime (низа од максимум 30 знаци)
prezime (низа од максимум 30 знаци)
plata (целобројна вредност)
За оваа класа да се креираат default конструктор и конструктор со аргументи. Да се
имплементираат и следните методи:
getPlata() која ја враќа платата на работникот
pecati() која ги печати името, презимето и платата.
Креирајте класа Fabrika во која има:
rabotnik [100] (низа од вработени)
brojVraboteni (целобројна вредност)
Во класта имплементирајте ги следните методи:
pecatiVraboteni() ги пречати сите вработени
pecatiSoPlata(int plata) ги печати сите вработени со плата поголема или еднаква на дадената во
аргументот (int plata).
Во главната функција се внесуваат податоци за n вработени. Притоа прво се несува n, па
податоците за сите n вработени. Во последниот ред се чита минималната плата.
На излез да се прикажат прво сите вработени, а потоа само оние со поголема плата од
минималната. Треба да се корисатат методите pecatiVraboteni и pecatiSoPlata!
#include <iostream>
#include <cstring>
using namespace std;
class Rabotnik{
 private:

 char ime[30];
 char prezime[30];
 int plata;

 public:

 Rabotnik(const Rabotnik &r){
 strncpy(ime,r.ime,30);
 strncpy(prezime,r.prezime,30);
 plata=r.plata;
 }
 Rabotnik(char *ime="no name",char*prezime="no surname",int plata=0){
 strncpy(this->ime,ime,30);
 strncpy(this->prezime,prezime,30);
 this->plata=plata;
 }
 int getPlata(){
 return plata;
 }
 void pecati(){
 cout<<ime<<" "<<prezime<<" "<<plata<<endl;
 }
 void setIme(char *ime){
 strncpy(this->ime,ime,30);
 }
 void setPrezime(char *prezime){
 strncpy(this->prezime,prezime,30);
 }
 void setPlata(int plata){
 this->plata=plata;
 }
};
class Fabrika{
 private:

 Rabotnik rabotnik[100];
 int brojVraboteni;

 public:
 Fabrika(){}
 Fabrika(int n,Rabotnik *r){
 for(int i=0;i<n;i++){
 rabotnik[i]=r[i];
 }
 brojVraboteni=n;
 }

 void pecatiVraboteni(){
 for(int i=0;i<brojVraboteni;i++){
 rabotnik[i].pecati();
 }
 }
 void pecatiSoPlata(int min){
 for(int i=0;i<brojVraboteni;i++){
 if(rabotnik[i].getPlata()>=min){
 rabotnik[i].pecati();
 }
 }
 }
};
int main(){
 int n;
 cin>>n;
 Rabotnik rabotnici[100];
 for(int i=0;i<n;i++){
 char ime[30],prezime[30];
 int plata;
 cin>>ime>>prezime>>plata;
 rabotnici[i].setIme(ime);
 rabotnici[i].setPrezime(prezime);
 rabotnici[i].setPlata(plata);
 }
 int minimalna;
 cin>>minimalna;
 Fabrika f(n,rabotnici);
 cout<<"Site vraboteni:"<<endl;
 f.pecatiVraboteni();
 cout<<"Vraboteni so plata povisoka od "<<minimalna<<" :"<<endl;
 f.pecatiSoPlata(minimalna);
 return 0;
}
Паркинг
Да се дефинира класа ParkingPlac во која се чуваат податоци за:
Адреса на плацот (низа од знаци, максимум 20),
Идентификациски број на плацот (динамичка низа од знаци),
Цена за паркирање за 1 час (цел број),
Заработка на паркинг плацот (цел број)
За потребите на класата да се имплементираат :
соодветни конструктори и деструктор, и потребните get-функции (погледнете ги повиците во main
функцијата)
функција pecati() за печатење на податоците за еден паркинг плац во следниот формат:
идентификациски_број адреса - X denari, ако X е заработката на паркинг плацот X не е 0
идентификациски_број адреса , ако X =0
функција platiCasovi(int casovi) која на заработката ја додава платената вредност за дадениот број
на часови.
функција daliIstaAdresa(ParkingPlac p) во која се споредува дали дадениот паркинг плац е на иста
адреса како паркинг плацот p.
Во дадената main функција прво се внесуваат n паркинг плацеви. Потоа се внесуваат m плаќања и
на крај се печатат сите паркинг плацеви од низата кои имаат иста адреса со дадениот паркинг
плац (објектот pCentar).
include<iostream>
//вашиот код
#include<cstring>
using namespace std;
class ParkingPlac{
 private:
 char adress[20];
 char *id;
 int priceph;
 int profit;
 public:
 ParkingPlac(char *adress=" ",char *id=" ",int priceph=0){
 this->priceph = priceph;
 strncpy(this->adress,adress,20);
 this->id = new char[strlen(id)];
 strncpy(this->id,id,strlen(id));
 this->profit=0;
 }
 ParkingPlac(const ParkingPlac &p){
 strncpy(this->adress,p.adress,20);
 this->priceph = p.priceph;
 this->profit = p.profit;
 this->id=new char[strlen(p.id)];
 strncpy(this->id,p.id,strlen(p.id));

 }
 ~ParkingPlac(){
 delete [] id;
 }
 ParkingPlac& operator=(const ParkingPlac& p){
 strncpy(adress,p.adress,20);
 strncpy(id,p.id,strlen(p.id));
 profit=p.profit;
 priceph=p.priceph;
 return *this;
 }
 void platiCasovi(int h){
 profit+=h*priceph;
 }
 bool daliIstaAdresa(ParkingPlac p){
 if(strcmp(adress,p.adress)==0) return true;
 else return false;
 }
 char* getId(){
 return id;
 }
 void pecati(){
 cout<<id<<" "<<adress;
 if(profit!=0) cout<<" - "<<profit<<" denari"<<endl;
 }

};
int main(){
ParkingPlac p[100];
int n,m;
char adresa[50],id[50];
int brojcasovi,cenacas;
cin>>n;
for (int i=0;i<n;i++){
 cin.get();
cin.getline(adresa,50);
cin>>id>>cenacas;
ParkingPlac edna(adresa,id,cenacas);

 //povik na operatorot =
 p[i]=edna;
}

//plakjanje
cin>>m;
for (int i=0;i<m;i++){
cin>>id>>brojcasovi;

 int findId=false;
 for (int j=0;j<n;j++){
 if (strcmp(p[j].getId(),id)==0){
 p[j].platiCasovi(brojcasovi);
 findId=true;
 }
 }
if (!findId)
 cout<<"Ne e platen parking. Greshen ID."<<endl;
}
 cout<<"========="<<endl;
 ParkingPlac pCentar("Cvetan Dimov","C10",80);
for (int i=0;i<n;i++)
 if (p[i].daliIstaAdresa(pCentar))
 p[i].pecati();
}
DVD
Да се дефинира класата Film во која се чуваат информации за:
име на филмот (динамички алоцирано поле од знаци)
мемориската зафатнина на филмот изразена во MB
жанр на филмот кој може да биде: акција, комедија или драма (енумерација zanr)
Да се обезбедат сите потребни методи за класата за правилно функционирање на програмата.
Дополнително за оваа класа да се дефинира функцијата:
pecati() - функција во која ќе се печатат одделени со цртичка(-): мемориска зафатнина на филмот
со постфикс MB и името на филмот во наводници.
Да се креира класата DVD во која се чуваат информации за :
низа од филмови снимени на DVD-то (Поле од најмногу 5 објекти од класата Film )
број на филмови снимени на DVD-то
меморискиот капацитет на DVD-то (во MB)
Да се обезбедат сите потребни методи за класата за правилно функционирање на програмата.
Дополнително за оваа класа да се дефинираат методите:
dodadiFilm (Film f) - со кој се додава филмот f на DVDто, но само ако има доволно преостанато
место (земајќи го предвид меморискиот капацитет на DVD-то и мемориската зафатнина на
снимените филмови) и притоа да има помалку од 5 филмови на DVD-то.
pecatiFilmoviDrugZanr(zanr z) – со кој се печатат информациите за сите филмови кои НЕ се од
жанрот zanr (акција, комедија или драма).
#include <iostream>
#include <cstring>
using namespace std;
enum zanr{action,comedy,drama};
class Film{

 private:

 char *name = new char [50];
 int size;
 zanr genre;

 public:

 Film(char *name=" ",int size=0, zanr genre=zanr(0)){
 strncpy(this->name,name,50);
 this->size=size;
 this->genre=genre;
 }

 Film(const Film &f){
 strncpy(name,f.name,50);
 size=f.size;
 genre=f.genre;
 }

 Film& operator=(const Film &f){
 strncpy(this->name,f.name,50);
 this->size=f.size;
 this->genre=f.genre;
 return *this;
 }

 ~Film(){
 delete [] name;
 }

 void pecati(){
 cout<<size<<"MB"<<"-\""<<name<<"\"";
 cout<<endl;
 }

 int getSize(){
 return size;
 }

 zanr getZanr(){
 return genre;
 }
};
class DVD{

 private:

 Film f[5];
 int num;
 int capacity;

 public:

 DVD(){}

 DVD(Film *f,int num,int capacity){
 this->num=num;
 this->capacity=capacity;
 for(int i=0;i<5;i++){
 this->f[i]=f[i];
 }
 }

 DVD(const DVD &d){
 for(int i=0;i<5;i++){
 f[i]=d.f[i];
 }
 num=d.num;
 capacity=d.capacity;
 }

 void dodadiFilm(Film f){
 if(num<5){
 if(capacity>=f.getSize()){
 this->f[num]=f;
 ++num;
 capacity-=f.getSize();
 }
 }

 }

 DVD(int capacity){
 this->capacity=capacity;
 num=0;
 }

 void pecatiFilmoviDrugZanr(zanr z){
 for(int i=0;i<num;i++){
 if(z!=f[i].getZanr()){
 f[i].pecati();
 }
 }
 }

 Film getFilm(int i){
 return f[i];
 }

 int getBroj(){
 return num;
 }

};
int main() {
 // se testira zadacata modularno
 int testCase;
 cin >> testCase;
 int n, memorija, kojzanr;
 char ime[50];
 if(testCase == 1) {
 cout << "===== Testiranje na klasata Film ======" << endl;
 cin >> ime;
 cin >> memorija;
 cin >> kojzanr; //se vnesuva 0 za AKCIJA,1 za KOMEDIJA i 2 za DRAMA
 Film f(ime,memorija,(zanr)kojzanr);
 f.pecati();
 } else if(testCase == 2) {
 cout << "===== Testiranje na klasata DVD ======" << endl;
 DVD omileno(50);
 cin>>n;
 for (int i=0; i<n; i++) {
 cin >> ime;
 cin >> memorija;
 cin >> kojzanr; //se vnesuva 0 za AKCIJA,1 za KOMEDIJA i 2 za DRAMA
 Film f(ime,memorija,(zanr)kojzanr);
 omileno.dodadiFilm(f);
 }
 for (int i=0; i<n; i++)
 (omileno.getFilm(i)).pecati();
 } else if(testCase == 3) {
 cout << "===== Testiranje na metodot dodadiFilm() od klasata DVD ======" << endl;
 DVD omileno(50);
 cin>>n;
 for (int i=0; i<n; i++) {
 cin >> ime;
 cin >> memorija;
 cin >> kojzanr; //se vnesuva 0 za AKCIJA,1 za KOMEDIJA i 2 za DRAMA
 Film f(ime,memorija,(zanr)kojzanr);
 omileno.dodadiFilm(f);
 }
 for (int i=0; i<omileno.getBroj(); i++)
 (omileno.getFilm(i)).pecati();
 } else if(testCase == 4) {
 cout << "===== Testiranje na metodot pecatiFilmoviDrugZanr() od klasata DVD ======" << endl;
 DVD omileno(50);
 cin>>n;
 for (int i=0; i<n; i++) {
 cin >> ime;
 cin >> memorija;
 cin >> kojzanr; //se vnesuva 0 za AKCIJA,1 za KOMEDIJA i 2 za DRAMA
 Film f(ime,memorija,(zanr)kojzanr);
 omileno.dodadiFilm(f);
 }
 cin>>kojzanr;
 omileno.pecatiFilmoviDrugZanr((zanr)kojzanr);
 } else if(testCase == 5) {
 cout << "===== Testiranje na metodot pecatiFilmoviDrugZanr() od klasata DVD ======" << endl;
 DVD omileno(50);
 cin>>n;
 for (int i=0; i<n; i++) {
 cin >> ime;
 cin >> memorija;
 cin >> kojzanr; //se vnesuva 0 za AKCIJA,1 za KOMEDIJA i 2 za DRAMA
 Film f(ime,memorija,(zanr)kojzanr);
 omileno.dodadiFilm(f);
 }
 cin>>kojzanr;
 omileno.pecatiFilmoviDrugZanr((zanr)kojzanr);
 }
 return 0;
}
Пицерија
Да се дефинира класа Пица за која ќе се чуваат податоци за:
име на пицата (низа од 15 знаци)
цена (цел број)
состојки (динамички алоцирана низа од знаци)
намалување на цената во проценти (цел број) - ако пицата не е на промоција намалувањето има
вредност нула, во спротивно, вредност поголема од нула и не поголема од 100.
За потребите на оваа класа да се креираат потребните конструктори и да се напише соодветен
деструктор. Дополнително за оваа класа да се дефинира функцијата:
pecati() - функција во која ќе се печатат податоците за пицата во следниот формат: име - состојки,
цена.
istiSe(Pica p) - функција за споредба на две пици според состојките :
Да се дефинира класа Picerija во која се чуваат (5 поени):
име (низа од максимум 15 знаци)
динмички алоцирана низа од објекти од класата Pica
број на пици (цел број)
За потребите на оваа класа да се дефинираат потребните конструктори и да се напише соодветен
деструктор. Да се имплементираат и следниве методи:
dodadi (Pica P) - за додавање нова пица во пицеријата, но само ако не постои иста во низата (нема
пица со исти состојки со пицата што треба да се додаде).
void piciNaPromocija() - се печатат сите пици од пицеријата што се на промоција во формат : име -
состојки, цена, цена со попуст.
#include <iostream>
#include <cstring>
using namespace std;
//Vasiot kod tuka
class Pica
{
private:
 char name[15];
 char *ing;
 int price, dis;
public:
 Pica(const char *name="", const int price=0, const char *ing="", const int dis=0)
 {
 strcpy(this->name, name);
 this->price=price;
 this->ing=new char[strlen(ing)+1];
 strcpy(this->ing, ing);
 this->dis=dis;
 }
 Pica(const Pica &p)
 {
 strcpy(name, p.name);
 price=p.price;
 ing=new char[strlen(p.ing)+1];
 strcpy(ing, p.ing);
 dis=p.dis;
 }
 Pica &operator=(const Pica &p)
 {
 if(this!=&p)
 {
 strcpy(name, p.name);
 price=p.price;
 delete [] ing;
 ing=new char[strlen(p.ing)+1];
 strcpy(ing, p.ing);
 dis=p.dis;
 }
 return *this;
 }
 ~Pica()
 {
 delete [] ing;
 }
 void pecati()
 {
 cout<<name<<" - "<<ing<<", "<<price;
 }
 bool istiSe(Pica p)
 {
 return strcmp(ing, p.ing)==0;
 }
 const int getPrice() {return price;}
 const int getDis() {return dis;}
};
class Picerija
{
private:
 char name[15];
 Pica *pc;
 int countP;
public:
 Picerija(const char *name)
 {
 strcpy(this->name, name);
 countP=0;
 }
 Picerija(const Picerija &p)
 {
 strcpy(name, p.name);
 countP=p.countP;
 pc=new Pica[countP];
 for(int i=0; i<countP; i++)
 {
 pc[i]=p.pc[i];
 }
 }
 Picerija &operator=(const Picerija &p)
 {
 if(this!=&p)
 {
 strcpy(name, p.name);
 countP=p.countP;
 delete [] pc;
 pc=new Pica[countP];
 for(int i=0; i<countP; i++)
 {
 pc[i]=p.pc[i];
 }
 }
 return *this;
 }
 ~Picerija()
 {
 delete [] pc;
 }
 void dodadi(Pica p)
 {
 bool notSame=true;
 for(int i=0; i<countP; i++)
 {
 if(pc[i].istiSe(p))
 {
 notSame=false;
 break;
 }
 }
 if(notSame)
 {
 Pica *tmp=new Pica[countP+1];
 for(int i=0; i<countP; i++)
 {
 tmp[i]=pc[i];
 }
 if(countP>0)
 delete [] pc;
 pc=tmp;
 pc[countP++]=p;
 }
 }
 void setIme(const char *name) {strcpy(this->name, name);}
 const char *getIme() {return name;}
 void piciNaPromocija()
 {
 for(int i=0; i<countP; i++)
 {
 if(pc[i].getDis())
 {
 pc[i].pecati();
 cout<<" "<<pc[i].getPrice()-(pc[i].getPrice()*pc[i].getDis())/100<<endl;
 }
 }
 }
};
int main () {
 int n;
 char ime[15];
 cin >> ime;
 cin >> n;
 Picerija p1(ime);
 for(int i = 0; i < n; i++){
 char imp[100];
 cin.get();
 cin.getline(imp,100);
 int cena;
 cin >> cena;
 char sostojki[100];
 cin.get();
 cin.getline(sostojki,100);
 int popust;
 cin >> popust;
 Pica p(imp,cena,sostojki,popust);
 p1.dodadi(p);
 }
 Picerija p2 = p1;
 cin >> ime;
 p2.setIme(ime);
 char imp[100];
 cin.get();
 cin.getline(imp,100);
 int cena;
 cin >> cena;
 char sostojki[100];
 cin.get();
 cin.getline(sostojki,100);
 int popust;
 cin >> popust;
 Pica p(imp,cena,sostojki,popust);
 p2.dodadi(p);
 cout<<p1.getIme()<<endl;
 cout<<"Pici na promocija:"<<endl;
 p1.piciNaPromocija();
 cout<<p2.getIme()<<endl;
 cout<<"Pici na promocija:"<<endl;
 p2.piciNaPromocija();
return 0;
}
Матрица
Да се напише класа за матрица. Во класата се чуваат елементите од матрицата од тип float
(матрица со максимална димензија [10]x[10]) и големината на матрицата (број на редици и
колони). За оваа класа да се преоптоварат следните оператори:
оператор + за собирање матрица со број
оператор - за одземање на матрици
оператор * за множење на матрици
операторот >> за внесување на елементите на матрицата
операторот << за печатење на елементите на матрицата
Во главната функција да се креираат објекти A, B и C со подразбирливиот конструктор на класата
Matrica. Од стандарден влез да се прочитаат нивните вредности. Да се отпечати вредноста на
изразот A-(B*C)+2 на стандарден излез.
Да се претпостави дека секогаш матриците ќе бидат квадратни со ист број на редици и колони.
//vashiot kod ovde
#include <iostream>
#include <cstring>
using namespace std;
class Matrica{

private:

 float matrix[10][10];
 int rows;
 int columns;

public:

 Matrica(){}

 Matrica(int rows,int columns){
 this->rows=rows;
 this->columns=columns;
 for(int i=0;i<rows;i++){
 for(int j=0;j<columns;j++){
 this->matrix[i][j]=0;
 }
 }

 }

 friend istream& operator>>(istream &input,Matrica &m){
 input>>m.rows>>m.columns;
 for(int i=0;i<m.rows;i++){
 for(int j=0;j<m.columns;j++){
 input>>m.matrix[i][j];
 }
 }
 return input;
 }

 friend ostream& operator<<(ostream &output,Matrica &m){
 for(int i=0;i<m.rows;i++){
 for(int j=0;j<m.columns;j++){
 output<<m.matrix[i][j]<<" ";
 }
 output<<endl;
 }
 return output;
 }

 Matrica& operator+(int a){
 for(int i=0;i<rows;i++){
 for(int j=0;j<columns;j++){
 matrix[i][j]+=a;
 }
 }
 return *this;
 }

 Matrica& operator-(Matrica &b){
 for(int i=0;i<rows;i++){
 for(int j=0;j<columns;j++){
 this->matrix[i][j]-=b.matrix[i][j];
 }
 }
 return *this;
 }

 Matrica operator*(Matrica &b){
 Matrica newmatrica(this->rows,this->columns);
 for(int i=0;i<rows;i++){
 for(int j=0;j<columns;j++){
 for(int k=0;k<columns;k++){
 newmatrica.matrix[i][j]+=this->matrix[i][k]*b.matrix[k][j];
 }
 }
 }
 return newmatrica;
 }

};
int main()
{
 Matrica A,B,C;
 cin>>A>>B>>C;
 Matrica D=B*C;
 Matrica R=A-D+2;
 cout<<R;
}
Планинарско друштво
Да се креира класа за претставување на планинарско друштво во која ќе се чуваат информации за
името на друштвото (динамички алоцирана низа од знаци), број на поминати тури (цел број) и
број на членови во планинарското друштво (цел број). За оваа класа да се напише:
оператор + за собирање на две друштва што како резултат враќа друштво со број на членови
еднаков на збирот од членовите од двете друштва, а останатите атрибути на резултантното
друштво ги добиваат вредностите на соодветните атрибути од друштвото со поголем број на
членови
оператори >, < за споредба во однос на бројот на членови во планинарските друштва
оператор << за печатење на информациите за планинарското друштво
Да се напише функција што на влез прима низа од планинарски друштва и вкупен број на друштва
во низата и го печати планинарското друштво што има најголем број на членови .
#include <iostream>
#include <string.h>
using namespace std;
class PlDrustvo{

private:

 char *ime;
 int brojTuri;
 int clenovi;

public:

 PlDrustvo(){
 ime=NULL;
 brojTuri=0;
 clenovi=0;
 }


 PlDrustvo(char *ime,int brojTuri,int clenovi){
 this->ime=new char [strlen(ime)+1];
 strcpy(this->ime,ime);
 this->brojTuri=brojTuri;
 this->clenovi=clenovi;
 }

 PlDrustvo(const PlDrustvo& p){
 this->ime=new char [strlen(p.ime)+1];
 strncpy(this->ime,p.ime,strlen(p.ime)+1);
 this->brojTuri=p.brojTuri;
 this->clenovi=p.clenovi;
 }

 PlDrustvo& operator=(const PlDrustvo &p){
 if(this!=&p){
 delete [] this->ime;
 this->ime=new char [strlen(p.ime)+1];
 strcpy(this->ime,p.ime);
 this->brojTuri=p.brojTuri;
 this->clenovi=p.clenovi;
 }
 return *this;
 }

 PlDrustvo operator+(const PlDrustvo &p){
 PlDrustvo p1;
 if(*this>p){
 delete [] p1.ime;
 p1.ime=new char [strlen(this->ime)+1];
 strncpy(p1.ime,this->ime,strlen(this->ime)+1);
 p1.brojTuri=this->brojTuri;
 p1.clenovi=this->clenovi+p.clenovi;
 } else {
 delete [] p1.ime;
 p1.ime=new char [strlen(p.ime)+1];
 strncpy(p1.ime,p.ime,strlen(p.ime)+1);
 p1.brojTuri=p.brojTuri;
 p1.clenovi=this->clenovi+p.clenovi;
 }
 return p1;
 }

 ~PlDrustvo(){
 delete [] ime;
 }

 friend ostream& operator<<( ostream& output,PlDrustvo &p){
 output<<"Ime: "<<p.ime<<" Turi: "<<p.brojTuri<<" Clenovi: "<<p.clenovi<<endl;
 return output;
 }

 bool operator<(const PlDrustvo& p){
 return this->clenovi<p.clenovi;
 }

 bool operator>(const PlDrustvo& p){
 return this->clenovi>p.clenovi;
 }


};
void najmnoguClenovi(PlDrustvo* drustva,int n){
 PlDrustvo max=drustva[0];
 for(int i=1;i<n;i++){
 if(drustva[i]>max){
 max=drustva[i];
 }
 }
 cout<<"Najmnogu clenovi ima planinarskoto drustvo: "<<max;
}
int main()
{
 PlDrustvo drustva[3];
 PlDrustvo pl;

 for (int i=0;i<3;i++)
 {
 char ime[100];
 int brTuri;
 int brClenovi;
 cin>>ime;
 cin>>brTuri;
 cin>>brClenovi;

 PlDrustvo p(ime,brTuri,brClenovi);

 drustva[i] = p;
 }

 pl = (drustva[0] + drustva[1]);

 cout<<pl;


 najmnoguClenovi(drustva, 3);

 return 0;
}
Автомобил
Да се напише класа Automobile во која се чуваат информации за марката на автомобилот
(динамички алоцирана низа од знаци), регистрација (динамички алоцирана низа од 5 цели броја)
и максимална брзина (цел број). За класата да се обезбедат set и get методите што се користат и
да се преоптоварат следните оператори:
оператор == за споредување на два автомобила според регистрацијата
оператор << за печатење на податоци на автомобил во формат Marka:име Registracija:[x y z k l]
Да се напише класа RentACar за агенција за измајмување возила во која се чуваат информација за
името на агенцијата (низа од 100 знци), низа од автомобили (динамички алоациана низа од
објекти од класата Automobile) и број на автомобили со кој располага (цел број). Во класата
RentACar да се напише конструктор со еден аргумент за иницијализација на името на агенцијата.
При секое додавање на нов автомобил, динамички алоцираната низа да го зголемува капацитетот
за 1 елемент. Во оваа класа да се преоптоварат операторите:
+= за додавање на нов автомобил во агенцијата и
-= за отстранување на даден автомобил од агенцијата (оној со иста регистрација).
Да се напише main функција во која се инстанцира објект од класата RentACar. Во овој објект да се
додадат сите автомобили чии информации се читаат од тастатура со операторот +=. Меѓутоа,
откриено е дека во внесувањето на податоците има грешка затоа што при обид да се додаде нов
автомобил во агенцијата, увидено е дека таа регистрација веќе постои. Во последниот ред од
влезот дадени се инфромации тој автомобил. Потребно е да се избрише автомобилот што
претходно е погрешно внесен и да се додаде новиот.
На излез да се отпечатат името на агенцијата и листа на автомобили што таа ги изнајмува, а чија
максимална брзина е поголема од 150. Последново да се направи со функција
_pecatiNadBrzina(int max)_ што треба да се дефинира во класата RentACar.
#include<iostream>
#include<cstring>
using namespace std;
class Automobile
{
private:
 char *marka;
 int *registracija;
 int maks_brzina;
public:
 Automobile(const char *m="", const int *reg=0, int maksb=0)
 {
 marka = new char[strlen(m)+1];
 strcpy(marka,m);
 registracija = new int[5];
 if(reg==0)
 {
 for(int i=0;i<5;i++)
 {
 registracija[i]=0;
 }
 }
 else
 {
 for(int i=0;i<5;i++)
 {
 registracija[i]=reg[i];
 }
 }
 maks_brzina=maksb;
 }
 Automobile(const Automobile &a)
 {
 marka = new char[strlen(a.marka)+1];
 strcpy(marka,a.marka);
 registracija = new int[5];
 for(int i=0;i<5;i++)
 {
 registracija[i]=a.registracija[i];
 }
 maks_brzina=a.maks_brzina;
 }
 Automobile &operator =(const Automobile &a)
 {
 if(this==&a)return *this;
 delete [] marka;
 marka = new char[strlen(a.marka)+1];
 strcpy(marka,a.marka);
 registracija = new int[5];
 for(int i=0;i<5;i++)
 {
 registracija[i]=a.registracija[i];
 }
 maks_brzina=a.maks_brzina;
 return *this;
 }
 ~Automobile(){delete [] marka; delete [] registracija;}
 bool operator ==(const Automobile &a)
 {
 bool flag=true;
 for(int i=0;i<5;i++)
 {
 if(registracija[i]!=a.registracija[i])
 flag=false;
 }
 return flag;
 }
 friend ostream &operator <<(ostream &out, const Automobile &a)
 {
 out<<"Marka\t";
 out<<a.marka<<""<<"\tRegistracija[ ";
 for(int i=0;i<5;i++)
 {
 out<<a.registracija[i]<<" ";
 }
 out<<"]"<<endl;
 }
 int get_brzina()
 {
 return maks_brzina;
 }
};
class RentACar
 {
 private:
 char ime[100];
 Automobile *av;
 int broj_alto;
 public:
 RentACar(const char *im="", const Automobile *avt=0, int br_al=0)
 {
 av = new Automobile[br_al];
 strcpy(ime,im);
 for(int i=0;i<br_al;i++)
 {
 av[i] = avt[i];
 }
 broj_alto=br_al;
 }
 RentACar (const RentACar &rc)
 {
 strcpy(ime,rc.ime);
 av = new Automobile[rc.broj_alto];
 for(int i=0;i<rc.broj_alto;i++)
 {
 av[i] = rc.av[i];
 }
 broj_alto=rc.broj_alto;
 }
 RentACar &operator +=(const Automobile &a)
 {
 Automobile *temp;
 temp = new Automobile [broj_alto+1];
 for(int i=0;i<broj_alto;i++)
 {
 temp[i] = av[i];
 }
 temp[broj_alto]=a;
 delete [] av;
 av=temp;
 broj_alto++;
 return *this;
 }
 RentACar &operator -=(const Automobile &a)
 {
 Automobile *temp;
 int brojac=0;
 for(int i=0;i<broj_alto;i++)
 {
 if(av[i]==a)brojac++;
 }
 temp = new Automobile[broj_alto-brojac];
 int b=0;
 for(int i=0;i<broj_alto;i++)
 {
 if(!(av[i]==a))
 {
 temp[b]=av[i];
 b++;
 }
 }
 delete [] av;
 av=temp;
 broj_alto=broj_alto-brojac;
 return *this;
 }
 void pecatiNadBrzina(int maks)
 {
 for(int i=0;i<broj_alto;i++)
 {
 if(av[i].get_brzina()>maks)
 cout<<av[i];
 }
 }
 };
int main()
{
 RentACar agencija("FINKI-Car");
 int n;
 cin>>n;
cout<<"FINKI-Car"<<endl;
 for (int i=0;i<n;i++)
 {
 char marka[100];
 int regisracija[5];
 int maximumBrzina;
 cin>>marka;
 for (int i=0;i<5;i++)
 cin>>regisracija[i];
 cin>>maximumBrzina;
 Automobile nov=Automobile(marka,regisracija,maximumBrzina);
 //dodavanje na avtomobil
 agencija+=nov;
 }
 //se cita grehsniot avtmobil, za koj shto avtmobilot so ista registracija treba da se izbrishe
 char marka[100];
 int regisracija[5];
 int maximumBrzina;
 cin>>marka;
 for (int i=0;i<5;i++)
 cin>>regisracija[i];
 cin>>maximumBrzina;
 Automobile greshka=Automobile(marka,regisracija,maximumBrzina);
 //brishenje na avtomobil
 agencija-=greshka;
 agencija.pecatiNadBrzina(150);
 return 0;
}
Недвижнина
Да се развие класа Nediviznina за коjа се чуваат следниве информации:
адреса (динамички алоцирана низа од знаци)
квадратура (цел боj)
цена за квадрат (цел боj)
За оваа класа да се имплементираат соодветните конструктори и следните методи:
cena() коj ќе jа ваќа цената на недвижнината (квадратура * цена-за-квадрат)
pecati() коj ќе ги испечати сите информации за истата
danokNaImot() коj го ваќа данокот што се плаќа за недвижнината, а истиот се пресметува како 5%
од цената на недвижнината.
Од оваа класа да се изведе класа Vila за коjа дополнително се чува данок на луксуз (цел боj, пр.
10%). За оваа класа да се преоптоварат методите:
pecati()
danokNaImot() со тоа што пресметаниот данок се зголемува процентуално за данокот на луксуз.
И за двете класи треба да се преоптовари operator >>.
//Vasiot kod ovde....
#include <iostream>
#include <cstring>
using namespace std;
class Nedviznina{
protected:
 char *adresa;
 int kv,cena;
public:
 Nedviznina(){
 adresa=new char[0];
 }
 //copy
 Nedviznina(const Nedviznina &n){
 adresa=new char[strlen(n.adresa)+1];
 strcpy(adresa,n.adresa);
 kv=n.kv;
 cena=n.cena;
 }
 //operator =
 Nedviznina& operator=(const Nedviznina &n){
 if(this!=&n){
 delete [] adresa;
 adresa=new char[strlen(n.adresa)+1];
 strcpy(adresa,n.adresa);
 kv=n.kv;
 cena=n.cena;
 }
 return *this;
 }
 //destructor
 ~Nedviznina(){
 delete [] adresa;
 }
 //metodi
 int Cena(){
 return kv*cena;
 }
 void pecati(){
 cout<<adresa<<", Kvadratura: "<<kv<<", Cena po Kvadrat: "<<cena<<endl;
 }
 float danokNaImot(){
 return (float)kv*cena*5/100;
 }
 char *getAdresa(){
 return adresa;
 }
 //operator >>
 friend istream& operator>>(istream &in,Nedviznina &n){
 in>>n.adresa;
 in>>n.kv;
 in>>n.cena;
 return in;
 }
};
class Vila:public Nedviznina{
private:
 int danok;
public:
 Vila(){}
 //metodi
 void pecati(){
 cout<<adresa<<", Kvadratura: "<<kv<<", Cena po Kvadrat: "<<cena<<", Danok na luksuz:
"<<danok<<endl;
 }
 float danokNaImot(){
 return Nedviznina::Cena()*(5+danok)/100;
 }
 //operator >>
 friend istream& operator>>(istream &in,Vila &v){
 return in>>v.adresa>>v.kv>>v.cena>>v.danok;
 }
};
int main(){
 Nedviznina n;
 Vila v;
 cin>>n;
 cin>>v;
 n.pecati();
 cout<<"Danok za: "<<n.getAdresa()<<", e: "<<n.danokNaImot()<<endl;
 v.pecati();
 cout<<"Danok za: "<<v.getAdresa()<<", e: "<<v.danokNaImot()<<endl;
 return 0;
}
Спортски екипи
Да се дефинира класа Ekipa за коjа се чуваат следниве информации:
името на екипата (низа од наjмногу 15 знаци)
броj на порази
броj на победи
За оваа класа да се дефинира метод pecati() коjа ги печати податоците за екипаta. Од оваа класа
да се изведe новa класa, FudbalskaEkipa.
За фудбалската екипа дополнително се чуваат информации за:
вкупниот броj на црвени картони
вкупниот броj жолти картони
броjот на нерешени натпревари
За фудбалската екипа да се преоптовари методот pecati(), така што покрај останатите
информации, ќе се испечатат и бројот на нерешени резултати и вкупен број на поени во формат:
Име на екипа, броj на победи, броj на порази, броj на нерешени натпревари и вкупен броj на
поени (за победа фудбалската екипа добива 3 поени, додека за нерешен резултата, 1 поен);
//Vasiot kod ovde
#include <iostream>
#include <cstring>
using namespace std;
class Ekipa{
protected:
 char ime[15];
 int porazi;
 int pobedi;
public:
 Ekipa(char ime[15]="",int pobedi=0,int porazi=0){
 strcpy(this->ime,ime);
 this->pobedi=pobedi;
 this->porazi=porazi;
 }
 ~Ekipa(){}
 void pecati(){
 cout<<"Ime: "<<ime<<" Pobedi: "<<pobedi<<" Porazi: "<<porazi;
 }
};
class FudbalskaEkipa:public Ekipa{
private:
 int crveni;
 int zolti;
 int nereseni;
public:
 FudbalskaEkipa(char ime[15]="",int pobedi=0,int porazi=0,int crveni=0,int zolti=0,int
nereseni=0):Ekipa(ime,pobedi,porazi){
 this->crveni=crveni;
 this->zolti=zolti;
 this->nereseni=nereseni;
 }
 FudbalskaEkipa(const FudbalskaEkipa &k):Ekipa(ime,pobedi,porazi){
 crveni=k.crveni;
 zolti=k.zolti;
 nereseni=k.nereseni;
 }
 ~FudbalskaEkipa(){}
 void pecati(){
 int poeni;
 poeni=(pobedi*3)+(1*nereseni);
 cout<<"Ime: "<<ime<<" Pobedi: "<<pobedi<<" Porazi: "<<porazi<<" Nereseni: "<<nereseni<<" Poeni:
"<<poeni<<endl;
 }
};
int main(){
char ime[15];
int pob,por,ck,zk,ner;
cin>>ime>>pob>>por>>ck>>zk>>ner;
FudbalskaEkipa f1(ime,pob,por,ck,zk,ner);
f1.pecati();
return 0;
}

/*Да се дефинира класа Пица за која ќе се чуваат податоци за (5 поени):

име на пицата (низа од 15 знаци)
цена (цел број)
состојки (динамички алоцирана низа од знаци)
намалување на цената во проценти (цел број) - ако пицата не е на промоција намалувањето има вредност нула, во спротивно, вредност поголема од нула и не поголема од 100.
За потребите на оваа класа да се креираат потребните конструктори и да се напише соодветен деструктор. (10 поени) Дополнително за оваа класа да се дефинира функцијата:

pecati() - функција во која ќе се печатат податоците за пицата во следниот формат: име - состојки, цена. (5 поени)
istiSe(Pica p) - функција за споредба на две пици според состојките (5 поени):
Да се дефинира класа Picerija во која се чуваат (5 поени):

име (низа од максимум 15 знаци)
динмички алоцирана низа од објекти од класата Pica
број на пици (цел број)
За потребите на оваа класа да се дефинираат потребните конструктори и да се напише соодветен деструктор. (10 поени) Да се имплементираат и следниве методи:

dodadi (Pica P) - за додавање нова пица во пицеријата, но само ако не постои иста во низата (нема пица со исти состојки со пицата што треба да се додаде). (10 поени)
void piciNaPromocija() - се печатат сите пици од пицеријата што се на промоција во формат : име - состојки, цена, цена со попуст. (10 поени)*/
using namespace std;
#include <iostream>
#include <cstring>

class Pica{
private:
char ime[15];
int cena;
char *sostojki;
int namaluvanje;
public:
Pica(){sostojki = new char[0];}

Pica(char *ime, int cena, char *s, int n)
{
    strcpy(this->ime, ime);
    this->cena=cena;
    sostojki=new char [strlen(s)+1];
    strcpy(sostojki,s);
    namaluvanje=n;
}

Pica(const Pica &p)
{
    strcpy(ime,p.ime);
    cena=p.cena;
    sostojki=new char [strlen(p.sostojki)+1];
    strcpy(sostojki,p.sostojki);
    namaluvanje=p.namaluvanje;
}

Pica& operator= (const Pica &p) // preoptovaruvanje na =
{
    if(this!=&p)
    {
        delete[] sostojki;
        strcpy(ime,p.ime);
        cena=p.cena;
        sostojki=new char [strlen(p.sostojki)+1];
        strcpy(sostojki,p.sostojki);
        namaluvanje=p.namaluvanje;
    }
    return *this;
}

~Pica(){delete[] sostojki;} // destructor
int getNamaluvanje(){return namaluvanje;}
char* getSostojki(){return sostojki;}

void pecati()
{
    cout<<ime<<" - "<<sostojki<<", "<<cena<<" "<<cena-cena*namaluvanje/100;
}

bool istiSe(Pica p)
{
    if(strcpy(p.sostojki,sostojki)==0)
    return 1;
    else return 0;
}

};


class Picerija{
private:
    char ime[15];
    Pica *pici;
    int brPici;

public:
Picerija(){pici=new Pica[0];}
Picerija(char *ime, Pica *p, int brP) {
    strcpy(this->ime,ime);
    pici=new Pica[brP];
    for(int i=0;i<brP;i++)
        pici[i]=p[i];
    brPici=brP;
}

Picerija(char *ime)
{
    strcpy(this->ime,ime);
    pici=new Pica[0];
    brPici=0;
}

Picerija(const Picerija &p)
{
    strcpy(ime,p.ime);
    pici=new Pica [p.brPici];
    for(int i=0;i<p.brPici;i++)
        pici[i]=p.pici[i];
    brPici=p.brPici;
}

Picerija& operator= (const Picerija &p)
{
    if(this!=&p)
    {
    delete [] pici;
    strcpy(ime,p.ime);
    pici=new Pica [p.brPici];
    for(int i=0;i<p.brPici;i++)
    pici[i]=p.pici[i];
    brPici=p.brPici;
    }
return *this;
}

~Picerija(){delete[] pici;}

void setIme(char *ime){strcpy(this->ime,ime);}
char* getIme(){return ime;}
void dodadi(Pica P)
{
    for(int i=0;i<brPici;i++)
    if(strcmp(P.getSostojki(),pici[i].getSostojki())==0)
        return;
    Pica *tmp;
    tmp=new Pica[brPici];
    for(int i=0;i<brPici;i++)
        tmp[i]=pici[i];
    delete[] pici;
    pici=new Pica[brPici+1];
    for(int i=0;i<brPici;i++)
        pici[i]=tmp[i];
    pici[brPici]=P;
    brPici++;
    delete [] tmp;
}

void piciNaPromocija()
{
    for(int i=0;i<brPici;i++)
    if(pici[i].getNamaluvanje()>0){
        pici[i].pecati();
    cout<<endl;}
}
};
int main () {
    int n;
    char ime[15];
    cin >> ime;
    cin >> n;
    Picerija p1(ime);
    for(int i = 0; i < n; i++){
        char imp[100];
        cin.get();
        cin.getline(imp,100);
        int cena;
        cin >> cena;
        char sostojki[100];
        cin.get();
        cin.getline(sostojki,100);
        int popust;
        cin >> popust;
        Pica p(imp,cena,sostojki,popust);
        p1.dodadi(p);
    }

    Picerija p2 = p1;
    cin >> ime;
    p2.setIme(ime);
    char imp[100];
    cin.get();
    cin.getline(imp,100);
    int cena;
    cin >> cena;
    char sostojki[100];
    cin.get();
    cin.getline(sostojki,100);
    int popust;
    cin >> popust;
    Pica p(imp,cena,sostojki,popust);
    p2.dodadi(p);

    cout<<p1.getIme()<<endl;
    cout<<"Pici na promocija:"<<endl;
    p1.piciNaPromocija();

    cout<<p2.getIme()<<endl;
    cout<<"Pici na promocija:"<<endl;
    p2.piciNaPromocija();
    return 0;
       }