ICT1018Coursework

#include<string.h>
#include <stdlib.h>
#include <iostream>
#include <cstdlib>
#include <time.h>
#include <cctype>
#include <algorithm>
using namespace std;

//Declarations
const int A_size = 256;
const int B_size = 257;
int TestList[10] = {0,2,2,3,4,6,6,8,9,9};
int A[A_size];
int B[B_size];
int C[A_size + B_size];
int temp;

//Question Declarations
void Question1();
void Question2();
void Question3(int arr[], int size);
void Question4(int arr[], int size);
void Question5(string input);
bool Question6a(int isprime);
bool Question6b(int isprime);
void Question7();
void Question8(int newt);
void Question9(int list[], int size);
void Question10(int list[], int size);
void Question11(char f, int in, int n);
void Question12(int n);

//General Use Function Declarations
void ShellSort(int arr[], int size);
void QuickSort(int arr[], int lower, int upper);
int Split(int arr[], int lower, int upper);
void Print(int list[], int size);
bool contains(int check, int list[], int size);
int FindMax(int list[], int size);
int Factorial(int n);
double sine(int in, int n);
double cosine(int in, int n);

int main()
{
    //execute questions
    Question1();
    Question2();
    Question3(A, A_size);
    //Question4(A, A_size); //running array A through question 4 takes a long time...
                            //uncomment at your own risk
    Question5("34+2+2x5/");
    Question5("345+++"); //testing error catching
    Question6a(100);
    Question6a(13);
    Question6b(14);
    Question6b(19);
    Question7();
    Question8(16);
    Question8(2);
    Question8(13);
    Question9(TestList, 10);
    Question10(A, A_size);
    Question11('c', 4, 4);
    Question11('s', 1, 6);
    Question12(11);
}

void Question1(){
    std::cout << "-------------------------------------------------------\n";
    std::cout << "Question 1\n";

    //seeding the rand fucntion to provide better random
    srand (time(NULL));

    //declaration of A
    for(int i = 0; i < A_size; i++){
        A[i] = 0 + (rand() % 1024);
    }
    //declaration of B
    for(int i = 0; i < B_size; i++){
        B[i] = 0 + (rand() % 1024);
    }
    //shell sort A
    ShellSort(A, A_size);
    std::cout << "A:\n";
    Print(A, A_size);
    //quick sort B
    QuickSort(B, 0, B_size - 1);
    std::cout << "B:\n";
    Print(B, B_size);

}
void Question2(){
    std::cout << "-------------------------------------------------------\n";
    std::cout << "Question 2\n";
    int a = 0, b = 0;
    //merge
    for(int c = 0; c < (A_size + B_size); c++){
        if(!(a < A_size)){
            C[c] = B[b];
            b++;
        }
        else if (!(b < B_size)){
            C[c] = A[a];
            a++;
        }
        else if (A[a] <= B[b]){
            C[c] = A[a];
            a++;
        }
        else{
            C[c] = B[b];
            b++;
        }
    }
    std::cout << "C:\n";
    Print(C, A_size + B_size);
}
void Question3(int arr[], int size){
    std::cout << "-------------------------------------------------------\n";
    std::cout << "Question 3\n";
    bool EXTREME = 0;
    for(int i = 0; i < size; i++){
        if(i !=0 && i != size - 1){
            if(arr[i - 1] < arr[i] && arr[i] > arr[i + 1] || arr[i - 1] > arr[i] && arr[i] < arr[i + 1]){
                EXTREME = 1;
                std::cout << "extreme\n";
            }
        }
    }
    if(!EXTREME){
        std::cout << "Sorted\n";
    }
}
void Question4(int arr[], int size){
    std::cout << "-------------------------------------------------------\n";
    std::cout << "Question 4\n";
    for(int a = 0; a < size; a++){
        for(int b = 0; b < size; b++){
            for(int c = 0; c < size; c++){
                for(int d = 0; d < size; d++){
                    if(a !=b && b != c && c != d){
                        int ab = a * b;
                        int cd = c * d;
                        if(ab == cd && ab != 0){
                            std::cout << a << "*" << b << ":"
                            << c << "*" << d << " = " << ab <<
                            "\n";
                        }
                    }

                }
            }
        }
    }
}
void Question5(string input){
    std::cout << "-------------------------------------------------------\n";
    std::cout << "Question 5\n";
    bool WRONG = false;
    bool numb = true; //bool to determine if next input should be number or operator;
    int currnum = 0; //int to hold current working num;
    int len = 0;
    while (input[len] != '\0') len++;
    if(isdigit(input.at(0))){
        int sum = (int)(input.at(0)) - (int)('0');
        for(int i = 1; i < len; i++){
            if(numb){
                if(isdigit(input.at(i))){
                    currnum = (int)(input.at(i)) - (int)('0');
                }else{
                     WRONG = true;
                }
            }else{
                //std::cout << sum << " " << input.at(i) << " " << currnum << " = ";
                switch(input.at(i)){
                    case '+': sum = sum + currnum; break;
                    case '-': sum = sum - currnum; break;
                    case 'x': sum = sum * currnum; break;
                    case '/': sum = sum / currnum; break;
                    default : WRONG = true;

                }
                //std::cout << sum << "\n";
            }
            numb = !numb;
        }
        if(!WRONG) std::cout << "Answer = " << sum << "\n";
        else std::cout << "Incorrect Syntax!\n";
    }

    else {
        std::cout << "First character must be a number!\n";
        WRONG = true;
    }
}
bool Question6a(int isprime){
    std::cout << "-------------------------------------------------------\n";
    std::cout << "Question 6a\n";
    bool prime = true;
    int half = isprime / 2;
    for(int i = 2; i < half; i++){
        int math = isprime % i;
        if(math == 0){
            prime = false;
        }
    }

    prime?(std::cout << isprime << " is prime\n"):
    (std::cout << isprime << " is not prime\n");
    return prime;
}
bool Question6b(int isprime){
    std::cout << "-------------------------------------------------------\n";
    std::cout << "Question 6b\n";
    int list[isprime];
    for(int i = 2; i < isprime + 1; i++){
        list[i] = i;
    }
    for(int i = 1; i < isprime + 1; i++){
        if(list[i] != 0){
            for(int j = i+1; j < isprime + 1; j++){
                int math = list[j] % list[i];
                if(math == 0){
                    list[j] = 0;
                }
            }
        }
    }
    if(list[isprime] != 0) {
        std::cout << isprime << " is prime\n";
    }else{
        std::cout << isprime << " is not prime\n";
    }
    if(list[isprime] != 0)return true;
    else return false;
}
void Question7(){

}
void Question8(int newt){
    std::cout << "-------------------------------------------------------\n";
    std::cout << "Question 8\n";
    double diff = 1;
    double out = newt / 2.0;
    double old;
    while(diff > 0.001){
        old = out;
        out = 0.5 * (out + (newt / out));
        diff = out - old;
        if(diff<0.0) diff =- diff;
    }
    std::cout << "Root of " << newt << " is " << out << "\n";
}
void Question9(int list[], int size){
    std::cout << "-------------------------------------------------------\n";
    std::cout << "Question 9\n";
    int repeated[size];
    int j = 0;
    for(int i = 0; i < size; i++){
        for(int k = i; k < size; k++){
            bool in = contains(list[k], repeated, j);
            if(!in){
                if(list[i] == list[k]){
                    repeated[j] = list[i];
                    j++;
                }
            }
        }
    }
    Print(repeated, j);
}
void Question10(int list[], int size){
    std::cout << "-------------------------------------------------------\n";
    std::cout << "Question 10\n";
    int maxi = FindMax(list, size);
    std::cout << "Max is " << maxi << "\n";
}
void Question11(char f, int in, int n){
    std::cout << "-------------------------------------------------------\n";
    std::cout << "Question 11\n";
    switch(f){
        case 's': std::cout << sine(in, n) << "\n"; break;
        case 'c': std::cout << cosine(in, n) << "\n"; break;
        default: std::cout << "Please select sine (s) or cosine (c)\n";
    }
}
void Question12( int n){
    std::cout << "-------------------------------------------------------\n";
    std::cout << "Question 12\n";
    int sum = 1;
    int old = 1;
    int oldR = 0;
    for (int i = 0; i < n+1; i++){
        if(i > 0) {
            if(i > 1) {
                int temp = old;
                old = old + oldR;
                sum+= old;
                oldR = temp;
            }
        }
    }
    std::cout<<"Sum of first " << n << " fib numbers = "<<sum<<"\n";
}
void ShellSort(int list[], int size){
    for (int i = size / 2.0; i > 0; i = i / 2.0){
        for (int j = i; j < size; j++){
            int k = j, temp = list[j];
            while((k>i-1) && (list[k-i] > temp)){
                list[k] = list[k-i];
                k = k-i;
            }
        list[k] = temp;
        }
    }
}
void QuickSort(int list[], int lower, int upper){
    if (upper - lower > 0) {
        int center = Split(list, lower, upper);
        QuickSort(list, lower, center - 1);
        QuickSort(list, center + 1, upper);
    }
}
int Split (int list[], int lower, int upper){
    int L = list[upper];
    int OIndex = (lower - 1);
    for (int j = lower; j <= upper-1; j++) {
        if (list[j] <= L) {
            OIndex++;
            int temp = list[OIndex];
            list[OIndex] = list[j];
            list[j] = temp;
        }
    }
    int NIndex = OIndex+1;
    int temp = list[NIndex];
    list[NIndex] = list[upper];
    list[upper] = temp;
    return (NIndex);
}
void Print(int list[], int size) {

    for (int i = 0; i < size; i++) {
        std::cout << list[i] << "\t";
    }
    std::cout << "\n";
}
bool contains(int check, int list[], int size){
    bool out = false;
    for(int i = 0; i < size; i++){
        if(check == list[i]){
            out = true;
            break;
        }
    }
    return out;
}
int FindMax(int list[], int size){
    if(size != 1){
        if(list[size-1] > FindMax(list, size - 1)){
            return list[size-1];
        }else{
            return FindMax(list, size - 1);
        }
    }
    else return list[0];
}
int Factorial(int n){
    int out = 1;
    for(int i = n; i > 0; i--){
        out = out * i;
    }
    return out;
}
double sine(int in, int n){
    double sum = in;
    bool negs = true;
    for(int i = 0; i < n; i++){
        int num = 3 + 2*i;
        double math = pow(in,(num)) / Factorial(num);
        if(negs)sum = sum - math;
            else sum = sum + math;
        negs = !negs;
    }
    return sum;
}
double cosine(int in, int n){
    double sum = 1;
    bool negc = true;
    for(int i = 0; i < n; i++){
        int num = 2 + 2*i;
        double math = pow(in,(num)) / Factorial(num);
        if(negc)sum = sum - math;
        else sum = sum + math;
        negc = !negc;
    }
    return sum;
}