def printFrom(findData):
    start = findNode(findData)
    if start == None:
        print(findData, 'not found')
        return
    printNodes(start)

head, current, pre = None, None, None
node = Node()
node.data, node.time = procs[0]
head = node
node.link = head
for name, t in procs[1:]:
    pre = node
    node = Node()
    node.data, node.time = name, t
    pre.link = node
    node.link = head

def roundRobin():
    global head, current, pre
    pre = node                          # last node
    current = head
    while True:
        run = min(QUANTUM, current.time)
        current.time -= run
        print(current.data, "run", run, "-> remaining", current.time)
        if current.time == 0:
            print(current.data, "finished")
            if current.link == current:     # only one process left
                head = None
                return
            pre.link = current.link         # remove from the circle
            if current == head:
                head = current.link
            current = current.link
        else:
            pre = current
            current = current.link

roundRobin()
print("All processes done")

class Node():
    def __init__(self):
        self.data = None
        self.link = None

def printNodes(start):
    if start == None:
        print("The list is empty.")
        return
    current = start
    print(current.data, end=' ')
    while current.link != start:
        current = current.link
        print(current.data, end=' ')
    print()

def insertNode(findData, insertData):
    global head
    node = Node()
    node.data = insertData
    current = head
    while True:                     # insert after the findData node
        if current.data == findData:
            node.link = current.link
            current.link = node
            return True
        current = current.link
        if current == head:
            return False

def deleteNode(deleteData):
    global head
    pre = head
    current = head.link
    while True:                     # find the target node and its previous node (pre)
        if current.data == deleteData:
            if current == pre:      # only one node in the list
                head = None
            else:
                pre.link = current.link
                if current == head:
                    head = current.link
            return True
        if current == head:
            return False
        pre = current
        current = current.link

def findNode(findData):
    current = head
    while True:
        if current.data == findData:
            return current
        current = current.link
        if current == head:
            return None

head = None

while True:
    print("Circular List (1:Insert, 2:Delete, 3:Search, 4:Print, 5:Exit)")
    select = input(">>")
    if select == '1':
        if head == None:            # first node
            head = Node()
            head.data = input(">>Enter data to insert : ")
            head.link = head
        else:
            findData = input(">>Insert position (after) : ")
            insertData = input(">>Data to insert : ")
            if not insertNode(findData, insertData):
                print(findData, "is not in the list.")
    elif select == '2':
        deleteData = input(">>Data to delete : ")
        if head != None and deleteNode(deleteData):
            print(deleteData + " has been deleted.")
        else:
            print(deleteData, "is not in the list.")
    elif select == '3':
        findData = input(">>Data to search : ")
        if head != None and findNode(findData) != None:
            print("Data found :", findData)
        else:
            print("Data not found :", findData)
    elif select == '4':
        printNodes(head)
    elif select == '5':
        print("Exiting the program.")
        break

def countMultiplesOf3():
    global head
    count = 0
    total = 0
    current = head
    while True:
        if current.data % 3 == 0:
            count += 1
            total += current.data
        current = current.link
        if current == head:
            break
    return count, total

# Usage
c, s = countMultiplesOf3()
print(f"Count of multiples of 3: {c}, Sum: {s}")

def findNeighbors(head, target):
    current = head
    while current != None:
        if current.data == target:
            prev = current.plink.data if current.plink else "None (first)"
            next_ = current.nlink.data if current.nlink else "None (last)"
            print(f"Previous: {prev}")
            print(f"Found: {current.data}")
            print(f"Next: {next_}")
            return
        current = current.nlink
    print("Name not found.")

def deleteMinority(head):
    # Count odd and even
    oddCnt = evenCnt = 0
    current = head
    while True:
        if current.data % 2 == 0:
            evenCnt += 1
        else:
            oddCnt += 1
        current = current.link
        if current == head:
            break

    # Determine which to delete
    target = 0 if oddCnt > evenCnt else 1  # 0=even, 1=odd

    current = head
    while True:
        nextNode = current.link
        if current.data % 2 == target:
            if current == head:
                # Find last node, update its link
                last = head
                while last.link != head:
                    last = last.link
                head = current.link
                last.link = head
            else:
                pre.link = current.link
        else:
            pre = current
        current = nextNode
        if current == head:
            break
    return head