(Financial application: find the profit-per-item) Use the scheme in programming Exercise 5.39 to write a function that computes the profit-per-item. The header of the function is: double computeProfitPerItem(double quantity) Write a test program that displays the following table:

#include<iostream>
using namespace std;
bool issafe(int** arr,int x,int y,int n){
    for(int row=0;row<=x;row++){
        if(arr[x][y]==1){
            return false;
        }
    }
    int row=x;
    int col=y;
    while(row>=0 && col>=0){
        if(arr[row][col]==1){
            return false;
        }
        row--;
        col--;
    }
     row=x;
     col=y;
    while(row>=0 && col<n){
        if(arr[row][col]==1){
            return false;
        }
        row--;
        col++;
    }
    return true ;
}
bool nqueen(int** arr,int x,int n){
    if(x>=n){
        return true;
    }
    for(int col=0;col<=n;col++){
        if(issafe(arr,x,col,n)){
            arr[x][col]==1;
            if(nqueen(arr,x+1,n)){
                return true;
            }
            arr[x][col]=0;  //backtracking
            
        }
    }
    return false;
}
int main(){
    int n;
    cin>>n;
    int** arr=new int*[n];
    for(int i=0;i<n;i++){
        arr[i]=new int[n];
        for(int j=0;j<n;j++){
            arr[i][j]=0;

        }
    }
    if(nqueen(arr,0,n)){
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                cout<<arr[i][j]<<"";
            }cout<<endl;
        }
    }


    return 0;
}

#include <iostream>
#include<cmath>
#include<ctime>
#include<string>
#include <iomanip>
#include <fstream>

using namespace std;




void decToBinary(int n)
{
    // array to store binary number 
    int binaryNum[3][3];
    
    //converting to binary 
    for (int i = 0; i < 3; i++) 
    {
        for (int j = 0; j < 3; j++)
        {
            binaryNum[i][j] = n % 2;
            n = n / 2;

        }
     }       

    // printing binary> array in reverse order 
    for (int i = 3-1; i >= 0; i--){
        for (int j = 3 - 1; j >= 0; j--)
        {
            if (binaryNum[i][j] == 0)
                cout << "H" << " ";
            else
                cout << "T" << " ";
        }
        cout << endl;
    }
    
 }

int main()
{
    int n;
    cout << "Enter a decimal number between 1 and 512 ";
    cin >> n;

    decToBinary(n);
    return 0;
}

#include<iostream>
using namespace std;

int sum(int arr[], int a);

int main() {
    int arr[1000], n;
    cin >> n;
    for (int i = 0; i < n; ++i) {
        cin >> arr[i];
        cout << sum(arr, n);
    }
}
int sum(int arr[], int a) {
    int i;
    sum = 0;
    for (i=0; i<n; ++i) {
        sum += arr[i];
    }
    return sum;
}#include<iostream>
using namespace std;

int sum(int arr[], int a);

int main() {
    int arr[1000], n;
    cin >> n;
    for (int i = 0; i < n; ++i) {
        cin >> arr[i];
        cout << sum(arr, n);
    }
}
int sum(int arr[], int a) {
    int i;
    sum = 0;
    for (i=0; i<n; ++i) {
        sum += arr[i];
    }
    return sum;
}

#include <iostream>
#include<cmath>
#include<ctime>
#include<string>
#include <iomanip>
#include <fstream>

using namespace std;

int main()
{
	cout << "enter the month ";
	int month;
	cin >> month;
	cout << "Enter The First Day Of The Month ";
	int firstDay;
	cin >> firstDay;
	int nextSunday = 1;
	
		switch (firstDay)
		{
			
		case 1: nextSunday += 7;
			cout << "The first day of this month is sunday "<<endl;
			while (nextSunday < 30)
			{
					cout << "Next Sunday of this month is on " << nextSunday << endl;
									nextSunday += 7 ;
			}
			break;

		case 2: nextSunday += 6;
			cout << "The first day of this month is monday " << endl;
			while (nextSunday < 30)
			{
				cout << "Next Sunday of this month is on " << nextSunday << endl;
				nextSunday += 7;
			}
			break;
		case 3: nextSunday += 5;
			cout << "The first day of this month is tuesday " << endl;
			while (nextSunday < 30)
			{
				cout << "Next Sunday of this month is on " << nextSunday << endl;
				nextSunday += 7;
			}
			break;
		case 4: nextSunday += 4;
			cout << "The first day of this month is wednesday " << endl;
			while (nextSunday < 30)
			{
				cout << "Next Sunday of this month is on " << nextSunday << endl;
				nextSunday += 7;
			}
			break;
		case 5: nextSunday += 3;
			cout << "The first dayof this month is thursday " << endl;
			while (nextSunday < 30)
			{
				cout << "Next Sunday of this month is on " << nextSunday << endl;
				nextSunday += 7;
			}
			break;
		case 6: nextSunday += 2;
			cout << "The first day of this month is friday " << endl;
			while (nextSunday < 30)
			{
				cout << "Next Sunday of this month is on " << nextSunday << endl;
				nextSunday += 7;
			}
			break;
		case 7: nextSunday += 1;
			cout << "The first day of this month is saturday " << endl;
			while (nextSunday < 30)
			{
				cout << "Next Sunday of this month is on " << nextSunday << endl;
				nextSunday += 7;
			}
			break;

		}
		
}

	
	

int maxSubArraySum(int a[], int size) 
{ 
int max_so_far = 0, max_ending_here = 0; 
for (int i = 0; i < size; i++) 
{ 
	max_ending_here = max_ending_here + a[i]; 
	if (max_ending_here < 0) 
		max_ending_here = 0; 

	/* Do not compare for all elements. Compare only 
		when max_ending_here > 0 */
	else if (max_so_far < max_ending_here) 
		max_so_far = max_ending_here; 
} 
return max_so_far; 
} 

	public:
	int findK(vector<vector<int>> &a, int n, int m, int k)
    {
        // 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
        // k=4
        // 1 2 3
        // 4 5 6
        // 7 8 9
        // Your code goes here
        // if(k==1) return a[0][0];
        int lrow=0;
        int lcol=0;
        int urow=n-1;
        int ucol=m-1;
        int count=0;
        int i=0,j=0;
        while(count!=k){
            //iterating from left to right
            for(j=lcol;j<=ucol;j++){
                // cout<<"i:"<<i<<"j:"<<j<<endl;
                count++;
                if(count==k) {
                    goto x;
                }
            }
            ucol--;
            j--;
            //iterating from up to down
            for(i=lrow+1;i<=urow;i++){
                // cout<<"i:"<<i<<"j:"<<j<<endl;
                count++;
                if(count==k) {
                    goto x;
                }
                
            }
            urow--;
            i--;
            //iterating from right to left
            for(j=ucol;j>=lcol;j--){
                // cout<<"i:"<<i<<"j:"<<j<<endl;
                count++;
                if(count==k) {
                    goto x;
                }
                
            }
            lcol++;
            j++;
            //iterating from down to up
             for(i=urow;i>=lrow+1;i--){
                //  cout<<"i:"<<i<<"j:"<<j<<endl;
                count++;
                if(count==k) {
            // cout<<"lrow:"<<lrow<<" urow:"<<urow<<" lcol:"<<lcol<<" ucol:"<<ucol<<endl;
                    goto x;
                }
                
            }
            lrow++;
            i++;
            
        }
        x:
        return a[i][j];
        
    }

class Solution {
public:
    vector<vector<int>> matrixReshape(vector<vector<int>>& mat, int r, int c) {
        vector<vector<int>>ans(r,vector<int>(c));
        int n = mat.size(), m = mat[0].size();
        if(n*m != r*c)  return mat;
        int p = 0, q = 0;
        for(int i = 0; i < r; ++i) {
            for(int j = 0; j < c; ++j) {
                ans[i][j] = mat[p][q];
                q = (q + 1) % m;
                if(q == 0)  p = p + 1;
            }
        }
        return ans;
    }
};

// TC - O(n) || SC - O(1)
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size() - 1, ans = 0, minSoFar = INT_MAX;
        for(int i = 0; i < n; ++i)  {
            minSoFar = min(minSoFar, prices[i]);
            ans = max(ans, (prices[i] - minSoFar));
        }
        return ans;
    }
};

// we can use auxilary array and store maxSoFar value

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int,int>mp;
        vector<int> ans;
        for(int i = 0; i < nums2.size(); ++i)   mp[nums2[i]]++;
    
        for(int i = 0; i < nums1.size(); ++i)   { 
            if(mp[nums1[i]] > 0)    {
                mp[nums1[i]]--;
                ans.push_back(nums1[i]);
            }
        }
        return ans;
    }
};

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        int i = 0, j = numbers.size() - 1;
        while(i < j) {
            int sum = numbers[i] + numbers[j];
            if(sum == target) return {i + 1, j + 1};
            else if(sum > target)  j--;
            else    i++;
        }
        return {};
    }
};

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        for(int i = 0, j = 0; i < nums.size(); i++) {
            if(nums[i]) {
                swap(nums[i],nums[j++]);
            }
        }
    }
};


//2nd approach
class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int zero = 0, one = 0, n = nums.size()-1;
        while(zero < n && one < n)  {
            while(zero < n && nums[zero] != 0)  {
                zero++;
            }
            one = zero;
            while(one < n && nums[one] == 0)    {
                one++;
            }
            swap(nums[zero],nums[one]);
            zero++; 

        }
    }
};

class Solution {
public:
    void myReverse(vector<int> &nums,int start, int end)   {
        while(start < end)  {
            swap(nums[start++], nums[end--]);
        }
    }
    void rotate(vector<int>& nums, int k) {
        if(nums.size()<2)   return;
        k = k % nums.size();
        myReverse(nums, 0, nums.size() - k - 1);
        myReverse(nums, nums.size()-k, nums.size() - 1);
        myReverse(nums, 0 , nums.size() - 1);
    }
};

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int>ans(nums.size());
        int first = 0, second = nums.size() - 1;
        for(int ind = nums.size() - 1; ind >= 0; ind--)  {
            if(abs(nums[first]) < nums[second]) 
                ans[ind] = nums[second] * nums[second--];
            else    ans[ind] = nums[first] * nums[first++];
        }
        return ans;
        
    }
}


//2nd approch
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int>ans;
        int first = 0,second = 0;
        while(first<nums.size() && nums[first]<0  ) {
            first++;
        }
        second = first;
        first -= 1;
        while(first>=0 && second<nums.size())   {
            if(abs(nums[first] * nums[first]) < (nums[second] * nums[second]))  {
                ans.push_back(nums[first] * nums[first]);
                first--;
            }
            else {
                ans.push_back(nums[second] * nums[second]);
                second++;
            }
        }
        while(first>=0) {
            ans.push_back(nums[first] * nums[first]);
            first--;
        }
        while(second<nums.size())   {
            ans.push_back(nums[second] * nums[second]);
            second++;
        }
        return ans;

    }
};

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_set<int>st(nums.begin(), nums.end());
        cout<<nums.size()<<"  "<<st.size()<<endl;
        return (nums.size() == st.size()) ? false : true; 
    }
};

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int p = m-1, q = n-1, ind = nums1.size()-1;
        while(p>=0 && q>=0) {
            if(nums2[q] > nums1[p]) {
                nums1[ind--] = nums2[q];
                q--;
            }
            else    {
                nums1[ind--] = nums1[p];
                p--;
            }
        }
        while(q >= 0)    {
            nums1[ind--] = nums2[q--];
        }
    }
};