Algorithms in C++ (এলগরিদম)

C++ তে অ্যালগরিদম হলো এমন একটি ধাপবদ্ধ প্রক্রিয়া বা পদ্ধতি যা একটি নির্দিষ্ট সমস্যা সমাধান করার জন্য ব্যবহৃত হয়। C++ স্ট্যান্ডার্ড লাইব্রেরি <algorithm> হেডার ফাইলে বিভিন্ন ধরনের অ্যালগরিদম সরবরাহ করে, যা ডেটা ম্যানিপুলেশন, অর্ডারিং, অনুসন্ধান, এবং অন্যান্য সাধারণ কাজ সম্পাদনে সহায়ক। এই অ্যালগরিদমগুলো সাধারণত ইটরেটর ব্যবহার করে কনটেইনারের উপাদানগুলোর ওপর কাজ করে।

C++ এ ব্যবহৃত কিছু সাধারণ অ্যালগরিদমগুলো হলো সোর্টিং, ফাইন্ডিং, ট্রান্সফরমেশন, ম্যাচিং ইত্যাদি। C++ স্ট্যান্ডার্ড লাইব্রেরি এই ধরনের অ্যালগরিদমের জন্য একটি শক্তিশালী সেট সরবরাহ করে, যার মাধ্যমে প্রোগ্রামাররা সহজেই কার্যকরী প্রোগ্রাম তৈরি করতে পারেন।

১. Sorting (সোর্টিং)

সিরিজের উপাদানগুলো সাজানোর জন্য std::sort() ফাংশন ব্যবহার করা হয়। এটি সাধারণত দ্রুততম এবং সবচেয়ে ব্যবহৃত সোর্টিং অ্যালগরিদম, যা QuickSort অথবা IntroSort ব্যবহার করে কাজ করে।

উদাহরণ (Sorting):

#include <iostream>
#include <vector>
#include <algorithm> // sort()

int main() {
    std::vector<int> vec = {5, 2, 9, 1, 5, 6};

    // সোজা ক্রমে সাজানো
    std::sort(vec.begin(), vec.end());

    // সাজানো ভেক্টরের উপাদানগুলো প্রদর্শন
    for (int num : vec) {
        std::cout << num << " ";
    }
    return 0;
}

std::sort():

• প্রথম প্যারামিটার: শুরু ইটরেটর (begin)।
• দ্বিতীয় প্যারামিটার: শেষ ইটরেটর (end)।
• এটি সোজা ক্রমে সাজায় (অর্থাৎ, ছোট থেকে বড়)।

Descending Order (বাঁধানো ক্রমে সাজানো):

std::sort(vec.begin(), vec.end(), std::greater<int>());

২. Searching (অনুসন্ধান)

C++ তে বিভিন্ন ধরণের অনুসন্ধান অ্যালগরিদম রয়েছে। সবচেয়ে সাধারণ দুটি হলো std::find() এবং **std::binary_search()**।

উদাহরণ (Linear Search with std::find()):

#include <iostream>
#include <vector>
#include <algorithm> // find()

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5, 6};

    // 4 উপাদান খুঁজে বের করা
    auto it = std::find(vec.begin(), vec.end(), 4);

    if (it != vec.end()) {
        std::cout << "Found 4 at position: " << (it - vec.begin()) << std::endl;
    } else {
        std::cout << "4 not found!" << std::endl;
    }

    return 0;
}

std::find():

• এটি একটি লিনিয়ার অনুসন্ধান অ্যালগরিদম যা কনটেইনারের মধ্যে একটি নির্দিষ্ট উপাদান খুঁজে বের করে।

উদাহরণ (Binary Search with std::binary_search()):

#include <iostream>
#include <vector>
#include <algorithm> // binary_search()

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5, 6};

    // 4 উপাদান খুঁজে বের করা
    if (std::binary_search(vec.begin(), vec.end(), 4)) {
        std::cout << "Found 4!" << std::endl;
    } else {
        std::cout << "4 not found!" << std::endl;
    }

    return 0;
}

std::binary_search():

• এটি একটি বাইনারি অনুসন্ধান অ্যালগরিদম, যা কেবল সাজানো কনটেইনারে কাজ করে।

৩. Transform (ট্রান্সফর্মেশন)

ট্রান্সফর্মেশন অ্যালগরিদম ব্যবহার করে, কনটেইনারের প্রতিটি উপাদানে একটি নির্দিষ্ট ফাংশন প্রয়োগ করা যায়। std::transform() ফাংশনটি ব্যবহার করে এটি করা হয়।

উদাহরণ (Transform):

#include <iostream>
#include <vector>
#include <algorithm> // transform
#include <functional> // negate

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // প্রতিটি উপাদানে negate ফাংশন প্রয়োগ করা
    std::transform(vec.begin(), vec.end(), vec.begin(), std::negate<int>());

    // পরিবর্তিত ভেক্টর প্রদর্শন
    for (int num : vec) {
        std::cout << num << " ";
    }

    return 0;
}

std::transform():

• প্রথম প্যারামিটার: শুরু ইটরেটর।
• দ্বিতীয় প্যারামিটার: শেষ ইটরেটর।
• তৃতীয় প্যারামিটার: আউটপুটে পরিবর্তন আনার জন্য।
• চতুর্থ প্যারামিটার: যে ফাংশনটি প্রতিটি উপাদানে প্রয়োগ করা হবে।

৪. Min/Max (সর্বনিম্ন/সর্বোচ্চ)

C++ স্ট্যান্ডার্ড লাইব্রেরি std::min() এবং std::max() ফাংশন ব্যবহার করে দুটি মানের মধ্যে সর্বনিম্ন এবং সর্বোচ্চ বের করা যায়।

উদাহরণ (Min/Max):

#include <iostream>
#include <algorithm> // min, max

int main() {
    int a = 10, b = 20;

    std::cout << "Minimum: " << std::min(a, b) << std::endl;
    std::cout << "Maximum: " << std::max(a, b) << std::endl;

    return 0;
}

std::min() এবং std::max():

• এই ফাংশনগুলো দুটি মানের মধ্যে সর্বনিম্ন এবং সর্বোচ্চ মান বের করে।

৫. Reversing (উল্টো করা)

C++ এ std::reverse() ফাংশন ব্যবহার করে একটি কনটেইনারের উপাদানগুলো উল্টো করা যায়।

উদাহরণ (Reversing):

#include <iostream>
#include <vector>
#include <algorithm> // reverse

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // ভেক্টর উল্টো করা
    std::reverse(vec.begin(), vec.end());

    // উল্টো করা ভেক্টরের উপাদানগুলো প্রদর্শন
    for (int num : vec) {
        std::cout << num << " ";
    }

    return 0;
}

std::reverse():

• এটি কনটেইনারের উপাদানগুলোর অর্ডার উল্টো করে।

৬. Copying (কপি করা)

C++ তে std::copy() ফাংশন ব্যবহার করে একটি কনটেইনারের উপাদান অন্য কনটেইনারে কপি করা যায়।

উদাহরণ (Copy):

#include <iostream>
#include <vector>
#include <algorithm> // copy

int main() {
    std::vector<int> vec1 = {1, 2, 3, 4, 5};
    std::vector<int> vec2(5);

    // vec1 এর উপাদান vec2 তে কপি করা
    std::copy(vec1.begin(), vec1.end(), vec2.begin());

    // vec2 এর উপাদানগুলো প্রদর্শন
    for (int num : vec2) {
        std::cout << num << " ";
    }

    return 0;
}

std::copy():

• এটি একটি কনটেইনারের উপাদান অন্য কনটেইনারে কপি করে।

উপসংহার

C++ এ স্ট্যান্ডার্ড লাইব্রেরি <algorithm> এর মাধ্যমে বিভিন্ন শক্তিশালী অ্যালগরিদম সরবরাহ করা হয়, যা প্রোগ্রামিংকে অনেক সহজ এবং দ্রুত করে তোলে। সোর্টিং, অনুসন্ধান, ট্রান্সফরমেশন, সর্বনিম্ন/সর্বোচ্চ, উল্টো করা, এবং কপি করা ইত্যাদি কাজের জন্য C++ এর অ্যালগরিদমগুলি অত্যন্ত কার্যকরী এবং সুবিধাজনক। এগুলো ইটরেটরের সাথে মিলিত হয়ে C++ প্রোগ্রামিংয়ের ক্ষমতাকে আরও বৃদ্ধি করে।

std::algorithm C++ স্ট্যান্ডার্ড লাইব্রেরির একটি গুরুত্বপূর্ণ হেডার, যা বিভিন্ন ধরণের অ্যালগরিদম সরবরাহ করে। এই অ্যালগরিদমগুলো কনটেইনারের উপর বিভিন্ন কার্য সম্পাদন করতে ব্যবহৃত হয়, যেমন সাজানো (sorting), অনুসন্ধান (searching), গণনা (counting), পরিবর্তন (modification) ইত্যাদি। std::algorithm হেডারটি কনটেইনারের সাথে সহজে এবং দ্রুত কাজ করার সুবিধা দেয়।

নিচে std::algorithm হেডারের কিছু গুরুত্বপূর্ণ ফাংশন এবং তাদের ব্যাখ্যা দেওয়া হলো:

১. std::sort

এই ফাংশনটি একটি রেঞ্জকে ছোট থেকে বড় বা বড় থেকে ছোট সাজানোর জন্য ব্যবহৃত হয়।

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

int main() {
    std::vector<int> vec = {5, 3, 1, 4, 2};
    std::sort(vec.begin(), vec.end()); // ছোট থেকে বড় সাজানো
    // আউটপুট: 1 2 3 4 5
    for (int n : vec) {
        std::cout << n << " ";
    }
    return 0;
}

২. std::reverse

একটি রেঞ্জকে উল্টিয়ে দেয়।

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::reverse(vec.begin(), vec.end());
    // আউটপুট: 5 4 3 2 1
    for (int n : vec) {
        std::cout << n << " ";
    }
    return 0;
}

৩. std::find

এই ফাংশনটি একটি নির্দিষ্ট উপাদান খুঁজে বের করতে ব্যবহৃত হয় এবং এটি প্রথম মিলের ইটরেটর রিটার্ন করে। যদি না পাওয়া যায়, তাহলে end() রিটার্ন করে।

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

int main() {
    std::vector<int> vec = {10, 20, 30, 40, 50};
    auto it = std::find(vec.begin(), vec.end(), 30);
    if (it != vec.end()) {
        std::cout << "Element found: " << *it << std::endl;
    } else {
        std::cout << "Element not found" << std::endl;
    }
    return 0;
}

৪. std::count

এই ফাংশনটি একটি নির্দিষ্ট উপাদানের সংখ্যা গণনা করে।

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

int main() {
    std::vector<int> vec = {1, 2, 3, 2, 4, 2};
    int count_of_2 = std::count(vec.begin(), vec.end(), 2);
    std::cout << "Count of 2: " << count_of_2 << std::endl; // আউটপুট: 3
    return 0;
}

৫. std::accumulate (numeric হেডারে অন্তর্ভুক্ত)

এই ফাংশনটি একটি রেঞ্জের উপাদানগুলোর সমষ্টি বের করে। এটি #include <numeric> এর অন্তর্গত।

#include <iostream>
#include <vector>
#include <numeric>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    int sum = std::accumulate(vec.begin(), vec.end(), 0);
    std::cout << "Sum: " << sum << std::endl; // আউটপুট: 15
    return 0;
}

৬. std::all_of, std::any_of, std::none_of

এই ফাংশনগুলো কন্ডিশনের ভিত্তিতে একটি রেঞ্জে চেক করে যে সমস্ত উপাদান, কিছু উপাদান বা কোনো উপাদানই কন্ডিশন পূরণ করে কিনা।

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    bool all_positive = std::all_of(vec.begin(), vec.end(), [](int i){ return i > 0; });
    bool any_negative = std::any_of(vec.begin(), vec.end(), [](int i){ return i < 0; });
    bool none_above_10 = std::none_of(vec.begin(), vec.end(), [](int i){ return i > 10; });

    std::cout << "All positive: " << all_positive << std::endl;   // true
    std::cout << "Any negative: " << any_negative << std::endl;   // false
    std::cout << "None above 10: " << none_above_10 << std::endl; // true

    return 0;
}

৭. std::copy

একটি রেঞ্জের উপাদানগুলোকে অন্য রেঞ্জে কপি করতে ব্যবহৃত হয়।

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::vector<int> vec_copy(vec.size());

    std::copy(vec.begin(), vec.end(), vec_copy.begin());

    for (int n : vec_copy) {
        std::cout << n << " ";
    }
    return 0;
}

৮. std::unique

একটি রেঞ্জের মধ্যে ডুপ্লিকেট উপাদান সরিয়ে দেয় (ধারাবাহিকভাবে থাকা ডুপ্লিকেট)। এটি std::erase এর সাথে ব্যবহার করতে হয়।

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

int main() {
    std::vector<int> vec = {1, 2, 2, 3, 4, 4, 5};
    auto last = std::unique(vec.begin(), vec.end());
    vec.erase(last, vec.end());

    for (int n : vec) {
        std::cout << n << " ";
    }
    return 0;
}

৯. std::transform

একটি ফাংশন প্রয়োগ করে একটি রেঞ্জের প্রতিটি উপাদানকে পরিবর্তন করতে ব্যবহৃত হয়।

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::vector<int> result(vec.size());

    std::transform(vec.begin(), vec.end(), result.begin(), [](int i){ return i * 2; });

    for (int n : result) {
        std::cout << n << " ";
    }
    return 0;
}

১০. std::fill

এই ফাংশন একটি নির্দিষ্ট মান দিয়ে একটি রেঞ্জের প্রতিটি উপাদান পূর্ণ করে।

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

int main() {
    std::vector<int> vec(5);
    std::fill(vec.begin(), vec.end(), 10);

    for (int n : vec) {
        std::cout << n << " ";
    }
    return 0;
}

উপসংহার

std::algorithm হেডারটি C++ এ অনেক ধরনের অ্যালগরিদম সরবরাহ করে, যা কনটেইনারের উপাদানগুলোর উপর দ্রুত এবং কার্যকরী কাজ করতে সাহায্য করে। এটি স্ট্যান্ডার্ড লাইব্রেরির একটি অত্যন্ত গুরুত্বপূর্ণ অংশ এবং এর ফাংশনগুলো ব্যবহার করে প্রোগ্রামাররা আরও সহজে এবং কার্যকরভাবে প্রোগ্রাম লিখতে পারে।

C++ স্ট্যান্ডার্ড লাইব্রেরিতে Searching এবং Sorting এর জন্য বেশ কিছু গুরুত্বপূর্ণ অ্যালগরিদম সরবরাহ করা হয়। এর মধ্যে প্রধান তিনটি হল std::sort(), std::find(), এবং std::binary_search()। এগুলো ডেটা সংগ্রহের সন্নিবেশ, অনুসন্ধান এবং সাজানোর জন্য ব্যবহৃত হয়।

এখানে এই তিনটি অ্যালগরিদমের কাজ এবং ব্যবহার সম্পর্কে বিস্তারিত আলোচনা করা হলো:

১. std::sort() – Sorting Algorithm

std::sort() একটি Sorting Algorithm, যা C++ স্ট্যান্ডার্ড লাইব্রেরির <algorithm> হেডার ফাইলে থাকে। এটি কনটেইনারের উপাদানগুলো সাজানোর জন্য ব্যবহৃত হয়। std::sort() সাধারণত Quick Sort অথবা Heap Sort অ্যালগরিদম ব্যবহার করে এবং এর O(n log n) টাইম কমপ্লেক্সিটি রয়েছে।

Syntax:

std::sort(iterator begin, iterator end);

• begin: কনটেইনারের প্রথম উপাদান।
• end: কনটেইনারের শেষ উপাদান (এটি সাজানোর জন্য সহায়ক হয়)।

উদাহরণ (std::sort):

#include <iostream>
#include <vector>
#include <algorithm>  // std::sort

int main() {
    std::vector<int> vec = {5, 2, 8, 1, 3};

    // std::sort() ব্যবহার করে ভেক্টর সাজানো
    std::sort(vec.begin(), vec.end());

    // সাজানো উপাদান প্রিন্ট করা
    for (int num : vec) {
        std::cout << num << " ";
    }

    return 0;
}

আউটপুট:

1 2 3 5 8

এখানে, std::sort() ভেক্টর vec এর উপাদানগুলো সাজিয়ে দিয়েছে।

কাস্টম কম্প্যারিজন ফাংশন:

আপনি যদি নিজস্ব ক্রম অনুসারে সাজাতে চান, তবে একটি কাস্টম কম্প্যারিজন ফাংশন ব্যবহার করতে পারেন। উদাহরণস্বরূপ:

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

bool compare(int a, int b) {
    return a > b;  // Descending order
}

int main() {
    std::vector<int> vec = {5, 2, 8, 1, 3};
    std::sort(vec.begin(), vec.end(), compare);

    for (int num : vec) {
        std::cout << num << " ";
    }

    return 0;
}

আউটপুট:

8 5 3 2 1

২. std::find() – Searching Algorithm

std::find() একটি Searching Algorithm, যা একটি সিকোয়েন্সে একটি নির্দিষ্ট উপাদান খুঁজে বের করার জন্য ব্যবহৃত হয়। এটি linear search ব্যবহার করে, অর্থাৎ এটি একটি উপাদান খুঁজতে কনটেইনারের প্রতিটি উপাদান পরীক্ষা করে। এটি O(n) টাইম কমপ্লেক্সিটি ধারণ করে।

Syntax:

std::find(iterator begin, iterator end, const T& value);

• begin: অনুসন্ধান শুরুর পয়েন্ট।
• end: অনুসন্ধানের শেষ পয়েন্ট।
• value: যে মানটি খুঁজতে চান।

উদাহরণ (std::find):

#include <iostream>
#include <vector>
#include <algorithm>  // std::find

int main() {
    std::vector<int> vec = {10, 20, 30, 40, 50};

    // std::find() ব্যবহার করে একটি উপাদান খোঁজা
    auto it = std::find(vec.begin(), vec.end(), 30);

    if (it != vec.end()) {
        std::cout << "Found: " << *it << std::endl;
    } else {
        std::cout << "Not Found" << std::endl;
    }

    return 0;
}

আউটপুট:

Found: 30

এখানে, std::find() 30 মানটি ভেক্টরের মধ্যে খুঁজে পেয়েছে এবং এটি প্রিন্ট করেছে।

৩. std::binary_search() – Searching Algorithm

std::binary_search() একটি Searching Algorithm যা binary search পদ্ধতি ব্যবহার করে একটি সাজানো কনটেইনারে দ্রুত অনুসন্ধান করে। এটি কেবল তখনই কার্যকরী, যখন কনটেইনারটি সাজানো থাকে। এর O(log n) টাইম কমপ্লেক্সিটি থাকে, যা std::find() থেকে অনেক দ্রুত।

Syntax:

bool std::binary_search(iterator begin, iterator end, const T& value);

• begin: অনুসন্ধান শুরুর পয়েন্ট।
• end: অনুসন্ধানের শেষ পয়েন্ট।
• value: যে মানটি খুঁজতে চান।

উদাহরণ (std::binary_search):

#include <iostream>
#include <vector>
#include <algorithm>  // std::binary_search

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // std::binary_search() ব্যবহার করে একটি উপাদান খোঁজা
    bool found = std::binary_search(vec.begin(), vec.end(), 5);

    if (found) {
        std::cout << "Found!" << std::endl;
    } else {
        std::cout << "Not Found!" << std::endl;
    }

    return 0;
}

আউটপুট:

Found!

এখানে, std::binary_search() 5 মানটি সাজানো ভেক্টরের মধ্যে খুঁজে পেয়েছে।

গুরুত্বপূর্ণ নোট:

• std::binary_search() শুধুমাত্র সাজানো কনটেইনারের জন্য কাজ করে। যদি কনটেইনারটি সাজানো না থাকে, তবে এটি সঠিক ফলাফল প্রদান করবে না।
• যদি std::binary_search() ব্যবহার করার পর আপনি সেই মানের অবস্থান জানতে চান, তাহলে std::lower_bound() বা std::upper_bound() ব্যবহার করতে পারেন।

পার্থক্য সারণী

উপসংহার

• std::sort(): এটি একটি কনটেইনারের উপাদানগুলোকে সাজানোর জন্য ব্যবহৃত হয় এবং এটি O(n log n) টাইম কমপ্লেক্সিটিতে কাজ করে।
• std::find(): এটি একটি সিকোয়েন্সের মধ্যে একটি উপাদান খুঁজে বের করার জন্য ব্যবহৃত হয় এবং এটি linear search পদ্ধতি ব্যবহার করে, যার O(n) টাইম কমপ্লেক্সিটি থাকে।
• std::binary_search(): এটি একটি সাজানো কনটেইনারে একটি উপাদান খুঁজে বের করার জন্য binary search পদ্ধতি ব্যবহার করে, যার O(log n) টাইম কমপ্লেক্সিটি থাকে।

এই অ্যালগরিদমগুলো C++ প্রোগ্রামে ডেটা অনুসন্ধান এবং সাজানোর জন্য গুরুত্বপূর্ণ টুল হিসেবে কাজ করে, এবং সঠিক ব্যবহারের মাধ্যমে কোডের কর্মদক্ষতা উন্নত করা সম্ভব।

C++ স্ট্যান্ডার্ড লাইব্রেরিতে কিছু ট্রান্সফর্মেশন অ্যালগরিদম রয়েছে যা কনটেইনারের উপাদানগুলির সাথে বিভিন্ন ধরনের কার্য সম্পাদন করতে সহায়তা করে। এই অ্যালগরিদমগুলির মধ্যে std::transform(), std::copy(), এবং std::replace() খুবই জনপ্রিয় এবং সাধারণভাবে ব্যবহৃত হয়। নিচে তাদের ব্যাখ্যা এবং উদাহরণ দেওয়া হলো:

১. std::transform()

std::transform() একটি অ্যালগরিদম যা কনটেইনারের উপাদানগুলোর ওপর একটি ফাংশন প্রয়োগ করে এবং ফলস্বরূপ নতুন ডেটা প্রদান করে। এই অ্যালগরিদমটি একটি রেঞ্জে একটি নির্দিষ্ট ফাংশন প্রয়োগ করার জন্য ব্যবহৃত হয়, যা কনটেইনারের সকল উপাদানে পরিবর্তন আনে।

বৈশিষ্ট্য:

• std::transform() দুটি রেঞ্জ গ্রহণ করে (একটি ইনপুট রেঞ্জ এবং একটি আউটপুট রেঞ্জ) এবং একটি নির্দিষ্ট অপারেশন (ফাংশন বা ল্যাম্বডা) প্রয়োগ করে।
• এটি মূল কনটেইনারের ডেটা পরিবর্তন না করে, একটি নতুন কনটেইনারে পরিবর্তনগুলি রাখে।

উদাহরণ:

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

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    std::vector<int> result(numbers.size());

    // std::transform ব্যবহার করে প্রতিটি উপাদানে 10 যোগ করা
    std::transform(numbers.begin(), numbers.end(), result.begin(), [](int x) { return x + 10; });

    std::cout << "Transformed elements: ";
    for (int num : result) {
        std::cout << num << " ";
    }

    return 0;
}

আউটপুট:

Transformed elements: 11 12 13 14 15

২. std::copy()

std::copy() একটি অ্যালগরিদম যা একটি রেঞ্জের উপাদানগুলো অন্য রেঞ্জে কপি করে। এটি মূল রেঞ্জের ডেটাকে অপর রেঞ্জে কপি করে, তবে এটি মূল ডেটাকে পরিবর্তন করে না।

বৈশিষ্ট্য:

• এটি দুটি রেঞ্জ নেয়: একটি ইনপুট রেঞ্জ এবং একটি আউটপুট রেঞ্জ।
• কপি অপারেশনটি শুধুমাত্র উপাদানগুলিকে কপি করে, মূল কনটেইনারের ডেটাকে পরিবর্তন না করে।

উদাহরণ:

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

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    std::vector<int> result(5);

    // std::copy ব্যবহার করে numbers কনটেইনার থেকে result কনটেইনারে উপাদান কপি করা
    std::copy(numbers.begin(), numbers.end(), result.begin());

    std::cout << "Copied elements: ";
    for (int num : result) {
        std::cout << num << " ";
    }

    return 0;
}

আউটপুট:

Copied elements: 1 2 3 4 5

৩. std::replace()

std::replace() একটি অ্যালগরিদম যা কনটেইনারের মধ্যে একটি নির্দিষ্ট মান খুঁজে সেই মানকে অন্য একটি মান দিয়ে প্রতিস্থাপন করে। এটি শুধুমাত্র কনটেইনারের বর্তমান ডেটাকে পরিবর্তন করে।

বৈশিষ্ট্য:

• এটি একটি মান এবং একটি প্রতিস্থাপন মান নেয় এবং কনটেইনারের মধ্যে সেই মানটি খুঁজে বের করে প্রতিস্থাপন করে।
• সাধারণত, এটি ঐ কনটেইনারের ডেটাকে পরিবর্তন করে, তবে কপি করা হয় না।

উদাহরণ:

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

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 2};

    // std::replace ব্যবহার করে সব 2 কে 10 দিয়ে প্রতিস্থাপন করা
    std::replace(numbers.begin(), numbers.end(), 2, 10);

    std::cout << "Replaced elements: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }

    return 0;
}

আউটপুট:

Replaced elements: 1 10 3 4 5 10

অ্যালগরিদমগুলোর সংক্ষিপ্ত তুলনা

উপসংহার

• std::transform(): কনটেইনারের উপাদানগুলোর ওপর একটি নির্দিষ্ট ফাংশন প্রয়োগ করে নতুন রেঞ্জ তৈরি করতে ব্যবহৃত হয়।
• std::copy(): একটি কনটেইনার থেকে উপাদান কপি করতে ব্যবহৃত হয়।
• std::replace(): কনটেইনারের উপাদানগুলির মধ্যে একটি নির্দিষ্ট মান খুঁজে সেটি প্রতিস্থাপন করতে ব্যবহৃত হয়।

এই অ্যালগরিদমগুলো স্ট্যান্ডার্ড লাইব্রেরির গুরুত্বপূর্ণ টুলস যা ডেটা ম্যানিপুলেশন, কপি এবং পরিবর্তন করতে সহজ ও কার্যকর উপায় প্রদান করে।

সি++ স্ট্যান্ডার্ড লাইব্রেরিতে অ্যালগরিদমগুলোকে মূলত দুইটি প্রধান শ্রেণীতে ভাগ করা যায়: Non-modifying algorithms এবং Modifying algorithms। এই শ্রেণীবিভাগগুলো মূলত তাদের কনটেইনারের উপাদানগুলোর ওপর প্রভাবের ওপর ভিত্তি করে করা হয়। Non-modifying অ্যালগরিদম উপাদানগুলো পরিবর্তন করে না, বরং এগুলো পরীক্ষা, গণনা, বা অন্বেষণ করে। Modifying অ্যালগরিদম উপাদানগুলো পরিবর্তন করে বা নতুনভাবে সাজায়।

Non-modifying Algorithms

Non-modifying অ্যালগরিদম কনটেইনারের উপাদানগুলো পরিবর্তন না করেই এগুলোর ওপর বিভিন্ন কার্য সম্পাদন করে। এদের মূলত ডেটা যাচাই, খোঁজা, এবং গণনার জন্য ব্যবহার করা হয়।

কিছু সাধারণ Non-modifying Algorithms:

• for_each: প্রতিটি উপাদানের উপর নির্দিষ্ট একটি ফাংশন প্রয়োগ করে।
• find: নির্দিষ্ট মানের প্রথম উপাদান খুঁজে বের করে।
• count: নির্দিষ্ট মানের উপাদানগুলোর সংখ্যা গণনা করে।
• count_if: নির্দিষ্ট শর্ত পূরণ করা উপাদানগুলোর সংখ্যা গণনা করে।
• all_of: পরীক্ষা করে যে সমস্ত উপাদান নির্দিষ্ট শর্ত পূরণ করে কিনা।
• any_of: পরীক্ষা করে যে কোনো একটি উপাদান নির্দিষ্ট শর্ত পূরণ করে কিনা।
• none_of: পরীক্ষা করে যে কোনো উপাদান নির্দিষ্ট শর্ত পূরণ করে না।
• equal: দুটি রেঞ্জ সমান কিনা তা পরীক্ষা করে।
• mismatch: দুটি রেঞ্জের প্রথম অমিল উপাদানটি খুঁজে বের করে।

উদাহরণ:

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

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // for_each অ্যালগরিদম ব্যবহার করে প্রতিটি উপাদান প্রিন্ট করা
    std::for_each(numbers.begin(), numbers.end(), [](int n) { std::cout << n << " "; });

    // count অ্যালগরিদম ব্যবহার করে সংখ্যা গণনা করা
    int count_of_3 = std::count(numbers.begin(), numbers.end(), 3);
    std::cout << "\nCount of 3: " << count_of_3 << std::endl;

    return 0;
}

এখানে for_each এবং count অ্যালগরিদম ব্যবহার করে কনটেইনারের উপাদানগুলো পরীক্ষা করা হয়েছে, কিন্তু কোনো উপাদান পরিবর্তন করা হয়নি।

Modifying Algorithms

Modifying অ্যালগরিদম কনটেইনারের উপাদানগুলো পরিবর্তন বা নতুনভাবে সাজানোর জন্য ব্যবহৃত হয়। এদের মাধ্যমে কনটেইনারের ডেটার স্ট্রাকচার পরিবর্তন, এলিমেন্টের স্থান পরিবর্তন, নতুন এলিমেন্ট যোগ ইত্যাদি করা যায়।

কিছু সাধারণ Modifying Algorithms:

• fill: একটি রেঞ্জের সমস্ত উপাদানে নির্দিষ্ট মান দিয়ে পূর্ণ করে।
• fill_n: একটি নির্দিষ্ট সংখ্যক উপাদানে নির্দিষ্ট মান দিয়ে পূর্ণ করে।
• copy: একটি রেঞ্জের উপাদানগুলো অন্য একটি রেঞ্জে কপি করে।
• copy_if: নির্দিষ্ট শর্ত পূরণ করা উপাদানগুলো অন্য একটি রেঞ্জে কপি করে।
• move: একটি রেঞ্জের উপাদানগুলোকে অন্য একটি রেঞ্জে সরিয়ে নিয়ে যায়।
• replace: নির্দিষ্ট মানগুলোকে নতুন মান দিয়ে প্রতিস্থাপন করে।
• replace_if: নির্দিষ্ট শর্ত পূরণ করা উপাদানগুলোকে নতুন মান দিয়ে প্রতিস্থাপন করে।
• remove: নির্দিষ্ট মানের উপাদানগুলো সরিয়ে দেয়।
• remove_if: নির্দিষ্ট শর্ত পূরণ করা উপাদানগুলো সরিয়ে দেয়।
• reverse: একটি রেঞ্জের উপাদানগুলো উল্টে দেয়।
• sort: একটি রেঞ্জের উপাদানগুলোকে সাজিয়ে দেয়।
• partition: নির্দিষ্ট শর্ত পূরণ করা উপাদানগুলোকে গ্রুপ করে।

উদাহরণ:

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

int main() {
    std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2};

    // sort অ্যালগরিদম ব্যবহার করে ভেক্টরকে সাজানো
    std::sort(numbers.begin(), numbers.end());

    // reverse অ্যালগরিদম ব্যবহার করে ভেক্টরকে উল্টে দেয়া
    std::reverse(numbers.begin(), numbers.end());

    // replace অ্যালগরিদম ব্যবহার করে 1 মানগুলোকে 10 দ্বারা প্রতিস্থাপন করা
    std::replace(numbers.begin(), numbers.end(), 1, 10);

    // পরবর্তীতে ভেক্টরের উপাদানগুলো প্রিন্ট করা
    for (int n : numbers) {
        std::cout << n << " ";
    }

    return 0;
}

উপরের উদাহরণে sort, reverse, এবং replace অ্যালগরিদমগুলো ব্যবহার করা হয়েছে যা কনটেইনারের উপাদানগুলো পরিবর্তন বা নতুনভাবে সাজাতে সহায়ক।

সংক্ষেপে

• Non-modifying Algorithms: এই অ্যালগরিদমগুলো কনটেইনারের উপাদানগুলো পরিবর্তন না করে তাদের ওপর বিভিন্ন কার্য সম্পাদন করে। যেমন: for_each, find, count, equal, ইত্যাদি।
• Modifying Algorithms: এই অ্যালগরিদমগুলো কনটেইনারের উপাদানগুলো পরিবর্তন বা নতুনভাবে সাজায়। যেমন: sort, replace, remove, fill, ইত্যাদি।

এই অ্যালগরিদমগুলো ব্যবহার করে C++ এ ডেটা প্রসেসিংকে সহজ করা যায় এবং প্রোগ্রামিংয়ে উচ্চমানের কার্যকারিতা নিশ্চিত করা যায়।