## 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.

// input your answer here
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(combo) {
    return combo - 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.

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

### 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.

// input your answer here
function combo_price(combo_num) {
    // const patty = 1.17;
    // const biggie = 0.50;
    // x === 1 ? return patty : x === 5 ? return patty + biggie : x === 2 ? 
    // return patty * 2 : x === 6 ? return (patty * 2) + biggie : x === 3 ? 
    // return patty * 3 : x === 7 ? return (patty * 3) + biggie : x === 4 ? 
    // return patty * 4 : return (patty * 4) + biggie;
    return is_biggie_size(combo_num) 
        ? 1.17 * unbiggie_size(combo_num) + 0.50 
        : 1.17 * combo_num;
}

### 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.

// input your answer here
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`.

// input your answer here
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`.

// input your answer here
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`.

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

function other_combos(order) {
    return math_floor(order / 10);
}

function foo(x, y, z) {

}