0Pricing
C++ Academy · บทเรียน

อัลกอริทึมเชิงตัวเลข accumulate reduce transform_reduce

รวมช่วงข้อมูลตัวเลขด้วย accumulate, reduce และ transform_reduce ที่เหมาะกับการประมวลผลแบบขนาน

อัลกอริทึมเชิงตัวเลข accumulate reduce transform_reduce เป็นบทเรียน C++ Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน C++ Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส C++ Academy มีบทเรียนทั้งหมด 4 บทเรียน

ส่วนหัว <numeric>

อัลกอริทึมเชิงตัวเลขทำงานกับช่วงข้อมูลที่เป็นตัวเลข โดยอยู่ใน <numeric>

std::accumulate

การลดค่ามาตรฐาน โดยค่าเริ่มต้นจะหาผลรวม — ส่งการดำเนินการทวิภาคแบบกำหนดเองเพื่อใช้กับการลดค่าแบบอื่น

#include <numeric>
std::vector<int> v = {1, 2, 3, 4, 5};
int sum = std::accumulate(v.begin(), v.end(), 0);
// sum = 15

การลดค่าแบบกำหนดเอง

ระบุค่าเริ่มต้นและการดำเนินการทวิภาค

int product = std::accumulate(v.begin(), v.end(), 1,
    std::multiplies<int>{});
// product = 120

ชนิดของค่าเริ่มต้นมีความสำคัญ

ชนิดของตัวสะสมจะอนุมานจากค่าเริ่มต้น ให้ค่า 0.0 เพื่อสะสมค่าชนิด double ให้เป็น double

std::vector<double> v = {1.5, 2.5, 3.5};
double sum_d = std::accumulate(v.begin(), v.end(), 0.0);    // 7.5
int    sum_i = std::accumulate(v.begin(), v.end(), 0);      // truncates to 6

std::reduce (C++17)

คล้ายกับ accumulate แต่การดำเนินการต้องมีสมบัติการจัดหมู่และการสลับที่ จึงสามารถประมวลผลแบบขนานได้

#include <numeric>
#include <execution>
std::vector<int> v(1000);
int sum = std::reduce(std::execution::par,
    v.begin(), v.end(), 0);

reduce เทียบกับ accumulate

มีความแตกต่างสองประการ:

  • reduce อาจทำงานแบบขนาน
  • reduce ไม่รับประกันลำดับการดำเนินการ ซึ่งเหมาะสำหรับ + และ * แต่จะใช้ไม่ได้กับการดำเนินการที่ไม่เป็นการจัดหมู่ เช่น การต่อสตริง

std::transform_reduce (C++17)

รวมการแปลงค่าและการลดค่าไว้ในการทำงานรอบเดียว เร็วกว่าและสื่อความหมายได้มากกว่าการใช้ transform และ reduce แยกกัน

// Dot product
std::vector<int> a = {1, 2, 3}, b = {4, 5, 6};
int dot = std::transform_reduce(
    a.begin(), a.end(), b.begin(),
    0,
    std::plus<int>{},          // reduce
    std::multiplies<int>{}     // transform
);
// dot = 1*4 + 2*5 + 3*6 = 32

std::inner_product

รุ่นก่อนหน้าของ transform_reduce ใช้คำนวณผลคูณภายใน (ดอตโปรดักต์) ของช่วงข้อมูลสองช่วง มีความทั่วไปน้อยกว่า แต่ส่วนเชื่อมต่อการใช้งานเรียบง่ายกว่า

std::partial_sum

เขียนผลรวมสะสมลงในช่วงข้อมูลผลลัพธ์

std::vector<int> v = {1, 2, 3, 4};
std::vector<int> sums(4);
std::partial_sum(v.begin(), v.end(), sums.begin());
// sums = {1, 3, 6, 10}

std::adjacent_difference

ตรงข้ามกับ partial_sum — เขียนผลต่างระหว่างสมาชิกที่อยู่ติดกัน

std::vector<int> v = {1, 3, 6, 10};
std::vector<int> diffs(4);
std::adjacent_difference(v.begin(), v.end(), diffs.begin());
// diffs = {1, 2, 3, 4}

ข้อควรระวังเกี่ยวกับเลขทศนิยม

สำหรับเลขทศนิยม ลำดับการสะสมมีความสำคัญเนื่องจากการปัดเศษ reduce อาจให้ผลลัพธ์แตกต่างจาก accumulate เล็กน้อย เนื่องจากไม่ได้ระบุลำดับการประเมินค่า

กรณีการใช้งานจริง

อัลกอริทึมเชิงตัวเลขเป็นพื้นฐานของ:

  • การคำนวณผลรวมและผลคูณ
  • ค่ารวมทางสถิติ เช่น ค่าเฉลี่ยและความแปรปรวน
  • ดอตโปรดักต์และนอร์มในพีชคณิตเชิงเส้น
  • ผลรวมสะสมสำหรับการค้นหาด้วยผลรวมคำนำหน้า

ตรวจสอบความเข้าใจ

อัลกอริทึมใดใน C++17 ที่ลดค่าช่วงข้อมูลแบบขนานด้วยการเรียกฟังก์ชันเพียงครั้งเดียว

ทบทวน

<numeric> มี accumulate, reduce, transform_reduce, partial_sum และ adjacent_difference สำหรับการลดค่าเชิงตัวเลขและการดำเนินการกับผลรวมคำนำหน้า เลือก reduce เมื่อต้องการประมวลผลแบบขนาน และเลือก accumulate เมื่อต้องการลำดับที่กำหนดแน่นอน

คำถามที่พบบ่อย

บทเรียน “อัลกอริทึมเชิงตัวเลข accumulate reduce transform_reduce” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “อัลกอริทึมเชิงตัวเลข accumulate reduce transform_reduce” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส C++ Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส C++ Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “อัลกอริทึมเชิงตัวเลข accumulate reduce transform_reduce”

รวมช่วงข้อมูลตัวเลขด้วย accumulate, reduce และ transform_reduce ที่เหมาะกับการประมวลผลแบบขนาน คุณปฏิบัติ C++ Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน C++ Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน C++ Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “อัลกอริทึมเชิงตัวเลข accumulate reduce transform_reduce” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน C++ Academy นี้ได้ไหม

ได้ บทเรียน C++ Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. อัลกอริทึมที่ไม่แก้ไข: find count all_of
  2. การแก้ไขด้วย transform copy_if replace
  3. การเรียงลำดับและแบ่งพาร์ทิชัน sort stable_partition
  4. อัลกอริทึมเชิงตัวเลข accumulate reduce transform_reduce
← กลับไปที่ C++ Academy