Computing quantity-based discounts I'm a CS professor and provided this code as a small piece of a refactoring assignment:
private double getTotalPrice(int quantity, double itemPrice) {
    if (quantity == 13) {
        return itemPrice * 12; // Baker's dozen
    }
    else if (quantity &gt;= 6) {
        return itemPrice * quantity * .95;
    } else {
        return itemPrice * quantity;
    }
}

Students are supposed to remove inappropriate magic numbers, but, when discussing the above code with them, I realized I don't know the best way to improve the above code. I'm not interested in improving performance, just teaching how to write clean and maintainable code.
Updates
I realize there are other problems with the code, some intentional. What I am most interested in is how to name the magic numbers.
The purpose of the code is to determine the total price for an order of up to 13 items (limit in place to prevent hoarding). My priorities are readability and maintainability.
Refactoring
The first thing I'd do is remove the redundant else statements.  If you return from every branch, then there's really no need for the else clauses, they're just adding noise.
Constants?
It seems like there's some scope for constants / or lookups since there's some numbers floating around that seem to have meaning (discount amount, discount trigger threshold) etc.  If you're labelling a number with a comment (baker's dozen), it's a good indication that it could be replaced with a constant to 'name' the value.
What are you really be looking for?
However, for me, I think the code actually serves more to prompt questions about whether or not it is performing as desired.  If it is performing as expected, then it's the type of pricing system I hate (because it relies on the customer to optimize their own purchases).
If I buy 12 items, I'm charged for 12 at the discounted rate.
If I buy 13, I'm charged for 12 items at the standard rate.
If I buy 14, I'm charged for 14 at the discounted rate.  This is more expensive than me buying 13, then buying a single item as a separate transaction.
Is this correct? Are you hitting me with the postage?  Why don't I get 26 for the price of 24?
etc...
Constants Revisited
I think some of the above contribute to your difficulty coming up with constants... I'd go with something like this:
private static double getTotalPrice(int quantity, double itemPrice) {
    if (quantity == SPECIAL_ONE_OFF_DISCOUNT_QUANTITY) {
        return itemPrice * (SPECIAL_ONE_OFF_DISCOUNT_QUANTITY - 1);
    }
    if (quantity &gt;= TRIGGER_DISCOUNT_QUANTITY) {
        return itemPrice * quantity * DISCOUNT_MULTIPLIER;
    }
    return itemPrice * quantity;
}

I'm using 'SPECIAL_ONE_OFF_DISCOUNT_QUANTITY', because it really is a special one off amount, with the current logic.  It doesn't duplicate at 26 etc.  I've got rid of the '12' constant, because really it's just 1 less than the trigger amount.  Having a 'ONE_OFF_DISCOUNTTED_QUANTITY' constant might make sense if you could see the need to pay for 10 when you bought 13 for example, however this seems a it unnecessary.
As I said, I'd prefer to rework the logic so that you always pay the lowest amount + so that discounts are additive.  This changes the output prices, so obviously wouldn't be possible if it didn't actually make sense to the client.  It does allow some of the constants to have different names though:
private static double getTotalPrice(int quantity, double itemPrice) {
    var chargeableQuantity = quantity - quantity / BUY_X_GET_ONE_FREE_QUANTITY;
    var valueMultiplier = chargeableQuantity &gt;= TRIGGER_DISCOUNT_QUANTITY ? DISCOUNT_MULTIPLIER : 1;

    return itemPrice * chargeableQuantity * valueMultiplier;
}

I think 'BUY_X_GET_ONE_FREE_QUANTITY' is a better name than 'SPECIAL_ONE_OFF_DISCOUNT_QUANTITY', but it only really makes sense if buying twice the amount results in twice the discount...