---
tags: cs1101s
---

# CS1101S Studio S2 (T08C)

## Source Academy Burger Joint
Suppose we're designing a point-of-sale and order-tracking system for a new burger joint. It is a small joint and it only sells 4 options for combos: Classic Single Combo (hamburger with one patty), Classic Double With Cheese Combo (2 patties), and Classic Triple with Cheese Combo (3 patties), Avant-Garde Quadruple with Guacamole Combo (4 patties). We shall encode these combos as 1, 2, 3, and 4 respectively. Each meal can be *biggie-sized* to acquire a larger box of fries and drink. A *biggie-sized* combo is represented by 5, 6, 7, and 8 respectively, for combos 1, 2, 3, and 4 respectively.

### Question 1
Write a function named `biggie_size` which when given a regular combo returns a *biggie-sized* version.

function biggie_size(combo) {
    return combo + 4;
}

### Question 2
Write a function named `unbiggie_size` which when given a *biggie-sized* combo returns a non-*biggie-sized* version.

function unbiggie_size(biggie) {
    return biggie - 4;
}

### Question 3
Write a function named `is_biggie_size` which when given a combo, returns `true` if the combo has been *biggie-sized* and `false` otherwise.

// Best solutions, concise and works
function is_biggie_size(combo) {
    return combo >= 5;
}

function is_biggie_size(combo) {
    return combo > 4;
}

// Also good except the studio sheet specifies that only valid inputs are allowed, so slightly more work
function is_biggie_size(combo) {
	return (5 <= combo) && (combo <= 8);
}

// Extra work since the predicate already returns the correct booleans
function is_biggie_size(burgercombo) {
    return burgercombo >= 5 ? true : false;
}

// Would be good if the studio sheet didn't already specify that only valid inputs are allowed (ensures that the function only works on the 4 integers specified)
function is_biggie_size(combo) {
    return combo === 5
        ? true
        : combo === 6
            ? true
            : combo === 7
                ? true
                : combo === 8
                    ? true
                    : false;
}

### Question 4
Write a function named `combo_price` which takes a combo and returns the price of the combo. Each patty costs $1.17, and a *biggie-sized* version costs $0.50 extra overall.

// Best solution, easily readable and works
function combo_price(combo_number) {
    return is_biggie_size(combo_number) 
        ? (unbiggie_size(combo_number) * 1.17) + 0.50
        : combo_number * 1.17;
}

// Not as good, while it's functionally equivalent to the above solution and shorter, repeats the predicate which is undesirable as the desired predicate might change, also less readable
function combo_price(combo){
    return x > 4
        ? (combo-4) * 1.17 + 0.50
        : 1.17 * combo;
} 

### Question 5
An order is a collection of combos. We will encode an order as each digit representing a combo. For example, the order 237 represents a Double, Triple, and *biggie-sized* Triple.

Write a function named `empty_order` which takes no arguments and returns an empty order which is represented by 0.

function empty_order() {
    return 0;
}

### Question 6
Write a function named `add_to_order` which takes an order and a combo and returns a new order which contains the contents of the old order and the new combo. For example, `add_to_order(1, 2)` returns `12`.

function add_to_order(order, combo) {
    return (order * 10) + combo;
}

### Question 7
Write a function named `last_combo` which takes an order and returns the last combo. For example, `last_combo(321)` returns `1`.

// This question teaches the importance of Googling! :)
function last_combo(order) {
    return order % 10;
}

### Question 8
Write a function named `other_combos` which takes an order and returns a new order without the last combo. For example, `other_combos(321)` returns `32`.

// Both solutions are equally good, the first solution uses a function that wasn't previously taught in lectures but is more concise, the second solution relies on the last_combo function to work, which may or may not break depending on whether the function changes
function other_combos(order){
    return math_floor(order / 10);
}

function other_combos(order){
    return (order - last_combo(order)) / 10;
}