from SLNode import SLNode

class QueueException$($Exception$)$:

$"""$

Custom exception to be used by Queue class

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

pass

class Queue:

def $\_\_$init$\_\_($self$)$:

$"""$

Initialize new queue with head and tail nodes

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

self.$\_$head $=$ None

self.$\_$tail $=$ None

def $\_\_$str$\_\_($self$)$:

$"""$

Return content of queue in human$-$readable form

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

out $=$ 'QUEUE $[\text{'}$

if not self.is$\_$empty$()$:

node $=$ self.$\_$head

out $=$ out $+$ str$($node$.$value$)$

node $=$ node.next

while node:

out $=$ out $+\text{'}->\text{'}+$ str$($node$.$value$)$

node $=$ node.next

return out $+\text{'}]\text{'}$

def is$\_$empty$($self$)->$ bool:

$"""$

Return True is the queue is empty, False otherwise

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

return self.$\_$head is None

def size$($self$)->$ int:

$"""$

Return number of elements currently in the queue

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

node $=$ self.$\_$head

length $=0$

while node:

length $+=1$

node $=$ node.next

return length

# $-----------------------------------------------------------------------$

def enqueue$($self$,$ value: object$)->$ None:

$"""$

TODO: Write this implementation

$"""$

pass

def dequeue$($self$)->$ object:

$"""$

TODO: Write this implementation

$"""$

pass

def front$($self$)->$ object:

$"""$

TODO: Write this implementation

$"""$

pass

# $-------------------$ BASIC TESTING $-----------------------------------------$

if $\_\_$name$\_\_=="\_\_$main$\_\_"$:

print$("$

# enqueue example $1")$

q $=$ Queue$()$

print$($q$)$

for value in $[1,2,3,4,5]$:

q$.$enqueue$($value$)$

print$($q$)$

print$("$

# dequeue example $1")$

q $=$ Queue$()$

for value in $[1,2,3,4,5]$:

q$.$enqueue$($value$)$

print$($q$)$

for i in range$(6)$:

try:

print$($q$.$dequeue$())$

except Exception as e:

print$("$No elements in queue", type$($e$))$

print$(\text{'}$

#front example $1\text{'})$

q $=$ Queue$()$

print$($q$)$

for value in $[\text{'}$A$\text{'},\text{'}$B$\text{'},\text{'}$C$\text{'},\text{'}$D$\text{'}]$:

try:

print$($q$.$front$())$

except Exception as e:

print$("$No elements in queue", type$($e$))$

q$.$enqueue$($value$)$

print$($q$)$

class QueueException$($Exception$)$:

$"""$

Custom exception to be used by Queue class.

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

pass

class Queue:

def $\_\_$init$\_\_($self$)->$ None:

$"""$

Initialize new queue based on Static Array.

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

self.$\_$sa $=$ StaticArray$(4)$

self.$\_$front $=0$

self.$\_$back $=-1$

self.$\_$current$\_$size $=0$

def $\_\_$str$\_\_($self$)->$ str:

$"""$

Override string method to provide more readable output.

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

size $=$ self.$\_$current$\_$size

out $=$ "QUEUE: $"+$ str$($size$)+"$ element$($s$).["$

front$\_$index $=$ self.$\_$front

for $\_$ in range$($size $-1)$:

out $+=$ str$($self$.\_$sa$[$front$\_$index$])+\text{'},\text{'}$

front$\_$index $=$ self.$\_$increment$($front$\_$index$)$

if size $>0$:

out $+=$ str$($self$.\_$sa$[$front$\_$index$])$

return out $+\text{'}]\text{'}$

def is$\_$empty$($self$)->$ bool:

$"""$

Return True if the queue is empty, False otherwise.

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

return self.$\_$current$\_$size $==0$

def size$($self$)->$ int:

$"""$

Return number of elements currently in the queue.

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

return self.$\_$current$\_$size

def print$\_$underlying$\_$sa$($self$)->$ None:

$"""$

Print underlying StaticArray. Used for testing purposes.

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

print$($self$.\_$sa$)$

def $\_$increment$($self$,$ index: int$)->$ int:

$"""$

Move index to next position.

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

# employ wraparound if needed

index $+=1$

if index $==$ self.$\_$sa$.$length$()$:

index $=0$

return index

# $----------------------------------------------------------------------$ #

def enqueue$($self$,$ value: object$)->$ None:

$"""$

TODO: Write this implementation

$"""$

pass

def dequeue$($self$)->$ object:

$"""$

TODO: Write this implementation

$"""$

pass

def front$($self$)->$ object:

$"""$

TODO: Write this implementation

$"""$

pass

TODO: Write this implementation

$"""$

pass

def dequeue$($self$)->$ object:

$"""$

TODO: Write this implementation

$"""$

pass

def front$($self$)->$ object:

$"""$

TODO: Write this implementation

$"""$

pass

# The method below is optional, but recommended, to implement. #

# You may alter it in any way you see fit. #

def $\_$double$\_$queue$($self$)->$ None:

$"""$

TODO: Write this implementation

$"""$

pass