Skip to content

Commit 56056b2

Browse files
YangFongYangFong
committed
feat: add solutions to lc problems: No.0622,0729
- No.0622.Design Circular Queue - No.0729.My Calendar I
1 parent efa21f1 commit 56056b2

File tree

7 files changed

+507
-0
lines changed

7 files changed

+507
-0
lines changed

‎solution/0600-0699/0622.Design Circular Queue/README.md

+145
Original file line numberDiff line numberDiff line change
@@ -182,6 +182,151 @@ class MyCircularQueue {
182182
*/
183183
```
184184

185+
### **TypeScript**
186+
187+
```ts
188+
class MyCircularQueue {
189+
private queue: number[];
190+
private left: number;
191+
private right: number;
192+
private capacity: number;
193+
194+
constructor(k: number) {
195+
this.queue = new Array(k);
196+
this.left = 0;
197+
this.right = 0;
198+
this.capacity = k;
199+
}
200+
201+
enQueue(value: number): boolean {
202+
if (this.isFull()) {
203+
return false;
204+
}
205+
this.queue[this.right % this.capacity] = value;
206+
this.right++;
207+
return true;
208+
}
209+
210+
deQueue(): boolean {
211+
if (this.isEmpty()) {
212+
return false;
213+
}
214+
this.left++;
215+
return true;
216+
}
217+
218+
Front(): number {
219+
if (this.isEmpty()) {
220+
return -1;
221+
}
222+
return this.queue[this.left % this.capacity];
223+
}
224+
225+
Rear(): number {
226+
if (this.isEmpty()) {
227+
return -1;
228+
}
229+
return this.queue[(this.right - 1) % this.capacity];
230+
}
231+
232+
isEmpty(): boolean {
233+
return this.right - this.left === 0;
234+
}
235+
236+
isFull(): boolean {
237+
return this.right - this.left === this.capacity;
238+
}
239+
}
240+
241+
/**
242+
* Your MyCircularQueue object will be instantiated and called as such:
243+
* var obj = new MyCircularQueue(k)
244+
* var param_1 = obj.enQueue(value)
245+
* var param_2 = obj.deQueue()
246+
* var param_3 = obj.Front()
247+
* var param_4 = obj.Rear()
248+
* var param_5 = obj.isEmpty()
249+
* var param_6 = obj.isFull()
250+
*/
251+
```
252+
253+
### **Rust**
254+
255+
```rust
256+
struct MyCircularQueue {
257+
queue: Vec<i32>,
258+
left: usize,
259+
right: usize,
260+
capacity: usize,
261+
}
262+
263+
/**
264+
* `&self` means the method takes an immutable reference.
265+
* If you need a mutable reference, change it to `&mut self` instead.
266+
*/
267+
impl MyCircularQueue {
268+
fn new(k: i32) -> Self {
269+
let k = k as usize;
270+
Self {
271+
queue: vec![0; k],
272+
left: 0,
273+
right: 0,
274+
capacity: k,
275+
}
276+
}
277+
278+
fn en_queue(&mut self, value: i32) -> bool {
279+
if self.is_full() {
280+
return false;
281+
}
282+
self.queue[self.right % self.capacity] = value;
283+
self.right += 1;
284+
true
285+
}
286+
287+
fn de_queue(&mut self) -> bool {
288+
if self.is_empty() {
289+
return false;
290+
}
291+
self.left += 1;
292+
true
293+
}
294+
295+
fn front(&self) -> i32 {
296+
if self.is_empty() {
297+
return -1;
298+
}
299+
self.queue[self.left % self.capacity]
300+
}
301+
302+
fn rear(&self) -> i32 {
303+
if self.is_empty() {
304+
return -1;
305+
}
306+
self.queue[(self.right - 1) % self.capacity]
307+
}
308+
309+
fn is_empty(&self) -> bool {
310+
self.right - self.left == 0
311+
}
312+
313+
fn is_full(&self) -> bool {
314+
self.right - self.left == self.capacity
315+
}
316+
}
317+
/**
318+
* Your MyCircularQueue object will be instantiated and called as such:
319+
* let obj = MyCircularQueue::new(k);
320+
* let ret_1: bool = obj.en_queue(value);
321+
* let ret_2: bool = obj.de_queue();
322+
* let ret_3: i32 = obj.front();
323+
* let ret_4: i32 = obj.rear();
324+
* let ret_5: bool = obj.is_empty();
325+
* let ret_6: bool = obj.is_full();
326+
*/
327+
*/
328+
```
329+
185330
### **...**
186331

187332
```

‎solution/0600-0699/0622.Design Circular Queue/README_EN.md

+145
Original file line numberDiff line numberDiff line change
@@ -181,6 +181,151 @@ class MyCircularQueue {
181181
*/
182182
```
183183

184+
### **TypeScript**
185+
186+
```ts
187+
class MyCircularQueue {
188+
private queue: number[];
189+
private left: number;
190+
private right: number;
191+
private capacity: number;
192+
193+
constructor(k: number) {
194+
this.queue = new Array(k);
195+
this.left = 0;
196+
this.right = 0;
197+
this.capacity = k;
198+
}
199+
200+
enQueue(value: number): boolean {
201+
if (this.isFull()) {
202+
return false;
203+
}
204+
this.queue[this.right % this.capacity] = value;
205+
this.right++;
206+
return true;
207+
}
208+
209+
deQueue(): boolean {
210+
if (this.isEmpty()) {
211+
return false;
212+
}
213+
this.left++;
214+
return true;
215+
}
216+
217+
Front(): number {
218+
if (this.isEmpty()) {
219+
return -1;
220+
}
221+
return this.queue[this.left % this.capacity];
222+
}
223+
224+
Rear(): number {
225+
if (this.isEmpty()) {
226+
return -1;
227+
}
228+
return this.queue[(this.right - 1) % this.capacity];
229+
}
230+
231+
isEmpty(): boolean {
232+
return this.right - this.left === 0;
233+
}
234+
235+
isFull(): boolean {
236+
return this.right - this.left === this.capacity;
237+
}
238+
}
239+
240+
/**
241+
* Your MyCircularQueue object will be instantiated and called as such:
242+
* var obj = new MyCircularQueue(k)
243+
* var param_1 = obj.enQueue(value)
244+
* var param_2 = obj.deQueue()
245+
* var param_3 = obj.Front()
246+
* var param_4 = obj.Rear()
247+
* var param_5 = obj.isEmpty()
248+
* var param_6 = obj.isFull()
249+
*/
250+
```
251+
252+
### **Rust**
253+
254+
```rust
255+
struct MyCircularQueue {
256+
queue: Vec<i32>,
257+
left: usize,
258+
right: usize,
259+
capacity: usize,
260+
}
261+
262+
/**
263+
* `&self` means the method takes an immutable reference.
264+
* If you need a mutable reference, change it to `&mut self` instead.
265+
*/
266+
impl MyCircularQueue {
267+
fn new(k: i32) -> Self {
268+
let k = k as usize;
269+
Self {
270+
queue: vec![0; k],
271+
left: 0,
272+
right: 0,
273+
capacity: k,
274+
}
275+
}
276+
277+
fn en_queue(&mut self, value: i32) -> bool {
278+
if self.is_full() {
279+
return false;
280+
}
281+
self.queue[self.right % self.capacity] = value;
282+
self.right += 1;
283+
true
284+
}
285+
286+
fn de_queue(&mut self) -> bool {
287+
if self.is_empty() {
288+
return false;
289+
}
290+
self.left += 1;
291+
true
292+
}
293+
294+
fn front(&self) -> i32 {
295+
if self.is_empty() {
296+
return -1;
297+
}
298+
self.queue[self.left % self.capacity]
299+
}
300+
301+
fn rear(&self) -> i32 {
302+
if self.is_empty() {
303+
return -1;
304+
}
305+
self.queue[(self.right - 1) % self.capacity]
306+
}
307+
308+
fn is_empty(&self) -> bool {
309+
self.right - self.left == 0
310+
}
311+
312+
fn is_full(&self) -> bool {
313+
self.right - self.left == self.capacity
314+
}
315+
}
316+
/**
317+
* Your MyCircularQueue object will be instantiated and called as such:
318+
* let obj = MyCircularQueue::new(k);
319+
* let ret_1: bool = obj.en_queue(value);
320+
* let ret_2: bool = obj.de_queue();
321+
* let ret_3: i32 = obj.front();
322+
* let ret_4: i32 = obj.rear();
323+
* let ret_5: bool = obj.is_empty();
324+
* let ret_6: bool = obj.is_full();
325+
*/
326+
*/
327+
```
328+
184329
### **...**
185330

186331
```

‎solution/0600-0699/0622.Design Circular Queue/Solution.rs

+72
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,72 @@
1+
struct MyCircularQueue {
2+
queue: Vec<i32>,
3+
left: usize,
4+
right: usize,
5+
capacity: usize,
6+
}
7+
8+
/**
9+
* `&self` means the method takes an immutable reference.
10+
* If you need a mutable reference, change it to `&mut self` instead.
11+
*/
12+
impl MyCircularQueue {
13+
fn new(k: i32) -> Self {
14+
let k = k as usize;
15+
Self {
16+
queue: vec![0; k],
17+
left: 0,
18+
right: 0,
19+
capacity: k,
20+
}
21+
}
22+
23+
fn en_queue(&mut self, value: i32) -> bool {
24+
if self.is_full() {
25+
return false;
26+
}
27+
self.queue[self.right % self.capacity] = value;
28+
self.right += 1;
29+
true
30+
}
31+
32+
fn de_queue(&mut self) -> bool {
33+
if self.is_empty() {
34+
return false;
35+
}
36+
self.left += 1;
37+
true
38+
}
39+
40+
fn front(&self) -> i32 {
41+
if self.is_empty() {
42+
return -1;
43+
}
44+
self.queue[self.left % self.capacity]
45+
}
46+
47+
fn rear(&self) -> i32 {
48+
if self.is_empty() {
49+
return -1;
50+
}
51+
self.queue[(self.right - 1) % self.capacity]
52+
}
53+
54+
fn is_empty(&self) -> bool {
55+
self.right - self.left == 0
56+
}
57+
58+
fn is_full(&self) -> bool {
59+
self.right - self.left == self.capacity
60+
}
61+
}
62+
/**
63+
* Your MyCircularQueue object will be instantiated and called as such:
64+
* let obj = MyCircularQueue::new(k);
65+
* let ret_1: bool = obj.en_queue(value);
66+
* let ret_2: bool = obj.de_queue();
67+
* let ret_3: i32 = obj.front();
68+
* let ret_4: i32 = obj.rear();
69+
* let ret_5: bool = obj.is_empty();
70+
* let ret_6: bool = obj.is_full();
71+
*/
72+
*/

0 commit comments

Comments
 (0)