Solving a Comprehensive Problem with Ranges

Lesson Introduction

In today's lesson, we'll explore a comprehensive problem using the Boost.Range library in C++. Completing this lesson will help you understand how to use ranges to solve complex tasks systematically. Our goal is to calculate the average price of houses that cost more than 50,000 by filtering, transforming, and accumulating values—operations that Boost.Range simplifies tremendously.

Understanding the Problem

Imagine you have a dataset filled with house prices. Our task is to find the average price of these houses, but only for those that cost more than 50,000. This problem involves multiple steps: filtering out houses costing 50,000 or less, applying a 10% discount to each remaining house price, and then calculating the average price. Let's see how we can achieve this efficiently with Boost.Range.

Setting Up

First, we'll introduce the necessary libraries and set up our data. Here's a code snippet for reference: C++#include <iostream> #include <vector> #include <boost/range/adaptor/filtered.hpp> #include <boost/range/adaptor/transformed.hpp> #include <boost/range/numeric.hpp> int main() { std::vector<int> house_prices = {45000, 52000, 61000, 49000, 75000, 80000}; } A vector is a dynamic array that can grow as needed, making it suitable for storing integer prices. The given array contains both houses costing more and less than 50,000.

Filtering with Boost.Range

Next, we need to filter out the houses costing 50,000 or less. Boost.Range provides the boost::adaptors::filtered functionality to achieve this: C++house_prices | boost::adaptors::filtered([](int price) { return price > 50000; }) Here, boost::adaptors::filtered uses a lambda function to filter out prices less than or equal to 50,000. The lambda function [](int price) { return price > 50000; } returns true for prices greater than 50,000, allowing them to pass through the filter.

Transforming with Boost.Range

Once filtered, we want to apply a 10% discount to the remaining prices. This is done using boost::adaptors::transformed: C++house_prices | boost::adaptors::filtered([](int price) { return price > 50000; }) | boost::adaptors::transformed([](int price) { return price * 0.90; }) The transformation uses another lambda function, [](int price) { return price * 0.90; }, which applies a 10% discount to each filtered price. We use the pipe operator to combine them

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Tying It All Together

Let's combine everything in the main function:

C++

#include <iostream>
#include <vector>
#include <boost/range/adaptor/filtered.hpp>
#include <boost/range/adaptor/transformed.hpp>
#include <boost/range/numeric.hpp> 

int main() {
    std::vector<int> house_prices = {45000, 52000, 61000, 49000, 75000, 80000};

    // Use boost::adaptors for filtering and transforming
    auto discounted_total = boost::accumulate(
        house_prices | boost::adaptors::filtered([](int price) { return price > 50000; }) // Filter houses costing more than 50000
                     | boost::adaptors::transformed([](int price) { return price * 0.90; }), // Apply a 10% discount
        0.0 // Initial value for accumulate
    );

    auto house_count = boost::distance(house_prices | boost::adaptors::filtered([](int price) { return price > 50000; }));
    double average_price = discounted_total / house_count;

    std::cout << "Average price of discounted houses: " << average_price << std::endl; // Output: Average price of discounted houses: 60300

    return 0;
}

#include <iostream>
#include <vector>
#include <boost/range/adaptor/filtered.hpp>
#include <boost/range/adaptor/transformed.hpp>
#include <boost/range/numeric.hpp> 

int main() {
    std::vector<int> house_prices = {45000, 52000, 61000, 49000, 75000, 80000};

    // Use boost::adaptors for filtering and transforming
    auto discounted_total = boost::accumulate(
        house_prices | boost::adaptors::filtered([](int price) { return price > 50000; }) // Filter houses costing more than 50000
                     | boost::adaptors::transformed([](int price) { return price * 0.90; }), // Apply a 10% discount
        0.0 // Initial value for accumulate
    );

    auto house_count = boost::distance(house_prices | boost::adaptors::filtered([](int price) { return price > 50000; }));
    double average_price = discounted_total / house_count;

    std::cout << "Average price of discounted houses: " << average_price << std::endl; // Output: Average price of discounted houses: 60300

    return 0;
}

By understanding each part separately, you can see how they work together to solve a complex problem efficiently.