dsa-programs/Lecture14.cpp at main · Aadharbindal/dsa-programs · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
// #include<iostream>
// using namespace std;

//  long long int sqrtInteger(int n) {

//         int s = 0;
//         int e = n;
//         long long int mid = s + (e-s)/2;

//         long long int ans = -1;
//         while(s<=e) {

//             long long int square = mid*mid;

//             if(square == n)
//                 return mid;

//             if(square < n ){
//                 ans = mid;
//                 s = mid+1;
//             }
//             else
//             {
//                 e = mid - 1;
//             }
//             mid = s + (e-s)/2;
//         }
//         return ans;
//     }

// double morePrecision(int n, int precision, int tempSol) {

//         double factor = 1;
//         double ans = tempSol;

//         for(int i=0; i<precision; i++) {
//             factor = factor/10;

//             for(double j=ans; j*j<n; j= j+factor ){
//                 ans = j;
//             }
//         }
//         return ans;
//     }

// int getPivot(int arr[], int n) {

//     int s = 0;
//     int e = n-1;
//     int mid = s + (e-s)/2;

//     while(s<e) {

//         if(arr[mid] >= arr[0])
//         {
//             s = mid+1;
//         }
//         else{
//             e = mid;
//         }
//         mid = s + (e-s)/2;
//     }
//     return s;
// }

// int binarySearch(int arr[], int s, int e, int key) {

//     int start = s;
//     int end = e;

//     int mid = start + (end-start)/2;         // to get in the range

//     while(start <= end) {

//         if(arr[mid] == key) {
//             return mid;
//         }

//         //go to right wala part
//         if(key > arr[mid]) {
//             start = mid + 1;
//         }
//         else{ //key < arr[mid]
//             end = mid - 1;
//         }

//         mid = start + (end-start)/2;
//     }

//     return -1;
// }

// /*************************************FIND IN A SORTED AND ROTATED ARRAY**********************************/

// int findposition(int arr[], int n, int k){

//     int pivot = getPivot(arr, n);
//     if( k >= arr[pivot] && k <= arr[n-1])
//     {//BS on second line
//         return binarySearch(arr, pivot, n-1, k);
//     }
//     else
//     {//BS on first line
//         return binarySearch(arr, 0, pivot - 1, k);
//     }
// }

// int main() {
//     int arr[5] = {7,9,1,2,3};
//     findposition(arr,5,3);
//     cout<<findposition(arr,5,3)<<endl;

//     cout<<sqrtInteger(37)<<endl;

//     int n;
//     cin>>n;
//     int tempSol = sqrtInteger(n);
//     cout <<" Answer is " << morePrecision(n, 3, tempSol) << endl;
// }