บทนำเชิงภาพเกี่ยวกับสัญกรณ์ Big O

 (samwho.dev)
2 คะแนน โดย GN⁺ 2025-08-26 | 1 ความคิดเห็น | แชร์ทาง WhatsApp
  • สัญกรณ์ Big O ใช้แสดงประสิทธิภาพของฟังก์ชันในรูปแบบของ แนวโน้มการเติบโตตามการเปลี่ยนแปลงของขนาดอินพุต
  • บทความนี้อธิบาย Big O ประเภทหลักอย่าง ค่าคงที่, ลอการิทึม, เชิงเส้น, และ กำลังสอง พร้อมตัวอย่างประกอบ
  • ความซับซ้อนเชิงเวลา แตกต่างกันไปตามโครงสร้างข้อมูลและอัลกอริทึม และเห็นความต่างได้จากงานอย่างการเรียงลำดับอาร์เรย์หรือการค้นหา
  • การปรับปรุงประสิทธิภาพของโค้ดจริงให้ดีขึ้นนั้น หัวใจสำคัญคือ การเลือกโครงสร้างข้อมูลที่เหมาะสม และการตัดการคำนวณที่ไม่จำเป็นภายในลูป
  • Big O จะแสดง ความสัมพันธ์ระหว่างอินพุตกับเวลาในการทำงาน ในรูปแบบที่เรียบง่ายที่สุดเสมอ และเมื่อปรับปรุงประสิทธิภาพ ควรวัดผลจากโค้ดจริงโดยตรง

ภาพรวมของสัญกรณ์ Big O

  • สัญกรณ์ Big O คือวิธีอธิบาย แนวโน้มการเติบโตของเวลาในการทำงานตามขนาดอินพุต (n) แทนการวัดเวลาโดยตรง
  • มันจัดประเภทเวลาในการทำงานของฟังก์ชันตามขนาดอินพุต โดยรูปแบบที่มักนำมาวิเคราะห์คือ ค่าคงที่ (O(1)), ลอการิทึม (O(log n)), เชิงเส้น (O(n)), และ กำลังสอง (O(n²))
  • บทความนี้อธิบายแนวคิดของแต่ละประเภท พร้อมตัวอย่างเชิงภาพและตัวอย่างโค้ดจริง เพื่อให้แม้แต่มือใหม่ก็เข้าใจได้

การวนซ้ำ (Iterating) และอัลกอริทึมเชิงเส้น

  • ฟังก์ชัน sum(n) เป็นตัวอย่างของโครงสร้างการวนซ้ำที่บวกค่าตั้งแต่ 1 ถึง n ซึ่งเมื่อค่าอินพุต n เพิ่มขึ้น เวลาในการทำงานก็ เพิ่มขึ้นแบบแปรผันตรง
  • ในทางปฏิบัติ sum(1e9) ใช้เวลาประมาณ 1 วินาที และ sum(2e9) ใช้เวลาประมาณ 2 วินาที ทำให้เวลาแบบนาฬิกาจริง (wall-clock time) เติบโตตามรูปแบบ O(n)
  • ความซับซ้อนเชิงเวลา คือความสัมพันธ์ระหว่างอินพุตของฟังก์ชันกับเวลาในการทำงาน และแสดงด้วย สัญกรณ์ Big O (O(n) — แปรผันตาม n)
  • หากใช้สูตรคณิตศาสตร์แทนการวนซ้ำ เช่น sum(n) = (n*(n+1))/2 เวลาในการทำงานจะ คงที่โดยไม่ขึ้นกับค่าอินพุต n
  • ฟังก์ชันแบบนี้เรียกว่า ความซับซ้อนเชิงเวลาคงที่ O(1) ซึ่งมีลักษณะเด่นคือเวลาในการทำงานไม่เติบโตตามการเปลี่ยนแปลงของอินพุต

ไวยากรณ์ของสัญกรณ์ Big O

  • O ใน Big O มาจากคำว่า “Order (ลำดับการเติบโต)” และใช้เพื่อ แสดงเฉพาะรูปแบบการเติบโตเท่านั้น
  • มันไม่ได้แสดงค่าจริงสัมบูรณ์ของเวลาในการทำงาน แต่ เขียนเฉพาะ 'รูปแบบ' ของการเติบโตเมื่อเทียบกับอินพุตอย่างกระชับ
  • ตัวอย่างเช่น แม้จะเป็นฟังก์ชัน O(n) ก็จะไม่เขียนซับซ้อนเป็น 'O(2n)' หรือ 'O(n+1)' แต่จะ เลือกเฉพาะพจน์ที่เรียบง่ายที่สุด

การลดเวลาโดยอาศัยการจัดรูปแบบอินพุต

  • เช่นในตัวอย่างสูตร sum(n) เราสามารถ ปรับปรุงอัลกอริทึมให้ความซับซ้อนเชิงเวลาเปลี่ยนจาก O(n) เป็น O(1) ได้
  • อย่างไรก็ตาม ความซับซ้อนเชิงเวลาคงที่ไม่ได้แปลว่าจะเร็วกว่าเสมอไป เพราะเวลาในการทำงานจริงยังต่างกันได้ตามประเภทของการคำนวณ
  • อัลกอริทึม O(n) อาจเร็วกว่า O(1) ในอินพุตบางแบบ แต่เมื่อขนาดอินพุตใหญ่ขึ้น วิธีแบบ O(1) จะได้เปรียบเสมอ

การเรียงลำดับ (Sorting) และอัลกอริทึมกำลังสอง (Quadratic): ตัวอย่าง Bubble Sort

  • Bubble Sort เป็นตัวอย่างพื้นฐานของการเรียงอาร์เรย์ด้วยการสลับค่าที่อยู่ติดกันซ้ำไปเรื่อย ๆ
  • หากเรียงอยู่แล้ว อาจวนเพียง 1 รอบ (O(n)) แต่ถ้าเรียงย้อนลำดับ ต้องไล่วนประมาณ n รอบซ้ำ ๆ → กรณีแย่ที่สุด จำนวนการทำงานรวมเป็น n²
  • อัลกอริทึม O(n²) จะมีเวลาในการทำงานเพิ่มขึ้นอย่างมากในลักษณะกำลังสองเมื่ออินพุตมีขนาดใหญ่ขึ้น
  • ในการใช้งานจริง Big O มักอิงจาก กรณีแย่ที่สุด (worst-case) เสมอ (แม้บางครั้งจะมีการระบุกรณีเฉลี่ยหรือกรณีดีที่สุดด้วย)
  • แม้จำนวนรอบการวนจะลดลงได้ตามสถานะเริ่มต้นของอาร์เรย์ แต่เมื่อพิจารณากรณีแย่ที่สุด ก็ยัง ถูกจัดเป็นความซับซ้อนเชิงเวลากำลังสอง

การค้นหา (Searching) และอัลกอริทึมลอการิทึม: ตัวอย่าง Binary Search

  • Binary Search จะประเมินค่ากลางของช่วงที่เรียงลำดับแล้ว และตัดพื้นที่ของคำตอบทิ้งไปครึ่งหนึ่งในแต่ละขั้น
  • ตัวอย่างเช่น การเดาเลขหนึ่งค่าระหว่าง 1~100 ใช้มากสุด 7 ครั้ง และแม้เป็นช่วง 1~1 พันล้าน ก็ยังใช้ไม่ถึง 31 ครั้ง
  • เพราะรายชื่อผู้สมัครคำตอบถูกลดลงครึ่งหนึ่งทุกขั้น เวลาในการทำงานจึงเป็น O(log n) (ความซับซ้อนเชิงเวลาลอการิทึม)
  • อัลกอริทึมแบบลอการิทึมจะเพิ่มขึ้นช้ามากเมื่อ n ใหญ่ขึ้น (มีประสิทธิภาพสูงกว่าทั้งแบบเชิงเส้นและกำลังสองอย่างชัดเจน)
  • เมื่อเทียบกราฟการเติบโต จะเห็นความต่างระหว่าง log n, n และ n² ได้อย่างเด่นชัด

การประยุกต์ใช้จริง: เคล็ดลับปรับปรุงความซับซ้อนเชิงเวลา

การค้นหารายการในลิสต์

  • โดยพื้นฐานแล้ว ฟังก์ชันค้นหาค่าในอาร์เรย์จะเป็น O(n)
  • หากมีการค้นหาบ่อยครั้ง การใช้โครงสร้างข้อมูลอย่าง Set จะช่วยปรับปรุงเป็น O(1) ได้
  • อย่างไรก็ตาม กระบวนการแปลงด้วย new Set(array) เองก็มีต้นทุน O(n) จึงเหมาะเมื่อมีการค้นหาซ้ำบ่อย ๆ เท่านั้น (ต้องคำนึงถึงต้นทุนการแปลงด้วย)
  • ตัวอย่าง: items.has("banana") ให้ความซับซ้อนเชิงเวลาคงที่

การเขียนลูปโดยใช้ดัชนี

  • โค้ดที่เรียก .indexOf ภายในลูปแบบด้านล่างนี้ มักเป็นสาเหตุของปัญหาด้านประสิทธิภาพ

    function buildList(items) {
  const output = [];
  for (const item of items) {
    const index = items.indexOf(item);
    output.push(`Item ${index + 1}: ${item}`);
  }
  return output.join("\n");
}

  • เนื่องจาก .indexOf เป็นการทำงานแบบ O(n) เมื่ออยู่ในลูป จึงทำให้โดยรวมกลายเป็นรูปแบบ O(n^2)

  • หากใช้การวนแบบอิงดัชนี หรือใช้ forEach((item, index) => ...) จะปรับปรุงเป็น O(n) ได้

    function buildList(items) {
  const output = [];
  for (let i = 0; i < items.length; i++) {
    output.push(`Item ${i + 1}: ${items[i]}`);
  }
  return output.join("\n");
}

การใช้ Memoization

  • โครงสร้างที่มีการคำนวณซ้ำเมื่อถูกเรียกหลายครั้ง เช่น factorial สามารถปรับปรุงประสิทธิภาพได้ด้วย การแคชผลลัพธ์ (ใช้ Map)

  • การค้นหาใน Map เป็น O(1) จึงช่วยลดการคำนวณซ้ำที่ไม่จำเป็น

  • อย่างไรก็ตาม การแคชช่วยปรับปรุงเวลาเฉลี่ย และแม้ ความซับซ้อนเชิงเวลาในกรณีแย่ที่สุดอาจไม่เปลี่ยน แต่ก็ช่วยเพิ่มประสิทธิภาพในการทำงานจริงได้

    const cache = new Map();
function factorial(n) {
  if (cache.has(n)) {
    return cache.get(n);
  }
  if (n === 0) {
    return 1;
  }
  const result = n * factorial(n - 1);
  cache.set(n, result);
  return result;
}

การประเมินประสิทธิภาพและบทสรุป

  • เมื่อต้องการปรับปรุงประสิทธิภาพของโค้ด ควรตรวจสอบด้วย การทดสอบการรันจริง ควบคู่กับความซับซ้อนเชิงเวลาทางทฤษฎี เพื่อยืนยันว่าดีขึ้นจริง
  • Big O แสดง ความสัมพันธ์และรูปแบบการเติบโต ระหว่างอินพุตกับเวลาในการทำงานในรูปแบบที่เรียบง่ายและเป็นแก่นที่สุด
  • การเลือกอัลกอริทึมที่ดีและการปรับโครงสร้างข้อมูลให้เหมาะสม สามารถเพิ่มประสิทธิภาพของโค้ดได้สูงสุด

สรุปย่อ

  • สัญกรณ์ Big O ใช้แสดงความสัมพันธ์ระหว่างค่าอินพุตของฟังก์ชันกับเวลาในการทำงาน
  • ระดับประสิทธิภาพหลัก: O(1) (ค่าคงที่), O(log n) (ลอการิทึม), O(n) (เชิงเส้น), O(n^2) (กำลังสอง)
  • หากต้องการเขียนโค้ดอย่างมีประสิทธิภาพ การเลือกอัลกอริทึมที่เหมาะสมและการปรับลูปให้เหมาะสม เป็นสิ่งสำคัญ
  • ควรวัดประสิทธิภาพจริงโดยตรงเพื่อยืนยันว่าการปรับปรุงได้ผล
  • สามารถใช้กราฟเปรียบเทียบรูปแบบการเติบโตเพื่อมองเห็นลักษณะของความซับซ้อนเชิงเวลาได้อย่างชัดเจน

บทความที่เกี่ยวข้อง

1 ความคิดเห็น

 
GN⁺ 2025-08-26
ความคิดเห็นจาก Hacker News

  • บทความนี้รวมถึงคอมเมนต์ใน HN ก็กำลังสืบทอดธรรมเนียมการอธิบาย Big O Notation พร้อมทั้งถกเถียงกันเรื่องการนำไปใช้จริงและรายละเอียดทางเทคนิคอยู่ต่อไป ตัวอย่างที่น่าอ่านมี บทความอธิบายนี้ และ บทความเกี่ยวกับทัศนคติของผู้เชี่ยวชาญ

    • ถ้าย้อนไปดูคอมเมนต์ของบทความก่อน จะเห็นว่าผู้ใช้ชื่อ Pyon มีท่าทีค่อนข้างกัดกร่อนและไม่ยืดหยุ่น แต่คำโต้แย้งของ Ned เองก็ไม่ได้ยอดเยี่ยมนัก เขาไม่ได้อธิบายรายละเอียดทางเทคนิคให้ชัดเจน และดูเหมือนจะพูดอ้อม ๆ ซ้ำไปมาว่าเป็นแค่ “รายละเอียดบางอย่าง” น่าเสียดายที่ไม่ได้ชี้ว่าทำไมคำวิจารณ์นั้นถึงเป็นการจับผิดเล็กน้อย และทำไมถึงต้องปัดเนื้อหาทิ้งไปด้วย Ned แสดงทิศทางที่ถูกต้องในเรื่องการสื่อสารและความเห็นอกเห็นใจบนโลกออนไลน์ก็จริง แต่ถ้าเป็นนักการศึกษา อย่างน้อยก็น่าจะชี้สักครั้งว่าประเด็นเทคนิคตรงนั้นจุกจิกเกินไปหรือเป็นการจับผิดอย่างไร การที่ Ned บอกเพียงว่า “ผมไม่รู้เรื่องนี้มาหลายสิบปี” เลยให้ความรู้สึกว่ายังไม่เพียงพอ และพอกลับไปดูเธรดคอมเมนต์ต้นฉบับอีกครั้ง จริง ๆ แล้ว Ned ก็โต้เถียงอย่างจริงจังและมีชั้นเชิงทางการทูตพอสมควร เลยสงสัยว่าทำไมการวิเคราะห์นั้นถึงหายไปจากโพสต์บล็อก ส่วนตัวฉันก็ไม่ค่อยรู้ว่ารายละเอียดทางเทคนิคคืออะไร แต่อยากให้มีการสรุปสั้น ๆ อธิบายสักครั้ง
    • ฉันค่อนข้างใกล้เคียงกับฝั่งผู้เชี่ยวชาญสายวิจารณ์ สิ่งที่ทำให้ผิดหวังเสมอเวลาเห็นบล็อกพยายามสอนหัวข้อซับซ้อน ก็คือมักเป็นคนที่ไม่เชี่ยวชาญมาอธิบายแล้วความแม่นยำตกหล่น ผลคือ 1) ข้อมูลที่ไม่ถูกต้องถูกคัดลอกแปะกระจายไปทั่วอินเทอร์เน็ต และ 2) ผู้อ่านเห็นแค่ระดับบล็อกแล้วไม่พยายามเรียนต่อ ทำให้ความไม่รู้ยิ่งฝังแน่นขึ้น อีกอย่างหนึ่งคือฉันไม่ชอบเลย์เอาต์ของหน้าเลย จากประสบการณ์ของคนที่มี ADHD และความจำไม่ค่อยดี ฉันต้องการการแบ่งรูปแบบที่เหมาะสม เช่น หัวข้อย่อย/ตัวหนา/สีแบ่งส่วน/รายการหัวข้อ ถึงจะตามทันได้ แต่บทความนี้ให้ความรู้สึกเหมือนกำแพงข้อความล้วน ยิ่งใช้เวลาจับประเด็นนานเท่าไร ก็ยิ่งเสียสมาธิง่ายขึ้น คำอธิบายเรื่อง Big O ใน Simple Wikipedia ตรงไปตรงมามากกว่าเยอะ ส่วนหน้าวิกิพีเดียปกติมีคณิตศาสตร์โผล่มาทันที ทำให้พอไปอ่านเองแล้วรู้ว่า Big O เป็นหัวข้อที่ซับซ้อนกว่าที่คิดมาก และเลยลงเอยด้วยข้อสรุปว่า “บางทีการทำให้ง่ายเกินไปอาจไม่ใช่เรื่องดี”
    • ลิงก์ที่สองไม่ได้พูดถึง Big-O และก็ไม่จำเป็นต้องเอาท่าทางแบบนั้นมาเป็นแบบอย่าง
    • Ned ส่งอีเมลมาหาฉันเมื่อไม่กี่วันก่อน ทำให้ฉันดีใจที่ได้มีส่วนร่วมในบทสนทนาแบบนี้เหมือนกัน
    • ถ้ามีบทเรียนอะไรจริง ๆ จากบทความแบบนี้ ก็คือไม่ใช่ว่า “ถ้ามีคำอธิบายที่ผิดหรือชวนให้เข้าใจผิด ก็หยุดแก้ไขเถอะ” แต่คือบนอินเทอร์เน็ตมี “ผู้เชี่ยวชาญ” บางคนที่แค่อยากเอาชนะในการโต้เถียงเท่านั้น พอดูท่าทีของ Pyon แล้วก็ดูค่อนข้างก้าวร้าวและคล้ายอินเทอร์เน็ตโทรลล์มาก แต่ห้ามสรุปเด็ดขาดว่า “งั้นรายละเอียดทางเทคนิคไม่สำคัญ และจะไม่แม่นยำก็ได้”

  • O(1) ในโลกจริงต้องอาศัยฟังก์ชันแฮช ซึ่งแม้จะไม่ใช่เรื่องง่าย แต่ก็ยังมีต้นทุนการคำนวณคงที่อยู่ ถ้าข้อมูลมีน้อยมาก อัลกอริทึมที่แย่ที่สุดอย่าง O(n^2) ก็อาจเร็วกว่าในแง่เวลาจริงได้

    • จริง แต่ไม่ควรตะโกนประเด็นนี้ดังเกินไป แค่ทำให้คนทำงานเข้าใจว่า n^2 ทำให้คอมพิวเตอร์แทบหยุดทำงานได้ในงานจริงก็ยากพอแล้ว แถมในบางกรณีก็สามารถใช้ฟังก์ชันแฮชที่สมบูรณ์แบบอย่าง mod ได้ด้วย

  • รู้สึกว่าความสำคัญของ Big-O ในยุคนี้ไม่มากเหมือนเมื่อก่อนแล้ว ฮาร์ดแวร์สมัยใหม่มีทั้งมัลติเธรด ไปป์ไลน์ NUMA แคชที่ซับซ้อน ฯลฯ ทำให้บางงานเสร็จได้ในไม่ถึงหนึ่งไซเคิล ขณะที่บางงานกลับใช้เวลาหลายร้อยถึงหลายพันไซเคิล ถ้าพยายามอธิบายอัลกอริทึมด้วยจำนวนรอบของ innermost loop อย่างเดียว ก็อาจบิดเบือนความจริงมากกว่าเดิม และเวลาพูดถึง Big-O ก็ควรพูดถึงสัญลักษณ์อื่นอย่าง Big-Omega ด้วยเสมอ (ว่าแต่แอนิเมชันที่ใช้ Big-O เป็นธีมก็ดูน่าสนุกดี)

    • ทฤษฎี Big-O เกิดขึ้นมาเพื่อพยายามนิยามปริมาณงานคำนวณโดยไม่ขึ้นกับปัจจัยเฉพาะของเครื่องแบบนั้น ในความหมายนั้นมันจึงเป็นเครื่องมือที่ไม่ขึ้นกับยุคสมัย (และถ้าเป็นผู้นำเสนอที่ดี ก็มักจะพูดเสมอว่า “ค่าคงที่อย่าง C มีความสำคัญมากเมื่อ N ยังเล็ก”)

  • สิ่งที่น่าสนใจจริง ๆ คือในคอมพิวเตอร์ควอนตัม มีการคำนวณบางอย่างที่เพิ่มขึ้นเป็น O(n^7) ตามจำนวนอะตอม แต่นักวิทยาศาสตร์ก็ไม่ได้กลัวที่จะรันมันจริง ๆ เพราะ N เล็กพอ คอมพิวเตอร์กับหน่วยความจำก็ยังเร็วขึ้นเรื่อย ๆ และผลลัพธ์ก็มีมูลค่าสูงมาก (ฉันไม่ได้เชี่ยวชาญวิทยาการคอมพิวเตอร์ ถ้าใช้สัญลักษณ์ O() ผิดก็ขออภัย)

    • พูดแค่ว่า “เพิ่มขึ้นตามสัดส่วนกับ n^7” ก็พอแล้ว ถ้าพูดว่า O(n^7) คนส่วนใหญ่ก็เข้าใจแหละ แต่ในเชิงคณิตศาสตร์ O หมายถึงแค่ ‘ขอบเขตบน’ จึงไม่แม่นเป๊ะนัก ถ้าจะให้เป๊ะจริงควรเขียนแบบ Ω(n^7)

  • ชอบการทำภาพให้เห็นมาก แม้จะเคยเรียนอัลกอริทึมมาแล้ว การได้เห็นเป็นภาพก็ยังช่วยได้มากอยู่ดี

  • อาจเพราะฉันเรียนวิศวกรรมไฟฟ้ามา เลยรู้สึกว่า Big O Notation ถูกปฏิบัติเหมือนเป็นแนวคิดที่ข้าม ๆ ไปตลอด เหมือนทุกคนรู้อยู่แล้วโดยปริยาย จึงไม่ค่อยเคยเห็นคำอธิบายที่เป็นมิตรจริง ๆ เลย สงสัยว่าในวิชาคณิตศาสตร์หรือวิทยาการคอมพิวเตอร์ระดับไหนถึงจะเริ่มแนะนำแนวคิดนี้เป็นครั้งแรก

    • ฉันเรียน Big-O อย่างเป็นระบบที่สุดในวิชา Discrete Math ของหลักสูตรวิทยาการคอมพิวเตอร์
    • ที่มหาวิทยาลัยของฉัน สอน Big-O และวิธีพิสูจน์หลายแบบในวิชา Algorithm Analysis (วิชาบังคับ) แต่เกือบจะเป็นวิชาปี 3-4 และในทางปฏิบัติก็มีสมมติฐานโดยนัยว่านักศึกษาน่าจะซึมซับแนวคิดนี้มาบ้างแล้วตั้งแต่ประมาณปี 1 (น่าจะจากการเจออยู่รอบตัว)
    • ในเชิงคณิตศาสตร์ การที่ฟังก์ชัน f(x) เป็น O(g(x)) หมายความว่า f(x)/g(x) มีค่าต่ำกว่าค่าคงที่ C บางค่าหนึ่ง กล่าวคือ “สำหรับทุก x จะมี f(x)/g(x) < C” ในสายคอมพิวเตอร์ มักใช้ f(x) แทนความซับซ้อน เช่น จำนวนครั้งของการคำนวณในอัลกอริทึมหนึ่ง ๆ
    • การออกแบบ Big-O Notation ตีความได้หลายแบบ ตัวอย่างเช่น ถ้ากำหนดอัลกอริทึมด้วยจำนวนสเต็ปการทำงานของ Turing Machine ก็จะไม่มีสิ่งที่เรียกว่าอัลกอริทึมเวลา log และ O(log n) จะถูกนับเป็น O(1)
    • ฉันเรียนมันในวิชาบังคับปี 1 ของสายคอมพิวเตอร์ ไม่มีอะไรซับซ้อนนัก แค่เป็นแนวคิดที่บอกว่าปริมาณงานคำนวณเพิ่มขึ้นอย่างไรเมื่อข้อมูลขาเข้าเพิ่มขึ้น ภายนอกอาจดูยาก แต่จริง ๆ เรียบง่ายและชัดเจนมาก

  • การทำภาพแบบเคลื่อนไหวช่วยให้เข้าใจได้มากจริง ๆ อยากให้มีบทเรียน/สื่อแบบนี้เพิ่มอีก

    • ขอบคุณมาก ดีใจที่ได้ยินแบบนั้น

  • ทุกครั้งที่มีเธรดเรื่อง Big-O Notation ฉันมักแอบหวังว่าจะมีใครอธิบายสักทีว่าแนวคิดนี้เชื่อมโยงกับอนิเมะ The Big O ยังไง จนถึงตอนนี้ก็ยังไม่ค่อยเข้าใจว่าอนิเมะนั้นเกี่ยวกับอะไร

    • (กระดกเบียร์ 4 กระป๋องรวด)เอาล่ะ ฟังนะ อนิเมะเรื่องนั้นเหมือนเอา Pacific Rim, Dark City และ The Matrix มาผสมกันทีละชั้น

  • สำหรับฉัน วิธีที่มีประสิทธิภาพที่สุดในการเข้าใจ Big O Notation คือโยงมันเข้ากับเรื่องในชีวิตประจำวัน

  • คิดว่าเป็นสื่อที่สวยมาก ฉันส่งสัญญาณไปแล้ว หวังว่าจะไปถึงนะ และก็เหมือนได้โดปามีนมาอีกช้อนแบบไม่มีเหตุผล

    • ไปถึงแล้ว ขอบคุณนะ