!! Unit test functions in TASK1 AND 2 ARE FROM CHATGPT !!

-----------------------------------------------------------------------------------
------------------------

TASK 1:

#include<iostream>
#include <cassert>

using namespace std;

template<typename T>
struct Node{
public:
Node* next;
Node* prev;
T data;

Node(T data){
this->data = data;
next = nullptr;
prev = nullptr;
}
};

template<typename T>
class deque{
Node<T>* headptr = nullptr;
Node<T>* tailptr = nullptr;
int count;
public:

deque(){
count = 0;
};

~deque(){};

bool empty() {
if (count == 0){
return true;
}
else
return false;
}

int size() const{

return count;
}

void push_front(const T item){

Node<T>* newnode = new Node<T>(item);
if(headptr == nullptr){
headptr = newnode;
count++;
}
else if(count == 1){
 headptr->prev = newnode;
tailptr = headptr;
headptr = headptr->prev;
headptr->next = tailptr;
count++;
}
else{
headptr->prev = newnode;
newnode->next = headptr;
headptr = newnode;
count++;
}
}

void push_back(const T item){

Node<T>* newnode = new Node<T>(item);
if(headptr == nullptr){
headptr = newnode;
tailptr = newnode;
count++;
}
else{
tailptr->next = newnode;
newnode->prev = tailptr;
tailptr = newnode;
count++;
}
}

T pop_front(){
T a;
if(empty()){
cout << "Deque is empty " << endl;
}
else if(count == 1){
Node<T>* temp = headptr;
a = temp->data;
delete temp;
headptr = nullptr;
tailptr = nullptr;
count--;
return a;
}
else{
Node<T>* temp = headptr;
headptr = headptr->next;
headptr->prev = nullptr;
delete temp;
count--;
return a;

}
return a;
}

T pop_back(){
T a;
if(empty()){
 cout << "Deque is empty " << endl;
}
else if(count == 1){
Node<T>* temp = headptr;
a = temp->data;
delete temp;
headptr = nullptr;
tailptr = nullptr;
count--;
return a;
}
else{
Node<T>* temp = tailptr;
tailptr = tailptr->prev;
tailptr->next = nullptr;
delete temp;
count--;
return a;

}
return a;

}
void display(){
Node<T>* temp = headptr;
while(temp != nullptr){
cout << temp->data << endl;
temp = temp->next;
}
}

};

static void unit_test() {

deque<int> deque;

// Test 1: Initial state of the deque

cout << "Test 1: Initial State" << endl;
assert(deque.empty() == true);
assert(deque.size() == 0);
cout << "Initial state test passed!" << endl;

// Test 2: Push elements to the front and check size

cout << "Test 2: Push front" << endl;
deque.push_front(10);
assert(deque.size() == 1);
assert(deque.empty() == false);

deque.push_front(20);
assert(deque.size() == 2);

// Test 3: Push elements to the back and check size

cout << "Test 3: Push back" << endl;
deque.push_back(30);
assert(deque.size() == 3);

deque.push_back(40);
assert(deque.size() == 4);
 // Test 4: Print and verify order (should print 20 10 30 40)
cout << "Test 4: Print deque" << endl;
deque.display(); // Expected: 20 10 30 40
cout << endl;

// Test 5: Pop from front

cout << "Test 5: Pop front" << endl;
deque.pop_front(); // Remove 20
assert(deque.size() == 3);

deque.pop_front(); // Remove 10
assert(deque.size() == 2);

// Test 6: Pop from back

cout << "Test 6: Pop back" << endl;
deque.pop_back(); // Remove 40
assert(deque.size() == 1);

deque.pop_back(); // Remove 30
assert(deque.size() == 0);
assert(deque.empty() == true);

// Test 7: Check popping from empty deque throws error

cout << "Test 7: Pop from empty deque" << endl;
try {
deque.pop_back();
assert(false); // Should not reach here
} catch (const runtime_error& e) {
cout << "Caught exception: " << e.what() << endl;
}

try {
deque.pop_front();
assert(false); // Should not reach here
} catch (const runtime_error& e) {
cout << "Caught exception: " << e.what() << endl;
}

cout << "All tests passed!" << endl;

}

int main ()
{
// deque<int> d1;
// d1.push_front(1);
// d1.push_front(2);
// d1.push_front(3);
// d1.push_back(5);
// d1.pop_front();
// d1.pop_back();
// d1.display();

unit_test();

}
-----------------------------------------------------------------------------------
------------------------

TASK 2:

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

template <typename Item>

class RandomisedQueue {
vector<Item> items;
public:
RandomisedQueue() {
srand(time(0));
}

bool empty() const {

return items.empty();
}

int size() const {

return items.size();
}

void enqueue(const Item& item) {

items.push_back(item);
}

Item dequeue() {
if (empty()) {
throw runtime_error("Queue is empty");
}
int index = rand() % items.size();
Item item = items[index];
items[index] = items[items.size() - 1]; // Swap with the last element
items.pop_back();
return item;
}

Item sample() const {

if (empty()) {
throw runtime_error("Queue is empty");
}
int index = rand() % items.size();
return items[index];
}

void display() const {

for (const auto& item : items) {
cout << item << " ";
}
cout << endl;
}
};

static void unit_test() {

 RandomisedQueue<int> q;

cout << "Unit Test for RandomisedQueue\n";

// Test 1: Enqueue items

cout << "Test 1: Enqueue items {10, 20, 30}\n";
q.enqueue(10);
q.enqueue(20);
q.enqueue(30);
q.display();

// Test 2: Size check

cout << "Test 2: Check size\n";
cout << "Queue size: " << q.size() << " (Expected: 3)\n\n";

// Test 3: Dequeue an item

cout << "Test 3: Dequeue an item\n";
int removedItem = q.dequeue();
cout << "Item removed: " << removedItem << endl;
q.display();
cout << "Queue size after dequeue: " << q.size() << " (Expected: 2)\n\n";

// Test 4: Sample an item

cout << "Test 4: Sample an item\n";
int sampledItem = q.sample();
cout << "Sampled item: " << sampledItem << endl;
cout << "Queue state (unchanged):\n";
q.display();
cout << "Queue size after sample: " << q.size() << " (Expected: 2)\n\n";

// Test 5: Empty check

cout << "Test 5: Empty check\n";
while (!q.empty()) {
q.dequeue();
}
cout << "Queue size after clearing: " << q.size() << " (Expected: 0)\n";
cout << (q.empty() ? "Queue is empty\n" : "Queue is not empty\n");

// Test 6: Dequeue on empty queue

cout << "Test 6: Dequeue on an empty queue (should throw exception)\n";
try {
q.dequeue();
} catch (const runtime_error& e) {
cout << "Caught expected exception: " << e.what() << endl;
}
}

int main() {
// RandomisedQueue<int> q;
// q.enqueue(1);
// q.enqueue(3);
// q.enqueue(5);
// q.enqueue(6);
// q.enqueue(9);

// cout << "Item removed: " << q.dequeue() << endl;

// q.display();
// cout << "Random item from queue: " << q.sample() << endl;
 unit_test();

return 0;
}

-----------------------------------------------------------------------------------
------------------------

TASK 3A:
#include<iostream>
#include<fstream>
#include <vector>
#include "RandomisedQueue.cpp"
using namespace std;

template<typename Item>
void subset(RandomisedQueue<Item>&queue){
int k;
cout << "Enter the number of elements you want in the subset: ";
cin >> k;

int size = queue.size() - k;

for(int i = 0;i < size;i++){

queue.dequeue();
}
}

int main(){

RandomisedQueue<char>distinct;
RandomisedQueue<string>duplicate;
char temp;
string temp2;

ifstream in("C:\\Users\\geniu\\OneDrive\\Desktop\\distinct.txt");
while(in >> temp){
distinct.enqueue(temp);
}
in.close();

distinct.display();
subset(distinct);
cout << "Subset: ";
distinct.display();

ifstream in2("C:\\Users\\geniu\\OneDrive\\Desktop\\duplicates.txt");
while(in2 >> temp2){
duplicate.enqueue(temp2);
}
in2.close();
duplicate.display();
subset(duplicate);
cout << "Subset: ";
duplicate.display();
}

-----------------------------------------------------------------------------------
------------------------

TASK 3B:

#include<iostream>
#include "Deque.cpp"
using namespace std;

bool palindrome(deque<char>d){
bool palindrome = true ;
string basepair;

while (d.size() > 1 ) {

char front = d.pop_front();
char back = d.pop_back();
string basepair = string(1, front) + string(1, back);

if (basepair != "AT" && basepair != "TA" && basepair != "CG" && basepair !=
"GC") {
palindrome = false;
break;
}
}
return palindrome;
}

int main ()
{
deque<char> d ;
char ch;
cout << "Enter a DNA sequence (A, T, C, G) --- (PRESS 'b' to exit): " << endl;

while (cin >> ch) {

if (ch == 'A' || ch == 'T' || ch == 'C' || ch == 'G') {
d.push_back(ch);
}
else if(ch == 'b'){
break;
}
else {
cout << "Invalid DNA sequenece: " << ch << ". Only A, T, C, G are
allowed." << endl;
}
}
cout << endl;
d.display();
if(palindrome(d)){
cout << "Sequence is palindrome" << endl;
}
else cout << "Not palindrome";
}