Btukfyl

Programming is not my strongest suit and though the due date for this assignment was not met, I want to at least learn how this works before retaking the course for next year.

The whole point of the program is to be a shipyard management system that handles new packages that are arranged in containers which cannot go over 2000 lbs else it creates a new container for the same destination.

EDIT 3: This is the updated code. Sorry for not clarifying!! :<

class Shipyard:

    def __init__(self):

        self._cont = self.Container(None, None, None, None) 

        self._size = 0



    def __len__(self):

        return self._size



    def isEmpty(self):

        return self._size == 0



    def add_pack(self, owner, dest, weight):

        # adds package when container check is done



        # If shipyard is empty or container name is alphabetically lower than

        # the first container by destination name.



        if self.isEmpty() or dest < self._cont._first._dest:

            self._size += 1

            self._cont._first = self.Container(owner, dest, 

                                               weight, self._cont._first)

            self._cont._first.add_pack(owner, dest, weight)



            return  



        # Else will go through the contents of the linkedlist to find the spot

        # it belongs to.



        cur_Cont = self._cont._first





        while(cur_Cont._next != None and  dest > cur_Cont._next._dest):

            cur_Cont = cur_Cont._next



        if dest == cur_Cont._dest:

            if (cur_Cont._weight + weight) > 2000:

                self._size += 1

                cur_Cont._next = self.Container(owner, dest, 

                                                weight, cur_Cont._next)

                cur_Cont._next.add_pack(owner, dest, weight)

                return



            if (cur_Cont._weight + weight) <= 2000:

                cur_Cont.add_pack(owner, dest, weight)

                return



            if (cur_Cont._next._weight + weight) <= 2000:

                cur_Cont._next.add_pack(owner, dest, weight)

                return





        self._size += 1



        # Creates a new container with the given sepcifications.

        cur_Cont._next = self.Container(owner, dest, weight, cur_Cont._next)

        cur_Cont._next.add_pack(owner, dest, weight)



        return



    def traversePrint(self) :                      # Use for Printing Container

        cur_Cont = self._cont._first               # Modify to include details

        c_weight = cur_Cont._weight



        while cur_Cont != None: # of container or packages

            c_weight = cur_Cont._weight

            print(cur_Cont._dest, c_weight)

            cur_Cont.traversePrint()

            cur_Cont = cur_Cont._next





# -----------------------------------------------------------------------------

# Nested within the Shipyard



    class Container:

        def __init__(self, owner, dest, weight, next):

            self._owner = owner

            self._dest = dest

            self._first = None

            self._size = 0

            self._weight = 0

            self._next = next

            self._pack = self.Packages(None, None, None, None)



        def __len__(self):

            return self._size



        def isEmpty(self):

            return self._size == 0



        def add_pack(self, owner, dest, weight):

            # Add pack for container class which adds a package.



            if self.isEmpty() or weight < self._pack._first._weight:

                self._size += 1

                self._pack._first = self.Packages(owner, dest, 

                                                  weight, self._pack._first)

                self._weight += weight

                return



            cur_Pack = self._pack._first



            while(cur_Pack._next != None and weight > cur_Pack._next._weight):

                cur_Pack = cur_Pack._next



            if weight == cur_Pack._weight:

                self._size += 1

                cur_Pack._next = self.Packages(owner, dest, 

                                                weight, cur_Pack._next)

                self._weight += weight

                return



            self._size += 1

            cur_Pack._next = self.Packages(owner, dest, 

                                           weight, cur_Pack._next)

            self._weight += weight



            return



        def traversePrint(self):

            cur_Pack = self._pack._first               # Modify to include details



            p_weight = cur_Pack._weight



            while cur_Pack != None: # of container or packages

                p_weight = cur_Pack._weight

                if cur_Pack._dest == self._pack._dest:

                    print(cur_Pack._owner, cur_Pack._dest, p_weight, end = " ")

                    cur_Pack = cur_Pack._next

                else:

                    print(cur_Pack._owner, cur_Pack._dest, p_weight)

                    cur_Pack = cur_Pack._next    



# -----------------------------------------------------------------------------

# Nested within Container doesn't contain any methods



        class Packages:



            def __init__(self, owner, dest, weight, next):

                self._first = None

                self._size = 0

                self._owner = owner

                self._dest = dest

                self._weight = weight

                self._next = next



# -----------------------------------------------------------------------------



class Weight(Exception):

    pass



# -----------------------------------------------------------------------------

shipyard = Shipyard()



len(shipyard)



shipyard.add_pack("Lori", "Bristol", 300)

shipyard.add_pack("Mallory", "Bristol", 200)

shipyard.add_pack("Chung", "Alabama", 700)

shipyard.add_pack("Roger", "Alabama", 900)

shipyard.add_pack("Ali", "Giza", 45)

shipyard.add_pack("Soumick", "New Delhi", 600)

shipyard.add_pack("Mizuki", "Tokyo", 1900)

shipyard.add_pack("Tadashi", "Tokyo", 120)

shipyard.add_pack("Kanna", "Tokyo", 220)





shipyard.traversePrint()

This is what appears when program is ran:

Alabama 1600

Chung Alabama 700

Roger Alabama 900

Bristol 500

Mallory Bristol 200

Lori Bristol 300

Giza 45

Ali Giza 45

New Delhi 600

Soumick New Delhi 600

Tokyo 220

Kanna Tokyo 220

Tokyo 120 # THIS AND Tokyo 220 must be added into the same container

Tadashi Tokyo 120 # I don't know what I didn't include because

Tokyo 1900 # It seems to me that Alabama 700 and Alabama 900 were

Mizuki Tokyo 1900 # Adding Correctly.

PROBLEM EDIT: Packages that should be adding aren't adding up together and instead creates an entirely new container. I don't know what part of the code is messing up now T_T.

If there is a question please ask me in the comments below.

Thank you for reading.

Edit: I plan to use an additional add_pack(owner, dest, weight) in the Container section to hold the owner input/parameter and will be called in the Shipyard version of add_pack(owner,dest, weight)

Edit 2: SO I was able to fix the initial problem but now I have another problem/question. Yes, the school required us to use LinkedLists else we didn't get marks for it. Now my new problem is I don't know if I should update the weight of the container class in the Shipyard method add_pack or if I should update it when using add_pack in the Container class.

Edit 3.5: So I updated the code and now it clearly shows the two add_pack methods: One in the Shipyard class and one in the Container class. Sorry for bad edits and formatting. I'm just really frustrated at how I can't figure this thing out.

Edit 4: I've got both traversePrint on Container and Shipyard. Shipyard's traversePrint lists the Containers and Container's traversePrint lists the packages within the containers. I'm able to display the packages w/c leads me to believe they are being added correctly.

Edit 5: I've mostly figured out how to add containers, and packages into containers but some condition checking i.e. If weight of two things add over 2000 lbs else add into the same one <- this isn't working.

Split the problem in happable chunks:

1. record the required shippables (as you currently do)


2. determine how many containers you need for each destination (probably math.ceil(weight(dest) / 2000.0) or something like that)

So your usage will become

shipyard.add_pack("X", "dest", 500)

shipyard.add_pack("X", "dest", 1500)

shipyard.add_pack("X", "dest", 2200)

...



containers = {

   dest: shipyard.containers_for(dest)

   for dest in shipyard.destinations()

}