using System;

using System.Collections;

public class Program

{

    // Implementacion pensada para una Single Linked List

    public class Node {

        public bool Status {get; set;}

        public uint Start {get; init;}

        public uint Final {get; set; }

        public Node Next { get; set; }

    }

    public class LinkedList {

        public enum FitAlgorithm {

            Best,

            Worst,

            First,

            Next

        }

        private Node lastFreeNode, firstNode;

        private void LinkNodes(Node n1, Node n2) {

                n1.Next = n2;

        }

        public void Assign(uint process, FitAlgorithm fitAlgorithm) {

            switch(fitAlgorithm) {

                case FitAlgorithm.First:

                    UseFirstFitAlgorithm(process);

                    break;

                case FitAlgorithm.Best:

                    UseBestFitAlgorithm(process);

                    break;

                case FitAlgorithm.Worst:

                    UseWorstFitAlgorithm(process);

                    break;

                case FitAlgorithm.Next:

                    UseNextFitAlgorith(process);

                    break;

            }

        }

        private void UseFirstFitAlgorithm(uint process) {

            Node current = firstNode.Next;

            while(current is not null) {            

                ContiguousFreePartitions(current);

                if(!current.Status && process <= (current.Final - current.Start + 1)) {

                    current.Status = true;

                    if((current.Final - current.Start + 1 - process) != 0) {                                    

                        Node frag = new Node() {

                            Status = false,

                            Start = current.Start + process,

                            Final = current.Final

                        };

                        current.Final = current.Start + process - 1;

                        frag.Next = current.Next;

                        current.Next = frag;

                    }

                }

                current = current.Next;

            }

        }

        private void ContiguousFreePartitions (Node current) {

            Node piv = current.Next;

            while(!current.Status && !piv.Status) 

            {

                current.Final = piv.Next.Final;

                current.Next = piv.Next.Next;

                piv = current.Next;

            }

        }

        // Recorrido en la lista completa

        private void UseBestFitAlgorithm(uint process) {

        }

        // Recorrido en la lista completa

        private void UseWorstFitAlgorithm(uint process) {

        }

        private void UseNextFitAlgorith(uint process) {

        }

    }

    public static void Main()

    {

    }

}