├── 01_datatypes
    └── datatypes.cpp
├── 02_if else
    ├── I_01_if else.cpp
    ├── I_02_if elseif else.cpp
    ├── I_03_armstrong no.cpp
    ├── I_04_nested if else (check max).cpp
    ├── I_05_oddeven.cpp
    ├── I_06_triangle type.cpp
    └── I_07_vowels and consonants.cpp
├── 03_loops
    ├── L_01_while loop for 10 times.cpp
    ├── L_02_while loop 2 conditions.cpp
    ├── L_03_infinite loop.cpp
    ├── L_04_even nos.cpp
    ├── L_05_natural nos.cpp
    └── L_06_odd nos below 10.cpp
├── 04_break continue
    ├── 03_prime non prime.cpp
    ├── 04_odd even.cpp
    ├── BC_01_ continue statement.cpp
    └── BC_02_break statement.cpp
├── 05_switch
    ├── 01_basic.cpp
    └── 02_calculator.cpp
├── 06_operators
    ├── O_01_ pre increment.cpp
    ├── O_02_post decrement.cpp
    ├── O_03_pre+post increment.cpp
    ├── O_04_ incr pre post mix prob.cpp
    ├── O_05_relational.cpp
    ├── O_05_relational_more than or equal to.cpp
    ├── O_06_logical_div by both 2 and 3.cpp
    └── O_07_(bitwise,assign,misc).cpp
├── 07_patterns
    ├── P_01_inverted no.cpp
    ├── P_02_zero one.cpp
    ├── P_03_no pyramid.cpp
    ├── P_04_solid rhombus.cpp
    ├── P_05_pascals triangle.cpp
    ├── P_06_rectangle.cpp
    ├── P_07_hollow rectangle.cpp
    ├── P_08_inverted half pyramid.cpp
    ├── P_09_half pyramid 180 rotation.cpp
    ├── P_10_half pyramid using nos.cpp
    ├── P_12_butterfly.cpp
    └── P_13_play button.cpp
├── 08_functions
    ├── 09_prime sieve.cpp
    ├── 10_prime factorization.cpp
    ├── F_01_1st n natural nos.cpp
    ├── F_02_ pythogorean triplet.cpp
    ├── F_03_euclid algo to find GCD.cpp
    ├── F_04_calculate ncr.cpp
    ├── F_05_factorial.cpp
    ├── F_06_fibenacci sequence.cpp
    ├── F_07_ print all primes btw 2 nos.cpp
    └── F_08_inclusion exclusion principle.cpp
├── 09_array
    ├── A_00_basic.cpp
    ├── A_01_maximum till i.cpp
    ├── A_02_ first repeating element.cpp
    ├── A_03_smalest positive missing.cpp
    └── A_04_find  min & max.cpp
├── 10_pointers
    ├── P_16_pointers and arrays.cpp
    ├── P_17_pointer  arithmetic.cpp
    ├── P_18_ basic.cpp
    ├── P_19_pointer  to pointer.cpp
    ├── P_20_pointer  to functions1.cpp
    └── P_21_pointer  to functions2.cpp
├── 11_strings
    ├── S_01_convert to upper and lower cases.cpp
    ├── S_02_upper case transform.cpp
    ├── S_03_biggest no from numeric s.cpp
    ├── S_04_occur max times.cpp
    ├── S_05_string declaration types 3.cpp
    ├── S_06_string functions 15.cpp
    └── S_07_balanced  parentheses.cpp
├── LICENSE
└── README.md


/01_datatypes/datatypes.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | 
 6 | 
 7 | */
 8 | 
 9 | #include<iostream>
10 | using namespace std;
11 | 
12 | int main(){
13 | 
14 |     int a; //declaration
15 |     a=12; //initialisation
16 | 
17 |     cout<<"size of int "<<sizeof(a)<<endl;
18 | 
19 |     float b;
20 |     cout<<"size of float "<<sizeof(b)<<endl;
21 | 
22 |     char c;
23 |     cout<<"size of char "<<sizeof(c)<<endl;
24 | 
25 |     bool d;
26 |     cout<<"size of bool "<<sizeof(d)<<endl;
27 | 
28 |     short int si;
29 |     long int li;
30 |     cout<<"size of shortint "<<sizeof(si)<<endl;
31 |     cout<<"size of longint "<<sizeof(li)<<endl;
32 | 
33 |     
34 | 
35 |     return 0;
36 | }
37 | 


--------------------------------------------------------------------------------
/02_if else/I_01_if else.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | // if else
 4 | 
 5 | #include<iostream>
 6 | using namespace std;
 7 | 
 8 | int main()
 9 | {
10 | 	int n=15;
11 | 	if(n>10)
12 | 	{
13 | 		cout<<"greater";
14 | 	}
15 | 	else
16 | 	{
17 | 		cout<<"smaller";
18 | 	}
19 | 	return 0;
20 | }
21 | 
22 | //greater
23 | 


--------------------------------------------------------------------------------
/02_if else/I_02_if elseif else.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | print greater than elements
 5 | use if else lader
 6 | 
 7 | */
 8 | 
 9 | 
10 | //IF-ELSEIF-ELSE
11 | 
12 | #include<iostream>
13 | using namespace std;
14 | 
15 | int main ()
16 | {
17 | 	int tt;
18 | 	cin>>tt;
19 | 	while(tt--){
20 | 		
21 | 	int n;
22 | 	cin>>n;
23 | 	
24 | 	if(n>1 && n<10)
25 |       cout<<"greater than 1 and less than 10";
26 | 		
27 | 	else if (n>=20 && n<=30)
28 | 		cout<<"greater than 20 nad less than 30 ";
29 | 		
30 | 	else
31 | 		cout<<"greater than 30";
32 | 	}
33 | 	return 0;
34 | }
35 | 
36 | //
37 | //3
38 | //2
39 | //greater than 1 and less than 10
40 | //21
41 | //greater than 20 nad less than 30
42 | //65
43 | //greater than 30
44 | 
45 | 


--------------------------------------------------------------------------------
/02_if else/I_03_armstrong no.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //armstrong number (cubes and add)
 4 | 
 5 | 
 6 | //Armstrong number is a number that is equal to the sum of cubes of its digits. 
 7 | //For example 0, 1, 153, 370, 371 and 407 are the Armstrong numbers
 8 | 
 9 | #include<iostream>
10 | #include<math.h>
11 | using namespace std;
12 | 
13 | int main(){
14 | 	int n;
15 | 	cin>>n;
16 | 	
17 | 	int sum=0;
18 | 	int originaln=n;
19 | 	while(n>0){
20 | 		int lastdigit = n%10;
21 | 		sum+= pow(lastdigit, 3);
22 | 		n = n/10;
23 | 	}
24 | 	
25 | 	if(sum==originaln){
26 | 		cout<<"armstrong"<<endl;
27 | 	}
28 | 	else{
29 | 		cout<<"not armstrong"<<endl;
30 | 	}
31 | 	
32 | 	
33 | 	return 0;
34 | }
35 | 
36 | //
37 | //20
38 | //not armstrong
39 | 


--------------------------------------------------------------------------------
/02_if else/I_04_nested if else (check max).cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | check the maximum from three given numbers
 6 | using nested if else
 7 | 
 8 | */
 9 | 
10 | 
11 | #include<bits/stdc++.h>
12 | 
13 | using namespace std;
14 | 
15 | int main()
16 | {
17 | 	int a,b,c;
18 | 	cin>>a>>b>>c;
19 | 	
20 | 	//a is greater than b
21 | 	if(a>b){
22 | 		if(a>c){
23 | 			cout<<a<<endl;
24 | 		}
25 | 		else{
26 | 			cout<<c<<endl;
27 | 		}
28 | 	}
29 | 	
30 | 	//b is greater than a (compare b and c)
31 | 	else {
32 | 		if(b>c)
33 | 			cout<<b<<endl;
34 | 		else
35 | 			cout<<c<<endl;
36 | 		}
37 | 	
38 |      return 0;
39 | }
40 | 
41 | 
42 | //12 56 32
43 | 
44 | //56
45 | 
46 | 


--------------------------------------------------------------------------------
/02_if else/I_05_oddeven.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | check if it odd or even using 
 6 | if lese statements
 7 | 
 8 | */
 9 | 
10 | 
11 | #include<bits/stdc++.h>
12 | 
13 | using namespace std;
14 | 
15 | int main()
16 | {
17 | 	int n;
18 | 	cin>>n;
19 | 	
20 | 	if(n%2!=0)
21 | 		cout<<"odd"<<endl;
22 | 	else
23 | 		cout<<"even"<<endl;
24 | 		
25 |      return 0;
26 | }
27 | 
28 | 


--------------------------------------------------------------------------------
/02_if else/I_06_triangle type.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | //which type of triangle it is
 3 | 
 4 | #include <iostream>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 | 
10 |     int sidea, sideb, sidec;
11 |     cout << "Input three sides of triangle: \n ";
12 |     cin >> sidea >> sideb >> sidec;
13 | 
14 |     if (sidea == sideb && sideb == sidec)
15 |     {
16 |         cout << "This is an equilateral triangle. \n ";
17 |     }
18 |     else if (sidea == sideb || sidea == sidec || sideb == sidec)
19 |     {
20 |         cout << "This is an isosceles triangle. \n ";
21 |     }
22 |     else
23 |     {
24 |         cout << "This is a scalene triangle. \n ";
25 |     }
26 | 
27 |     return 0;
28 | }
29 | 
30 | 
31 | // 12 3 4
32 | //This is a scalene triangle.
33 | 
34 | // 1 2 2
35 | //This is an isosceles triangle.
36 | 
37 | // 12 12 12
38 | //This is an equilateral triangle.
39 | 


--------------------------------------------------------------------------------
/02_if else/I_07_vowels and consonants.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | 
 6 | 
 7 | */
 8 | 
 9 | 
10 | #include <iostream>
11 | using namespace std;
12 | 
13 | int main()
14 | {
15 |     char c;
16 |     int isLowercaseVowel, isUppercaseVowel;
17 | 
18 |     cout << "Enter an alphabet: ";
19 |     cin >> c;
20 | 
21 |     isLowercaseVowel = (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u');
22 | 
23 |     isUppercaseVowel = (c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U');
24 | 
25 |     if (isLowercaseVowel || isUppercaseVowel)
26 |         cout << c << " is a vowel.";
27 |     else
28 |         cout << c << " is a consonant.";
29 | 
30 |     return 0;
31 | }
32 | 
33 | 
34 | //Enter an alphabet: a
35 | //a is a vowel.
36 | 
37 | //Enter an alphabet: k
38 | //k is a consonant.
39 | 
40 | 


--------------------------------------------------------------------------------
/03_loops/L_01_while loop for 10 times.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //while loop
 4 | //infinite loop for 10 times
 5 | 
 6 | #include<iostream>
 7 | 
 8 | using namespace std;
 9 | 
10 | int main()
11 | {
12 | 	int i=0;  //i is just our varibal
13 | 	while(i<10)
14 | 	{
15 | 		cout<<"hi"<<endl;
16 | 		i++;
17 | 	}
18 | 	return 0;
19 | }
20 | 
21 | //hi
22 | //hi
23 | //hi
24 | //hi
25 | //hi
26 | //hi
27 | //hi
28 | //hi
29 | //hi
30 | //hi
31 | 


--------------------------------------------------------------------------------
/03_loops/L_02_while loop 2 conditions.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | //author :shreyamalogi
 3 | 
 4 | /*
 5 | 
 6 | while loop satisfying both thec conditions
 7 | for 10 times with test cases
 8 | 
 9 | */
10 | 
11 | 
12 | #include<iostream>
13 | 
14 | using namespace std;
15 | 
16 | int main()
17 | {
18 | 	int t;
19 | 	cin>>t;
20 | 	while(t--){
21 | 	
22 | 	int i;
23 | 	cin>>i;
24 | 	while(i<10 && i>5)
25 | 	{
26 | 		cout<<"hi"<<endl;
27 | 		i++;
28 | 	}
29 | 	
30 | }
31 | 	return 0;
32 | }
33 | 
34 | 
35 | //4 test cases
36 | //2 no output
37 | //6 6 ki 4 his ostai
38 | //hi
39 | //hi
40 | //hi
41 | //hi
42 | //7  7 ki 3 times hi
43 | //hi
44 | //hi
45 | //hi
46 | //3  3 ki no output cuz it is less rthan 5
47 | 
48 | 
49 | 


--------------------------------------------------------------------------------
/03_loops/L_03_infinite loop.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | 
 6 | 
 7 | */
 8 | 
 9 | //WHILE LOOP infinite loop
10 | 
11 | #include<iostream>
12 | using namespace std;
13 | 
14 | int main()
15 | {
16 | 	while(1)  //no condition so it goes into infinite loop
17 | 	{
18 | 		cout<<"hi";
19 | 	}
20 | 	return 0;
21 | }
22 | 
23 | 
24 | 
25 | 
26 | //hihihihihihihihihihihihihihihihihihihihihihihihihihihi
27 | 
28 | 
29 | 


--------------------------------------------------------------------------------
/03_loops/L_04_even nos.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //print even numbers upto 10th element
 4 | //by using for loop
 5 | 
 6 | #include<iostream>
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 | 	for(int i=1; i<=10; i++) 		//equal to symbol is compulsory without which we get onnly 9 elements
12 | 	{
13 | 		cout<<i*2<<" ";  			//variable should be multiplied by 2 in order to get even
14 | 	}
15 | 	return 0;
16 | }
17 | 
18 | //2 4 6 8 10 12 14 16 18 20
19 | //0 2 4 6 8 10 12 14 16 18 20    if i=0 (if we include 0 also)
20 | 


--------------------------------------------------------------------------------
/03_loops/L_05_natural nos.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | 
 4 | //FOR LOOP to print n natural nos upto 10
 5 | 
 6 | #include<iostream>
 7 | 
 8 | using namespace std;
 9 | int main()
10 | {
11 | 	for(int i=0 ;i<10 ;i++ )
12 | 	{
13 | 		cout<<i+1<<" ";   //natural numbers start with i+1 i.e 0+1
14 | 	}
15 | 	return 0;
16 | }
17 | 
18 | //1 2 3 4 5 6 7 8 9 10
19 | 
20 | 


--------------------------------------------------------------------------------
/03_loops/L_06_odd nos below 10.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | // print all the odd numbers below 10
 4 | //by using for loop
 5 | 
 6 | #include<iostream>
 7 | 
 8 | using namespace std;
 9 | int main()
10 | {
11 | 	for(int i=0 ;i<10 ;i++ )
12 | 	{
13 | 		if((i%2)!=0)  //check with remainder and if it is not equal to zero then it is odd
14 | 		{
15 | 				cout<<i<<" ";
16 | 		}
17 | 		
18 | 	}
19 | 	return 0;
20 | }
21 | 
22 | //1 3 5 7 9
23 | 


--------------------------------------------------------------------------------
/04_break continue/03_prime non prime.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | 
 6 | 
 7 | */
 8 | 
 9 | 
10 | #include <iostream>
11 | using namespace std;
12 | 
13 | int main() {
14 |     
15 |     int n;
16 |     cin>>n;
17 |     bool flag=0;
18 | 
19 |     for(int i=2;i*i<=n;i++){
20 |         if(n%i==0){
21 |             cout<<"Non-Prime"<<endl;
22 |             flag=1;
23 |             break;
24 |         }
25 |     }
26 | 
27 |     if(flag==0){
28 |         cout<<"Prime"<<endl;
29 |     }
30 | 
31 | 
32 |     
33 |     return 0;
34 | }
35 | 
36 | //
37 | //5
38 | //Prime
39 | 
40 | 
41 | //9
42 | //Non-Prime
43 | 
44 | 


--------------------------------------------------------------------------------
/04_break continue/04_odd even.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | 
 6 | 
 7 | */
 8 | 
 9 | 
10 | #include <iostream>
11 | using namespace std;
12 |  
13 | int main() {
14 |   
15 |    int n;
16 |    cout<<"Enter a number: ";
17 |    cin>>n;
18 |   
19 |    for (int i=1; i<=n; i++) {
20 |       
21 |        if (i%2==0) {                  // i is even
22 |            continue;
23 |        }
24 |        cout<<i<<endl;
25 |    }
26 |   
27 |    return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/04_break continue/BC_01_ continue statement.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 07 jumps in loops which consits of 2 statements
 5 | with break and continue statements
 6 | 
 7 | these are used when we want to control the flow of a loop
 8 | on meeting specified condition
 9 | 
10 | */
11 | 
12 | 
13 | #include<bits/stdc++.h>
14 | 
15 | using namespace std;
16 | 
17 | int main()
18 | {
19 | 	
20 | 	for(int i=1; i<=30; i++) 	//date in month from 1 to 30
21 | 	if(i%2==0)
22 | 		continue;				//continue hit hothe hi, jo hamara next statement hai go out vo execute nahi hogi, we will skip to the next iteration
23 | 	else
24 | 		cout<<"go out"<<endl;
25 |      return 0;
26 | }
27 | 
28 | 
29 | //go out
30 | //go out
31 | //go out
32 | //go out
33 | //go out
34 | //go out
35 | //go out
36 | //go out
37 | //go out
38 | //go out
39 | //go out
40 | //go out
41 | //go out
42 | //go out
43 | //go out
44 | 
45 | 
46 | //it is printing 15 times to go out in a month which are the odd days
47 | 
48 | 


--------------------------------------------------------------------------------
/04_break continue/BC_02_break statement.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | break statement is used to terminate a loop
 5 | 
 6 | 
 7 | */
 8 | 
 9 | 
10 | #include<bits/stdc++.h>
11 | 
12 | using namespace std;
13 | 
14 | int main()
15 | {
16 | 	int pocketMoney=3000;
17 | 	for(int i=1; i<=30; i++){ 	//date in month from 1 to 30
18 | 	if(i%2==0)
19 | 		continue;				//continue hit hothe hi, jo hamara next statement hai go out vo execute nahi hogi, we will skip to the next iteration
20 | 		
21 | 	if(pocketMoney==0)			//when pocket money becomes zero we come outta the loop
22 | 		break;
23 | 
24 | 	else
25 | 		cout<<"go out"<<endl;
26 | 		pocketMoney = pocketMoney - 300;  //jis din neha will go out we will subtract 300 from her total pocket money
27 | 	}
28 |      return 0;
29 | }
30 | 
31 | 
32 | //go out
33 | //go out
34 | //go out
35 | //go out
36 | //go out
37 | //go out
38 | //go out
39 | //go out
40 | //go out
41 | //go out
42 | 
43 | //in 10 days her money will become 0, so she cant go out the next more 5 days
44 | 
45 | 


--------------------------------------------------------------------------------
/05_switch/01_basic.cpp:
--------------------------------------------------------------------------------
 1 | // switch
 2 | 
 3 | #include<iostream>
 4 | using namespace std;
 5 | 
 6 | int main()
 7 | {
 8 | 	int t;
 9 | 	cin>>t;
10 | 	while(t--){
11 | 		
12 | 	int n;
13 | 	cin>>n;
14 | 	
15 | 	switch(n)
16 | 	{
17 | 		case 10 : cout<<"value is 10";
18 | 		break;
19 | 		
20 | 		case 15 : cout<< "value is 15";
21 | 		break;
22 | 		
23 | 		default : cout<< "not found";
24 | 	}
25 | 	
26 | }
27 | 	return 0;
28 | }
29 | 
30 | 
31 | 
32 | //3
33 | //10
34 | //value is 10
35 | //16
36 | //not found
37 | //15.
38 | //value is 15
39 | 


--------------------------------------------------------------------------------
/05_switch/02_calculator.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //implement a simple calculator using switch
 4 | #include <iostream>
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 |     float n1, n2;
10 |     cout << "Input 2 numbers: ";
11 |     cin >> n1 >> n2;
12 | 
13 |     char op;
14 |     cout << "input an operator";
15 |     cin >> op;
16 | 
17 |     switch (op)
18 |     {
19 |     case '+':
20 |         cout << n1 + n2 << endl;
21 |         break;
22 |     case '-':
23 |         cout << n1 - n2 << endl;
24 |         break;
25 |     case '*':
26 |         cout << n1 * n2 << endl;
27 |         break;
28 |     case '/':
29 |         cout << n1 / n2 << endl;
30 |         break;
31 | 
32 |     default:
33 |         cout << "Enter another operator:" << endl;
34 |         break;
35 |     }
36 | 
37 |     return 0;
38 | }
39 | 
40 | 
41 | //Input 2 numbers: 5 6
42 | //input an operator: +
43 | //11
44 | //
45 | //Input 2 numbers: 79 90
46 | //input an operator*
47 | //7110
48 | 
49 | 


--------------------------------------------------------------------------------
/06_operators/O_01_ pre increment.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | #include<bits/stdc++.h>
 4 | 
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 | 	int a=10;  //initially a will be 10
10 | 	int b;		//and b will be 0
11 | 	
12 | 	b=++a;		//declaration.....pehle a ki value increment horahi, fir jake b me stor horahi
13 | 	cout<<a<<" "<<b<<endl; //print a and b values
14 |      return 0;
15 | }
16 | 
17 | 
18 | //11 11
19 | 


--------------------------------------------------------------------------------
/06_operators/O_02_post decrement.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //postincrement: current value of a is preserved temporarily
 4 | //a will increment before next statement is executed
 5 | 
 6 | #include<bits/stdc++.h>
 7 | 
 8 | using namespace std;
 9 | 
10 | int main()
11 | {
12 | 	int a=10;
13 | 	int b;
14 | 	
15 | 	b=a++;// 10 will go in b then increment
16 | 	cout<<a<<" "<<b<<endl;
17 |      return 0;
18 | }
19 | 
20 | //11 10
21 | 
22 | 


--------------------------------------------------------------------------------
/06_operators/O_03_pre+post increment.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //post + pre
 4 | 
 5 | #include<bits/stdc++.h>
 6 | 
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 | 	int i=1; //initially i is 1
12 | 	
13 | 	//1     //3
14 | 	i=i++ + ++i; //i++ means 1 on hand 1 in mind = 2, ++i=2 on hand
15 | 	cout<<i<<endl;
16 |      return 0;
17 | }
18 | 
19 | 
20 | //4
21 | 


--------------------------------------------------------------------------------
/06_operators/O_04_ incr pre post mix prob.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | #include<bits/stdc++.h>
 4 | 
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 | 	
10 | 	//initialize 3 variables
11 | 	int i=1;
12 | 	int j=2;
13 | 	int k;
14 | 	
15 | 	//1  //2  //1  //2   //3   //4  
16 | 	k=i + j + i++ + j++ + ++i + ++j;
17 | 	cout<<i<<" "<<j<<" "<<k;
18 |      return 0;
19 | }
20 | 
21 | //
22 | //3 4 13  //last me i aur j ki value 3 aur 4 thi
23 | 


--------------------------------------------------------------------------------
/06_operators/O_05_relational.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //input a no. and tell if it is more than or equal to 10
 4 | 
 5 | #include<bits/stdc++.h>
 6 | 
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 | 	int n;
12 | 	cin>>n;
13 | 	
14 | 	if(n>=10)
15 | 		cout<<"no is greater than or equal to 10"<<endl;
16 | 	else
17 | 		cout<<"no is less than 10"<<endl;
18 |      return 0;
19 | }
20 | 
21 | 


--------------------------------------------------------------------------------
/06_operators/O_05_relational_more than or equal to.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //input a no. and tell if it is more than or equal to 10
 4 | 
 5 | #include<bits/stdc++.h>
 6 | 
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 | 	int n;
12 | 	cin>>n;
13 | 	
14 | 	if(n>=10)
15 | 		cout<<"no is greater than or equal to 10"<<endl;
16 | 	else
17 | 		cout<<"no is less than 10"<<endl;
18 |      return 0;
19 | }
20 | 
21 | 


--------------------------------------------------------------------------------
/06_operators/O_06_logical_div by both 2 and 3.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //write a program to output whether a no. is divisible by both 2 and 3 
 4 | //or divisible by only 1 of them
 5 | 
 6 | #include<bits/stdc++.h>
 7 | 
 8 | using namespace std;
 9 | 
10 | int main()
11 | {
12 | 	int tt;
13 | 	cin>>tt;
14 | 	while(tt--){
15 | 	int n;
16 | 	cin>>n;
17 | 	
18 | 	if(n%2==0 && n%3==0)
19 | 		cout<<" divisible by 2 and 3"<<endl;
20 | 	else if (n%2==0) 
21 | 		cout<<"divisible by 2 "<<endl;
22 | 	else if (n%3==0)
23 | 		cout<<"divisible by 3"<<endl;
24 | 	else
25 | 		cout<<"divisible by none";
26 | 	}
27 | 	
28 | 	
29 |      return 0;
30 | }
31 | 
32 | 
33 | //4  (test cases)
34 | //6
35 | // divisible by 2 and 3
36 | //4
37 | //divisible by 2
38 | //9
39 | //divisible by 3
40 | //11
41 | //divisible by none
42 | 
43 | 


--------------------------------------------------------------------------------
/06_operators/O_07_(bitwise,assign,misc).cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | 
 4 | //bitwise operators
 5 | 
 6 | //AND OPERATOR : 			if both are 1, then only ans is 1
 7 | //OR OPERATOR : 			any one of the element shoube 1
 8 | //XOR OPERATOR: 			SAME VALUES	will be 0, diff values will be 1
 9 | //ones compliment : 		ulta
10 | //left shift operator: 		4<<1 (0100) will give 1000 which is 8 ka decimal...(shift one position towards left)
11 | //right shift operator: 	4>>1 (0100) will give 0010 which is 2 ka decimal....
12 | 
13 | //a<<n = a multiplied by 2 power n
14 | //a>>n = a divided by 2 power n
15 | 
16 | #include<bits/stdc++.h>
17 | 
18 | using namespace std;
19 | 
20 | int main()
21 | {
22 | //	int a;
23 | //	cout<<&a;
24 |     return 0;
25 | }
26 | //
27 | ////assignment operators
28 | //
29 | //	=		assigns right operand to left operand
30 | //	+=		assigns sum of two operands to the left operand  a+=b means a=a+b
31 | //	-=  	diff
32 | //	*=  	product
33 | //	/=  	quotient 
34 | 
35 | //miscellaneous operators
36 | 
37 | //sizeof()  		//returns the size of the variable eg:int a;.....sizeof(a)-->4 cuz integer takes 4 bytes
38 | //condition? x:y  	//returns value of x if condition is true or else value of y
39 | //cast				//convert one data type to another....eg: char ch='a'  int(ch)-->97 (it will cout the ascii value)
40 | //,              	//causes a sequence of operations to be performed
41 | //&					//reference operator	returns address of the variable
42 | //*					//pointer to a variable
43 | 
44 | 
45 | //refer precendence and asociativity table
46 | 
47 | 


--------------------------------------------------------------------------------
/07_patterns/P_01_inverted no.cpp:
--------------------------------------------------------------------------------
 1 | //to print inverted pattern
 2 | //
 3 | //1 2 3 4 5
 4 | //1 2 3 4
 5 | //1 2 3
 6 | //1 2
 7 | //1
 8 | 
 9 | #include<iostream>
10 | using namespace std;
11 | 
12 | int main()
13 | {
14 | 	int n;
15 | 	cin>>n;
16 | 	for(int i=1; i<=n; i++)
17 | 	{
18 | 		for(int j=1; j<=n+1-i; j++)
19 | 		{
20 | 			cout<<j<<" ";
21 | 		}
22 | 	    cout<<endl;
23 | 	}
24 |     return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/07_patterns/P_02_zero one.cpp:
--------------------------------------------------------------------------------
 1 | //0-1 pattern
 2 | 
 3 | // 1
 4 | // 0 1
 5 | // 1 0 1
 6 | // 0 1 0 1
 7 | // 1 0 1 0 1
 8 | 
 9 | // note -   rows : 1 to n
10 | //          coloumn : 1 to row number
11 | //          element : row no + column no, if even print 1, if odd print 0
12 | #include<iostream>
13 | using namespace std;
14 | 
15 | int main()
16 | {
17 | 	int n;
18 | 	cin>>n;
19 | 	
20 |     for(int i=1; i<=n; i++){
21 |   	for(int j=1; j<=i; j++){
22 |   		if((i+j)%2==0){
23 |   			cout<<" 1";
24 | 		  }
25 | 		else{
26 | 			cout<<" 0";
27 | 		}  
28 | 	  }
29 | 	  cout<<endl;
30 |   } 
31 |   return 0;	
32 | }
33 | 


--------------------------------------------------------------------------------
/07_patterns/P_03_no pyramid.cpp:
--------------------------------------------------------------------------------
 1 |  //number pyramid pattern
 2 |  
 3 | // 6
 4 | //     1
 5 | //    1 2
 6 | //   1 2 3
 7 | //  1 2 3 4
 8 | // 1 2 3 4 5
 9 | //1 2 3 4 5 6
10 | 
11 | #include<iostream>
12 | 
13 | using namespace std;
14 | 
15 | int main()
16 | {
17 | 	int n;
18 | 	cin>>n;
19 | 	
20 | 	for(int i=1; i<=n; i++){
21 | 		for(int j=1; j<=n-i; j++){
22 | 			cout<<" ";
23 | 		}
24 | 		for(int j=1; j<=i; j++){
25 | 			cout<<j<<" ";
26 | 		}
27 | 		cout<<endl;
28 |         }
29 |         
30 | 	return 0;
31 | }
32 | 
33 | 


--------------------------------------------------------------------------------
/07_patterns/P_04_solid rhombus.cpp:
--------------------------------------------------------------------------------
 1 | //solid rhombus pattern 
 2 | 
 3 | 
 4 | //6
 5 | //    *****
 6 | //   *****
 7 | //  *****
 8 | // *****
 9 | //*****
10 | 
11 | //note : rows       : 1 to n
12 | //       coloums 1  ; [to print space] is n-row number i.e n-i
13 | //       coloumn 2  ; 1 to n .
14 | 
15 | 
16 | #include<iostream>
17 | 
18 | using namespace std;
19 | 
20 | int main()
21 | {
22 | 	int n;
23 | 	cin>>n;
24 | 	
25 | 	for(int i=1; i<n; i++)
26 | 	{
27 | 		for(int j=1; j<n-i; j++){
28 | 			cout<<" ";
29 | 		}
30 | 		for( int j=1; j<n; j++){
31 | 			cout<<"*";
32 | 		}
33 | 		cout<<endl;
34 | 	}
35 | 	return 0; 
36 | }
37 | 


--------------------------------------------------------------------------------
/07_patterns/P_05_pascals triangle.cpp:
--------------------------------------------------------------------------------
 1 | //1
 2 | //1 1
 3 | //1 2 1
 4 | //1 3 3 1
 5 | //1 4 6 4 1
 6 | 
 7 | //pascals triangle
 8 | 
 9 | // i! / j!*(i-j)!
10 | 
11 | #include<iostream>
12 | using namespace std;
13 | 
14 | int fact(int n){
15 | 	int factorial=1;
16 | 	for(int i=2; i<=n; i++){
17 | 		factorial*=i;
18 | 	}
19 | 	return factorial;
20 | 
21 | }
22 | 
23 | int main(){
24 | 	
25 | 	int n;
26 |     cin>>n;
27 |     
28 |     for(int i=0; i<=n; i++){
29 |     	for(int j=0; j<=i; j++){
30 |     		cout<<fact(i)/(fact(j)*fact(i-j))<<" ";
31 | 		}
32 | 		cout<<endl;
33 | 	}
34 |        
35 |  
36 |     return 0;
37 | }
38 | 
39 |  
40 | 


--------------------------------------------------------------------------------
/07_patterns/P_06_rectangle.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //RECTANGLE PATTERN
 4 | 
 5 | //5 4
 6 | //****
 7 | //****
 8 | //****
 9 | //****
10 | //****
11 | 
12 | 
13 | #include<bits/stdc++.h>
14 | 
15 | using namespace std;
16 | 
17 | int main()
18 | {
19 | 	int n,m;   //taking rows and coloums
20 | 	cin>>n>>m;
21 | 	
22 | 	for(int i=1;i<=n;i++){
23 | 			for(int j=1;j<=m;j++){
24 | 				cout<<"*";	
25 | 			}
26 | 			cout<<endl;
27 | 		}
28 | 		
29 | 		
30 |      return 0;
31 | }
32 | 
33 | 


--------------------------------------------------------------------------------
/07_patterns/P_07_hollow rectangle.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //holow rectangle pattern
 4 | 
 5 | //pro tip : always keep i<= //equal to sign is compulsary in patterns
 6 | 
 7 | //5 4
 8 | //****
 9 | //*  *
10 | //*  *
11 | //*  *
12 | //****
13 | 
14 | #include<bits/stdc++.h>
15 | 
16 | using namespace std;
17 | 
18 | int main()
19 | {
20 | 	int n,m;
21 | 	cin>>n>>m;
22 | 	
23 | 	for(int i=1;i<=n;i++){    		//rows k liye
24 | 		for(int j=1;j<=m;j++){		//coloums k liye
25 | 			if(i==1 || i==n || j==1 || j==m){
26 | 				cout<<"*";
27 | 			}
28 | //			else if(j==1 || j==m){
29 | //				cout<<"*";
30 | //			}
31 | 			else{
32 | 				cout<<" ";
33 | 			}
34 | 		}
35 | 		cout<<endl;  
36 | 	}
37 |      return 0;
38 | }
39 | 
40 | 


--------------------------------------------------------------------------------
/07_patterns/P_08_inverted half pyramid.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //inverted half pyramid
 4 | 
 5 | //1st row here is 5th row cuz its inverted and keep printing the stars bases upon the row number
 6 | //eg: row 1 is 5th row so print 5 stars then keep decresaing
 7 | 
 8 | //5
 9 | //*****
10 | //****
11 | //***
12 | //**
13 | //*
14 | 
15 | #include<bits/stdc++.h>
16 | 
17 | using namespace std;
18 | 
19 | int main()
20 | {
21 | 	int n;   //only 1 input
22 | 	cin>>n;
23 | 	
24 | 	for(int i=n;i>=1;i--){    //n to 1
25 | 		for(int j=1;j<=i;j++) //j eqal to row no.
26 | 			cout<<"*";
27 | 		cout<<endl;
28 | 	}
29 |      return 0;
30 | }
31 | 
32 | 


--------------------------------------------------------------------------------
/07_patterns/P_09_half pyramid 180 rotation.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //half pyramid after 180 degree rotation
 4 | 
 5 | //i is the row number
 6 | //eg: 1st row me 1 star but n-1=4 4 is 4 spaces
 7 | 
 8 | 
 9 | //6
10 | //     *
11 | //    **
12 | //   ***
13 | //  ****
14 | // *****
15 | //******
16 | 
17 | 
18 | #include<bits/stdc++.h>
19 | 
20 | using namespace std;
21 | 
22 | int main()
23 | {
24 | 	int n;
25 | 	cin>>n;
26 | 	
27 | 	for(int i=1;i<=n;i++){
28 | 		for(int j=1;j<=n; j++){
29 | 				if(j<=n-i){
30 | 					cout<<" ";
31 | 				}
32 | 				else{
33 | 					cout<<"*";
34 | 				}
35 | 			}
36 | 			cout<<endl;	
37 | 		}
38 |      return 0;
39 | }
40 | 
41 | 


--------------------------------------------------------------------------------
/07_patterns/P_10_half pyramid using nos.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //half pyramid using numbers
 4 | 
 5 | //ROWS: 1 to n, col= t to row no
 6 | //i is row number
 7 | 
 8 | 
 9 | //5
10 | //1
11 | //2 2
12 | //3 3 3
13 | //4 4 4 4
14 | //5 5 5 5 5
15 | 
16 | #include<bits/stdc++.h>
17 | 
18 | using namespace std;
19 | 
20 | int main()
21 | {
22 | 	int n;
23 | 	cin>>n;
24 | 	
25 | 	for(int i=1;i<=n;i++){
26 | 		for(int j=1;j<=i;j++){
27 | 			cout<<i<<" ";  //print row no.
28 | 		}
29 | 		cout<<endl;
30 | 	}
31 |      return 0;
32 | }
33 | 
34 | 


--------------------------------------------------------------------------------
/07_patterns/P_12_butterfly.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //BUTTERFLY PATTERN
 4 | 
 5 | //for upper pattern
 6 | //rows: 1 to n
 7 | //* is row number
 8 | //space: 2*n-2* row no.
 9 | 
10 | //for lower pattern
11 | //rows: n to 1
12 | 
13 | 
14 | //7
15 | //*            *
16 | //**          **
17 | //***        ***
18 | //****      ****
19 | //*****    *****
20 | //******  ******
21 | //**************
22 | //**************
23 | //******  ******
24 | //*****    *****
25 | //****      ****
26 | //***        ***
27 | //**          **
28 | //*            *
29 | 
30 | #include<bits/stdc++.h>
31 | 
32 | using namespace std;
33 | 
34 | int main()
35 | 
36 | {
37 |   int r,i,j;
38 |   cin>>r;
39 |   
40 |   for(i=1;i<=r;i++)
41 |   {
42 |     for(j=1;j<=i;j++)
43 |     cout<<"*";
44 |     for(j=1;j<=2*(r-i);j++)
45 |     cout<<" ";
46 |     for(j=1;j<=i;j++)
47 |     cout<<"*";
48 |     cout<<"\n";
49 |   }
50 |   
51 |   for(i=r;i>=1;i--)
52 |   {s
53 |     for(j=1;j<=i;j++)
54 |     cout<<"*";
55 |     for(j=1;j<=2*(r-i);j++)
56 |     cout<<" ";
57 |     for(j=1;j<=i;j++)
58 |     cout<<"*";
59 |     cout<<"\n";
60 |   }
61 |   return 0;
62 | }
63 | 	
64 | 	
65 | 	
66 | 	
67 | 
68 | 


--------------------------------------------------------------------------------
/07_patterns/P_13_play button.cpp:
--------------------------------------------------------------------------------
 1 | //play button pattern
 2 | 
 3 | #include<iostream>
 4 | 
 5 | using namespace std;
 6 | 
 7 | int main()
 8 | {
 9 | 	int n;
10 | 	cout<<"enter number of columns:";
11 | 	cin>>n;
12 | 	
13 | 	for(int i=1; i<=n; i++)
14 | 	{
15 | 		for(int j=1; j<=i; j++)
16 | 		{
17 | 			cout<<"*";
18 | 		}
19 | 		cout<<endl;
20 | 	}
21 | 	for(int i=n-1; i>=1; i--)
22 | 	{
23 | 		for(int j=1; j<=i; j++)
24 | 		{
25 | 			cout<<"*";
26 | 		}
27 | 		cout<<endl;
28 | 	}
29 | 	return 0;
30 | }
31 | 
32 | 
33 | //enter number of columns:5
34 | //*
35 | //**
36 | //***
37 | //****
38 | //*****
39 | //****
40 | //***
41 | //**
42 | //*
43 | 


--------------------------------------------------------------------------------
/08_functions/09_prime sieve.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | prime sieve using sieve of eratosthenes
 6 | 
 7 | */
 8 | 
 9 | 
10 | #include<iostream>
11 | using namespace std;
12 | 
13 | void primeSieve(int n){
14 | 
15 |     int prime[100]={0};
16 | 
17 |     for(int i=2;i<=n;i++){ //satrt with 2
18 |         if(prime[i]==0){	//checdk if unmarked
19 |             for(int j=i*i;j<=n;j+=i){
20 |                 prime[j]=1;
21 |             }
22 |         }
23 |     }
24 | 
25 |     for(int i=2;i<=n;i++){
26 |         if(prime[i]==0){
27 |             cout<<i<<" ";
28 |         }
29 |     }cout<<endl;
30 | }
31 | 
32 | 
33 | int main(){
34 | 
35 |     int n;
36 |     cin>>n;
37 | 
38 |     primeSieve(n);
39 |     
40 | 
41 |     return 0;
42 | }
43 | 
44 | 
45 | 
46 | //30
47 | //2 3 5 7 11 13 17 19 23 29
48 | 
49 | 


--------------------------------------------------------------------------------
/08_functions/10_prime factorization.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | /*
 4 | 
 5 | prime factorization using sieve
 6 | 
 7 | */
 8 | 
 9 | 
10 |   
11 | #include<iostream>
12 | using namespace std;
13 | 
14 | 
15 | void primefactor(int n){
16 | 
17 |     int spf[100]={0};
18 |     for(int i=2;i<=n;i++){
19 |         spf[i]=i;
20 |     }
21 | 
22 |     for(int i=2;i<=n;i++){
23 |         if(spf[i]==i){
24 |             for(int j=i*i;j<=n;j+=i){
25 |                 if(spf[j]==j){
26 |                     spf[j]=i;
27 |                 }
28 |             }
29 |         }
30 |     }
31 | 
32 |     while(n!=1){
33 |         cout<<spf[n]<<" ";
34 |         n=n/spf[n];
35 |     }
36 | }
37 | 
38 | 
39 | 
40 | int main(){
41 | 
42 |     int n;
43 |     cin>>n;
44 | 
45 |     primefactor(n);
46 |     return 0;
47 | }
48 | 
49 | //
50 | //60
51 | //2 2 3 5
52 | 
53 | 


--------------------------------------------------------------------------------
/08_functions/F_01_1st n natural nos.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //SUM OF FIRST N NATURAL NUMBERS
 4 | 
 5 | #include<bits/stdc++.h>
 6 | 
 7 | using namespace std;
 8 | 
 9 | int sum(int n){
10 | 	int ans =0;
11 | 	for(int i=1;i<=n;i++)
12 | 		ans += i;
13 | 	return ans;
14 | }
15 | 
16 | int main()
17 | {
18 | 	int n;
19 | 	cin>>n;
20 | 	
21 | 	cout<<sum(n)<<endl;
22 |      return 0;
23 | }
24 | 
25 | //5
26 | //15.
27 | 
28 | 


--------------------------------------------------------------------------------
/08_functions/F_02_ pythogorean triplet.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //check whether a given triplet is pythogorean triplet or not
 4 | 
 5 | 
 6 | #include<bits/stdc++.h>
 7 | 
 8 | using namespace std;
 9 | 
10 | bool check(int x, int y, int z)		//return type will be bool
11 | {
12 | 	int a = max(x, max(y,z));   //store max value in a
13 | 	int b, c;
14 | 	
15 | 	if(a==x){
16 | 		b=y;
17 | 		c=z;
18 | 	}
19 | 	else if(a==y){
20 | 		b=x;
21 | 		c=z;
22 | 	}
23 | 	else{
24 | 		b=x;
25 | 		c=y;
26 | 	}
27 | 	
28 | 	if(a*a == b*b + c*c)
29 | 		return true;
30 | 	else
31 | 		return false;
32 | }
33 | 
34 | 
35 | int main()
36 | {
37 | 	int x,y,z;
38 | 	cin>>x>>y>>z;
39 | 	
40 | 	if (check(x,y,z))
41 | 	{
42 | 		cout<<"yes, it is pythogorean triplet";
43 | 		
44 | 	}
45 | 	else
46 | 	{
47 | 		cout<<"not a pythogorean triplet";
48 | 	}
49 |      return 0;
50 | }
51 | 
52 | //
53 | //3 4 5
54 | //pythogorean triplet.
55 | 


--------------------------------------------------------------------------------
/08_functions/F_03_euclid algo to find GCD.cpp:
--------------------------------------------------------------------------------
 1 | //LOGIC
 2 | //
 3 | //24 = 2*2*2*3
 4 | //42 = 2*3*7
 5 | //COMMON = 2*3=6
 6 | //
 7 | //42-24=18
 8 | //24-18=6
 9 | //18-6=12
10 | //12-6=6
11 | //6-6=0
12 | //
13 | //OR
14 | //
15 | //42%24=18
16 | //24%18=5
17 | //18%6=0
18 | 
19 | //number theory
20 | 
21 | #include<iostream>
22 | using namespace std;
23 | 
24 | int gcd(int a, int b){
25 | 	while(b!=0){                  //jb tk b ki value 0 nai hoti
26 |    	  int rem=a%b;              //me sabse pehle remainder find out karungi
27 |    	  a=b;                     //a me b ki value dalenge
28 |    	  b=rem;                   //aur b me remainder ki value
29 |    }
30 |    return a; 
31 | }
32 |                 //jb hamara b ki value 0 hojayega toh apan return karenge a ki value
33 | 
34 | int main()
35 | {
36 | 	int a,b;                  //declare a and b
37 | 	cin>>a>>b;                //user se input lelete
38 | 	cout<<gcd(a,b)<<endl;     //output ko print kare
39 | 	return 0;
40 | }
41 | 


--------------------------------------------------------------------------------
/08_functions/F_04_calculate ncr.cpp:
--------------------------------------------------------------------------------
 1 | //to calculate nCr
 2 | 
 3 | //nCr = n!/(n-r)!*r!
 4 | 
 5 | #include<iostream>
 6 | #include<math.h>
 7 | using namespace std;
 8 | 
 9 | int fact(int n){
10 | 	int factorial=1;
11 | 	for(int i=2; i<=n; i++){
12 | 		factorial=factorial*i;
13 | 	}
14 | 	return factorial;
15 | }
16 | 
17 | int main(){
18 | 	
19 | 	int n,r;
20 | 	cin>>n>>r;
21 | 	
22 | 	int ans = fact(n)/(fact(r)*fact(n-r));
23 | 	cout<<ans<<endl;
24 | 	
25 | 	return 0;
26 | }
27 | 
28 | 
29 | 


--------------------------------------------------------------------------------
/08_functions/F_05_factorial.cpp:
--------------------------------------------------------------------------------
 1 | //FACTORIAL
 2 | 
 3 | //n!=n*n-1*n-2*n-3.....x1
 4 | //eg:3! = 1*2*3
 5 | 
 6 | #include<iostream>
 7 | #include<math.h>
 8 | 
 9 | using namespace std;
10 | 
11 | int fact(int n){
12 | 	int factorial=1;
13 | 	for(int i=2; i<=n; i++){
14 | 		factorial=factorial*i;
15 | 	}
16 | 	return factorial;
17 | }
18 | 
19 | 
20 | int main(){
21 | 	
22 | 	int n;
23 | 	cin>>n;
24 | 	
25 | 	int ans = fact(n);
26 | 	cout<<ans<<endl;
27 | 	return 0;
28 | }
29 | 
30 | 


--------------------------------------------------------------------------------
/08_functions/F_06_fibenacci sequence.cpp:
--------------------------------------------------------------------------------
 1 | //FIBENACCI SEQUENCE (SUM OF PREV 2 TERMS)
 2 | 
 3 | #include<iostream>
 4 | #include<math.h>
 5 | 
 6 | using namespace std;
 7 | 
 8 | void fibenacci(int n){
 9 | 	
10 | 	int t1=0;
11 | 	int t2=1;
12 | 	int nextTerm;
13 | 	
14 | 	for(int i=1; i<n; i++){
15 | 		cout<<t1<<endl;
16 | 		nextTerm=t1+t2;
17 | 		t1=t2;
18 | 		t2=nextTerm;
19 | 	}
20 | 	return;
21 | }
22 | 
23 | int main(){
24 | 	
25 | 	int n;
26 | 	cin>>n;
27 | 	
28 | 	fibenacci(n);
29 | 	
30 | 	
31 | 	return 0;
32 | }
33 | 
34 | 
35 | 


--------------------------------------------------------------------------------
/08_functions/F_07_ print all primes btw 2 nos.cpp:
--------------------------------------------------------------------------------
 1 | //PRINT ALL PRIME NOS BETWEEN 2 GIVEN NUMBERS
 2 | 
 3 | #include<iostream>
 4 | #include<math.h>
 5 | using namespace std;
 6 | 
 7 | bool isprime(int num){
 8 | 	for(int i=2; i<sqrt(num); i++){
 9 | 		if(num%i==0){
10 | 			return false;
11 | 		}
12 | 	}
13 | 	return true;
14 | }
15 | 
16 | int main(){
17 | 	
18 | 	
19 | 	int a,b;
20 | 	cin>>a>>b;
21 | 	
22 | 	for(int i=a; i<=b; i++){
23 | 	   if(isprime(i)){
24 | 		cout<<i<<endl;
25 | 	   }
26 | 	}
27 | 	
28 | 	return 0;
29 | }
30 | 


--------------------------------------------------------------------------------
/08_functions/F_08_inclusion exclusion principle.cpp:
--------------------------------------------------------------------------------
 1 | // question: how many numbers between 1 and 1000 are divisible by 5 or 7
 2 | 
 3 | //logic
 4 | // ex:total students: n1+n2-n3
 5 | //ex: n1 students have took math, n2 students science, n3 students took both 
 6 | 
 7 | //inclusion exclusion principle in functions
 8 | //number theory concept
 9 | 
10 | #include<bits/stdc++.h>
11 | 
12 | using namespace std;
13 | 
14 | int divisible(int n, int a, int b){
15 | 	int c1=n/a;
16 | 	int c2=n/b;
17 | 	int c3=n/(a*b);
18 | 	
19 | 	return c1+c2-c3;
20 | 	
21 | }
22 | 
23 | int main()
24 | {
25 | 	int n,a,b;
26 | 	cin>>n>>a>>b;
27 | 	cout<<divisible(n,a,b)<<endl;
28 | 	return 0;
29 | }
30 | 
31 | 
32 | //5 3 2
33 | //3
34 | 


--------------------------------------------------------------------------------
/09_array/A_00_basic.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //an array is a list of variables of same similar type
 4 | //it is single block of memory with partitions
 5 | 
 6 | //syntax: datatype arrayname[size];
 7 | 
 8 | //limitations: fixed size, contiguous blocks of memory, insertion or deletion is costly
 9 | 
10 | #include<bits/stdc++.h>
11 | 
12 | using namespace std;
13 | 
14 | int main()
15 | {
16 | 	int n;		//declare size
17 | 	cin>>n;  	//take in the size
18 | 	int a[n]; 	 //declare array of size n
19 | 	//cin>>a[0]; cin>>a[1]....
20 | 	//but
21 | 	for(int i=0; i<n;i++) 	//here i is just a variable nothing to do with it....but it goes from array of 0 to n
22 | 	cin>>a[i]; 				//full array kosam 
23 | 	   
24 | 	for(int i=0; i<n;i++) 	//here i is just a variable nothing to do with it....but it goes from array of 0 to n
25 | 	cout<<a[i]<<" "; 				//full array kosam 
26 |      return 0;
27 | }
28 | 
29 | //5
30 | //12 34 2 4 67
31 | //12 34 2 4 67
32 | 
33 | 


--------------------------------------------------------------------------------
/09_array/A_01_maximum till i.cpp:
--------------------------------------------------------------------------------
 1 | //MAX TILL I
 2 | //given an array of size n, for every i from 0 to n-1
 3 | //outpur max(a[0], a[1], ..... a[i]
 4 | 
 5 | //author :shreyamalogi
 6 | 
 7 | 
 8 | //approach:   keep a variable mx which stores the maximum till ith element
 9 |  //           iterate over the array and update
10 |  //dry run :  move the pointer and compare with the next and check which is maximum and update the maximum
11 |  
12 | #include<bits/stdc++.h>
13 | 
14 | using namespace std;
15 | 
16 | int main()
17 | {
18 | 	int mx=-1999999;    //give any small value so that we can find the maximum value
19 | 	int n;
20 | 	cin>>n;
21 | 	int a[n],i;
22 | 	for(i=0; i<n; i++)
23 | 		cin>>a[i];
24 | 	
25 | 	//main logic	
26 | 	for(i=0; i<n; i++){
27 | 		mx = max(mx,a[i]);   // we send in 2 arguments in max function max till a[i] or update it
28 | 		cout<< mx <<endl;
29 | 	}
30 | 		
31 |      return 0;
32 | }
33 | 
34 | //input
35 | //6
36 | //0 -9 1 3 -4 5
37 | //
38 | //output (compare btw 0 and -9 and check which is max val)
39 | //0
40 | //0
41 | //1
42 | //3
43 | //3
44 | //5
45 | 
46 | 


--------------------------------------------------------------------------------
/09_array/A_02_ first repeating element.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | // first repeating element
 3 | 
 4 | //IDX ARRAY IS a[i], normal array is i
 5 | 
 6 | #include<bits/stdc++.h>
 7 | 
 8 | using namespace std;
 9 | 
10 | int main()
11 | {
12 | 	int n;
13 | 	cin>>n;
14 | 	int a[n];
15 | 	for(int i=0;i<n;i++) 
16 | 	{
17 | 		cin>>a[i];	
18 | 	}
19 | 	
20 | 	
21 | 	const int N = 1e6+2;  //10 power 6, const is cuz we cant change n ki value
22 | 	int idx[N];       //DECLARING OUR IDX ARRAY OF SIZE CAPITAL N
23 | 	for(int i=0; i<N; i++) 
24 | 	{
25 | 		idx[i] =-1; //initializing index i with -1
26 | 	}
27 | 	
28 | 	//declaring our minimum index and initialize with a very large value
29 | 	
30 | 	int mnidx=INT_MAX;
31 | 	
32 | 	for(int i=0; i<n; i++)
33 | 	{
34 | 		if(idx[a[i]] != -1) //if idx of a[i] is not eqal to -1
35 | 		{
36 | 			mnidx = min(mnidx, idx[a[i]]);  //minindex me minimize karke ,update kardo
37 | 		}
38 | 		else
39 | 		{
40 | 			idx[a[i]] = i; //idx of ai me i daldo cuz pehle -1 tha na
41 | 		}
42 | 	}
43 | 	
44 | 	//agr min index mila itch nai
45 | 	if(mnidx==INT_MAX) //if min index barabar intmax
46 | 	{
47 | 		cout<<"-1"<<endl;
48 | 	}
49 | 	else
50 | 	{
51 | 		cout<<mnidx + 1<<endl;
52 | 	}
53 | 	
54 | 	
55 |     return 0;
56 | }
57 | 
58 | //7
59 | // 1 5 3 4 3 5 6
60 | 
61 | //2
62 | 
63 | 


--------------------------------------------------------------------------------
/09_array/A_03_smalest positive missing.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | //smallest positive missing
 3 | 
 4 | #include<bits/stdc++.h>
 5 | 
 6 | using namespace std;
 7 | 
 8 | int main()
 9 | {
10 | 	int n;
11 | 	cin>>n;
12 | 	int a[n];
13 | 	for(int i=0;i<n;i++) cin>>a[i];
14 | 	
15 | 	const int N= 1e6+2;
16 | 	bool  check[N];   //our check array
17 | 	for(int i=0;i<N;i++) 
18 | 	{
19 | 		check[i]=0; //first initialize it with false
20 | 		
21 | 	}
22 | 	
23 | 	//iterate over the array and the ones which is non negative mark it as true
24 | 	for(int i=0;i<n;i++)
25 | 	{
26 | 		if(a[i]>=0)   //non negitive
27 | 		{
28 | 			check[a[i]]= 1; //check of a[i] ko true mark kardo
29 | 			
30 | 		}
31 | 		
32 | 	}
33 | 	int ans= -1;  //initialize
34 | 	for(int i=1;i<N;i++)  //iterate it with 1 cuz we need to find positive
35 | 	{
36 | 			if(check[i]==0)	//if check of i is false
37 | 			{
38 | 				ans=i;    //ans me dalenge i ko
39 | 				break;    //break;
40 | 			}
41 | 	}
42 | 
43 | 		cout<<ans<<endl;	
44 | 	
45 | 	
46 |      return 0;
47 | }
48 | 
49 | 
50 | //6
51 | //0 -9 1 3 -4 5
52 | 
53 | //2
54 | 


--------------------------------------------------------------------------------
/09_array/A_04_find  min & max.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //print max and min elements
 4 | 
 5 | #include<bits/stdc++.h>
 6 | //#include<climits>
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 | 	int n;
12 | 	cin>>n;
13 | 	
14 | 	int a[n];
15 | 	for(int i=0;i<n;i++) cin>>a[i];
16 | 	
17 | //	each element ko maximum aur minimum value se compare karenge 
18 | //	aur jaha pe currect max zyada miljatha hai toh hum maximum ko update kardete hai
19 | //	aur jaha pe km miljatha hai toh minimum ko update kardete hai
20 | 
21 | //	int mx;
22 | //	int mn;  //just delaring is not enough we have to even initialize it
23 | 
24 | 	int mx = INT_MIN;
25 | 	int mn = INT_MAX;
26 | 	
27 | 	for(int i=0;i<n;i++)
28 | 	{
29 | //		if(a[i]>mx)		//if hamara number(unknown) 
30 | //			mx= a[i];		//toh mx ko update kardo apne no se
31 | //		if(a[i]<mn)
32 | //			mn= a[i];
33 | 
34 | 	mx = max(mx,a[i]);  //max is a built in function
35 | 	mn = min(mn,a[i]);
36 | 	}
37 | 	
38 | 	cout<<mx<<" "<<mn;
39 |      return 0;
40 | }
41 | 
42 | 
43 | //5
44 | //10 29 47 100 42
45 | //100 10
46 | 
47 | 


--------------------------------------------------------------------------------
/10_pointers/P_16_pointers and arrays.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | //pointers and arrays
 3 | 
 4 | #include<bits/stdc++.h>
 5 | 
 6 | using namespace std;
 7 | 
 8 | int main()
 9 | {
10 | 	//by using array
11 | 	int a[]={10,20,30};
12 | 	cout<<*a<<endl;				//10 which is 0th element
13 | 	
14 | 	//by using pointer
15 | 	int *ptr=a;
16 | 	for(int i=0;i<3;i++)		//pointer k madad se pura array print karwana
17 | 		{
18 | 			cout<<*ptr<<endl;
19 | 			ptr++;				//ye 4 bytes aagae chalajayega and we get our 2nd lement which is 20
20 | 		}
21 |     return 0;
22 | }
23 | 
24 | 
25 | //arr++ is illegal
26 | 
27 | 


--------------------------------------------------------------------------------
/10_pointers/P_17_pointer  arithmetic.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/shreyamalogi/CPP-Programming-Training/65e3121edfa3605bef8463327b796fbf7c5b8004/10_pointers/P_17_pointer  arithmetic.cpp


--------------------------------------------------------------------------------
/10_pointers/P_18_ basic.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //pointers are variables that store the address of other variables
 4 | //pointer use karke variable ko access bhi karsakthe aur modify bhi
 5 | #include<bits/stdc++.h>
 6 | 
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 | 	int a=10;
12 | 	int* aptr = &a;
13 | 	
14 | 	cout<<*aptr<<endl;  //10
15 | 	*aptr=20;
16 | 	cout<<a<<endl;		//20
17 |      return 0;
18 | }
19 | 
20 | 


--------------------------------------------------------------------------------
/10_pointers/P_19_pointer  to pointer.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //pointer to pointer
 4 | 
 5 | #include<bits/stdc++.h>
 6 | 
 7 | using namespace std;
 8 | 
 9 | int main()
10 | {
11 | 	int a=10;
12 | 	int *p;
13 | 	p=&a;
14 | 	
15 | 	cout<<*p<<endl; 			//10
16 | 	
17 | 	int**q=&p;
18 | 	
19 | 	cout<<*q<<endl; 			//2000
20 | 	cout<<**q<<endl; 			// 10
21 |      return 0;
22 | }
23 | 
24 | 
25 | 
26 | 
27 | //10
28 | //0x6ffe14
29 | //10
30 | 
31 | 


--------------------------------------------------------------------------------
/10_pointers/P_20_pointer  to functions1.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //pointers to functions using pass by vale
 4 | 
 5 | #include<bits/stdc++.h>
 6 | 
 7 | using namespace std;
 8 | 
 9 | void increment(int a){
10 | 	a++;
11 | }
12 | 
13 | int main()
14 | {
15 | 	int a=2;
16 | 	increment(a);	//pass by value
17 | 	cout<<a<<endl;   //2
18 |      return 0;
19 | }
20 | 
21 | 


--------------------------------------------------------------------------------
/10_pointers/P_21_pointer  to functions2.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //pass by ref
 4 | 
 5 | #include<bits/stdc++.h>
 6 | 
 7 | using namespace std;
 8 | 
 9 | swap(int *a, int*b){
10 | 	int temp = *a;
11 | 	*a = *b;
12 | 	*b = temp;
13 | }
14 | //swap(int a, int b){
15 | //	int temp = a;
16 | //	a = b;
17 | //	b = temp;
18 | //}
19 | 
20 | int main()
21 | {
22 | 	int a=2;
23 | 	int b=4;
24 | 	
25 | 	int *aptr=&a;
26 | 	int *bptr=&b;            //without using 2 lines we can access adress
27 | 	
28 | 	swap(aptr,bptr);         //or &a, &b
29 | 	cout<<a<<" "<<b<<endl;		//4 2
30 | 	
31 | 	
32 | //	swap(a,b);
33 | //	cout<<a<<" "<<b<<endl; 		//2 4
34 | 	
35 |      return 0;
36 | }
37 | 
38 | 


--------------------------------------------------------------------------------
/11_strings/S_01_convert to upper and lower cases.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | //to convert a string to upper case and lower case
 3 | 
 4 | //hint: //cout<<'a'-'A'<<endl;         //ASCII VALUE IS 32 
 5 | //author :shreyamalogi
 6 | 
 7 | #include<bits/stdc++.h>
 8 | 
 9 | using namespace std;
10 | 
11 | int main()
12 | {
13 |    string str = "aggyfggfrnjl";
14 |    
15 |    // convert to upper case
16 |    for(int i=0; i<str.size(); i++){
17 |    	if (str[i]>='a'  && str[i]<='z')  //koi bhi character string ka is greater than or equal to a and less than equal to z
18 |    	   str[i]-=32;
19 |    }
20 |    cout<<str<<endl;
21 |    
22 |    //convert to lower case
23 |    for(int i=0; i<str.size(); i++){
24 |    	if(str[i]>='A'  && str[i]<='Z')
25 |    	 str[i]+=32;
26 |    }
27 |    cout<<str<<endl;
28 |    
29 |   return 0;
30 |   }
31 |   
32 |   //AGGYFGGFRNJL
33 | 
34 | 


--------------------------------------------------------------------------------
/11_strings/S_02_upper case transform.cpp:
--------------------------------------------------------------------------------
 1 | //AN OTHER WAY OF CONVERTING STRINGS TO UPPER CASE USING TRANSFORM
 2 | //author :shreyamalogi
 3 | 
 4 | #include<bits/stdc++.h>
 5 | 
 6 | using namespace std;
 7 | 
 8 | int main()
 9 | {
10 |   string s = "hwkefHkw";
11 |   
12 |   // TO CONVERT TO UPPER CASE
13 |   transform(s.begin(),s.end(),  s.begin(), ::toupper);
14 |   cout<<s<<endl; 
15 |   
16 |   //TO CONVERT TO LOWER CASE
17 |   transform(s.begin(),s.end(),   s.begin(), ::tolower);
18 |   cout<<s<<endl;
19 |   return 0;
20 |   }
21 |   
22 | //HWKEFHKW
23 | //hwkefhkw
24 | 
25 | 


--------------------------------------------------------------------------------
/11_strings/S_03_biggest no from numeric s.cpp:
--------------------------------------------------------------------------------
 1 | //form the biggest number from the numeric string
 2 | 
 3 | //hint: decreasing order me sort kare toh wahi biggest hoga na
 4 | //author :shreyamalogi
 5 | 
 6 | #include<bits/stdc++.h>
 7 | 
 8 | using namespace std;
 9 | 
10 | int main()
11 | {
12 |   string s = "572305729898";
13 |   sort(s.begin(), s.end(), greater<int>()); // 2 arguments pass karne ka hai ek ye sort wala argument dusra ye greater int wala argument
14 |   cout<<s<<endl;
15 |   return 0;
16 |   }
17 | 
18 | 


--------------------------------------------------------------------------------
/11_strings/S_04_occur max times.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | //GIVEN A STRING we must output the ones which occur maximum times
 3 | //author :shreyamalogi
 4 | 
 5 | 
 6 | //hint: " a b c a c b a d e" (a occurs max times)
 7 | //frequency = 3, output =3
 8 | 
 9 | //hint 2 : count pata karne ka hai (size 26) as in a to z 
10 | #include<bits/stdc++.h>
11 | 
12 | using namespace std;
13 | 
14 | int main()
15 | {
16 |    string s ="ekwhfheglweg";
17 |    int freq[26];
18 |    
19 |    for(int i=0; i<26; i++)
20 |       freq[i]=0;
21 |       
22 |     for(int i=0; i<s.size(); i++)  
23 |       freq[s[i]-'a']++;
24 |       
25 |     char ans = 'a';
26 | 	int maxF = 0;
27 | 	
28 | 	for(int i=0; i<26; i++)  
29 | 	{
30 | 		if(freq[i]>maxF){
31 | 			maxF = freq[i];
32 | 			ans = i+'a';
33 | 		}
34 | 	}
35 | 	cout<<maxF<<" "<<ans<<endl;
36 |   return 0;
37 |   }
38 | 
39 | 


--------------------------------------------------------------------------------
/11_strings/S_05_string declaration types 3.cpp:
--------------------------------------------------------------------------------
 1 | //3 types of string declarations
 2 | 
 3 | //different ways to use strings
 4 | //author :shreyamalogi
 5 | 
 6 | #include<bits/stdc++.h>
 7 | 
 8 | using namespace std;
 9 | 
10 | int main()
11 | {
12 |   string str;
13 |   
14 |   cin>>str;
15 |   cout<<str;
16 |   return 0;
17 |   }
18 |   
19 |   
20 |   
21 |   
22 |   
23 | // declaring string with size and character
24 | //author :shreyamalogi
25 | 
26 | #include<bits/stdc++.h>
27 | 
28 | using namespace std;
29 | 
30 | int main()
31 | {
32 |   string str;
33 |   string str1(5, 's'); // declare with size (it prints n character 5 times)
34 |   cout<<str1<<endl;   //prints nnnnn
35 |   return 0;
36 |   }
37 |   
38 |   
39 |   
40 |   
41 |   
42 | 
43 | #include<bits/stdc++.h>
44 | 
45 | using namespace std;
46 | 
47 | int main()
48 | {
49 |    string str = "shreya malogi";
50 |    cout<<str;  //pints shreyamalogi
51 |   return 0;
52 |   }
53 | 
54 | 
55 | 


--------------------------------------------------------------------------------
/11_strings/S_06_string functions 15.cpp:
--------------------------------------------------------------------------------
  1 | //GETLINE() to input ////declare with value but with spaces and full sentence will be printed
  2 | //author :shreyamalogi
  3 | 
  4 | #include<bits/stdc++.h>
  5 | 
  6 | using namespace std;
  7 | 
  8 | int main()
  9 | {
 10 |   string str;
 11 |   //cin>>str     //wont work (panga hosaktha kyunki it will print just hfh
 12 |   getline(cin, str); //pure k pure sentence ko input karalega
 13 |   cout<<str;
 14 |   return 0;
 15 |   }
 16 | 
 17 | //INPUT
 18 | hfh  jkfhdkshf kuhrfuWHRF
 19 | //OUTPUT
 20 | hfh  jkfhdkshf kuhrfuWHRF
 21 | 
 22 | 
 23 | 
 24 | 
 25 | 
 26 | 
 27 | //append strings {jodna}
 28 | //author :shreyamalogi
 29 | 
 30 | #include<bits/stdc++.h>
 31 | 
 32 | using namespace std;
 33 | 
 34 | int main()
 35 | {
 36 |   string str;
 37 |   
 38 |   string s1 = "fam";
 39 |   string s2 = "ily";
 40 |   
 41 |   //method 1
 42 |   s1.append(s2); // agr s1 me append karana s2 ko 
 43 |   cout<<s1<<endl; // toh output ajayega family
 44 |   
 45 |   //or method 2
 46 |   
 47 |   //s1=s1+s2                //we can also declare like this
 48 |   //cout<<s1+s2<<endl;      //without using append 
 49 |    
 50 |    
 51 |     //agr s1 ka dusra character access karna hei toh
 52 |                            
 53 |    //cout<<s1[2]<<endl;    
 54 |   return 0;
 55 |   }
 56 |   
 57 |   
 58 |  
 59 |  
 60 |  
 61 |  
 62 |  //STRING WITH length function 1
 63 | //author :shreyamalogi
 64 | 
 65 | #include<bits/stdc++.h>
 66 | 
 67 | using namespace std;
 68 | 
 69 | int main()
 70 | {
 71 |   string s1 = "nincompoop";
 72 |   cout<<s1.size()<<endl;
 73 |   return 0;
 74 |   }
 75 |   
 76 |   //OUTPUT 10
 77 |   
 78 |   
 79 |   
 80 |    
 81 |   
 82 |   
 83 | //length() 2
 84 | //length function by using for loop
 85 | //author :shreyamalogi
 86 | 
 87 | #include<bits/stdc++.h>
 88 | 
 89 | using namespace std;
 90 | 
 91 | int main()
 92 | {
 93 |   string s1 = "nincompoop";
 94 |   
 95 |   for(int i=0; i<s1.length(); i++)  //ek ek character pe ja sakthi hu loop lagake
 96 |   cout<<s1[i]<<endl;
 97 |   return 0;
 98 |   }
 99 |   
100 |   //output
101 | //n
102 | //i
103 | //n
104 | //c
105 | //o
106 | //m
107 | //p
108 | //o
109 | //o
110 | //p
111 | 
112 | 
113 | 
114 | 
115 | 
116 | //to string()
117 | //to string function in strings
118 | //author :shreyamalogi
119 | 
120 | #include<bits/stdc++.h>
121 | 
122 | using namespace std;
123 | 
124 | int main()
125 | {
126 |   int x=786;
127 |   cout<<to_string(x) + "2";
128 |   return 0;
129 |   }
130 |   
131 |   
132 |   
133 |   
134 |   
135 |   //substring()
136 | //strings with substring function
137 | //substring is a part of string
138 | //author :shreyamalogi
139 | 
140 | #include<bits/stdc++.h>
141 | 
142 | using namespace std;
143 | 
144 | int main()
145 | {
146 |   string s1 = "nincompoop";
147 |   
148 |   string s = s1.substr(6,4); //(KONSE INDEX SE , KITNE CHARATERS agae TK chahiyae)
149 |   cout<<s;
150 |   return 0;
151 |   }
152 |   
153 |   //poop
154 |   
155 |   
156 |   
157 |   
158 |   
159 |   
160 | //strings with sort function
161 | //author :shreyamalogi
162 | 
163 | #include<bits/stdc++.h>
164 | //#include <algorithm> me baithe hotha ye sort function
165 | //#include<string>     me baita hotha ye strings sb
166 | using namespace std;
167 | 
168 | int main()
169 | {
170 |   string s1 = "acazdgweitupmbnhg";
171 |   sort(s1.begin(), s1.end());  // it will sort from a to z in ascending order
172 |   
173 |   cout<<s1;
174 |   return 0;
175 |   }
176 | 
177 | //aabcdegghimnptuwz
178 | 
179 | 
180 | 
181 | 
182 | 
183 | 
184 | //strings with insert function {beech me kuch gussani hai}
185 | //author :shreyamalogi
186 | 
187 | #include<bits/stdc++.h>
188 | 
189 | using namespace std;
190 | 
191 | int main()
192 | {
193 |   string s1 ="nincompoop";
194 |   s1.insert(2,"lol"); //(KIS INDEX PE, STRING NAME TO BE INSERTED
195 |   cout<<s1;
196 |   return 0;
197 |   }
198 |   
199 |   //OUTPUT
200 |   //nilolncompoop
201 |   
202 |   
203 |   
204 |   
205 |   
206 |   //strings with find fUnction
207 | //author :shreyamalogi
208 | 
209 | #include<bits/stdc++.h>
210 | 
211 | using namespace std;
212 | 
213 | int main()
214 | {
215 |   string s1 = "nincompoop";
216 |   
217 |   cout<<s1.find("poo")<<endl;  //ye uska peha index return karega kaha pe ye miltha hai
218 |   return 0;
219 |   }
220 |   
221 |   //output
222 |   //6
223 |   
224 |   //as  6rd index se start hora mera p
225 |   
226 |   
227 |   
228 |   
229 |   
230 |   
231 | //STRINGS ERASE FUNCTION
232 | //author :shreyamalogi
233 | 
234 | #include<bits/stdc++.h>
235 | 
236 | using namespace std;
237 | 
238 | int main()
239 | {
240 |   string s1= "nincompoop";
241 |   
242 |   s1.erase(3,2);  //arguments me we must send (index,character)
243 |   cout<<s1;
244 |   return 0;
245 |   }
246 |   
247 |   
248 |   
249 |   
250 |   //empty function
251 |   //author :shreyamalogi
252 | 
253 | #include<bits/stdc++.h>
254 | 
255 | using namespace std;
256 | 
257 | int main()
258 | {
259 |    string s1 = "abc";
260 |    cout<<s1<<endl;     //first it will print abc
261 |    
262 |    s1.clear();         //then it will clear abc
263 |    
264 |    if(s1.empty())
265 |     cout<<"string is empty";  //then it will print this
266 |   return 0;
267 |   }
268 |   
269 |   //output (as there are 2 couts so 2 couts will be printed )s
270 |   //abc
271 |   //string is empty
272 |   
273 |   
274 |   
275 |   
276 |   
277 |   
278 |   //STRINGS WITH COMPARE FUNCTION
279 | //author :shreyamalogi
280 | 
281 | #include<bits/stdc++.h>
282 | 
283 | using namespace std;
284 | 
285 | int main()
286 | {
287 |   string s1 = "abc";
288 |   string s2 = "xyz";
289 |   cout<<s2.compare(s1)<<endl; //ye s2 ko compare karaha s1 se
290 |   return 0;
291 |   }
292 |   
293 |   
294 |   
295 |   
296 |   
297 |   //compare function part 2
298 | //author :shreyamalogi
299 | 
300 | #include<bits/stdc++.h>
301 | 
302 | using namespace std;
303 | 
304 | int main()
305 | {
306 |   string s1 = "abc";
307 |   string s2 = "abc";
308 |   
309 |   cout<<s2.compare(s1)<<endl;
310 |   return 0;
311 |   }
312 |   
313 |   //output 0
314 |   
315 |   
316 |   
317 |   
318 |   
319 | 
320 | 
321 | 
322 | 
323 | 
324 | 
325 | 
326 | 
327 | 
328 | 
329 | 


--------------------------------------------------------------------------------
/11_strings/S_07_balanced  parentheses.cpp:
--------------------------------------------------------------------------------
 1 | //author :shreyamalogi
 2 | 
 3 | //balanced parenthesis
 4 | 
 5 | //strings with stack approach wala problem including (switch case)
 6 | 
 7 | # include<bits/stdc++.h>
 8 | using namespace std;
 9 | string isBalanced(string s){
10 |     stack <char> st;
11 |     for(auto c:s){
12 |         switch (c){
13 |         	//declare the cases of opening brackets and push it into the stack
14 |             case '(':
15 |             case '{':
16 |             case '[':
17 |                   st.push(c);
18 |                    break;
19 |                    
20 |         	//intitialize case of closing bracket seoperate seperately
21 |             case '}':
22 |                 if(st.empty() || st.top()!='{' )  //if stack is empty or the top element in the stack is not equal to its partner the say no
23 |                     return "NO";				//return no
24 |                 st.pop();						//pop out
25 |                 break;							//and break
26 |             //copy paste same 
27 |             case ']':
28 |                 if(st.empty() || st.top()!='[')
29 |                     return "NO";
30 |                 st.pop();
31 |                 break;
32 |             case ')':
33 |                 if(st.empty() || st.top()!='(')
34 |                     return "NO";
35 |                 st.pop();
36 |                 break;
37 |             default: break;		//dont forget to mention default
38 |         }
39 |     }
40 |     return st.empty() ? "YES":"NO";  //check if stack is empty or not
41 | }
42 | 
43 | int main(){
44 |     int t;
45 |     cin >> t;
46 |     for(int i = 0; i < t; i++){
47 |         string s;
48 |         cin >> s;
49 |         cout << isBalanced(s) << endl;
50 |     }
51 |     return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 CodeMacrocosm
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | 
 2 | # 📚 C++ Programming 10-Day Training
 3 | 
 4 | 
 5 | Welcome to the C++ Programming 10-Day Training repository led by Shreya Malogi! 🌟 , a hands-on program designed to provide you with practical knowledge and intensive experience in C++ programming. 🚀
 6 | 
 7 | ## 📖 About This Training
 8 | 
 9 | This comprehensive 10-day training program is designed to immerse you in the world of C++ programming and equip you with the skills needed to excel in this versatile language. Each day of training focuses on key concepts and practical exercises to ensure you build a strong foundation in C++.
10 | 
11 | ## 🌟 Why C++?
12 | 
13 | C++ is a powerful and versatile programming language used in a wide range of applications, from game development to system programming. By learning C++, you open up opportunities to work on exciting projects and contribute to the world of technology.
14 | 
15 | ## 📜 Training Resources
16 | 
17 | In this repository, you'll find a structured collection of chapters and topics that cover essential aspects of C++ programming. Each section is tailored to the daily training schedule and includes hands-on exercises to reinforce your learning.
18 | 
19 | ## 📚 What's Covered?
20 | 
21 | Here's an overview of what's covered during this 10-day training:
22 | 
23 | 1. **Day 1: Datatypes** 📊
24 |    - Understanding fundamental data types in C++.
25 | 
26 | 2. **Day 2: If-Else Statements** 🤔
27 |    - Exploring conditional statements for decision-making.
28 | 
29 | 3. **Day 3: Loops** 🔄
30 |    - Learning about loops for repetitive tasks.
31 | 
32 | 4. **Day 4: Break and Continue** ⏸️
33 |    - Mastering control flow with break and continue statements.
34 | 
35 | 5. **Day 5: Switch Statements** 🔄
36 |    - Diving into switch statements for multi-case scenarios.
37 | 
38 | 6. **Day 6: Operators** 🤖
39 |    - Exploring C++ operators for various operations.
40 | 
41 | 7. **Day 7: Patterns** 🌟
42 |    - Creating interesting patterns using loops and characters.
43 | 
44 | 8. **Day 8: Functions** 📦
45 |    - Understanding functions for modular and reusable code.
46 | 
47 | 9. **Day 9: Arrays** 📊
48 |    - Working with arrays to store and manipulate data.
49 | 
50 | 10. **Day 10: Pointers and Strings** 🔗📝
51 |     - Exploring pointers for memory management and manipulating character strings in C++.
52 | 
53 | ## 📜 License
54 | 
55 | This training program is open-source and distributed under the MIT License.
56 | 
57 | MIT License
58 | 
59 | Copyright (c) 2021 CodeMacrocosm
60 | 
61 | ## ⭐ Star This Repository
62 | 
63 | If you find this C++ Programming 10-Day Training helpful and informative, don't forget to star this repository to show your appreciation! ⭐
64 | 
65 | ## 🚀 Let's Get Started!
66 | 
67 | Embark on your 10-day journey to becoming a C++ programming pro by exploring the chapters and topics provided in this repository. We hope you find these resources valuable.
68 | 
69 | Happy Learning! 🖥️
70 | 
71 | 
72 | 


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