diff --git a/Exercise_1.cpp b/Exercise_1.cpp
deleted file mode 100644
index 381e274d5..000000000
--- a/Exercise_1.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include <bits/stdc++.h> 
-  
-using namespace std; 
-  
-#define MAX 1000 
-  
-class Stack {
-  //Please read sample.java file before starting.
-  //Kindly include Time and Space complexity at top of each file
-    int top; 
-  
-public: 
-    int a[MAX]; // Maximum size of Stack 
-  
-    Stack() { //Constructor here } 
-    bool push(int x); 
-    int pop(); 
-    int peek(); 
-    bool isEmpty(); 
-}; 
-  
-bool Stack::push(int x) 
-{ 
-    //Your code here
-    //Check Stack overflow as well
-} 
-  
-int Stack::pop() 
-{ 
-    //Your code here
-    //Check Stack Underflow as well 
-} 
-int Stack::peek() 
-{ 
-    //Your code here
-    //Check empty condition too
-} 
-  
-bool Stack::isEmpty() 
-{ 
-    //Your code here 
-} 
-  
-// Driver program to test above functions 
-int main() 
-{ 
-    class Stack s; 
-    s.push(10); 
-    s.push(20); 
-    s.push(30); 
-    cout << s.pop() << " Popped from stack\n"; 
-  
-    return 0; 
-} 
diff --git a/Exercise_1.java b/Exercise_1.java
deleted file mode 100644
index 314a3cb45..000000000
--- a/Exercise_1.java
+++ /dev/null
@@ -1,46 +0,0 @@
-class Stack { 
-    //Please read sample.java file before starting.
-  //Kindly include Time and Space complexity at top of each file
-    static final int MAX = 1000; 
-    int top; 
-    int a[] = new int[MAX]; // Maximum size of Stack 
-  
-    boolean isEmpty() 
-    { 
-        //Write your code here 
-    } 
-
-    Stack() 
-    { 
-        //Initialize your constructor 
-    } 
-  
-    boolean push(int x) 
-    { 
-        //Check for stack Overflow
-        //Write your code here
-    } 
-  
-    int pop() 
-    { 
-        //If empty return 0 and print " Stack Underflow"
-        //Write your code here
-    } 
-  
-    int peek() 
-    { 
-        //Write your code here
-    } 
-} 
-  
-// Driver code 
-class Main { 
-    public static void main(String args[]) 
-    { 
-        Stack s = new Stack(); 
-        s.push(10); 
-        s.push(20); 
-        s.push(30); 
-        System.out.println(s.pop() + " Popped from stack"); 
-    } 
-}
diff --git a/Exercise_1.js b/Exercise_1.js
deleted file mode 100644
index 207189ea0..000000000
--- a/Exercise_1.js
+++ /dev/null
@@ -1,35 +0,0 @@
-class Stack {
-  //Please read sample.java file before starting.
-  //Kindly include Time and Space complexity at top of each file
-​
-    constructor() {
-        //Initialize your constructor
-        this.MAX = 1000;
-        this.top = -1;
-        this.a = new Array(this.MAX);
-    }
-​
-    function isEmpty() {
-        //Write your code here
-    }
-​
-    function push(x) {
-        //Check for stack Overflow
-        //Write your code here
-    }
-​
-    function pop() {
-        //If empty return 0 and print " Stack Underflow"
-        //Write your code here
-    }
-​
-    function peek() {
-       //Write your code here
-    }
-}
-​
-let s = new Stack();
-s.push(10);
-s.push(20);
-s.push(30);
-console.log(s.pop() + " Popped from stack");
diff --git a/Exercise_1.py b/Exercise_1.py
deleted file mode 100644
index 532833f5d..000000000
--- a/Exercise_1.py
+++ /dev/null
@@ -1,24 +0,0 @@
-class myStack:
-  #Please read sample.java file before starting.
-  #Kindly include Time and Space complexity at top of each file
-     def __init__(self):
-         
-     def isEmpty(self):
-         
-     def push(self, item):
-         
-     def pop(self):
-        
-        
-     def peek(self):
-        
-     def size(self):
-         
-     def show(self):
-         
-
-s = myStack()
-s.push('1')
-s.push('2')
-print(s.pop())
-print(s.show())
diff --git a/Exercise_2.cpp b/Exercise_2.cpp
deleted file mode 100644
index 1eb3de9b9..000000000
--- a/Exercise_2.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-#include <bits/stdc++.h> 
-using namespace std; 
-  
-// A structure to represent a stack 
-class StackNode { 
-public: 
-    int data; 
-    StackNode* next; 
-}; 
-  
-StackNode* newNode(int data) 
-{ 
-    StackNode* stackNode = new StackNode(); 
-    stackNode->data = data; 
-    stackNode->next = NULL; 
-    return stackNode; 
-} 
-  
-int isEmpty(StackNode* root) 
-{ 
-    //Your code here 
-} 
-  
-void push(StackNode** root, int data) 
-{ 
-    //Your code here 
-} 
-  
-int pop(StackNode** root) 
-{ 
-    //Your code here 
-} 
-  
-int peek(StackNode* root) 
-{ 
-    //Your code here 
-} 
-  
-int main() 
-{ 
-    StackNode* root = NULL; 
-  
-    push(&root, 10); 
-    push(&root, 20); 
-    push(&root, 30); 
-  
-    cout << pop(&root) << " popped from stack\n"; 
-  
-    cout << "Top element is " << peek(root) << endl; 
-  
-    return 0; 
-} 
\ No newline at end of file
diff --git a/Exercise_2.java b/Exercise_2.java
deleted file mode 100644
index 5a9c4868c..000000000
--- a/Exercise_2.java
+++ /dev/null
@@ -1,52 +0,0 @@
-public class StackAsLinkedList { 
-  
-    StackNode root; 
-  
-    static class StackNode { 
-        int data; 
-        StackNode next; 
-  
-        StackNode(int data) 
-        { 
-            //Constructor here 
-        } 
-    } 
-    
-	
-    public boolean isEmpty() 
-    { 
-        //Write your code here for the condition if stack is empty. 
-    } 
-  
-    public void push(int data) 
-    { 
-        //Write code to push data to the stack. 
-    } 
-  
-    public int pop() 
-    { 	
-	//If Stack Empty Return 0 and print "Stack Underflow"
-        //Write code to pop the topmost element of stack.
-	//Also return the popped element 
-    } 
-  
-    public int peek() 
-    { 
-        //Write code to just return the topmost element without removing it.
-    } 
-  
-	//Driver code
-    public static void main(String[] args) 
-    { 
-  
-        StackAsLinkedList sll = new StackAsLinkedList(); 
-  
-        sll.push(10); 
-        sll.push(20); 
-        sll.push(30); 
-  
-        System.out.println(sll.pop() + " popped from stack"); 
-  
-        System.out.println("Top element is " + sll.peek()); 
-    } 
-} 
diff --git a/Exercise_2.js b/Exercise_2.js
deleted file mode 100644
index 2e3216f94..000000000
--- a/Exercise_2.js
+++ /dev/null
@@ -1,36 +0,0 @@
-class StackAsLinkedList {
-​
-    static stackNode = class {
-​
-        constructor(d) {
-            //Constructor here
-            this.data = d;
-            this.next = null;
-        }
-    }
-​
-    function isEmpty() {
-        //Write your code here for the condition if stack is empty.
-    }
-​
-    function push(data) {
-       //Write code to push data to the stack.
-    }
-​
-    function pop() {
-       //If Stack Empty Return 0 and print "Stack Underflow"
-       //Write code to pop the topmost element of stack.
-       //Also return the popped element
-    }
-​
-    function peek() {
-       //Write code to just return the topmost element without removing it.
-    }
-}
-//Driver code
-const sll = new StackAsLinkedList();
-sll.push(10);
-sll.push(20);
-sll.push(30);
-console.log(sll.pop() + " popped from stack");
-console.log("Top element is " + sll.peek());
diff --git a/Exercise_2.py b/Exercise_2.py
deleted file mode 100644
index b11492215..000000000
--- a/Exercise_2.py
+++ /dev/null
@@ -1,32 +0,0 @@
-
-class Node:
-    def __init__(self, data):
-       self.data = data
-       self.next = None
- 
-class Stack:
-    def __init__(self):
-        
-    def push(self, data):
-        
-    def pop(self):
-        
-a_stack = Stack()
-while True:
-    #Give input as string if getting an EOF error. Give input like "push 10" or "pop"
-    print('push <value>')
-    print('pop')
-    print('quit')
-    do = input('What would you like to do? ').split()
-    #Give input as string if getting an EOF error. Give input like "push 10" or "pop"
-    operation = do[0].strip().lower()
-    if operation == 'push':
-        a_stack.push(int(do[1]))
-    elif operation == 'pop':
-        popped = a_stack.pop()
-        if popped is None:
-            print('Stack is empty.')
-        else:
-            print('Popped value: ', int(popped))
-    elif operation == 'quit':
-        break
diff --git a/Exercise_3.cpp b/Exercise_3.cpp
deleted file mode 100644
index f34d89ac1..000000000
--- a/Exercise_3.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-#include <bits/stdc++.h> 
-using namespace std; 
-  
-// A linked list node (changes) 
-class Node  
-{  
-    public: 
-    int data;  
-    Node *next;  
-};  
-  
-/* Given a reference (pointer to pointer) 
-to the head of a list and an int, inserts 
-a new node on the front of the list. */
-void push(Node** head_ref, int new_data)  
-{  
-    /* 1. allocate node */ 
-  
-    /* 2. put in the data */  
-  
-    /* 3. Make next of new node as head */ 
-  
-    /* 4. move the head to point to the new node */
-}  
-  
-/* Given a node prev_node, insert a new node after the given  
-prev_node */
-void insertAfter(Node* prev_node, int new_data)  
-{  
-    /*1. check if the given prev_node is NULL */ 
-  
-    /* 2. allocate new node */ 
-  
-    /* 3. put in the data */ 
-  
-    /* 4. Make next of new node as next of prev_node */
-  
-    /* 5. move the next of prev_node as new_node */ 
-}  
-  
-/* Given a reference (pointer to pointer) to the head  
-of a list and an int, appends a new node at the end */
-void append(Node** head_ref, int new_data)  
-{  
-    /* 1. allocate node */ 
-  
-    /* 2. put in the data */ 
-  
-    /* 3. This new node is going to be  
-    the last node, so make next of  
-    it as NULL*/  
-  
-    /* 4. If the Linked List is empty, 
-    then make the new node as head */
-  
-    /* 5. Else traverse till the last node */
-  
-    /* 6. Change the next of last node */ 
-}  
-  
-// This function prints contents of 
-// linked list starting from head  
-void printList(Node *node)  
-{  
-    //Your code here
-}  
-  
-/* Driver code*/
-int main()  
-{  
-    Node* head = NULL;   
-    append(&head, 6);  
-    push(&head, 7);  
-    push(&head, 1);    
-    append(&head, 4);    
-    insertAfter(head->next, 8);  
-    cout<<"Created Linked list is: ";  
-    printList(head);  
-    return 0;  
-}  
\ No newline at end of file
diff --git a/Exercise_3.java b/Exercise_3.java
deleted file mode 100644
index fb66d329d..000000000
--- a/Exercise_3.java
+++ /dev/null
@@ -1,70 +0,0 @@
-import java.io.*; 
-  
-// Java program to implement 
-// a Singly Linked List 
-public class LinkedList { 
-  
-    Node head; // head of list 
-  
-    // Linked list Node. 
-    // This inner class is made static 
-    // so that main() can access it 
-    static class Node { 
-  
-        int data; 
-        Node next; 
-  
-        // Constructor 
-        Node(int d) 
-        { 
-            //Write your code here 
-        } 
-    } 
-  
-    // Method to insert a new node 
-    public static LinkedList insert(LinkedList list, int data) 
-    { 
-        // Create a new node with given data 
-   
-        // If the Linked List is empty, 
-        // then make the new node as head 
-        
-            // Else traverse till the last node 
-            // and insert the new_node there 
-
-            // Insert the new_node at last node 
-        // Return the list by head 
-        
-    } 
-  
-    // Method to print the LinkedList. 
-    public static void printList(LinkedList list) 
-    {  
-        // Traverse through the LinkedList 
-   
-            // Print the data at current node 
-       
-            // Go to next node 
-    } 
-   
-    // Driver code 
-    public static void main(String[] args) 
-    { 
-        /* Start with the empty list. */
-        LinkedList list = new LinkedList(); 
-  
-        // 
-        // ******INSERTION****** 
-        // 
-  
-        // Insert the values 
-        list = insert(list, 1); 
-        list = insert(list, 2); 
-        list = insert(list, 3); 
-        list = insert(list, 4); 
-        list = insert(list, 5); 
-  
-        // Print the LinkedList 
-        printList(list); 
-    } 
-}
\ No newline at end of file
diff --git a/Exercise_3.js b/Exercise_3.js
deleted file mode 100644
index d1511f80e..000000000
--- a/Exercise_3.js
+++ /dev/null
@@ -1,49 +0,0 @@
-// Java program to implement
-// a Singly Linked List
-class LinkedList {
-    constructor() {
-        this.head = null;
-    }
-     // Linked list Node.
-     static Node = class {
-        constructor(d) {
-            this.data = d;
-            this.next = null;
-        }
-    }
-​
-     // Method to insert a new node
-    function insert(list, data) {
-        // Create a new node with given data
-​
-        // If the Linked List is empty,
-        // then make the new node as head
-​
-        // Else traverse till the last node
-        // and insert the new_node there
-​
-        // Insert the new_node at last node
-        // Return the list by head
-    }
-​
-     // Method to print the LinkedList.
-    function printList(list) {
-        // Traverse through the LinkedList
-​
-        // Print the data at current node
-​
-        // Go to next node
-    }
-}
-       // Driver code
-       /* Start with the empty list. */
-       let list = new LinkedList();
-​
-        // ******INSERTION******
-        // Insert the values
-        list.insert(list, 1);
-        list.insert(list, 2);
-        list.insert(list, 3);
-        list.insert(list, 4);
-        // Print the LinkedList
-        list.printList(list);
diff --git a/Exercise_3.py b/Exercise_3.py
deleted file mode 100644
index a5d466b59..000000000
--- a/Exercise_3.py
+++ /dev/null
@@ -1,32 +0,0 @@
-class ListNode:
-    """
-    A node in a singly-linked list.
-    """
-    def __init__(self, data=None, next=None):
-    
-class SinglyLinkedList:
-    def __init__(self):
-        """
-        Create a new singly-linked list.
-        Takes O(1) time.
-        """
-        self.head = None
-
-    def append(self, data):
-        """
-        Insert a new element at the end of the list.
-        Takes O(n) time.
-        """
-        
-    def find(self, key):
-        """
-        Search for the first element with `data` matching
-        `key`. Return the element or `None` if not found.
-        Takes O(n) time.
-        """
-        
-    def remove(self, key):
-        """
-        Remove the first occurrence of `key` in the list.
-        Takes O(n) time.
-        """
diff --git a/Precourse1-Swift/LinkedList.swift b/Precourse1-Swift/LinkedList.swift
new file mode 100644
index 000000000..0a4e30bdd
--- /dev/null
+++ b/Precourse1-Swift/LinkedList.swift
@@ -0,0 +1,89 @@
+//
+//  LinkedList.swift
+//  DSA-Practice
+//
+//  Created by Paridhi Malviya on 12/16/25.
+//
+
+
+/*
+ To implement a linked list, we need two primary components
+ A Node class - to hold the data aand reference ot the next node
+ LinkedList class - to manage the nodes and provide methods for operations like insertion and traversal
+ */
+
+class Node<T> {
+    var value: T
+    var next: Node<T>? //refrence to the next node in the linkedlist.
+    
+    init(value: T, next: Node<T>? = nil) {
+        self.value = value
+        self.next = next
+    }
+}
+
+//the linkedlist class
+class LinkedList<T> {
+    private var head: Node<T>?
+    private var tail: Node<T>?
+    
+    var isEmpty: Bool {
+        return head == nil
+    }
+    
+    init() { }
+}
+
+//append - insert at the end of the LinkedList
+extension LinkedList {
+    func append(value: T) {
+        let newNode = Node(value: value)
+        if let currentTail = tail {
+            currentTail.next = newNode
+        } else {
+            //If the list was empty, then the new node is both head and tail
+            head = newNode
+        }
+        tail = newNode
+    }
+    
+    //prepend - insert at the beginning
+    //This add a new node to the front of the list, which is an O(1) operation.
+    func prepend(value: T) {
+        let newNode = Node(value: value)
+        if let currentHead = head {
+            newNode.next = currentHead
+        } else {
+            //if the list is empty then head and tail both will be the new node
+            tail = newNode
+        }
+        head = newNode
+    }
+}
+
+//Traversal and display (optional, for testing)
+extension LinkedList: CustomStringConvertible {
+    //you can loop through the list to print it's elements. Can make linkedList conform to the CustomStringConvertible  to easily prints it's elements
+    var description: String {
+        var text = "["
+        var currentHead = head
+        while let node = currentHead {
+            text += "\(node.value)"
+            currentHead = node.next
+            if currentHead != nil  {
+                text += ", "
+            }
+        }
+        return text + "]"
+    }
+}
+
+class LinkedListPractice {
+    init() {
+        let linkedList = LinkedList<String>()
+        linkedList.append(value: "a")
+        linkedList.append(value: "b")
+        linkedList.append(value: "c")
+        print(linkedList)
+    }
+}
diff --git a/Precourse1-Swift/LinkedListToStackAdapter.swift b/Precourse1-Swift/LinkedListToStackAdapter.swift
new file mode 100644
index 000000000..d4294a015
--- /dev/null
+++ b/Precourse1-Swift/LinkedListToStackAdapter.swift
@@ -0,0 +1,159 @@
+//
+//  LinkedListToStackAdapter.swift
+//  DSA-Practice
+//
+//  Created by Paridhi Malviya on 12/16/25.
+//
+
+//Implement stack using linked list
+
+class LLNode<T> {
+    var value: T
+    var next: LLNode<T>?
+    
+    init(value: T, next: LLNode<T>?) {
+        self.value = value
+        self.next = next
+    }
+}
+
+class LLLinkedList<T> {
+    private var head: LLNode<T>?
+    private var tail: LLNode<T>?
+    
+    var isEmpty: Bool {
+        return head == nil
+    }
+    
+    var count: Int {
+        var currentHead = head
+        var count = 0
+        while (currentHead != nil) {
+            count += 1
+            currentHead = currentHead?.next
+        }
+        return count
+    }
+    
+    init() {
+        
+    }
+}
+
+extension LLLinkedList {
+    func append(value: T) {
+        let newNode = LLNode(value: value, next: nil)
+        if head == nil {
+            //means linkedlist is empty, so set the newnode as the head and tail both
+            tail = newNode
+            head = newNode
+        } else {
+            //if linked list is not empty then do normal appending
+            tail?.next = newNode
+            tail = newNode
+        }
+    }
+    
+    func prepend(value: T) {
+        let newNode = LLNode(value: value, next: nil)
+        if head == nil {
+            //linked list is empty
+            head = LLNode(value: value, next: nil)
+            tail = head
+        } else {
+            // linked list is not empty
+            newNode.next = head
+            head = newNode
+        }
+    }
+    
+    func removeFirstNode() -> LLNode<T>? {
+        if (head == nil) {
+            //it means the ll is empty
+            return nil
+        } else {
+            //if the ll is not empty
+            let currentHead = head
+            if let nextNode = head?.next {
+                head = nextNode
+            } else if (head?.next == nil) {
+                head = nil
+            }
+            return currentHead
+        }
+    }
+    
+    var currentHead: LLNode<T>? {
+        return head
+    }
+}
+
+extension LLLinkedList: CustomStringConvertible {
+    var description: String {
+        var currentNode = head
+        var descString = "["
+        while currentNode != nil {
+            descString += "\(String(describing: currentNode?.value))"
+            currentNode = currentNode?.next
+            if (currentNode != nil) {
+                descString += ","
+            }
+        }
+        return descString
+    }
+}
+
+class StackUsingLL<T>: CustomStringConvertible {
+    private var llList: LLLinkedList<T>?
+    
+    init(llList: LLLinkedList<T>) {
+        self.llList = llList
+    }
+    
+    func push(value: T) {
+        //append the first element at the start of the linked list
+        llList?.prepend(value: value)
+    }
+    
+    func pop() -> T? {
+        //remove the first node from the linked list and return it.
+        let removedItem = llList?.removeFirstNode()
+        return removedItem?.value
+    }
+    
+    func peek() -> T? {
+        return llList?.currentHead?.value
+    }
+    
+    func isEmpty() -> Bool {
+        return llList?.isEmpty ?? true
+    }
+
+    var description: String {
+        var currentHead = llList?.currentHead
+        var descString = "["
+        while (currentHead != nil) {
+            descString += "\(currentHead!.value)"
+            currentHead = currentHead!.next
+            if (currentHead != nil) {
+                descString += ","
+            }
+        }
+        return descString
+    }
+}
+
+class LinkedListToStackAdapter {
+    
+    init() {
+        let stack = StackUsingLL<Int>(llList: LLLinkedList())
+        stack.push(value: 2)
+        stack.push(value: 3)
+        stack.push(value: 6)
+        let poppedElement = stack.pop()
+        print("popped element \(poppedElement, default: "NA")")
+        let topElement = stack.peek()
+        print("topElement \(topElement, default: "NA")")
+        print("printed linked list \(stack.description)")
+    }
+}
diff --git a/Precourse1-Swift/SinglyLinkedList.swift b/Precourse1-Swift/SinglyLinkedList.swift
new file mode 100644
index 000000000..b06282cc6
--- /dev/null
+++ b/Precourse1-Swift/SinglyLinkedList.swift
@@ -0,0 +1,73 @@
+//
+//  SinglyLinkedList.swift
+//  DSA-Practice
+//
+//  Created by Paridhi Malviya on 12/17/25.
+//
+
+class SinglyLLNode<T> {
+    var value: T
+    var next: SinglyLLNode<T>?
+    
+    init(value: T, next: SinglyLLNode<T>?) {
+        self.value = value
+        self.next = next
+    }
+}
+
+class SinglyLinkedList<T> {
+    
+    private var head: SinglyLLNode<T>?
+    private var tail: SinglyLLNode<T>?
+    
+    public init() {
+
+    }
+    
+    public var isEmpty: Bool {
+        return head == nil
+    }
+    
+    //adds a new node at the fron tof the list O(1) operation
+    public func push(_ value: T) {
+        head = SinglyLLNode(value: value, next: head)
+        if tail == nil {
+            tail = head
+        }
+    }
+    
+    //Adds a new node at the end of the list with O(1) operation if tail reference is kept
+    func append(value: T) {
+        guard !isEmpty else {
+            push(value)
+            return
+        }
+        //the current tail's next pointer is set to the new node
+        tail?.next = SinglyLLNode(value: value, next: nil)
+        //the new node becomes the new tail
+        tail = tail?.next
+    }
+        
+    public func displayList() {
+        var currentHead = head
+        while currentHead != nil {
+            print("\(currentHead!.value) -> ")
+            currentHead = currentHead?.next
+        }
+    }
+    
+    public func currentHead() -> SinglyLLNode<T>? {
+        return self.head
+    }
+}
+
+class SinglyLinkedListImpl {
+    init() {
+        let linkedlist = SinglyLinkedList<Int>()
+        linkedlist.append(value: 1)
+        linkedlist.append(value: 2)
+        linkedlist.push(30)
+        print("Linked list contents:")
+        linkedlist.displayList()
+    }
+}
diff --git a/Precourse1-Swift/Stack.swift b/Precourse1-Swift/Stack.swift
new file mode 100644
index 000000000..a25a12e71
--- /dev/null
+++ b/Precourse1-Swift/Stack.swift
@@ -0,0 +1,70 @@
+//
+//  Stack.swift
+//  DSA-Practice
+//
+//  Created by Paridhi Malviya on 12/16/25.
+//
+
+struct Stack<T> {
+    private var storage: [T] = []
+    
+    //checks if the stack is empty
+    var isEmpty: Bool {
+        return storage.isEmpty
+    }
+    
+    //returns the number of elements in the stack
+    var count: Int {
+        return storage.count
+    }
+    
+    //adds a new element to the top of the stack
+    mutating func push(element: T) {
+        storage.append(element)
+    }
+    
+    //pop - pops the last element and returns the last element
+    mutating func pop() -> T? {
+        return storage.popLast()
+    }
+    
+    func peek() -> T? {
+        return storage.last
+    }
+    
+    func printDescription() {
+        for element in storage {
+            print(element)
+        }
+    }
+}
+
+struct StringStack {
+    private var stringStack = Stack<String>()
+
+    init() {
+        stringStack.push(element: "first")
+        stringStack.push(element: "second")
+        stringStack.push(element: "third")
+        
+        //check the top element
+        if let topElement = stringStack.peek() {
+            print("the top element is \(topElement)")
+        } else {
+            print("The stack is empty")
+        }
+        
+        let poppedItem = stringStack.pop()
+        print("popped item is \(poppedItem ?? "NA")")
+        
+        print("is stack empty? \(stringStack.isEmpty)")
+        print("stack size \(stringStack.count) *** stack is \(stringStack.printDescription())")
+    
+        print("string stack \(stringStack)")
+        //Example with integers
+        var intStack = Stack<Int>()
+        intStack.push(element: 1)
+        intStack.push(element: 2)
+        print("stack count \(intStack.count)")
+    }
+}