From 7bed15831db2eac0e121ce93f40ed2adc1101541 Mon Sep 17 00:00:00 2001
From: unknown <mrjfz13841393@gmail.com>
Date: Sat, 6 Apr 2024 17:04:14 +0330
Subject: [PATCH 1/4] file added

---
 1/1.cpp | 48 ++++++++++++++++++++++++++++++------------------
 1 file changed, 30 insertions(+), 18 deletions(-)

diff --git a/1/1.cpp b/1/1.cpp
index b83dbef..11be5ea 100644
--- a/1/1.cpp
+++ b/1/1.cpp
@@ -4,14 +4,26 @@
 #include <algorithm>
 using namespace std;
 
-class Person {
+class person {
 public:
 	
-	Person(const string& name) {
+	person(const string& name) {
 		this->name = name;
-
 	}
-	string& getName()  { return name; }
+	person(const string& _name,int _age) {
+		this->name = _name;
+		this->age = _age;
+	}
+	person() { name = ""; age = 0; }
+	string& getname()  { return name; }
+	string getname() const { return name; }
+	string setname(string _name) { name=_name; }
+	int setage(int _age) { age = _age; }
+
+	int getage() const { return age; }
+	friend ostream& operator<<(ostream& out, const person& p);
+
+	friend class Group;
 
 private:
 	string name;
@@ -19,8 +31,8 @@ class Person {
 
 };
 
-ostream& operator<<(ostream& out, const Person& p) {
-	cout << p.getName();
+ostream& operator<<(ostream& out, const person& p) {
+	cout << p.getname()<<endl;
 	return out;
 }
 
@@ -29,12 +41,12 @@ ostream& operator<<(ostream& out, const Person& p) {
 class Group {
 public:
 
-	Group(int max_lenght)  {
+	Group(int max_lenght) {
 		this->cap = max_lenght;
-		this->members = new Person[max_lenght];
+		this->members = new person[max_lenght];
 		this->size = 0;
 	}
-	void add(Person p) {
+	void add(person p) {
 		if (this->size == this->cap) {
 			return;
 		}
@@ -57,11 +69,12 @@ class Group {
 	~Group() {
 		delete[] members;
 	}
+	friend bool isGroupFull(Group g);
 
 private:
 	int size;
 	int cap;
-	Person* members;
+	person* members;
 
 };
 
@@ -71,26 +84,25 @@ bool isGroupFull(Group g) {
 
 int main()
 {
-	/*
-	Person p1("somename");
-	Person p1("somename2");
+	person p1("somename");
+	person p2("somename2");
 	cout << p1<<p2;
-	*/
-	/*
+	
+	
 	Group g1(5);
 	g1.add({ "Erfan",20 });
 	g1.add({ "Saba",20 });
 	g1.add({ "Mahrokh",20 });
 	g1.add({ "Yasin",21 });
 	cout<<isGroupFull(g1)<<endl;
-	*/
-	/*
+	
+	
 	Group g2(g1);
 	Group g3(10);
 	g2.deletePerson("Erfan");
 	cout << g1<<endl;//should cout every person in it with a \t as the separator
 	cout << g2 << endl;
-	*/
+
 	/*
 	g3 = g1;
 	cout << g3;

From a1674e198c36893258244be9168e31097d55c47a Mon Sep 17 00:00:00 2001
From: unknown <mrjfz13841393@gmail.com>
Date: Mon, 8 Apr 2024 07:48:19 +0330
Subject: [PATCH 2/4] oreator<< for Group has been declared

---
 1/1.cpp | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/1/1.cpp b/1/1.cpp
index 11be5ea..9cd25be 100644
--- a/1/1.cpp
+++ b/1/1.cpp
@@ -46,6 +46,17 @@ class Group {
 		this->members = new person[max_lenght];
 		this->size = 0;
 	}
+	Group(Group& g) {
+		this->cap =g.cap;
+		this->members = new person[g.cap];
+		this->size = 0;
+
+		for (int i = 0; i < g.size; i++) {
+			this->members[i].name = g.members[i].name;
+			this->members[i].age = g.members[i].age;
+			this->size++;
+		}
+	}
 	void add(person p) {
 		if (this->size == this->cap) {
 			return;
@@ -70,6 +81,7 @@ class Group {
 		delete[] members;
 	}
 	friend bool isGroupFull(Group g);
+	friend ostream& operator<<(ostream& out, Group g);
 
 private:
 	int size;
@@ -78,6 +90,13 @@ class Group {
 
 };
 
+ostream& operator<<(ostream& out, Group g) {
+	for (int i = 0; i < g.size; i++) {
+		out << g.members[i].getname() << " \t";
+	}
+	return out;
+}
+
 bool isGroupFull(Group g) {
 	return (g.size == g.cap);
 }
@@ -94,7 +113,7 @@ int main()
 	g1.add({ "Saba",20 });
 	g1.add({ "Mahrokh",20 });
 	g1.add({ "Yasin",21 });
-	cout<<isGroupFull(g1)<<endl;
+	//cout<<isGroupFull(g1)<<endl;
 	
 	
 	Group g2(g1);

From 104cf2cb53566948fc93c522156d49a8b0ef85e0 Mon Sep 17 00:00:00 2001
From: unknown <mrjfz13841393@gmail.com>
Date: Thu, 11 Apr 2024 18:14:48 +0330
Subject: [PATCH 3/4] Final code without bugs

---
 1/1.cpp | 150 ++++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 114 insertions(+), 36 deletions(-)

diff --git a/1/1.cpp b/1/1.cpp
index 9cd25be..d02bde6 100644
--- a/1/1.cpp
+++ b/1/1.cpp
@@ -1,29 +1,45 @@
+/*?????? 
+* Complex Number (Part 1)
+* AP ??? ?? ????????
+* 1403/1/23
+* ???????? ?????
+*/
 
 #include <iostream>
 #include <vector>
 #include <algorithm>
+#include <string>
+
 using namespace std;
 
-class person {
+class Person {
 public:
 	
-	person(const string& name) {
+	Person(const string& name) {
 		this->name = name;
 	}
-	person(const string& _name,int _age) {
+	Person(const string& _name,int _age) {
 		this->name = _name;
 		this->age = _age;
 	}
-	person() { name = ""; age = 0; }
+	Person() { name = ""; age = 0; }
+
+	//Add distructor
+	~Person(){}
+
 	string& getname()  { return name; }
 	string getname() const { return name; }
-	string setname(string _name) { name=_name; }
-	int setage(int _age) { age = _age; }
 
-	int getage() const { return age; }
-	friend ostream& operator<<(ostream& out, const person& p);
+	void setname(string _name) { name=_name; }
+	void setage(int _age) { age = _age; }
+	int  getage() const { return age; }
+
+	//Overload boolian operator
+	bool operator<(const Person& p) { return stoi(name) < stoi(p.name); }
+	bool operator==(const Person& p) { return name == p.name; }
 
 	friend class Group;
+	friend ostream& operator<<(ostream& out, const Person& p);
 
 private:
 	string name;
@@ -31,24 +47,23 @@ class person {
 
 };
 
-ostream& operator<<(ostream& out, const person& p) {
+ostream& operator<<(ostream& out, const Person& p) {
 	cout << p.getname()<<endl;
 	return out;
 }
 
 
-
 class Group {
 public:
 
 	Group(int max_lenght) {
 		this->cap = max_lenght;
-		this->members = new person[max_lenght];
+		this->members = new Person[max_lenght];
 		this->size = 0;
 	}
 	Group(Group& g) {
 		this->cap =g.cap;
-		this->members = new person[g.cap];
+		this->members = new Person[g.cap];
 		this->size = 0;
 
 		for (int i = 0; i < g.size; i++) {
@@ -57,7 +72,12 @@ class Group {
 			this->size++;
 		}
 	}
-	void add(person p) {
+	Group() {
+		cap = 0;
+		size = 0;
+	}
+
+	void add(Person p) {
 		if (this->size == this->cap) {
 			return;
 		}
@@ -69,7 +89,6 @@ class Group {
 		for (i = 0; i < size; i++) {
 			if(members[i].name == name)
 				break;
-			
 		}
 		for (int index = i; index < size - 1; index++) {
 			members[index] = members[index + 1];
@@ -80,19 +99,85 @@ class Group {
 	~Group() {
 		delete[] members;
 	}
+
+	//Overloading operators
+	Group operator+(const Group& g) {
+		Group result;
+		result.cap = cap + g.cap;
+		result.size = size + g.size;
+		result.members = new Person[result.cap];
+
+		int i = 0;
+		for (i = 0; i < size; i++) {
+			result.members[i].name = members[i].name;
+			result.members[i].age = members[i].age;
+		}
+
+		for (int j = 0; j < g.size; j++) {
+			result.members[i].name = g.members[j].name;
+			result.members[i].age = g.members[j].age;
+			i++;
+		}
+
+		return result;
+	}
+
+	Group& operator+=(const Group& g) {
+		int new_size = size + g.size;
+		int new_cap = cap + g.cap;
+		Person* new_members = new Person[new_cap];
+
+		for (int i = 0; i < size; i++) {
+			new_members[i].name = members[i].name;
+			new_members[i].age = members[i].age;
+		}
+
+		for (int j = 0; j < g.size; j++) {
+			new_members[size + j].name = g.members[j].name;
+			new_members[size + j].age = g.members[j].age;
+		}
+
+		delete[] members;
+		members = new_members;
+		size = new_size;
+		cap = new_cap;
+
+		return *this;
+	}
+
+	Group& operator=(const Group& g) {
+		if (this == &g) {
+			return *this;
+		}
+
+		delete[] members;
+
+		cap = g.cap;
+		size = g.size;
+		members = new Person[cap];
+
+		for (int i = 0; i < size; i++) {
+			members[i].name = g.members[i].name;
+			members[i].age = g.members[i].age;
+		}
+
+		return *this;
+	}
+	
+	//Friends
 	friend bool isGroupFull(Group g);
 	friend ostream& operator<<(ostream& out, Group g);
 
 private:
 	int size;
 	int cap;
-	person* members;
+	Person* members;
 
 };
 
 ostream& operator<<(ostream& out, Group g) {
 	for (int i = 0; i < g.size; i++) {
-		out << g.members[i].getname() << " \t";
+		out << g.members[i].getname() << "\t";
 	}
 	return out;
 }
@@ -103,8 +188,8 @@ bool isGroupFull(Group g) {
 
 int main()
 {
-	person p1("somename");
-	person p2("somename2");
+	Person p1("somename");
+	Person p2("somename2");
 	cout << p1<<p2;
 	
 	
@@ -113,7 +198,7 @@ int main()
 	g1.add({ "Saba",20 });
 	g1.add({ "Mahrokh",20 });
 	g1.add({ "Yasin",21 });
-	//cout<<isGroupFull(g1)<<endl;
+	cout<<isGroupFull(g1)<<endl;
 	
 	
 	Group g2(g1);
@@ -122,35 +207,28 @@ int main()
 	cout << g1<<endl;//should cout every person in it with a \t as the separator
 	cout << g2 << endl;
 
-	/*
+	
 	g3 = g1;
 	cout << g3;
 	g3 =  g2 + g3;//adds members of g2 and g3 to each other
+	cout << g3<<endl;
 	g3 += g3 += g3 += g3;
-	*/
-	/*
+	cout << g3;
+
 	Person persons[10];
 	Person Erfan("Erfan",20);
 	persons[1]=Erfan;
 	for(int i=0;i<10;i++){
-		persons[i].getName()=to_string(rand()%100);
+		persons[i].getname()=to_string(rand()%100);
 	}
+
 	sort(persons,persons+10);//what operator should be overloaded for sort? :)
 
+	cout << endl;
 	for(int i=0;i<10;i++){
-		cout<<persons[i].getName()<<' ';
-	}*/
-	/*
-	cout<<*find(persons,persons+10,Erfan);
-	*/
+		cout << persons[i].getname() << ' ';
+	}
 	
-
-
-
-
-
-
-
-
+	cout << endl << find(persons, persons + 10, Erfan);
 }
 

From 1d9feb3f878478af48a2b28ed2568d03a820aa7b Mon Sep 17 00:00:00 2001
From: unknown <mrjfz13841393@gmail.com>
Date: Fri, 12 Apr 2024 11:51:49 +0330
Subject: [PATCH 4/4] file 2 fixed

---
 2/Score.cpp | 38 ++++++++++++++++++++++++++++++++++++++
 2/Score.h   | 13 +++++++++++++
 2/main.cpp  |  2 ++
 3 files changed, 53 insertions(+)

diff --git a/2/Score.cpp b/2/Score.cpp
index c107032..9e5a43e 100644
--- a/2/Score.cpp
+++ b/2/Score.cpp
@@ -1,5 +1,7 @@
 #include "Score.h"
 
+int Score::ID_generator = 0;
+
 Score::Score(int score,char* detail, Label label) :ID(Score::ID_generator) {
 	this->score = score;
 	this->label = label;
@@ -8,5 +10,41 @@ Score::Score(int score,char* detail, Label label) :ID(Score::ID_generator) {
 	ID_generator++;
 
 }
+Score::Score(int score, const char* _detail, Label label) :ID(Score::ID_generator),detail(_detail) {
+	this->score = score;
+	this->label = label;
+	
+	ID_generator++;
+}
+Score::Score(int score, string detail, Label label) :ID(Score::ID_generator) {
+	this->score = score;
+	this->label = label;
+	this->detail = detail;
 
+	ID_generator++;
+
+}
+Score::Score() :ID(Score::ID_generator) {
+	this->score = 0;
+	this->detail = "";
+	ID_generator++;
+}
+
+void Score::setID_generator(int num) { ID_generator = num; }
+
+Score& Score::operator=(const Score& S)
+{
+	this->score = S.score;
+	this->detail = S.detail;
+	this->label = S.label;
+
+	return *this;
+}
 
+void print(const Score& score)
+{
+	cout << endl << "ID      -> " << score.ID << endl;
+	cout << "Score   -> " << score.score << endl;
+	cout << "Lable   -> " << score.label << endl;
+	cout << "Detail  -> " << score.detail << endl;
+}
\ No newline at end of file
diff --git a/2/Score.h b/2/Score.h
index 0dd79cb..339f89b 100644
--- a/2/Score.h
+++ b/2/Score.h
@@ -1,8 +1,13 @@
+#pragma once
 #include <iostream>
 #include <string>
+
 using namespace std;
+
 class Score {
 public:
+
+	friend int main();
 	friend void print(const Score& score);
 	
 	typedef enum {
@@ -12,7 +17,15 @@ class Score {
 		BAD,
 	}Label;
 
+	Score();
 	Score(int score,  char* detail, Label label);
+	Score(int score, string detail, Label label);
+	Score(int score, const char* _detail, Label label);
+
+	Score& operator=(const Score& S);
+
+	static void setID_generator(int num);
+		
 private:
 	int score;
 	Label label;
diff --git a/2/main.cpp b/2/main.cpp
index 64d213e..6b3624d 100644
--- a/2/main.cpp
+++ b/2/main.cpp
@@ -5,7 +5,9 @@
 #include <algorithm>
 #include "Score.h"
 #include "SomeRandomDotHFile.h"
+
 using namespace std;
+
 #define FOR(n) for(int i=0;i<n;i++)
 #define SETSCORE(i) int score=rand()%20+1;/*no 0s*/\
 scores[i] = Score( score,("some string " + to_string(i)).c_str(),Score::Label(3-score/5)) ;