pair আর tuple: দুই বা তার বেশি জিনিস, নাম একটাই

Zara-র দরকার সপ্তাহের সবচেয়ে ঠান্ডা reading আর সেটা কোন দিন হয়েছিল। C-তে function একটাই মান ফেরত দেয়। তাই ও reading-টা return করত, আর দিনের জন্য একটা pointer পাঠাত, যেভাবে lesson 03-এর exercise reference দিয়ে করেছিল। C++-এ উত্তরটা আরও ছোট: দুইটা মান একটা প্যাকেটে ভরো, আর প্যাকেটটাই return করো। প্যাকেটটার নাম pair, আর STL সব জায়গায় তোমার হাতে pair ধরিয়ে দেয়, প্রতিটা map থেকে শুরু করে দুইটা সংখ্যার প্রতিটা sort পর্যন্ত।

এক function থেকে Zara-র দুইটা উত্তর

C-র পথটা এরকম, দ্বিতীয় উত্তর ফেরত আসে একটা pointer দিয়ে।

#include <stdio.h>

int coldest(const int temps[], int n, int *day)
{
    int best = temps[0];
    *day = 0;
    for (int i = 1; i < n; i++) {
        if (temps[i] < best) {
            best = temps[i];
            *day = i;
        }
    }
    return best;
}

int main(void)
{
    int temps[7] = {4, -2, 1, -6, 0, -6, 3};
    int day = 0;
    int t = coldest(temps, 7, &day);

    printf("coldest %d on day %d\n", t, day + 1);
    return 0;
}

coldest -6 on day 4

আর এই হলো C++, যেখানে function দুইটা উত্তরই ফেরত দেয় একটা std::pair হিসেবে।

#include <iostream>
#include <utility>

std::pair<int, int> coldest(const int temps[], int n)
{
    int best = temps[0];
    int day = 0;
    for (int i = 1; i < n; i++) {
        if (temps[i] < best) {
            best = temps[i];
            day = i;
        }
    }
    return {best, day};
}

int main()
{
    int temps[7] = {4, -2, 1, -6, 0, -6, 3};
    auto [t, day] = coldest(temps, 7);

    std::cout << "coldest " << t << " on day " << day + 1 << '\n';
    return 0;
}

coldest -6 on day 4

Output একই। return {best, day}; মান দুইটা প্যাক করে, আর auto [t, day] = ... খুলে দুইটা নামে রাখে; দুইটাই নিচে বোঝানো হয়েছে। দিন 6-এর -6 জেতে না, কারণ < best-কে বদলায় শুধু আসলেই বেশি ঠান্ডা দিনে। মানে একটা function এখন দুইটা উত্তর দেয়, কোনো pointer ছাড়া, আর call-এর সময় কিছু পাঠাতে মনে রাখার ঝামেলা ছাড়া।

Pair: একটা নামের নিচে দুইটা মান

std::pair একটা নামের নিচে ঠিক দুইটা মান রাখে, দুইটার type আলাদাও হতে পারে। এটা থাকে <utility>-এ। এর দুই অংশের নাম সবসময় .first আর .second, আর এরা সাধারণ variable, পড়াও যায়, লেখাও যায়। এটা একটা class template (lesson 05), দুইটা type দিয়ে ভরা।

std::pair<Type1, Type2> p = {value1, value2};
auto q = std::make_pair(value1, value2);
p.first     p.second

#include <iostream>
#include <string>
#include <utility>

int main()
{
    std::pair<std::string, int> city = {"Oslo", -3};
    auto other = std::make_pair(std::string("Cairo"), 31);

    std::cout << city.first << ": " << city.second << '\n';
    city.second = -1;
    std::cout << city.first << " at noon: " << city.second << '\n';
    std::cout << other.first << ": " << other.second << '\n';
    return 0;
}

Oslo: -3
Oslo at noon: -1
Cairo: 31

মানে pair হলো একসাথে চলা দুইটা নাম দেওয়া বাক্স: .first আর .second, যেকোনো variable-এর মতোই পড়া আর বদলানো যায়।

দুইটা pair কীভাবে তুলনা হয়, আর কীভাবে সাজে

একই type-এর দুইটা pair তুলনা হয় অভিধান যেভাবে শব্দ তুলনা করে সেভাবে। আগে সিদ্ধান্ত নেয় .first অংশ দুইটা। ওরা সমান হলে তবেই সিদ্ধান্ত নেয় .second অংশ দুইটা। একে বলে lexicographic ক্রম।

#include <iostream>
#include <utility>

int main()
{
    std::pair<int, int> a = {1, 9};
    std::pair<int, int> b = {2, 0};
    std::pair<int, int> c = {2, 5};

    std::cout << (a < b) << ' ' << (b < c) << ' ' << (c == b) << '\n';
    return 0;
}

1 1 0

a < b সত্যি, কারণ 1 ছোট 2-এর চেয়ে, আর 9-এর দিকে তাকানোই হয় না। b < c সত্যি, কারণ first দুইটা 2-এ সমান, তারপর 0 ছোট 5-এর চেয়ে। ==-এর জন্য দুই অংশই সমান হতে হয়।

এই ক্রমের জন্যই pair সুন্দরভাবে সাজে। এখানে একটা sort, আগাম দেখে নাও: std::vector-এর ওপর (Module 2) std::sort (Module 12), vector হলো এমন array যে নিজের size জানে। Kenji-র scoreboard সাজে নাম ধরে, আর কোনো নাম দুইবার থাকলে score ধরে।

#include <algorithm>
#include <iostream>
#include <string>
#include <utility>
#include <vector>

int main()
{
    std::vector<std::pair<std::string, int>> board = {
        {"Zara", 40}, {"Bob", 75}, {"Amara", 60}, {"Bob", 20}
    };

    std::sort(board.begin(), board.end());
    for (const auto& p : board) {
        std::cout << p.first << ' ' << p.second << '\n';
    }
    return 0;
}

Amara 60
Bob 20
Bob 75
Zara 40

দুইজন Bob নামে সমান, তাই score ঠিক করে ক্রম: 20 আগে, 75 পরে। মানে pair তুলনা হয় আগে .first দিয়ে, তারপর .second দিয়ে, আর pair-এর sort বাড়তি কোনো code ছাড়াই ঠিক ওই ক্রমটাই মানে।

tuple: তিন বা তার বেশি, আর std::get

std::tuple হলো এমন pair, যে যতগুলো খুশি মান রাখতে পারে। এটা থাকে <tuple>-এ। এর অংশগুলোর .first-এর মতো কোনো নাম নেই; ওদের নম্বর 0 থেকে, আর std::get<0>(t) পড়ে 0 নম্বর অংশ। নম্বরটা angle bracket-এ যায়, কারণ অংশটার type জানতে compiler-কে compile-এর সময়েই নম্বরটা জানতে হয়।

#include <iostream>
#include <string>
#include <tuple>

int main()
{
    std::tuple<std::string, int, double> book = {"Dune", 1965, 4.5};

    std::cout << std::get<0>(book) << " (" << std::get<1>(book) << "), rated " << std::get<2>(book) << '\n';
    std::get<2>(book) = 4.8;
    std::cout << "new rating " << std::get<2>(book) << '\n';
    return 0;
}

Dune (1965), rated 4.5
new rating 4.8

Tuple-ও pair-এর মতো একই lexicographic নিয়মে তুলনা হয় আর সাজে, আগে 0 নম্বর অংশ। মানে tuple হলো বেশি অংশওয়ালা pair, অংশগুলোর নামের বদলে নম্বর, আর std::get<N> পৌঁছায় N নম্বর অংশে।

Structured binding: প্রতিটা অংশের একটা নাম

std::get<2>(book) বলে না 2 নম্বর অংশটা আসলে কী। C++17 এনেছে structured binding: একটাই declaration, যেটা pair, tuple বা array-র প্রতিটা অংশকে নিজের একটা নাম দেয়। Lesson-এর শুরুতেই একটা দেখেছ।

auto [name1, name2, ...] = something_with_parts;
auto& [name1, name2, ...] = something_with_parts;

#include <iostream>
#include <string>
#include <tuple>
#include <utility>

int main()
{
    std::pair<std::string, int> city = {"Oslo", -3};
    std::tuple<std::string, int, double> book = {"Dune", 1965, 4.5};
    int point[2] = {3, 4};

    auto [place, temp] = city;
    auto [title, year, rating] = book;
    auto& [x, y] = point;

    std::cout << place << ' ' << temp << '\n';
    std::cout << title << ' ' << year << ' ' << rating << '\n';
    x = 10;
    std::cout << point[0] << ' ' << point[1] << '\n';
    return 0;
}

Oslo -3
Dune 1965 4.5
10 4

Array-র ওপর auto& binding আসল বাক্সগুলোরই নাম দিয়েছে, তাই x = 10 বদলে দিয়েছে point[0]। Pair-এর ওপর range-for-এ structured binding সবচেয়ে বেশি কাজে আসে: for (const auto& [name, score] : board) পড়তে p.first আর p.second-এর চেয়ে অনেক ভালো। তাই অংশগুলো নাম পাওয়ার যোগ্য হলেই এই track structured binding লেখে, আর সেটা প্রায় সবসময়।

মুহূর্তের জন্য pair, জিনিসের জন্য struct

Pair চটজলদি কাজের, আর সেটাই এর বিপদ। p.first আর p.second বলে না ভিতরে কী আছে, আর এগুলোয় ভরা program পড়তে লাগে ধাঁধার মতো। Amara-র নিয়ম: মুহূর্তের জন্য pair, জিনিসের জন্য struct।

Pair ঠিক তখন, যখন দুইটা মান অল্প সময়ের জন্য একসাথে হয়: একটা function-এর দুইটা উত্তর, sort-এর একটা key, map-এর একটা element। নাম দেওয়া field-ওয়ালা C struct ঠিক তখন, যখন মানগুলো মিলে এমন একটা জিনিস, যেটা তোমার program রেখে দেয় আর যার কথা বলে। একটা parcel-এর ওজন আর দাম আছে, আর parcel.weight সেটা মুখে বলে দেয়।

#include <iostream>
#include <string>
#include <utility>

struct Parcel {
    std::string to;
    int weight;
    int price;
};

std::pair<int, int> splitMinutes(int total)
{
    return {total / 60, total % 60};
}

int main()
{
    Parcel p = {"Kenji", 3, 120};
    std::cout << p.to << ": " << p.weight << " kg, " << p.price << '\n';

    auto [hours, minutes] = splitMinutes(135);
    std::cout << "delivery in " << hours << " h " << minutes << " min\n";
    return 0;
}

Kenji: 3 kg, 120
delivery in 2 h 15 min

Parcel একটা জিনিস, রাখা হয়, print হয়, তাই তার field-গুলোর নাম আছে। ঘণ্টা আর মিনিট বাঁচে এক লাইনের জন্য, তাই pair-ই যথেষ্ট, আর structured binding সাথে সাথে তাদের নাম দিয়ে দেয়। মানে মান দুইটা যখন এক মুহূর্তের উত্তর, তখন pair নাও; আর যখন নাম থাকা একটা জিনিস, তখন struct।

std::tie আর std::ignore

Structured binding সবসময় নতুন নাম বানায়। কখনো কখনো variable-গুলো আগে থেকেই থাকে। <tuple>-এর std::tie আগে থেকে থাকা variable-গুলোর reference দিয়ে একটা tuple বানায়, তাই এতে একটা tuple assign করলে variable-গুলো ভরে যায়। std::ignore বসে সেই অংশের জায়গায়, যেটা তুমি চাও না।

#include <iostream>
#include <string>
#include <tuple>

int main()
{
    std::tuple<std::string, int, double> book = {"Dune", 1965, 4.5};
    std::string title;
    double rating = 0;

    std::tie(title, std::ignore, rating) = book;
    std::cout << title << ' ' << rating << '\n';
    return 0;
}

Dune 4.5

std::tie বেশিরভাগ সময় পড়বে অন্যের code-এ, প্রায়ই std::tie(a.x, a.y) < std::tie(b.x, b.y)-এর মতো তুলনায়, যেটা দুইটা struct-কে field ধরে ধরে তুলনা করে, pair যেভাবে করে। মানে std::tie আগে থেকে থাকা variable ভরে, আর std::ignore একটা অংশ বাদ দেয়।

#include <iostream>
#include <string>
#include <utility>

int main()
{
    std::pair<std::string, int> a = {"Lima", 19};
    std::pair<std::string, int> b = {"Perth", 24};

    std::pair<std::string, int> hotter = a;
    if (b.second > a.second) {
        hotter = b;
    }
    std::cout << hotter.first << " is hotter at " << hotter.second << '\n';
    return 0;
}

Perth is hotter at 24

#include <iostream>
#include <tuple>

std::tuple<int, long long, double> summary(const int sales[], int n)
{
    long long total = 0;
    for (int i = 0; i < n; i++) {
        total += sales[i];
    }
    return {n, total, (double)total / n};
}

int main()
{
    int sales[5] = {120, 80, 45, 300, 55};
    auto [count, total, average] = summary(sales, 5);

    std::cout << count << " sales, total " << total << ", average " << average << '\n';
    return 0;
}

5 sales, total 600, average 120

#include <algorithm>
#include <iostream>
#include <string>
#include <utility>

int main()
{
    int n = 0;
    std::cin >> n;

    std::pair<int, std::string> best = {0, ""};
    for (int i = 0; i < n; i++) {
        std::string name;
        int x = 0;
        int y = 0;
        std::cin >> name >> x >> y;

        std::pair<int, std::string> here = {x * x + y * y, name};
        if (i == 0) {
            best = here;
        } else {
            best = std::min(best, here);
        }
    }
    auto [dist2, name] = best;
    std::cout << name << " (squared distance " << dist2 << ")\n";
    return 0;
}

fruit (squared distance 25)

std::pair<int, int> p = {3, 4};
std::cout << p.first() << '\n';

std::cout << p << '\n';

std::tuple<std::string, int, double> t = {"Zara", 3, 2.5};
std::cout << std::get<3>(t) << '\n';

auto [name, count] = t;

#include <iostream>
#include <string>
#include <utility>

int main()
{
    std::pair<int, int> a = {1, 2};
    std::pair<int, int> b = {1, 3};
    std::pair<std::string, int> c = {"Zara", 1};
    std::pair<std::string, int> d = {"apple", 9};

    std::cout << (a < b) << ' ' << (b < a) << ' ' << (c < d) << '\n';
    return 0;
}

#include <iostream>
#include <string>
#include <utility>

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int n = 0;
    std::cin >> n;

    std::pair<std::string, int> best;

    // Read n lines, each a name and a mark. Keep the best one in best:
    // the highest mark, and on a tie the one that came first.
    // Then print best's name and mark, separated by one space.

    return 0;
}

#include <iostream>
#include <utility>

// Return {sweets each friend gets, sweets left over}.
std::pair<int, int> share(int sweets, int friends)
{
    return {0, 0}; // replace this line
}

int main()
{
    int t = 0;
    std::cin >> t;
    for (int i = 0; i < t; i++) {
        int sweets = 0;
        int friends = 0;
        std::cin >> sweets >> friends;

        // Call share, name the two answers with a structured binding,
        // and print them as: each E, left L
    }
    return 0;
}

#include <algorithm>
#include <iostream>
#include <utility>
#include <vector>

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int n = 0;
    std::cin >> n;

    // A vector is an array that knows its own size (Module 2 teaches it).
    std::vector<std::pair<int, int>> v(n);
    for (auto& p : v) {
        std::cin >> p.first >> p.second;
    }

    // Sort v by first, and by second when the firsts are equal.
    // Then print one pair per line: first, one space, second.

    return 0;
}

#include <iostream>
#include <utility>

const int MAX_K = 1000;

// Return the smallest and the largest of a[0] to a[k - 1], in that order.
std::pair<int, int> minMax(const int a[], int k)
{
    return {0, 0}; // replace this line
}

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int t = 0;
    std::cin >> t;

    int a[MAX_K];
    for (int i = 0; i < t; i++) {
        int k = 0;
        std::cin >> k;
        for (int j = 0; j < k; j++) {
            std::cin >> a[j];
        }

        // Call minMax and print the smallest and the largest,
        // separated by one space.
    }
    return 0;
}

এরপর lesson 07 বোঝাবে এই module-এর প্রতিটা নামের সামনের std::, আর STL-এর কোন অংশ কোন header-এ থাকে।