/* This program demonstrates
 * 1. Reading and printing array values
 * 2. Working with arrays and functions.
 * 2.a: Linear Search
 * 2.b: Left Array Shift
 * a.c: Right Array Shift
 *
 * Arrays can be passed into function like regular variables.
 * However, arrays always behave like they have been passed by reference. 
 * So any changes made to the array in the function will be preserved across the 
 * function call and will be refected in main, or any other calling function.
 */

#include<iostream>
#include<cmath>
using namespace std;

/* Declare the functions here
 * when we pass an array into the function, we don't have to mention the size
 * the array. Mentioning it won't result in an error, but it is not necessary.
 * However, we have to specify it is an array, by using the []
 *
 * Function names are self-descriptive here. They are described while being defined.
 */
 
void cubeElements(double arr[], int size);

int linearSearch(double arr[], int size, double key);

void leftArrayShift(double arr[], int size);



int main()
{
    double arr[10];     // declare the array
    const int NUM = 10;
    //accept array values from the user
    cout<<"\nEnter values for the array: ";
    for(int i=0; i<10; i++)
    {
        cin>>arr[i];
    }

	 /* calling the cubeElements function. Note that when we call the
    * function, we only mention the name of the array.
    */

    cubeElements(arr, NUM);

    /* You will notice that changing the values of array elements in the
     * cubeElements function has resulted in squaring the values of the
     * array in the main function as well. This is because arrays always pass
     * by address (which resembles pass by reference), even without us
     * explicitly saying anything */
	 
    cout<<"After function call: ";
    for(int i=0; i<NUM; i++)
        cout<<arr[i]<<"\t";
    cout<<endl;

    double searchVal;
    int foundPos;
    cout<<"Enter the search value: ";
    cin>>searchVal;

    //call the function, store the returned value in "found"
    foundPos = linearSearch(arr, NUM, searchVal);

    if( foundPos == -1)
        cout<<"The element is not in the array"<<endl;
    else cout<<"The element was found in position "<<foundPos<<endl;

    leftArrayShift(arr, NUM);
    cout<<"\nAfter left shift:\n";
    for(int i=0; i< 10; i++)
    {
        cout<< arr[i]<<"\t";
    }

   
    return 0;
}

/* Function cubeeElements - 2 parameters, returns nothing
 * iterates through the array and cubes the individual elements
 *
 * This function serves to demonstrate that arrays automatically pass by reference
 * We square each array element and put it back in the same place.
 */
void cubeElements( double arr[], int size)
{
    for(int i=0; i<size; i++)
    {
        arr[i] = pow(arr[i],3);
    }
}

/* function linearSearch
 * parameters - array, size, and search value
 * returns - position where search value was found
 *
 * 12 8 19 -6 7, size = 5, search value = 19
 * Ans: return position 2
 *
 * Move through the array
 * Compare value in current index to search key
 *    if found, mark position
 *  If element not found, return an impossible index
 */
int linearSearch(double arr[], int size, double key)
{
    int pos = -1;   // impossibe index for an element to be found in
    for(int i=0; i<size; i++)
    {
        if( arr[i] == key)
        {
            pos = i;
        }
    }
    return pos;
}

/* function leftShift
 * parameters - array and its size
 * returns nothing
 *
 * Moves array elements one spot to the left
 * start at the beginning, N-1 moves
 *
 * element in index 1 moves to index 0
 * element in index 2 moves to index 1
 * elements in index 3 moves to index 2
 *
 * element in index i+1 moves to index i
 * place a 0 in the last index
 */
void leftArrayShift(double arr[], int size)
{
    for(int i=0; i<size -1; i++)
    {
        arr[i] = arr[i+1];
    }
    arr[size-1] = 0;
}