├── Module 1
    ├── .gitignore
    ├── float_output.cpp
    ├── header_file.cpp
    ├── input.cpp
    ├── min_max.cpp
    ├── output.cpp
    ├── string_input.cpp
    ├── swap.cpp
    ├── switch_case.cpp
    ├── switch_case_2.cpp
    ├── switch_case_3.cpp
    └── test.cpp
├── Module 2
    ├── .gitignore
    ├── dynamic_array.cpp
    ├── dynamic_array_size_increase.cpp
    ├── dynamic_data.cpp
    ├── return_array_from_function.cpp
    ├── static_data.cpp
    └── ternary_operator.cpp
├── Module 3
    ├── .gitignore
    ├── class_and_object.cpp
    ├── constructor.cpp
    ├── dynamic_object.cpp
    ├── return_object_from_function.cpp
    └── sorting.cpp
├── Module 5
    ├── .gitignore
    ├── capacity.cpp
    ├── element_access.cpp
    ├── iterator.cpp
    ├── modifiers.cpp
    ├── string.cpp
    ├── string_input_space.cpp
    └── stringstream.cpp
├── Module 6.5
    ├── .gitignore
    ├── P_Count_Words.cpp
    └── find.cpp
├── Module 6
    ├── .gitignore
    ├── dynamic_object_copy.cpp
    ├── function_in_class.cpp
    ├── namespaces.cpp
    ├── ranged_based_for_loop.cpp
    ├── reference.cpp
    ├── reverse_word_printing.cpp
    ├── sort_string.cpp
    ├── string_constructor.cpp
    └── this_keyword.cpp
├── Module 7
    ├── array_of_objects.cpp
    ├── counting_sort.cpp
    ├── custom_sort_using_frequency_object_array.cpp
    ├── max_from_objects.cpp
    ├── sort_array_using_selection_sort.cpp
    └── sort_array_using_sort_function.cpp
└── README.md


/Module 1/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 1/float_output.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<iomanip>
 3 | using namespace std;
 4 | int main()
 5 | {
 6 |     float a;
 7 |     cin>>a;
 8 |     cout<<fixed<<setprecision(2)<<a;
 9 |     return 0;
10 | }


--------------------------------------------------------------------------------
/Module 1/header_file.cpp:
--------------------------------------------------------------------------------
1 | #include<bits/stdc++.h>
2 | using namespace std;
3 | int main()
4 | {
5 |     
6 |     return 0;
7 | }


--------------------------------------------------------------------------------
/Module 1/input.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int a,b;
 6 |     // scanf("%d %d",&a,&b);
 7 |     cin>>a>>b;
 8 |     cout<<a<<"->"<<b<<endl;
 9 |     return 0;
10 | }


--------------------------------------------------------------------------------
/Module 1/min_max.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<algorithm>
 3 | using namespace std;
 4 | // int my_min(int a,int b)
 5 | // {
 6 | //     if(a<b) return a;
 7 | //     else return b;
 8 | // }
 9 | // int my_max(int a,int b)
10 | // {
11 | //     if(a>b) return a;
12 | //     else return b;
13 | // }
14 | int main()
15 | {
16 |     int a,b;
17 |     cin>>a>>b;
18 |     int mn=min(a,b);
19 |     int mx=max(a,b);
20 |     cout<<mn<<" "<<mx<<endl;
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/Module 1/output.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     // printf("Hello World"); -> for c
 6 |     // std::cout<<"Hello World";
 7 |     // std::cout<<"Hello\n";
 8 |     // std::cout<<"World\n";
 9 |     // std::cout<<"Hello "<<"World";
10 |     // std::cout<<"Hello"<<std::endl<<"World";
11 |     int a=100,b=200;
12 |     // printf("%d",a);
13 |     // std::cout<<a<<b;
14 |     cout<<a<<" "<<b<<endl;
15 |     return 0;
16 | }


--------------------------------------------------------------------------------
/Module 1/string_input.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<string.h>
 3 | using namespace std;
 4 | int main()
 5 | {
 6 |     char s[100];
 7 |     cin.getline(s,100);
 8 |     cout<<strlen(s);
 9 |     return 0;
10 | }


--------------------------------------------------------------------------------
/Module 1/swap.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<utility>
 3 | using namespace std;
 4 | // void my_swap(int *a,int *b)
 5 | // {
 6 | //     int tmp=*a;
 7 | //     *a=*b;
 8 | //     *b=tmp;
 9 | // }
10 | int main()
11 | {
12 |     int a,b;
13 |     cin>>a>>b;
14 |     swap(a,b);
15 |     cout<<a<<" "<<b<<endl;
16 |     return 0;
17 | }


--------------------------------------------------------------------------------
/Module 1/switch_case.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int v;
 6 |     cin>>v;
 7 |     switch(v)
 8 |     {
 9 |         case 1:
10 |             cout<<"One"<<endl;
11 |             break;
12 |         case 2:
13 |             cout<<"Two"<<endl;
14 |             break;
15 |         case 3:
16 |             cout<<"Three"<<endl;
17 |             break;
18 |         case 4:
19 |             cout<<"Four"<<endl;
20 |             break;
21 |         case 5:
22 |             cout<<"Five"<<endl;
23 |             break;
24 |         default:
25 |             cout<<"Didn't maatch"<<endl;
26 |     }
27 |     return 0;
28 | }


--------------------------------------------------------------------------------
/Module 1/switch_case_2.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     char a;
 6 |     cin>>a;
 7 |     switch(a)
 8 |     {
 9 |         case 'a':
10 |             cout<<"Vowel"<<endl;
11 |             break;
12 |         case 'e':
13 |             cout<<"Vowel"<<endl;
14 |             break;
15 |         case 'i':
16 |             cout<<"Vowel"<<endl;
17 |             break;
18 |         case 'o':
19 |             cout<<"Vowel"<<endl;
20 |             break;
21 |         case 'u':
22 |             cout<<"Vowel"<<endl;
23 |             break;
24 |         default:
25 |             cout<<"Consonant"<<endl;
26 |     }
27 |     return 0;
28 | }


--------------------------------------------------------------------------------
/Module 1/switch_case_3.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int a;
 6 |     cin>>a;
 7 |     switch(a%2) // 0 or 1
 8 |     {
 9 |         case 0:
10 |             cout<<"Even"<<endl;
11 |             break;
12 |         default:
13 |             cout<<"Odd"<<endl;
14 |     }
15 |     return 0;
16 | }


--------------------------------------------------------------------------------
/Module 1/test.cpp:
--------------------------------------------------------------------------------
1 | #include<stdio.h>
2 | int main()
3 | {
4 |     printf("Hello");
5 |     return 0;
6 | }


--------------------------------------------------------------------------------
/Module 2/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 2/dynamic_array.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int * a=new int[5]; // int a[5]
 6 |     for(int i=0;i<5;i++)
 7 |     {
 8 |         cin>>a[i];
 9 |     }
10 |     for(int i=0;i<5;i++)
11 |     {
12 |         cout<<a[i]<<" ";
13 |     }
14 |     return 0;
15 | }


--------------------------------------------------------------------------------
/Module 2/dynamic_array_size_increase.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int *a=new int[5];
 6 |     for(int i=0;i<5;i++) 
 7 |     {
 8 |         cin>>a[i];
 9 |     }
10 |     int *b=new int[7];
11 |     for(int i=0;i<5;i++)
12 |     {
13 |         b[i]=a[i];
14 |     }
15 |     b[5]=60;
16 |     b[6]=70;
17 |     for(int i=0;i<7;i++)
18 |     {
19 |         cout<<b[i]<<" ";
20 |     }
21 |     cout<<endl;
22 |     // delete a array
23 |     delete[] a;
24 |     for(int i=0;i<5;i++)
25 |     {
26 |         cout<<a[i]<<" ";
27 |     }
28 |     return 0;
29 | }


--------------------------------------------------------------------------------
/Module 2/dynamic_data.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     // int * a=new int; // syntax
 6 |     // *a=10;
 7 |     // cout<<*a<<endl;
 8 | 
 9 |     float * f=new float;
10 |     *f=2.56;
11 |     cout<<*f<<endl;
12 |     delete f;// delete 
13 |     return 0;
14 | }


--------------------------------------------------------------------------------
/Module 2/return_array_from_function.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int* fun()
 4 | {
 5 |     int *a=new int[5];
 6 |     // int a[5];
 7 |     for(int i=0;i<5;i++)
 8 |     {
 9 |         cin>>a[i];
10 |     }
11 |     return a;
12 | }
13 | int main()
14 | {
15 |     int *a=fun();
16 |     for(int i=0;i<5;i++)
17 |     {
18 |         cout<<a[i]<<" ";
19 |     }
20 |     cout<<endl;
21 |     
22 |     
23 |     // code
24 |     return 0;
25 | }


--------------------------------------------------------------------------------
/Module 2/static_data.cpp:
--------------------------------------------------------------------------------
1 | #include<bits/stdc++.h>
2 | using namespace std;
3 | int main()
4 | {
5 |     int x=10;
6 |     return 0;
7 | }


--------------------------------------------------------------------------------
/Module 2/ternary_operator.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int x=10;
 6 |     // if(x%2==0)
 7 |     // {
 8 |     //     cout<<"Even";
 9 |     // }
10 |     // else 
11 |     // {
12 |     //     cout<<"Odd";
13 |     // }
14 |     // ternary
15 |     (x%2==0)? cout<<"Even" : cout<<"Odd";
16 |     return 0;
17 | }


--------------------------------------------------------------------------------
/Module 3/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 3/class_and_object.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | class Student
 4 | {
 5 |     public:
 6 |         char name[100];
 7 |         int roll;
 8 |         int cls;
 9 |         char section;
10 | };
11 | int main()
12 | {
13 |     Student rahim;
14 |     rahim.roll=29;
15 |     rahim.cls=9;
16 |     rahim.section='A';
17 |     char nm[100]="Rahim Uddin";
18 |     strcpy(rahim.name,nm);
19 | 
20 |     Student karim;
21 |     karim.roll=55;
22 |     karim.cls=9;
23 |     karim.section='C';
24 |     char nm2[100]="Karim Cholimulla";
25 |     strcpy(karim.name,nm2);
26 | 
27 |     cout<<rahim.roll;
28 |     return 0;
29 | }


--------------------------------------------------------------------------------
/Module 3/constructor.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | class Student
 4 | {
 5 |     public:
 6 |         char name[100];
 7 |         int roll;
 8 |         int cls;
 9 |         char section;
10 | 
11 |         Student(int r,char s,int c,char* n)
12 |         {
13 |             roll=r;
14 |             section=s;
15 |             cls=c;
16 |             strcpy(name,n);
17 |         }
18 | };
19 | int main()
20 | {
21 |     Student rahim(29,'A',7,"Rahim Ullah");
22 |     Student karim(55,'D',7,"Karim Cholimullah");
23 |     
24 |     
25 | 
26 |     cout<<karim.roll<<endl;
27 |     cout<<rahim.roll<<endl;
28 |     return 0;
29 | }


--------------------------------------------------------------------------------
/Module 3/dynamic_object.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | class Student
 4 | {
 5 |     public:
 6 |         char name[100];
 7 |         int roll;
 8 |         int cls;
 9 |         char section;
10 | 
11 |         Student(int r,char s,int c,char* n)
12 |         {
13 |             roll=r;
14 |             section=s;
15 |             cls=c;
16 |             strcpy(name,n);
17 |         }
18 | };
19 | int main()
20 | {
21 |     char name[100]="Rahim Ullah";
22 |     // Student rahim(5,'A',11,name);
23 |     Student* rahim = new Student(5,'A',11,name);
24 |     (*rahim).roll=55;
25 | 
26 |     // int * a = new int;
27 |     // *a=10;
28 |     // cout<<*a<<endl;
29 | 
30 |     // cout<<(*rahim).name<<endl;
31 |     // cout<<(*rahim).roll<<endl;
32 |     // cout<<(*rahim).section<<endl;
33 |     // cout<<(*rahim).cls<<endl;
34 | 
35 |     // shortcut upay
36 |     // arrow sign
37 |     // (*rahim). = rahim->
38 | 
39 |     cout<<rahim->name<<endl;
40 |     cout<<rahim->roll<<endl;
41 |     cout<<rahim->section<<endl;
42 |     cout<<rahim->cls<<endl;
43 | 
44 |     // delete an object 
45 |     delete rahim;
46 | 
47 |     cout<<rahim->name<<endl;
48 |     cout<<rahim->roll<<endl;
49 |     cout<<rahim->section<<endl;
50 |     cout<<rahim->cls<<endl;
51 |     return 0;
52 | }


--------------------------------------------------------------------------------
/Module 3/return_object_from_function.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | class Student
 4 | {
 5 |     public:
 6 |         char name[100];
 7 |         int roll;
 8 |         int cls;
 9 |         char section;
10 | 
11 |         Student(int r,char s,int c,char* n)
12 |         {
13 |             roll=r;
14 |             section=s;
15 |             cls=c;
16 |             strcpy(name,n);
17 |         }
18 | };
19 | Student fun()
20 | {
21 |     char name[100]="Rahim Ullah";
22 |     Student r(29,'C',7,name);
23 |     return r;
24 | }
25 | int main()
26 | {
27 |     Student rahim=fun();
28 | 
29 |     cout<<rahim.name<<endl;
30 |     cout<<rahim.roll<<endl;
31 |     cout<<rahim.section<<endl;
32 |     cout<<rahim.cls<<endl;
33 |     return 0;
34 | }


--------------------------------------------------------------------------------
/Module 3/sorting.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n; 
 6 |     cin>>n;
 7 |     int a[n];
 8 |     for(int i=0;i<n;i++)
 9 |     {
10 |         cin>>a[i];
11 |     }
12 |     // sorting ascending
13 |     // sort(a,a+n);
14 |     // sorting descending
15 |     // sort(a,a+n,greater<int>());
16 |     for(int i=0;i<n;i++)
17 |     {
18 |         cout<<a[i]<<" ";
19 |     }
20 |     return 0;
21 | }


--------------------------------------------------------------------------------
/Module 5/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 5/capacity.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     // string s="Hello World";
 6 |     // cout<<s.size()<<endl;
 7 |     // cout<<s.max_size()<<endl;
 8 |     // string a="bfujdbkjvfdshjbjfbjbsdjkbfb hfgbkbjbjfbjb";
 9 |     // cout<<a.capacity()<<endl;
10 |     // a="hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh";
11 |     // cout<<a.capacity()<<endl;
12 |     // cout<<a.size()<<endl;
13 | 
14 |     // string s="Hello";
15 |     // cout<<s<<endl;
16 |     // s.clear();
17 |     // cout<<s<<endl;
18 |     // cout<<s.size()<<endl;
19 | 
20 |     // string s="Hello";
21 |     // s.clear();
22 |     // if(s.empty()==true) cout<<"Empty"<<endl;
23 |     // else cout<<"Not Empty"<<endl;
24 | 
25 |     string s;
26 |     cin>>s;
27 |     // s.resize(5);
28 |     // s.resize(20,'X');
29 |     // cout<<s.size()<<endl;
30 |     // cout<<s<<endl;
31 |     s.resize(5);
32 |     cout<<s<<endl;
33 |     s.resize(11,'X');
34 |     cout<<s<<endl;
35 |     return 0;
36 | }


--------------------------------------------------------------------------------
/Module 5/element_access.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     string s;
 6 |     cin>>s;
 7 |     cout<<s[0]<<endl;
 8 |     cout<<s.at(0)<<endl;
 9 |     cout<<s[s.size()-1]<<endl;
10 |     cout<<s.back()<<endl;
11 |     cout<<s.front()<<endl;
12 |     return 0;
13 | }


--------------------------------------------------------------------------------
/Module 5/iterator.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     string s;
 6 |     cin>>s;
 7 |     // for(int i=0;i<s.size();i++)
 8 |     // {
 9 |     //     cout<<s[i]<<endl;
10 |     // }
11 |     // cout<<*s.begin()<<endl;
12 |     // cout<<*(s.end()-1)<<endl;
13 |     for(auto it=s.begin();it<s.end();it++)
14 |     {
15 |         cout<<*it<<endl;
16 |     }
17 |     return 0;
18 | }


--------------------------------------------------------------------------------
/Module 5/modifiers.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     // string a="Hello";
 6 |     // string b="A";
 7 |     // a+=b;
 8 |     // a.append(b);
 9 |     // cout<<a<<endl;
10 |     // cout<<b<<endl;
11 |     // a="HelloA"; -> works
12 |     // a=a+"A"; -> works
13 |     // a[5]='A'; -> didn't work
14 |     // a.push_back('A'); // works
15 |     // a.pop_back();
16 |     // a.pop_back();
17 |     // cout<<a<<endl;
18 | 
19 |     // a="Gelo";
20 |     // a.assign("Gelo");
21 |     // cout<<a<<endl;
22 | 
23 | 
24 |     string a="HelloWorld";
25 |     // a.erase(4,3);
26 |     a.replace(5,0,"so");
27 |     // a.insert(5,"Rahat");
28 |     cout<<a<<endl;
29 |     return 0;
30 | }


--------------------------------------------------------------------------------
/Module 5/string.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     string s1="Hello";
 6 |     string s2="hello";
 7 |     if(s1 == s2)
 8 |     {
 9 |         cout<<"Same"<<endl;
10 |     }
11 |     else 
12 |     {
13 |         cout<<"Not Same"<<endl;
14 |     }
15 |     return 0;
16 | }


--------------------------------------------------------------------------------
/Module 5/string_input_space.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int x;
 6 |     cin>>x;
 7 |     // cin.ignore();
 8 |     getchar();
 9 |     string s;
10 |     // cin>>s;
11 |     // cin.getline(s,100); char s[100];
12 |     getline(cin,s);
13 |     cout<<x<<endl;
14 |     cout<<s<<endl;
15 |     return 0;
16 | }


--------------------------------------------------------------------------------
/Module 5/stringstream.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     string s;
 6 |     getline(cin,s);
 7 |     stringstream ss;
 8 |     ss<<s;
 9 |     string word;
10 |     int cnt=0;
11 |     while(ss >> word)
12 |     {
13 |         cnt++;
14 |     }
15 |     cout<<cnt<<endl;
16 |     
17 |     return 0;
18 | }


--------------------------------------------------------------------------------
/Module 6.5/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 6.5/P_Count_Words.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     string s;
 6 |     getline(cin,s);
 7 |     bool inside_word=false;
 8 |     int cnt=0;
 9 |     for(char c:s)
10 |     {
11 |         if(isalpha(c))
12 |         {
13 |             if(inside_word==false)
14 |             {
15 |                 cnt++;
16 |             }
17 |             inside_word=true;
18 |         }
19 |         else
20 |         {
21 |             inside_word=false;
22 |         }
23 |     }
24 |     cout<<cnt<<endl;
25 |     return 0;
26 | }


--------------------------------------------------------------------------------
/Module 6.5/find.cpp:
--------------------------------------------------------------------------------
1 | #include<bits/stdc++.h>
2 | using namespace std;
3 | int main()
4 | {
5 |     string s="BRITISHEGYPTGHANA";
6 |     int t=s.find("EGYPT");
7 |     cout<<t<<endl;
8 |     return 0;
9 | }


--------------------------------------------------------------------------------
/Module 6/.gitignore:
--------------------------------------------------------------------------------
1 | .cph/
2 | .vscode/
3 | *.txt
4 | *.exe
5 | *.bin


--------------------------------------------------------------------------------
/Module 6/dynamic_object_copy.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | class Person
 4 | {
 5 |     public:
 6 |         string name;
 7 |         int age;
 8 |         Person(string name,int age)
 9 |         {
10 |             this->name=name;
11 |             this->age=age;
12 |         }
13 | };
14 | int main()
15 | {
16 |     Person* rakib=new Person("Rakib Ahsan",25);
17 |     Person* sakib=new Person("Sakib Ahamed",23);
18 | 
19 |     // rakib=sakib;
20 |     // rakib->name=sakib->name;
21 |     // rakib->age=sakib->age;
22 |     *rakib=*sakib;
23 |     delete sakib;
24 |     cout<<rakib->name<<" "<<rakib->age<<endl;
25 |     return 0;
26 | }


--------------------------------------------------------------------------------
/Module 6/function_in_class.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | class Person
 4 | {
 5 |     public:
 6 |         string name;
 7 |         int age;
 8 |         int marks1;
 9 |         int marks2;
10 |         Person(string nm,int ag,int m1,int m2)
11 |         {
12 |             name=nm;
13 |             age=ag;
14 |             marks1=m1;
15 |             marks2=m2;
16 |         }
17 |         void hello()
18 |         {
19 |             cout<<name<< " " <<age<<endl;
20 |         }
21 |         int total_marks()
22 |         {
23 |             return marks1+marks2;
24 |         }
25 | };
26 | int main()
27 | {
28 |     Person rakib("Rakib Ahsan",24,95,85);
29 |     cout<<rakib.name<<endl;
30 |     return 0;
31 | }


--------------------------------------------------------------------------------
/Module 6/namespaces.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | namespace Rakib
 4 | {
 5 |     int age=24;
 6 |     void hello()
 7 |     {
 8 |         cout<<"Rakib namespaces"<<endl;
 9 |     }
10 | }
11 | namespace Sakib
12 | {
13 |     int age=30;
14 |     void hello()
15 |     {
16 |         cout<<"Sakib namespaces"<<endl;
17 |     }
18 | }
19 | using namespace Rakib;
20 | int main()
21 | {
22 |     cout<<age<<endl;
23 |     hello();
24 |     Sakib::hello();
25 |     return 0;
26 | }


--------------------------------------------------------------------------------
/Module 6/ranged_based_for_loop.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     string s;
 6 |     cin>>s;
 7 |     // for(int i=0;i<s.size();i++)
 8 |     // {
 9 |     //     cout<<s[i]<<endl;
10 |     // }
11 |     for(char c:s)
12 |     {
13 |         cout<<c<<endl;
14 |     }
15 |     return 0;
16 | }


--------------------------------------------------------------------------------
/Module 6/reference.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | void print(string s)
 4 | {
 5 |     s="world";
 6 | }
 7 | int main()
 8 | {
 9 |     string s="hello";
10 |     print(s);
11 |     cout<<s<<endl;
12 |     return 0;
13 | }


--------------------------------------------------------------------------------
/Module 6/reverse_word_printing.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | void print(stringstream& ss)
 4 | {
 5 |     string word;
 6 |     if(ss>>word)
 7 |     {
 8 |         
 9 |         print(ss);
10 |         cout<<word<<endl;
11 |     }
12 | }
13 | int main()
14 | {
15 |     string s;
16 |     getline(cin,s);
17 |     stringstream ss(s);
18 |     print(ss);
19 |     return 0;
20 | }


--------------------------------------------------------------------------------
/Module 6/sort_string.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     string s;
 6 |     cin>>s;
 7 |     sort(s.begin(),s.end());
 8 |     cout<<s<<endl;
 9 |     return 0;
10 | }


--------------------------------------------------------------------------------
/Module 6/string_constructor.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     // string s="hello world";
 6 |     // 1
 7 |     // string s("hello world");
 8 |     // 2
 9 |     // string s("hello world",7);
10 |     // 3
11 |     // string a="hello world";
12 |     // string s(a,4);
13 |     // 4
14 |     string s(26,'A');
15 |     cout<<s<<endl;
16 |     return 0;
17 | }


--------------------------------------------------------------------------------
/Module 6/this_keyword.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | class Person
 4 | {
 5 |     public:
 6 |         string name;
 7 |         int age;
 8 |         Person(string name,int age)
 9 |         {
10 |             this->name=name;
11 |             this->age=age;
12 |         }
13 |         void hello()
14 |         {
15 |             cout<<"Hello"<<endl;
16 |         }
17 | };
18 | int main()
19 | {
20 |     Person rakib("Rakib Ahsan",24);
21 |     cout<<rakib.name<<" "<<rakib.age<<endl;
22 |     return 0;
23 | }


--------------------------------------------------------------------------------
/Module 7/array_of_objects.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | class Student
 4 | {
 5 |     public:
 6 |         string name;
 7 |         int roll;
 8 |         int marks;
 9 | };
10 | int main()
11 | {
12 |     Student a[3];
13 |     for(int i=0;i<3;i++)
14 |     {
15 |         getline(cin,a[i].name);
16 |         cin>>a[i].roll>>a[i].marks;
17 |         cin.ignore();
18 |     }
19 |     for(int i=0;i<3;i++)
20 |     {
21 |         cout<<a[i].name<<" "<<a[i].roll<<" "<<a[i].marks<<endl;
22 |     }
23 |     return 0;
24 | }


--------------------------------------------------------------------------------
/Module 7/counting_sort.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n; 
 6 |     cin>>n;
 7 |     int frq[26]={0};
 8 |     for(int i=0;i<n;i++)
 9 |     {
10 |         char a;
11 |         cin>>a;
12 |         frq[a-'a']++;
13 |     }
14 |     for(char i='a';i<='z';i++)
15 |     {
16 |         if(frq[i-'a'] > 0)
17 |         {
18 |             for(int j=0;j<frq[i-'a'];j++)
19 |             {
20 |                 cout<<i;
21 |             }
22 |         }
23 |     }
24 |     return 0;
25 | }


--------------------------------------------------------------------------------
/Module 7/custom_sort_using_frequency_object_array.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | class CustomSort
 4 | {
 5 |     public:
 6 |         char c;
 7 |         int cnt;
 8 | };
 9 | bool cmp(CustomSort a, CustomSort b)
10 | {
11 |     if(a.cnt > b.cnt) return true;
12 |     else return false;
13 | }
14 | int main()
15 | {
16 |     int n; 
17 |     cin>>n;
18 |     // int frq[26]={0};
19 |     CustomSort frq[26];
20 |     for(int i=0;i<26;i++)
21 |     {
22 |         frq[i].c=(i+'a');
23 |         frq[i].cnt=0;
24 |     }
25 |     for(int i=0;i<n;i++)
26 |     {
27 |         char c;
28 |         cin>>c;
29 |         frq[c-'a'].cnt++;
30 |     }
31 |     sort(frq,frq+26,cmp);
32 |     for(int i=0;i<26;i++)
33 |     {
34 |         if(frq[i].cnt>0)
35 |         {
36 |             for(int j=0;j<frq[i].cnt;j++)
37 |             {
38 |                 cout<<frq[i].c;
39 |             }
40 |         }
41 |     }
42 |     return 0;
43 | }


--------------------------------------------------------------------------------
/Module 7/max_from_objects.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | class Student
 4 | {
 5 |     public:
 6 |         string name;
 7 |         int roll;
 8 |         int marks;
 9 | };
10 | int main()
11 | {
12 |     Student a[3];
13 |     for(int i=0;i<3;i++)
14 |     {
15 |         getline(cin,a[i].name);
16 |         cin>>a[i].roll>>a[i].marks;
17 |         cin.ignore();
18 |     }
19 |     Student mx;
20 |     mx.marks=INT_MIN;
21 |     for(int i=0;i<3;i++)
22 |     {
23 |         if(a[i].marks>mx.marks)
24 |         {
25 |             mx=a[i];
26 |         }
27 |     }
28 |     cout<<mx.name<<" "<<mx.roll<<" "<<mx.marks<<endl;
29 | 
30 |     Student mn;
31 |     mn.marks=INT_MAX;
32 |     for(int i=0;i<3;i++)
33 |     {
34 |         if(a[i].marks<mn.marks)
35 |         {
36 |             mn=a[i];
37 |         }
38 |     }
39 |     cout<<mn.name<<" "<<mn.roll<<" "<<mn.marks<<endl;
40 |     return 0;
41 | }


--------------------------------------------------------------------------------
/Module 7/sort_array_using_selection_sort.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | class Student
 4 | {
 5 |     public:
 6 |         string name;
 7 |         int roll;
 8 |         int marks;
 9 | };
10 | int main()
11 | {
12 |     Student a[3];
13 |     for(int i=0;i<3;i++)
14 |     {
15 |         getline(cin,a[i].name);
16 |         cin>>a[i].roll>>a[i].marks;
17 |         cin.ignore();
18 |     }
19 |     for(int i=0;i<2;i++)
20 |     {
21 |         for(int j=i+1;j<3;j++)
22 |         {
23 |             if(a[i].roll > a[j].roll)
24 |             {
25 |                 swap(a[i],a[j]);
26 |             }
27 |         }
28 |     }
29 |     for(int i=0;i<3;i++)
30 |     {
31 |         cout<<a[i].name<<" "<<a[i].roll<<" "<<a[i].marks<<endl;
32 |     }
33 |     return 0;
34 | }


--------------------------------------------------------------------------------
/Module 7/sort_array_using_sort_function.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | class Student
 4 | {
 5 |     public:
 6 |         string name;
 7 |         int roll;
 8 |         int marks;
 9 | };
10 | bool cmp(Student a,Student b)
11 | {
12 |     if(a.marks > b.marks) return true;
13 |     else return false;
14 | }
15 | int main()
16 | {
17 |     Student a[3];
18 |     for(int i=0;i<3;i++)
19 |     {
20 |         getline(cin,a[i].name);
21 |         cin>>a[i].roll>>a[i].marks;
22 |         cin.ignore();
23 |     }
24 |     // sort function
25 |     sort(a,a+3,cmp);
26 |     for(int i=0;i<3;i++)
27 |     {
28 |         cout<<a[i].name<<" "<<a[i].roll<<" "<<a[i].marks<<endl;
29 |     }
30 |     return 0;
31 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Batch-3-Introduction-to-cpp-for-DSA
2 | 


--------------------------------------------------------------------------------