1class MyCircularDeque {
2    // Array to store deque elements
3    private int[] deque;
4    // Index pointing to the front element
5    private int frontIndex;
6    // Current number of elements in the deque
7    private int currentSize;
8    // Maximum capacity of the deque
9    private int maxCapacity;
10
11    /**
12     * Initialize your data structure here. Set the size of the deque to be k.
13     * @param k The maximum capacity of the circular deque
14     */
15    public MyCircularDeque(int k) {
16        deque = new int[k];
17        frontIndex = 0;
18        currentSize = 0;
19        maxCapacity = k;
20    }
21
22    /**
23     * Adds an item at the front of Deque. Return true if the operation is successful.
24     * @param value The value to be inserted at the front
25     * @return true if insertion is successful, false if deque is full
26     */
27    public boolean insertFront(int value) {
28        // Check if deque is full
29        if (isFull()) {
30            return false;
31        }
32      
33        // Move front pointer backwards only if deque is not empty
34        if (!isEmpty()) {
35            // Circular decrement: move front index one position back
36            frontIndex = (frontIndex - 1 + maxCapacity) % maxCapacity;
37        }
38      
39        // Insert value at new front position
40        deque[frontIndex] = value;
41        currentSize++;
42        return true;
43    }
44
45    /**
46     * Adds an item at the rear of Deque. Return true if the operation is successful.
47     * @param value The value to be inserted at the rear
48     * @return true if insertion is successful, false if deque is full
49     */
50    public boolean insertLast(int value) {
51        // Check if deque is full
52        if (isFull()) {
53            return false;
54        }
55      
56        // Calculate rear position: front + size gives us the next empty slot
57        int rearIndex = (frontIndex + currentSize) % maxCapacity;
58        deque[rearIndex] = value;
59        currentSize++;
60        return true;
61    }
62
63    /**
64     * Deletes an item from the front of Deque. Return true if the operation is successful.
65     * @return true if deletion is successful, false if deque is empty
66     */
67    public boolean deleteFront() {
68        // Check if deque is empty
69        if (isEmpty()) {
70            return false;
71        }
72      
73        // Move front pointer forward (circular increment)
74        frontIndex = (frontIndex + 1) % maxCapacity;
75        currentSize--;
76        return true;
77    }
78
79    /**
80     * Deletes an item from the rear of Deque. Return true if the operation is successful.
81     * @return true if deletion is successful, false if deque is empty
82     */
83    public boolean deleteLast() {
84        // Check if deque is empty
85        if (isEmpty()) {
86            return false;
87        }
88      
89        // Simply decrease size, no need to move pointers
90        currentSize--;
91        return true;
92    }
93
94    /**
95     * Get the front item from the deque.
96     * @return The front element value, or -1 if deque is empty
97     */
98    public int getFront() {
99        if (isEmpty()) {
100            return -1;
101        }
102        return deque[frontIndex];
103    }
104
105    /**
106     * Get the last item from the deque.
107     * @return The rear element value, or -1 if deque is empty
108     */
109    public int getRear() {
110        if (isEmpty()) {
111            return -1;
112        }
113      
114        // Calculate rear position: last element is at (front + size - 1)
115        int rearIndex = (frontIndex + currentSize - 1) % maxCapacity;
116        return deque[rearIndex];
117    }
118
119    /**
120     * Checks whether the circular deque is empty or not.
121     * @return true if deque is empty, false otherwise
122     */
123    public boolean isEmpty() {
124        return currentSize == 0;
125    }
126
127    /**
128     * Checks whether the circular deque is full or not.
129     * @return true if deque is full, false otherwise
130     */
131    public boolean isFull() {
132        return currentSize == maxCapacity;
133    }
134}
135
136/**
137 * Your MyCircularDeque object will be instantiated and called as such:
138 * MyCircularDeque obj = new MyCircularDeque(k);
139 * boolean param_1 = obj.insertFront(value);
140 * boolean param_2 = obj.insertLast(value);
141 * boolean param_3 = obj.deleteFront();
142 * boolean param_4 = obj.deleteLast();
143 * int param_5 = obj.getFront();
144 * int param_6 = obj.getRear();
145 * boolean param_7 = obj.isEmpty();
146 * boolean param_8 = obj.isFull();
147 */
148

1class MyCircularDeque {
2private:
3    vector<int> buffer;      // Fixed-size array to store deque elements
4    int frontIndex;          // Index pointing to the front element
5    int currentSize;         // Current number of elements in the deque
6    int maxCapacity;         // Maximum capacity of the deque
7  
8public:
9    // Constructor: Initialize circular deque with maximum size k
10    MyCircularDeque(int k) {
11        buffer.assign(k, 0);
12        frontIndex = 0;
13        currentSize = 0;
14        maxCapacity = k;
15    }
16  
17    // Insert an element at the front of the deque
18    bool insertFront(int value) {
19        // Check if deque is full
20        if (isFull()) {
21            return false;
22        }
23      
24        // Move front pointer backward circularly (only if deque is not empty)
25        if (!isEmpty()) {
26            frontIndex = (frontIndex - 1 + maxCapacity) % maxCapacity;
27        }
28      
29        // Insert value at new front position
30        buffer[frontIndex] = value;
31        currentSize++;
32        return true;
33    }
34  
35    // Insert an element at the rear of the deque
36    bool insertLast(int value) {
37        // Check if deque is full
38        if (isFull()) {
39            return false;
40        }
41      
42        // Calculate rear position and insert value
43        int rearIndex = (frontIndex + currentSize) % maxCapacity;
44        buffer[rearIndex] = value;
45        currentSize++;
46        return true;
47    }
48  
49    // Delete the front element from the deque
50    bool deleteFront() {
51        // Check if deque is empty
52        if (isEmpty()) {
53            return false;
54        }
55      
56        // Move front pointer forward circularly
57        frontIndex = (frontIndex + 1) % maxCapacity;
58        currentSize--;
59        return true;
60    }
61  
62    // Delete the last element from the deque
63    bool deleteLast() {
64        // Check if deque is empty
65        if (isEmpty()) {
66            return false;
67        }
68      
69        // Simply decrease size (rear pointer is calculated dynamically)
70        currentSize--;
71        return true;
72    }
73  
74    // Get the front element of the deque
75    int getFront() {
76        return isEmpty() ? -1 : buffer[frontIndex];
77    }
78  
79    // Get the rear element of the deque
80    int getRear() {
81        if (isEmpty()) {
82            return -1;
83        }
84        // Calculate rear position: (front + size - 1) with wrap-around
85        int rearIndex = (frontIndex + currentSize - 1) % maxCapacity;
86        return buffer[rearIndex];
87    }
88  
89    // Check if the deque is empty
90    bool isEmpty() {
91        return currentSize == 0;
92    }
93  
94    // Check if the deque is full
95    bool isFull() {
96        return currentSize == maxCapacity;
97    }
98};
99
100/**
101 * Your MyCircularDeque object will be instantiated and called as such:
102 * MyCircularDeque* obj = new MyCircularDeque(k);
103 * bool param_1 = obj->insertFront(value);
104 * bool param_2 = obj->insertLast(value);
105 * bool param_3 = obj->deleteFront();
106 * bool param_4 = obj->deleteLast();
107 * int param_5 = obj->getFront();
108 * int param_6 = obj->getRear();
109 * bool param_7 = obj->isEmpty();
110 * bool param_8 = obj->isFull();
111 */
112

1// Global variables for circular deque implementation
2let vals: number[];      // Array to store deque elements
3let length: number;       // Current number of elements in deque
4let size: number;         // Maximum capacity of deque
5let start: number;        // Index pointing to the front element
6let end: number;          // Index pointing to the position after rear element
7
8/**
9 * Initialize the circular deque with maximum size k
10 * @param k - Maximum capacity of the deque
11 */
12function MyCircularDeque(k: number): void {
13    vals = new Array(k).fill(0);
14    start = 0;
15    end = 0;
16    length = 0;
17    size = k;
18}
19
20/**
21 * Add an element at the front of the deque
22 * @param value - Value to be inserted
23 * @returns true if operation successful, false if deque is full
24 */
25function insertFront(value: number): boolean {
26    // Check if deque is full
27    if (isFull()) {
28        return false;
29    }
30
31    // Move start pointer backward circularly
32    if (start === 0) {
33        start = size - 1;
34    } else {
35        start--;
36    }
37  
38    // Insert value at new front position
39    vals[start] = value;
40    length++;
41    return true;
42}
43
44/**
45 * Add an element at the rear of the deque
46 * @param value - Value to be inserted
47 * @returns true if operation successful, false if deque is full
48 */
49function insertLast(value: number): boolean {
50    // Check if deque is full
51    if (isFull()) {
52        return false;
53    }
54
55    // Insert value at current end position
56    vals[end] = value;
57    length++;
58  
59    // Move end pointer forward circularly
60    if (end + 1 === size) {
61        end = 0;
62    } else {
63        end++;
64    }
65    return true;
66}
67
68/**
69 * Delete an element from the front of the deque
70 * @returns true if operation successful, false if deque is empty
71 */
72function deleteFront(): boolean {
73    // Check if deque is empty
74    if (isEmpty()) {
75        return false;
76    }
77
78    // Move start pointer forward circularly
79    if (start + 1 === size) {
80        start = 0;
81    } else {
82        start++;
83    }
84    length--;
85    return true;
86}
87
88/**
89 * Delete an element from the rear of the deque
90 * @returns true if operation successful, false if deque is empty
91 */
92function deleteLast(): boolean {
93    // Check if deque is empty
94    if (isEmpty()) {
95        return false;
96    }
97
98    // Move end pointer backward circularly
99    if (end === 0) {
100        end = size - 1;
101    } else {
102        end--;
103    }
104    length--;
105    return true;
106}
107
108/**
109 * Get the front element of the deque
110 * @returns Front element value, or -1 if deque is empty
111 */
112function getFront(): number {
113    // Return -1 if deque is empty
114    if (isEmpty()) {
115        return -1;
116    }
117
118    // Return element at start position
119    return vals[start];
120}
121
122/**
123 * Get the rear element of the deque
124 * @returns Rear element value, or -1 if deque is empty
125 */
126function getRear(): number {
127    // Return -1 if deque is empty
128    if (isEmpty()) {
129        return -1;
130    }
131
132    // Get the actual rear position (one position before end)
133    if (end === 0) {
134        return vals[size - 1];
135    }
136    return vals[end - 1];
137}
138
139/**
140 * Check if the deque is empty
141 * @returns true if deque is empty, false otherwise
142 */
143function isEmpty(): boolean {
144    return length === 0;
145}
146
147/**
148 * Check if the deque is full
149 * @returns true if deque is full, false otherwise
150 */
151function isFull(): boolean {
152    return length === size;
153}
154