Shipping Cost Calculator

medium

CodingReported Dec 2025 · Single frequency

Shipping Cost Computation

Coding roles: Software Engineer, Machine Learning Engineer

Problem Overview

Create a shipping-fee calculator for an e-commerce service. It must determine an order's overall shipping charge using pricing schemes that can vary by destination country and product.

The task advances through three stages, with each stage adding more behavior:

Basic Fixed Pricing: Determine shipping fees from one fixed per-product rate.
Tiered Incremental Pricing: Apply quantity brackets whose per-item price becomes lower at larger volumes.
Mixed Pricing Models: Calculate charges when fixed tiers and incremental tiers appear in the same pricing setup.

Input Format

Two primary structures are provided:

Order Object: Holds a country identifier along with the ordered items.

{
    "country": "GB",
    "items": [
        {"product": "keyboard", "quantity": 12},
        {"product": "monitor", "quantity": 3}
    ]
}

Shipping Cost Configuration: A nested dictionary that describes product-specific pricing by country.

The configuration format changes as you move through the three stages.

Problem Statement

Write compute_shipping_cost(order, shipping_cost) to return the complete shipping charge when every product has one constant per-unit fee.

Example

Input:

order_gb = {
    "country": "GB",
    "items": [
        {"product": "keyboard", "quantity": 12},
        {"product": "monitor", "quantity": 3}
    ]
}

order_de = {
    "country": "DE",
    "items": [
        {"product": "keyboard", "quantity": 12},
        {"product": "monitor", "quantity": 3}
    ]
}

shipping_cost = {
    "GB": [
        {"product": "keyboard", "cost": 420},
        {"product": "monitor", "cost": 850}
    ],
    "DE": [
        {"product": "keyboard", "cost": 510},
        {"product": "monitor", "cost": 920}
    ]
}

Output:

compute_shipping_cost(order_gb, shipping_cost) == 7590
# Calculation: (12 × 420) + (3 × 850) = 5040 + 2550 = 7590

compute_shipping_cost(order_de, shipping_cost) == 8880
# Calculation: (12 × 510) + (3 × 920) = 6120 + 2760 = 8880

Requirements

An order may contain more than one product.
Prices must be allowed to differ between countries.
Produce the total shipping fee as an integer.

Problem Statement

Enhance the implementation to support quantity-based price tiers, where the per-unit amount is determined by the item's quantity bracket. Every tier provides a lower bound, upper bound, and unit charge for that interval.

This resembles volume discounting: units that land in larger quantity bands can have a cheaper individual rate.

Example

Input:

# The orders are unchanged from Part 1

shipping_cost = {
    "GB": [
        {
            "product": "keyboard",
            "costs": [
                {"minQuantity": 0, "maxQuantity": None, "cost": 420}
            ]
        },
        {
            "product": "monitor",
            "costs": [
                {"minQuantity": 0, "maxQuantity": 1, "cost": 850},
                {"minQuantity": 1, "maxQuantity": None, "cost": 760}
            ]
        }
    ],
    "DE": [
        {
            "product": "keyboard",
            "costs": [
                {"minQuantity": 0, "maxQuantity": None, "cost": 510}
            ]
        },
        {
            "product": "monitor",
            "costs": [
                {"minQuantity": 0, "maxQuantity": 1, "cost": 920},
                {"minQuantity": 1, "maxQuantity": None, "cost": 830}
            ]
        }
    ]
}

Output:

compute_shipping_cost(order_gb, shipping_cost) == 7410
# Calculation:
# keyboard: 12 × 420 = 5040 (every unit has the same rate)
# monitor: (1 × 850) + (2 × 760) = 850 + 1520 = 2370
# Total: 5040 + 2370 = 7410

compute_shipping_cost(order_de, shipping_cost) == 8700
# Calculation:
# keyboard: 12 × 510 = 6120
# monitor: (1 × 920) + (2 × 830) = 920 + 1660 = 2580
# Total: 6120 + 2580 = 8700

Requirements

Traverse quantity bands in ascending order, from the lowest tier onward.
A maxQuantity value of None means that the tier has no upper limit.
Quantity intervals are half-open: [minQuantity, maxQuantity), including the minimum but excluding the maximum.
Compute each tier's charge independently, then add those charges together.

Clarification Questions to Ask

Is the list of cost tiers guaranteed to be ordered by minQuantity?
Should ranges be half-open, [min, max), or should both endpoints be included? This affects calculations at tier boundaries.
Can tiers intersect, or can there be uncovered intervals between them?
What is the expected behavior for conditions such as a quantity of zero or an unavailable product?

Problem Statement

Further extend the implementation so that tiers can use either of two pricing methods within one tier list:

incremental: Apply a per-item charge, as in Part 2 (quantity × cost).
fixed: Apply one flat charge, independent of the number of units covered by that tier.

One product's tiers may alternate between fixed and incremental pricing.

Example

Input:

# The orders are unchanged

shipping_cost = {
    "GB": [
        {
            "product": "keyboard",
            "costs": [
                {
                    "type": "incremental",
                    "minQuantity": 0,
                    "maxQuantity": None,
                    "cost": 420
                }
            ]
        },
        {
            "product": "monitor",
            "costs": [
                {
                    "type": "fixed",
                    "minQuantity": 0,
                    "maxQuantity": 1,
                    "cost": 850
                },
                {
                    "type": "incremental",
                    "minQuantity": 1,
                    "maxQuantity": None,
                    "cost": 760
                }
            ]
        }
    ],
    "DE": [
        {
            "product": "keyboard",
            "costs": [
                {
                    "type": "incremental",
                    "minQuantity": 0,
                    "maxQuantity": None,
                    "cost": 510
                }
            ]
        },
        {
            "product": "monitor",
            "costs": [
                {
                    "type": "fixed",
                    "minQuantity": 0,
                    "maxQuantity": 1,
                    "cost": 920
                },
                {
                    "type": "incremental",
                    "minQuantity": 1,
                    "maxQuantity": None,
                    "cost": 830
                }
            ]
        }
    ]
}

Output:

compute_shipping_cost(order_gb, shipping_cost) == 7410
# Calculation:
# keyboard: 12 × 420 = 5040 (incremental)
# monitor: 850 (fixed for the first 1) + (2 × 760) = 850 + 1520 = 2370
# Total: 5040 + 2370 = 7410

compute_shipping_cost(order_de, shipping_cost) == 8700
# Calculation:
# keyboard: 12 × 510 = 6120 (incremental)
# monitor: 920 (fixed for the first 1) + (2 × 830) = 920 + 1660 = 2580
# Total: 6120 + 2580 = 8700

Requirements

Recognize both the "fixed" and "incremental" price types.
For fixed tiers, add cost once whenever quantity reaches that tier.
For incremental tiers, multiply the applicable unit count by cost, as in Part 2.
Support alternating sequences such as fixed → incremental → fixed → incremental.

Edge Cases to Consider:

An order whose items list is empty.
A product that does not appear in the shipping cost table.
An invalid country identifier.
Quantities equal to zero or below zero.
Missing or null input values.

Follow-Up Discussion Topics

Code Quality and Production Readiness

Question: If this implementation were going into production, what changes would you make to improve its clarity and long-term maintainability?

Considerations:

Separation of Concerns: Move tier evaluation into dedicated helper functions.
Type Safety: Introduce type annotations and structured representations such as dataclasses or TypedDict.
Error Handling: Check inputs and deal gracefully with absent data.
Testing: Create broad unit-test coverage for edge conditions.
Configuration Validation: Verify shipping-cost configurations before they are used at runtime.
Logging: Record pricing-calculation details to help diagnose issues.
Documentation: Provide docstrings that describe the pricing behavior.

BackBack to problems

Shipping Cost Calculator

medium

CodingReported Dec 2025 · Single frequency

Shipping Cost Computation

Coding roles: Software Engineer, Machine Learning Engineer

Problem Overview

Create a shipping-fee calculator for an e-commerce service. It must determine an order's overall shipping charge using pricing schemes that can vary by destination country and product.

The task advances through three stages, with each stage adding more behavior:

Basic Fixed Pricing: Determine shipping fees from one fixed per-product rate.
Tiered Incremental Pricing: Apply quantity brackets whose per-item price becomes lower at larger volumes.
Mixed Pricing Models: Calculate charges when fixed tiers and incremental tiers appear in the same pricing setup.

Input Format

Two primary structures are provided:

Order Object: Holds a country identifier along with the ordered items.

{
    "country": "GB",
    "items": [
        {"product": "keyboard", "quantity": 12},
        {"product": "monitor", "quantity": 3}
    ]
}

Shipping Cost Configuration: A nested dictionary that describes product-specific pricing by country.

The configuration format changes as you move through the three stages.

Problem Statement

Write compute_shipping_cost(order, shipping_cost) to return the complete shipping charge when every product has one constant per-unit fee.

Example

Input:

order_gb = {
    "country": "GB",
    "items": [
        {"product": "keyboard", "quantity": 12},
        {"product": "monitor", "quantity": 3}
    ]
}

order_de = {
    "country": "DE",
    "items": [
        {"product": "keyboard", "quantity": 12},
        {"product": "monitor", "quantity": 3}
    ]
}

shipping_cost = {
    "GB": [
        {"product": "keyboard", "cost": 420},
        {"product": "monitor", "cost": 850}
    ],
    "DE": [
        {"product": "keyboard", "cost": 510},
        {"product": "monitor", "cost": 920}
    ]
}

Output:

compute_shipping_cost(order_gb, shipping_cost) == 7590
# Calculation: (12 × 420) + (3 × 850) = 5040 + 2550 = 7590

compute_shipping_cost(order_de, shipping_cost) == 8880
# Calculation: (12 × 510) + (3 × 920) = 6120 + 2760 = 8880

Requirements

An order may contain more than one product.
Prices must be allowed to differ between countries.
Produce the total shipping fee as an integer.

Problem Statement

This resembles volume discounting: units that land in larger quantity bands can have a cheaper individual rate.

Example

Input:

# The orders are unchanged from Part 1

shipping_cost = {
    "GB": [
        {
            "product": "keyboard",
            "costs": [
                {"minQuantity": 0, "maxQuantity": None, "cost": 420}
            ]
        },
        {
            "product": "monitor",
            "costs": [
                {"minQuantity": 0, "maxQuantity": 1, "cost": 850},
                {"minQuantity": 1, "maxQuantity": None, "cost": 760}
            ]
        }
    ],
    "DE": [
        {
            "product": "keyboard",
            "costs": [
                {"minQuantity": 0, "maxQuantity": None, "cost": 510}
            ]
        },
        {
            "product": "monitor",
            "costs": [
                {"minQuantity": 0, "maxQuantity": 1, "cost": 920},
                {"minQuantity": 1, "maxQuantity": None, "cost": 830}
            ]
        }
    ]
}

Output:

compute_shipping_cost(order_gb, shipping_cost) == 7410
# Calculation:
# keyboard: 12 × 420 = 5040 (every unit has the same rate)
# monitor: (1 × 850) + (2 × 760) = 850 + 1520 = 2370
# Total: 5040 + 2370 = 7410

compute_shipping_cost(order_de, shipping_cost) == 8700
# Calculation:
# keyboard: 12 × 510 = 6120
# monitor: (1 × 920) + (2 × 830) = 920 + 1660 = 2580
# Total: 6120 + 2580 = 8700

Requirements

Traverse quantity bands in ascending order, from the lowest tier onward.
A maxQuantity value of None means that the tier has no upper limit.
Quantity intervals are half-open: [minQuantity, maxQuantity), including the minimum but excluding the maximum.
Compute each tier's charge independently, then add those charges together.

Clarification Questions to Ask

Is the list of cost tiers guaranteed to be ordered by minQuantity?
Should ranges be half-open, [min, max), or should both endpoints be included? This affects calculations at tier boundaries.
Can tiers intersect, or can there be uncovered intervals between them?
What is the expected behavior for conditions such as a quantity of zero or an unavailable product?

Problem Statement

Further extend the implementation so that tiers can use either of two pricing methods within one tier list:

incremental: Apply a per-item charge, as in Part 2 (quantity × cost).
fixed: Apply one flat charge, independent of the number of units covered by that tier.

One product's tiers may alternate between fixed and incremental pricing.

Example

Input:

# The orders are unchanged

shipping_cost = {
    "GB": [
        {
            "product": "keyboard",
            "costs": [
                {
                    "type": "incremental",
                    "minQuantity": 0,
                    "maxQuantity": None,
                    "cost": 420
                }
            ]
        },
        {
            "product": "monitor",
            "costs": [
                {
                    "type": "fixed",
                    "minQuantity": 0,
                    "maxQuantity": 1,
                    "cost": 850
                },
                {
                    "type": "incremental",
                    "minQuantity": 1,
                    "maxQuantity": None,
                    "cost": 760
                }
            ]
        }
    ],
    "DE": [
        {
            "product": "keyboard",
            "costs": [
                {
                    "type": "incremental",
                    "minQuantity": 0,
                    "maxQuantity": None,
                    "cost": 510
                }
            ]
        },
        {
            "product": "monitor",
            "costs": [
                {
                    "type": "fixed",
                    "minQuantity": 0,
                    "maxQuantity": 1,
                    "cost": 920
                },
                {
                    "type": "incremental",
                    "minQuantity": 1,
                    "maxQuantity": None,
                    "cost": 830
                }
            ]
        }
    ]
}

Output:

compute_shipping_cost(order_gb, shipping_cost) == 7410
# Calculation:
# keyboard: 12 × 420 = 5040 (incremental)
# monitor: 850 (fixed for the first 1) + (2 × 760) = 850 + 1520 = 2370
# Total: 5040 + 2370 = 7410

compute_shipping_cost(order_de, shipping_cost) == 8700
# Calculation:
# keyboard: 12 × 510 = 6120 (incremental)
# monitor: 920 (fixed for the first 1) + (2 × 830) = 920 + 1660 = 2580
# Total: 6120 + 2580 = 8700

Requirements

Recognize both the "fixed" and "incremental" price types.
For fixed tiers, add cost once whenever quantity reaches that tier.
For incremental tiers, multiply the applicable unit count by cost, as in Part 2.
Support alternating sequences such as fixed → incremental → fixed → incremental.

Edge Cases to Consider:

An order whose items list is empty.
A product that does not appear in the shipping cost table.
An invalid country identifier.
Quantities equal to zero or below zero.
Missing or null input values.

Follow-Up Discussion Topics

Code Quality and Production Readiness

Question: If this implementation were going into production, what changes would you make to improve its clarity and long-term maintainability?

Considerations:

Separation of Concerns: Move tier evaluation into dedicated helper functions.
Type Safety: Introduce type annotations and structured representations such as dataclasses or TypedDict.
Error Handling: Check inputs and deal gracefully with absent data.
Testing: Create broad unit-test coverage for edge conditions.
Configuration Validation: Verify shipping-cost configurations before they are used at runtime.
Logging: Record pricing-calculation details to help diagnose issues.
Documentation: Provide docstrings that describe the pricing behavior.

Shipping Cost Calculator

Shipping Cost Computation

Problem Overview

Input Format

Part 1: Fixed Rate Shipping

Problem Statement

Example

Requirements

Part 2: Tiered Incremental Pricing

Problem Statement

Example

Requirements

Clarification Questions to Ask

Part 3: Mixed Pricing Models (Fixed + Incremental)

Problem Statement

Example

Requirements

Edge Cases to Consider:

Follow-Up Discussion Topics

Code Quality and Production Readiness

Shipping Cost Calculator

Shipping Cost Computation

Problem Overview

Input Format

Part 1: Fixed Rate Shipping

Problem Statement

Example

Requirements

Part 2: Tiered Incremental Pricing

Problem Statement

Example

Requirements

Clarification Questions to Ask

Part 3: Mixed Pricing Models (Fixed + Incremental)

Problem Statement

Example

Requirements

Edge Cases to Consider:

Follow-Up Discussion Topics

Code Quality and Production Readiness