Wate
Bechamel
White Suga
Chedda
Milk
Rennet
Citric Acid
AP Flou
Gluten
Eggs
Butte
Salt
Yeast
Oil
Tomato
Molasses
Baking Soda
Noodles
Garlic Bread Garlic Butter,Bread Dough,Mozzarella
Pizza Bread Dough,Tomato Sauce,Mozzarella
Ginger Cookies Ginger,Rye,Brown Sugar,Baking Powder,Salted Butte
Mac & Cheese Cheese Sauce,Noodles
Cheese Bread Bread Dough,Cheddar,Mozzarella
Brownies AP Flour,Butter,Chocolate,Coffee,Baking Powder,Eggs
Pancakes Baking Soda,Buttermilk,AP Flour,White Sugar,Salt
Tzatziki Yogurt,Dill,Cucumber,Garlic,Salt,Oil
Chippy Cookies AP Flour,Chocolate,Baking Soda,Butter,Eggs,White Sugar,Brown Sugar,Salt
Spaghetti Noodles,Tomato Sauce
----------
Bread Dough Bread Flour,Water,White Sugar,Salt,Yeast,Oil
Baking Powder Baking Soda,Cream of Tarta
Bechamel Milk,Roux
Bread Flour AP Flour,Gluten
Brown Sugar Molasses,White Suga
Butter Milk
Cheese Sauce Bechamel,Chedda
Mozzarella Milk,Rennet,Citric Acid
Noodles AP Flour,Eggs,Wate
Pickles Cucumber,Salt,Vinega
Relish Pickles
Roux AP Flour,Butte
Salted Butter Butter,Salt
Tomato Sauce Tomato
Task 3 — Who’s hungry?
Did you know there once existed a time when you couldn’t get a single iced capp delivered straight to your door without
having to
ave the cruel harsh weather of a mildly humid day, all for a pittance of a delivery fee of only ten bucks or so?
It’s true!
(Where the heck did I put that cane again...)
Back in my day, we used to actually cook for ourselves, dangit! (Disclaimer: this is a lie. Ignore the goofy premise because
it can help us immensely with things like compilers, dependencies, task scheduling, and myriad genuine graph problems)
If all we had was flour, eggs, water, and tomatoes, why that’s enough to make some basic noodles with a tomato sauce!
You want some cookies, but the recipe calls for
own sugar? Just combine white sugar and molasses! (Because molasses
is totally more common to keep around than
own sugar)
In fact, many common ingredients can actually be made from basic staples (you can even make
ead flour from AP flour
if for some reason you have vital wheat gluten lying around). And of course, ingredients can be made into tasty, tasty
dishes!
This assignment is the graphs assignment, and centres around either working out what dishes you could make based
only on what’s already in your pantry, generating a ‘shopping list’ to know what you’d need to pick up if you already have
the week’s meals planned out, or even just knowing what to set out in the kitchen before working on a single dish.
Of course, this could raise issues like some ingredients being both derivable and purchaseable, but luckily it’ll always be
pretty straight-forward (e.g. if you only have salt + butter, you don’t need to buy salted butter; but nobody would ever
say “oh? I need salted butter and already have salt? I should totally buy the unsalted butter then!”).
The Task:
Again, this is the graphs assignment. This means you’re creating a graph. More specifically, you’re going to approach this
using an adjacency list or matrix. However, you’ll need to be very careful about how you do so!
Above, you can see part of one possible Cookbook: it is a graph that shows how myriad ingredients can be combined to
form dishes. Ostensibly there are three different types of item:
• Base ingredients (e.g. Oil): You have them, or you don’t. Suitable for a shopping list, and might be found in you
Pantry, or it might not be
• Derivable ingredients (e.g. Tomato Sauce): These are also something you might see on a shopping list, but if you
have all the Base ingredients (or other derivable ingredients) that lead to them, then you might still be able to
make them (so anything relying on them can also be made)
• Dishes: The only thing that distinguishes these from derivable ingredients is they’ll never show up on the
shopping list. e.g. if you want Mac & Cheese, then you’re only getting it if the Cheese Sauce and Noodles come
from some combination of Pantry and shopping list
The user will select a data file for the cookbook; you only need to wo
y about one for a given execution, but there could
e several different ones in general. The format for the data file is as follows:
• One line each for the dishes:
o First the name of the dish
o Then a tab characte
o Then comma-separated ingredients necessary to make that dish
o Spaces are permitted (for both the dish and the ingredients); simply take them as the whole term (e.g.
Garlic Bread is a dish)
• A line of precisely 10 dashes: ----------
• One line each for the derivable ingredients (that aren’t dishes):
o Same convention as for the dishes
The user will also select a data file for preloading the initial state of the Pantry. The data file’s format is trivial:
• Each line is an ingredient
• It’s legal to be a ‘base ingredient’ or a ‘derivable ingredient’ (there’s no need for a distinction)
• (Note: there is no concept of quantity. For the purpose of this assignment, if you have eggs, you have eggs)
It should be pretty obvious from the bold and Courier font, but the Cookbook and Pantry are separate classes from
your main program. For the sake of simplicity, you are permitted to assume that, across all dishes and ingredients, there
will never be more than 1000 labels to keep track of. (i.e. once you get to dealing with the graph, you can assume an
upper limit of 1000 vertices, if you like)
The program, after loading in the cookbook and pantry contents, must offer the user some basic options:
• The ability to display everything that could be made, using the recipes in the cookbook
• The ability to see all of the available options for dishes that could be made
• The ability to see all dishes that could be made with the cu
ent stock in the Pantry
o Note: this obviously includes taking advantage of recipes for derivable ingredients
• The ability to see the contents of your Pantry
• The ability to add more items to the Pantry
• The ability to ask whether or not a user-specified dish can be made based on the Pantry’s cu
ent stock
• Creation of a shopping list:
o Based on a selection of desired dishes, as well as the cu
ent stock of the Pantry
o You will not purchase a derivable ingredient if you already have all components necessary to make it
o You will purchase a derivable ingredient if you’re missing even one component (as per the first page, if
you have salt, but need salted butter, you’re just going to buy some salted butter; not regular butter with
the expectation of salting it. But if you have salt and milk, then you can make salted butter)
• Display a listing for mise en place:
o It’s just the thing where you get all the ingredients you’re going to need ready in advance. In othe
words, based on a desired dish (that you have the ingredients to make, in some form or another), simply
display them all
Tips
Remember that you need to actually design a solution.
• You’re
eaking this up into multiple classes, and actually having a point in doing so
o This includes actual abstraction
o This includes knowing when to use public, private, and package-private
o This also means knowing what a parameter is, and how to use it co
ectly
o Your instructor would love to discuss different approaches with you in person
• There should be one class that displays anything to the user, which should probably be the one opening files as
well. If another class has information to display? Then it should return that to the one doing output!
o And if there are multiple pieces of information, a
ays are a thing that exist
• The reason you’re permitted to choose between adjacency list vs matrix is because each makes it a bit
easie
harder in a different way
o Personally, I used a matrix, because a task like this feels a bit easier when you can more directly asks
‘what leads here?’
• You’re doing this as a graph
o Since your graph will operate on vertex IDs, but there’s no natural between a label and a number here,
you’ll need to make a separate class just for keeping track of that. A sort of ‘bidirectional mapping’ is
actually very easy to implement, and is suggested as the first step (since it can be done independently of
everything else anyhoo)
o I found the ‘add’ method of mine far more useful with two details:
▪ Whenever I tried adding a number:label pairing that already existed, it just silently ignored it
▪ I had it return the id of any label added (to make the client’s code just a bit easier to write)
o The point is to be able to request the id co
esponding to a label/key, or ask for the label co
esponding
to a numerical id
▪ The user program deals virtually entirely with text
▪ The graph operations deal pretty much exclusively with numbers
o Personally, I made a mapping available only to my Cookbook (which is also the graph)
• There won’t be a 1:1 mapping between the behaviours available to the user and the methods offered by you
Cookbook/Pantry, but there also doesn’t need to be
o e.g. if you have functionality for retrieving ‘all dishes’, and for ‘asking if you can make a dish with you
pantry’, then just combine them and you’ve got ‘all the dishes your pantry can support’!
• As mentioned earlier, you need to map text to numbers and numbers to text, but be careful!
o A common first instinct might be to use something like HashMap. Besides not being permitted, that
would also be 100% wrong
o Don’t forget you can whip this up first, just ‘something that works’, and then make it more efficient late
if needed
• Make it exceptionally clear how to use your program. Your marker will not try to guess, nor will he put more
effort into your program than you put into writing it
There are also some basic coding tips to remember:
• The only imports you should require are for reading the file and Scanner
o So implement everything else yourself
• Use basic sanity checks when dealing with user input. See the previous point
• Some parts of this will use things like a
ays, exceptions, etc.
• In addition to the tip above about parameters, try to keep the instance variables to a minimum. Remember:
class members are for things relating to the class as a whole; not individual tasks!
Additional tidbits:
Everyone should already know these, and it’s literally impossible to provide an exhaustive list, but some common things
to watch out for:
⚫ Please develop the entirety of your solution on a single machine, from start to finish within the same instance of
IntelliJ. If for some reason this is not possible, include an explanation with your submission. Failure to do so will
esult in a zero. You may not decide to submit additional components after the assignment closes
⚫ Several students who submitted ‘solutions’ for entirely the wrong task didn’t properly document their code (or
document it at all). Please remember this is separate from commenting!
⚫ Format your code co
ectly. Don’t put in a
itrary blank lines or biza
e indenting. The penalty for this nonsense is
now up to 75% of your assignment before the actual evaluation starts
⚫ Also, uh, packages are... a thing? When did everyone stop using packages?
⚫ Similarly, when submitting, include:
◼ The entire project
◼ Sample execution, instructions, etc.
⚫ You’ll be using the static keyword for your main method, only. There are many valid uses in general for that
keyword, but not in this task. If you do it elsewhere, it’s wrong. Don’t be wrong
⚫ The permitted imports are itemized above
◼ To be absolutely crystal clear: this does not mean you look up an implementation of, e.g., A
ayList so that
technically you aren’t importing it. It’s almost unfathomable that anybody needs to be told that. Stop trying to
circumvent the rules, solely to facilitate the wrong bloody solution