#include <iostream>

struct tuple {
    int tuple_count = 0;
    char * tuple_arr_type = new char[48];

    bool * tuple_bool = new bool[48];
    char * tuple_char = new char[48];
    int * tuple_int = new int[48];
    double * tuple_double = new double[48];
    long int * tuple_lint = new long int[48];
};


void tuple_add(tuple & arr, bool elem) {
    arr.tuple_bool[arr.tuple_count] = elem;
    arr.tuple_arr_type[arr.tuple_count] = 'b';
    arr.tuple_count++;
}

void tuple_add(tuple & arr, char elem) {
    arr.tuple_char[arr.tuple_count] = elem;
    arr.tuple_arr_type[arr.tuple_count] = 'c';
    arr.tuple_count++;
}

void tuple_add(tuple & arr, int elem) {
    arr.tuple_int[arr.tuple_count] = elem;
    arr.tuple_arr_type[arr.tuple_count] = 'i';
    arr.tuple_count++;
}

void tuple_add(tuple & arr, double elem) {
    arr.tuple_double[arr.tuple_count] = elem;
    arr.tuple_arr_type[arr.tuple_count] = 'd';
    arr.tuple_count++;
}

void tuple_add(tuple & arr, long int elem) {
    arr.tuple_lint[arr.tuple_count] = elem;
    arr.tuple_arr_type[arr.tuple_count] = 'l';
    arr.tuple_count++;
}

// Del function's (no tuple)
void del_elem_arr(bool * arr, int size, int index) {
    for (int i = index; i < size - 1; i++) {
        arr[i] = arr[i + 1];
    }
}

void del_elem_arr(char * arr, int size, int index) {
    for (int i = index; i < size - 1; i++) {
        arr[i] = arr[i + 1];
    }
}

void del_elem_arr(int * arr, int size, int index) {
    for (int i = index; i < size - 1; i++) {
        arr[i] = arr[i + 1];
    }
}

void del_elem_arr(double * arr, int size, int index) {
    for (int i = index; i < size - 1; i++) {
        arr[i] = arr[i + 1];
    }
}

void del_elem_arr(long int * arr, int size, int index) {
    for (int i = index; i < size - 1; i++) {
        arr[i] = arr[i + 1];
    }
}

// Del function (tuple)
void tuple_del(tuple & arr, int index) {
    if (index < arr.tuple_count && index > -1) {
        char type = arr.tuple_arr_type[index];


        del_elem_arr(arr.tuple_arr_type, arr.tuple_count, index);

        if (type == 'b') {
            del_elem_arr(arr.tuple_bool, arr.tuple_count, index);
        } else
        if (type == 'c') {
            del_elem_arr(arr.tuple_char, arr.tuple_count, index);
        } else
        if (type == 'i') {
            del_elem_arr(arr.tuple_int, arr.tuple_count, index);
        } else
        if (type == 'd') {
            del_elem_arr(arr.tuple_double, arr.tuple_count, index);
        } else
        if (type == 'l') {
            del_elem_arr(arr.tuple_lint, arr.tuple_count, index);
        }

        arr.tuple_count--;
    } else {
        std::cout << "\nERROR: invalid index\n";
    }
}

// Return function's
bool tuple_return_bool(tuple & arr, int index) {
    char type = arr.tuple_arr_type[index];
    bool value = 0;

    if (type == 'b') {
        value = arr.tuple_double[index];
    } else
    if (type == 'c') {
        value = arr.tuple_char[index];
    } else
    if (type == 'i') {
        value = arr.tuple_int[index];
    } else
    if (type == 'd') {
        value = arr.tuple_double[index];
    } else
    if (type == 'l') {
        value = arr.tuple_lint[index];
    }

    if (index >= arr.tuple_count || index < 0) {
        std::cout << "\nERROR: invalid index. Return value zero (false).\n";
        return 0;
    }

    return value;
}

char tuple_return_char(tuple & arr, int index) {
    char type = arr.tuple_arr_type[index];
    char value = 0;

    if (type == 'b') {
        value = arr.tuple_double[index];
    } else
    if (type == 'c') {
        value = arr.tuple_char[index];
    } else
    if (type == 'i') {
        value = arr.tuple_int[index];
    } else
    if (type == 'd') {
        value = arr.tuple_double[index];
    } else
    if (type == 'l') {
        value = arr.tuple_lint[index];
    }

    if (index >= arr.tuple_count || index < 0) {
        std::cout << "\nERROR: invalid index. Return value zero (false).\n";
        return 0;
    }

    return value;
}

int tuple_return_int(tuple & arr, int index) {
    char type = arr.tuple_arr_type[index];
    int value = 0;

    if (type == 'b') {
        value = arr.tuple_double[index];
    } else
    if (type == 'c') {
        value = arr.tuple_char[index];
    } else
    if (type == 'i') {
        value = arr.tuple_int[index];
    } else
    if (type == 'd') {
        value = arr.tuple_double[index];
    } else
    if (type == 'l') {
        value = arr.tuple_lint[index];
    }

    if (index >= arr.tuple_count || index < 0) {
        std::cout << "\nERROR: invalid index. Return value zero (false).\n";
        return 0;
    }

    return value;
}

double tuple_return_double(tuple & arr, int index) {
    char type = arr.tuple_arr_type[index];
    double value = 0;

    if (type == 'b') {
        value = arr.tuple_double[index];
    } else
    if (type == 'c') {
        value = arr.tuple_char[index];
    } else
    if (type == 'i') {
        value = arr.tuple_int[index];
    } else
    if (type == 'd') {
        value = arr.tuple_double[index];
    } else
    if (type == 'l') {
        value = arr.tuple_lint[index];
    }

    if (index >= arr.tuple_count || index < 0) {
        std::cout << "\nERROR: invalid index. Return value zero (false).\n";
        return 0;
    }

    return value;
}

long int tuple_return_long_int(tuple & arr, int index) {
    char type = arr.tuple_arr_type[index];
    double value = 0;

    if (type == 'b') {
        value = arr.tuple_double[index];
    } else
    if (type == 'c') {
        value = arr.tuple_char[index];
    } else
    if (type == 'i') {
        value = arr.tuple_int[index];
    } else
    if (type == 'd') {
        value = arr.tuple_double[index];
    } else
    if (type == 'l') {
        value = arr.tuple_lint[index];
    }

    if (index >= arr.tuple_count || index < 0) {
        std::cout << "\nERROR: invalid index. Return value zero (false).\n";
        return 0;
    }

    return value;
}

void tuple_output(tuple & arr) {
    std::cout << "\nOutput tuple (size: " << arr.tuple_count << "): {";
    for (int i = 0; arr.tuple_count > i; i++) {
        char type = arr.tuple_arr_type[i];

        if (type == 'b') {
            if (arr.tuple_bool[i] == 0) {
                std::cout << " False ";
            } else {
                std::cout << " True ";
            }

        } else
        if (type == 'c') {
            std::cout << " '" << arr.tuple_char[i] << "' ";
        } else
        if (type == 'i') {
            std::cout << " " << arr.tuple_int[i] << " ";
        } else
        if (type == 'd') {
            std::cout << " " << arr.tuple_double[i] << " ";
        } else
        if (type == 'l') {
            std::cout << " " << arr.tuple_lint[i] << " ";
        }
    }
    std::cout << "}\n";
}

int main() {
    tuple tuple_test;

    tuple_add(tuple_test, 0.3);
    for (int i = 0; 5 > i; i++) {
        static int k = 1;
        k *= 2;

        tuple_add(tuple_test, k);
    }
    tuple_add(tuple_test, 0.6);

    for (int i = 0; 5 > i; i++) {
        static int k = 1;
        k *= 2;

        tuple_add(tuple_test, k);
    }

    tuple_output(tuple_test);

    for (int i = 0; 7 > i; i++) {
        tuple_del(tuple_test, 0);
    }

    tuple_output(tuple_test);

    for (int i = 0; tuple_test.tuple_count > i; i++) {
        static int k = 0;
        k += tuple_return_int(tuple_test, i);

        if (i == tuple_test.tuple_count - 1) {
            std::cout << "Summa: " << k << std::endl;
        }
    }

    int k = tuple_test.tuple_count;
    for (int i = 0; k > i; i++) {
        char symbol = (tuple_return_int(tuple_test, i) % 26) + 65;
        tuple_add(tuple_test, symbol);
    }

    tuple_output(tuple_test);

    return 0;
}