วิทยาศาสตร์คอมพิวเตอร์

ในหลักสูตรอัลกอริทึมมาตรฐานเราได้รับการสอนว่าquicksortคือโดยเฉลี่ยและในกรณีที่แย่ที่สุด ในเวลาเดียวกันขั้นตอนวิธีการเรียงลำดับอื่น ๆ มีการศึกษาซึ่งเป็นในกรณีที่เลวร้ายที่สุด (เช่นmergesortและheapsort ) และเวลาแม้กระทั่งการเชิงเส้นในกรณีที่ดีที่สุด (เช่นการเรียงลำดับแบบฟอง ) แต่มีความต้องการเพิ่มเติมบางส่วนของหน่วยความจำO ( n 2 ) O ( n log n )O ( n บันทึกn )O(nlog⁡n)O(n \log n)O ( n2)O(n2)O(n^2)O ( n บันทึกn )O(nlog⁡n)O(n \log n) หลังจากมองผ่าน ๆ ในเวลาที่วิ่งเร็วขึ้นมันเป็นเรื่องธรรมดาที่จะบอกว่า quicksort ไม่ควรมีประสิทธิภาพเหมือนกับคนอื่น ๆ นอกจากนี้ให้พิจารณาว่านักเรียนเรียนรู้ในหลักสูตรการเขียนโปรแกรมพื้นฐานที่การเรียกซ้ำโดยทั่วไปไม่ดีนักเพราะอาจใช้หน่วยความจำมากเกินไป ฯลฯ ดังนั้น (และแม้ว่านี่จะไม่ใช่การโต้แย้งจริง) สิ่งนี้ทำให้เกิดความคิดว่า ดีจริงๆเพราะเป็นอัลกอริทึมแบบเรียกซ้ำ เหตุใด quicksort จึงมีประสิทธิภาพสูงกว่าอัลกอริทึมการเรียงลำดับอื่น ๆ …

308 algorithms  sorting 

ฉันอยู่ในหลักสูตรเกี่ยวกับการคำนวณและความซับซ้อนและไม่สามารถเข้าใจความหมายของคำเหล่านี้ได้ สิ่งที่ฉันรู้ก็คือว่า NP เป็นเซตย่อยของ NP-complete ซึ่งเป็นเซตย่อยของ NP-hard แต่ฉันไม่รู้ว่าพวกมันหมายถึงอะไรจริง ๆ วิกิพีเดียไม่ได้ช่วยอะไรมากนักเนื่องจากคำอธิบายยังอยู่ในระดับที่สูงเกินไป

247 complexity-theory  terminology  complexity-classes  p-vs-np  reference-question 

ฉันสังเกตว่าฉันพบว่ามันง่ายกว่ามากในการเขียนหลักฐานทางคณิตศาสตร์โดยไม่ทำผิดพลาดไปกว่าเขียนโปรแกรมคอมพิวเตอร์ที่ไม่มีข้อบกพร่อง ดูเหมือนว่านี่เป็นสิ่งที่แพร่หลายมากกว่าเพียงแค่ประสบการณ์ของฉัน คนส่วนใหญ่ทำข้อบกพร่องซอฟต์แวร์ตลอดเวลาในการเขียนโปรแกรมและพวกเขามีคอมไพเลอร์เพื่อบอกพวกเขาว่าสิ่งที่ผิดพลาดอยู่ตลอดเวลา ฉันไม่เคยได้ยินใครบางคนที่เขียนโปรแกรมคอมพิวเตอร์ขนาดใหญ่โดยไม่มีข้อผิดพลาดในครั้งเดียวและมีความมั่นใจเต็มที่ว่าจะไม่มีข้อผิดพลาด (อันที่จริงโปรแกรมแทบจะไม่มีข้อบกพร่องแม้แต่โปรแกรมที่ดีบั๊กมาก ๆ ) แต่ผู้คนสามารถเขียนบทความหรือหนังสือทั้งหมดที่มีข้อพิสูจน์ทางคณิตศาสตร์โดยไม่ต้องมีคอมไพเลอร์ใด ๆ ให้คำติชมว่าพวกเขาทำผิดพลาด ให้ฉันมีความชัดเจน นี่ไม่ใช่การบอกว่าคนไม่ทำผิดพลาดในการพิสูจน์ทางคณิตศาสตร์ แต่สำหรับนักคณิตศาสตร์ที่มีประสบการณ์เพียงเล็กน้อยความผิดพลาดมักจะไม่ใช่ปัญหานั้นและสามารถแก้ไขได้โดยไม่ต้องใช้ "oracle ภายนอก" เช่นคอมไพเลอร์ชี้ไปที่ ผิดพลาด อันที่จริงถ้าไม่ใช่อย่างนั้นคณิตศาสตร์ก็แทบจะเป็นไปได้ ดังนั้นสิ่งนี้ทำให้ฉันถามคำถาม: อะไรคือความแตกต่างเกี่ยวกับการเขียนหลักฐานทางคณิตศาสตร์ที่ไม่ผิดพลาดและการเขียนรหัสคอมพิวเตอร์ที่ผิดพลาดที่ทำให้มันเป็นแบบนั้นเพื่อให้อดีตเป็นเวไนยมากขึ้นกว่าหลัง? อาจกล่าวได้ว่ามันเป็นความจริงที่ว่าผู้คนมี "oracle ภายนอก" ของคอมไพเลอร์ชี้ให้พวกเขาเห็นความผิดพลาดที่ทำให้โปรแกรมเมอร์ขี้เกียจป้องกันไม่ให้พวกเขาทำสิ่งที่จำเป็นในการเขียนโค้ดอย่างจริงจัง มุมมองนี้จะหมายความว่าหากพวกเขาไม่มีคอมไพเลอร์พวกเขาจะสามารถเป็นนักคณิตศาสตร์ได้อย่างไร้ข้อผิดพลาด คุณอาจพบว่าการโน้มน้าวใจนี้ แต่จากประสบการณ์การเขียนโปรแกรมและการเขียนหลักฐานทางคณิตศาสตร์ดูเหมือนว่าโดยสัญชาตญาณสำหรับฉันว่านี่ไม่ใช่คำอธิบาย ดูเหมือนว่ามีบางสิ่งที่แตกต่างกันโดยพื้นฐานเกี่ยวกับความพยายามทั้งสอง ความคิดเริ่มต้นของฉันคือสิ่งที่อาจเป็นความแตกต่างคือสำหรับนักคณิตศาสตร์การพิสูจน์ที่ถูกต้องจะต้องใช้ทุกขั้นตอนตรรกะในการแก้ไขเท่านั้น หากทุกขั้นตอนถูกต้องหลักฐานทั้งหมดจะถูกต้อง ในทางตรงกันข้ามสำหรับโปรแกรมที่จะไม่มีข้อบกพร่องไม่เพียง แต่ทุกบรรทัดของรหัสจะต้องถูกต้อง แต่มันเกี่ยวข้องกับทุกบรรทัดของรหัสในโปรแกรมจะต้องทำงานเช่นกัน ในคำอื่น ๆ ถ้าขั้นตอนในหลักฐานถูกต้องจากนั้นทำผิดพลาดในขั้นตอนจะไม่เลอะขั้นตอนเคย แต่ถ้าบรรทัดของโค้ดถูกเขียนลงอย่างถูกต้องแล้วการทำผิดในบรรทัดจะมีผลต่อการทำงานของบรรทัดดังนั้นเมื่อใดก็ตามที่เราเขียน lineเราต้องคำนึงถึงความสัมพันธ์กับบรรทัดอื่นทั้งหมด เราสามารถใช้การห่อหุ้มและสิ่งเหล่านั้นเพื่อ จำกัด สิ่งนี้ แต่มันไม่สามารถลบออกได้อย่างสมบูรณ์Y X X Y X XXXXYYYXXXXXXYYYXXXXXX ซึ่งหมายความว่ากระบวนการสำหรับการตรวจสอบข้อผิดพลาดในการพิสูจน์ทางคณิตศาสตร์นั้นเป็นเชิงเส้นในจำนวนขั้นตอนการพิสูจน์ แต่กระบวนการสำหรับการตรวจสอบข้อผิดพลาดในรหัสคอมพิวเตอร์นั้นเป็นเลขชี้กำลังเชิงเส้นในจำนวนบรรทัดของรหัส คุณคิดอย่างไร? …

190 correctness-proof  mathematical-foundations  philosophy 

ลองดูที่หน้าเว็บของ Juliaคุณสามารถดูเกณฑ์มาตรฐานของหลายภาษาในหลาย ๆ อัลกอริทึม (การกำหนดเวลาที่แสดงด้านล่าง) ภาษาที่คอมไพเลอร์เขียนด้วยภาษา C ได้ดีกว่าโค้ด C อย่างไร รูป: เวลามาตรฐานเทียบกับ C (เล็กกว่าดีกว่า, ประสิทธิภาพ C = 1.0)

175 programming-languages  compilers  efficiency 

มีคำถามมากมายเกี่ยวกับวิธีการวิเคราะห์เวลาทำงานของอัลกอริทึม (ดูเช่นการวิเคราะห์รันไทม์และการวิเคราะห์อัลกอริทึม ) หลายคนมีความคล้ายคลึงกันตัวอย่างเช่นผู้ที่ขอการวิเคราะห์ต้นทุนของลูปซ้อนกันหรืออัลกอริทึม & พิชิต แต่คำตอบส่วนใหญ่ดูเหมือนจะปรับให้เหมาะสม ในทางกลับกันคำตอบสำหรับคำถามทั่วไปอีกข้ออธิบายให้เห็นภาพรวมที่ใหญ่ขึ้น (โดยเฉพาะเกี่ยวกับการวิเคราะห์เชิงเส้นกำกับ) ด้วยตัวอย่างบางส่วน แต่ไม่ใช่วิธีทำให้มือของคุณสกปรก มีโครงสร้างวิธีการทั่วไปสำหรับการวิเคราะห์ต้นทุนของอัลกอริทึมหรือไม่ ค่าใช้จ่ายอาจเป็นเวลาทำงาน (ความซับซ้อนของเวลา) หรือการวัดค่าใช้จ่ายอื่น ๆ เช่นจำนวนการเปรียบเทียบที่ดำเนินการความซับซ้อนของพื้นที่หรืออย่างอื่น นี่ควรจะเป็นคำถามอ้างอิงที่สามารถใช้ชี้ผู้เริ่มต้น; ดังนั้นขอบเขตที่กว้างกว่าปกติ โปรดใช้ความระมัดระวังในการให้คำตอบทั่วไปที่นำเสนอโดยไม่ได้ตั้งใจซึ่งแสดงอย่างน้อยหนึ่งตัวอย่าง แต่อย่างไรก็ตามยังครอบคลุมหลาย ๆ สถานการณ์ ขอบคุณ!

159 algorithms  algorithm-analysis  runtime-analysis  proof-techniques  reference-question 

ฉันไม่เข้าใจว่าทำไมปัญหา Haltingจึงมักถูกใช้เพื่อยกเลิกความเป็นไปได้ในการพิจารณาว่าโปรแกรมหยุดทำงานหรือไม่ วิกิพีเดีย [บทความ] [1] อธิบายอย่างถูกต้องว่าเครื่องกำหนดค่าที่มีหน่วยความจำ จำกัด จะหยุดหรือทำซ้ำสถานะก่อนหน้า คุณสามารถใช้อัลกอริทึมที่ตรวจพบว่ามีการเชื่อมโยงรายการลูปเพื่อใช้ฟังก์ชัน Halting กับความซับซ้อนของพื้นที่ของ O (1) สำหรับฉันแล้วดูเหมือนว่าการพิสูจน์ปัญหา Halting นั้นไม่ได้เป็นอะไรมากไปกว่า "ความขัดแย้ง" ที่อ้างถึงตัวเอง (อย่างน้อยก็เป็นวัฏจักร) ที่ขัดแย้งกันในลักษณะเดียวกับความขัดแย้งของคนโกหก ข้อสรุปเพียงอย่างเดียวก็คือฟังก์ชั่นหยุดทำงานนั้นไวต่อคำถามที่มีรูปร่างผิดปกติ ดังนั้นหากไม่รวมโปรแกรมที่ขัดแย้งกันฟังก์ชัน Halting จะถูกตัดสินได้ เหตุใดเราจึงถือเป็นหลักฐานของสิ่งตรงกันข้าม 4 ปีต่อมา : เมื่อฉันเขียนสิ่งนี้ฉันเพิ่งดูวิดีโอนี้ โปรแกรมเมอร์ได้รับโปรแกรมบางโปรแกรมต้องกำหนดว่ารายการใดจะถูกยกเลิกและวิดีโอจะอธิบายว่าทำไมจึงเป็นไปไม่ได้ ฉันรู้สึกท้อแท้เพราะฉันรู้ว่ามีโปรแกรมตามอำเภอใจบางอย่างมีความเป็นไปได้ที่ตัวเอกจะสามารถพิสูจน์ได้ว่าพวกเขาจะยุติ แนวคิดของความมีอยู่ทั่วไปได้หายไปอย่างใด เป็นความแตกต่างระหว่างการพูดว่า "บางโปรแกรมไม่สามารถพิสูจน์ได้ว่าจะยุติ" และ "ไม่มีโปรแกรมที่สามารถพิสูจน์ได้ว่าจะยุติ" อัลกอริทึมหลายอย่างเป็นทางการแสดงให้เห็นถึงการทำเช่นนั้น ความล้มเหลวในการสร้างความแตกต่างนี้จากการอ้างอิงทุกครั้งที่พบในบรรทัดคือวิธีที่ฉันมาที่ชื่อของคำถามนี้ ด้วยเหตุนี้ฉันขอขอบคุณคำตอบจริงๆ ที่นิยามฟังก์ชันการหยุดชั่วคราวเป็น ternary แทนที่จะเป็นบูลีน

149 computability  halting-problem 

เราได้รับแบบฝึกหัดต่อไปนี้ ปล่อย ฉ( n ) = { 100n เกิดขึ้นในการแทนทศนิยมของ πอื่นf(n)={10n occurs in the decimal representation of π0else\qquad \displaystyle f(n) = \begin{cases} 1 & 0^n \text{ occurs in the decimal representation of } \pi \\ 0 & \text{else}\end{cases} พิสูจน์ว่าคำนวณได้ฉff เป็นไปได้อย่างไร? เท่าที่ผมรู้ว่าเราไม่ทราบว่าสภาพอากาศมีลำดับของตัวเลขทุก (หรือ) และขั้นตอนวิธีการได้อย่างแน่นอนไม่ได้ตัดสินใจว่าลำดับบางอย่างจะไม่เกิดขึ้น ดังนั้นฉันคิดว่าfไม่สามารถคำนวณได้เพราะปัญหาพื้นฐานเป็นแบบกึ่งตัดสินใจได้เท่านั้นππ\pifff

130 computability  undecidability 

ฉันใช้ภาษา C / C ++ ได้อย่างคล่องแคล่วและสามารถใช้ภาษาสคริปต์ต่าง ๆ ได้ (awk / sed / perl) ฉันเริ่มใช้ python มากขึ้นเพราะมันรวมแง่มุมที่ดีของ C ++ เข้ากับความสามารถในการเขียนสคริปต์ของ awk / sed / perl แต่ทำไมมีภาษาการเขียนโปรแกรมที่แตกต่างกันมากมาย ฉันเดาว่าทุกภาษาเหล่านี้สามารถทำสิ่งเดียวกันดังนั้นทำไมไม่ยึดติดกับภาษาใดภาษาหนึ่งและใช้มันกับโปรแกรมคอมพิวเตอร์? โดยเฉพาะอย่างยิ่งมีเหตุผลใดบ้างที่ฉันควรรู้ภาษาการใช้งานในฐานะโปรแกรมเมอร์คอมพิวเตอร์? การอ่านที่เกี่ยวข้องบางส่วน: เหตุใดภาษาการเขียนโปรแกรมใหม่จึงประสบความสำเร็จ - หรือล้มเหลว ยังมีงานวิจัยที่ต้องทำในภาษาโปรแกรมหรือไม่

130 programming-languages 

ให้ฉันอธิบาย: ได้รับ scatterplot ของจำนวนจุดที่กำหนด n หากฉันต้องการค้นหาจุดที่ใกล้ที่สุดไปยังจุดใด ๆ ในพล็อตทางจิตใจฉันสามารถละเว้นจุดส่วนใหญ่ในกราฟได้ทันทีโดย จำกัด ทางเลือกของฉันให้แคบลงเรื่อย ๆ . แต่ในการเขียนโปรแกรมได้รับชุดของจุด n เพื่อที่จะหาจุดที่ใกล้ที่สุดเพื่อคนใดคนหนึ่งจะต้องมีการตรวจสอบทุกจุดอื่น ๆ ซึ่งเป็นเวลาO ( n )O(n){\cal O}(n) ฉันเดาว่าภาพที่เห็นด้วยตาของกราฟน่าจะเท่ากับโครงสร้างข้อมูลบางอย่างที่ฉันไม่สามารถเข้าใจได้ เพราะด้วยการเขียนโปรแกรมโดยการแปลงคะแนนเป็นวิธีการที่มีโครงสร้างมากขึ้นเช่น quadtree เราสามารถหาจุดที่ใกล้ที่สุดไปยังจุดในในเวลาหรือ ammortizedเวลาn k ⋅ บันทึก( n ) O ( บันทึกn )kkknnnk ⋅ บันทึก( n )k⋅log⁡(n)k\cdot\log(n)O (บันทึกn )O(log⁡n){\cal O}(\log n) แต่ยังไม่มีใครรู้อัลกอรึทึมที่ถูกทำให้เป็นด่าง (ที่ฉันหาได้) สำหรับการหาจุดหลังจากปรับโครงสร้างข้อมูลO ( 1 )O(1){\cal O}(1) …

122 algorithms  computer-vs-human  human-computing 

ฉันกำลังเรียน Haskell และฉันก็หลงใหลในภาษานี้ อย่างไรก็ตามฉันไม่มีพื้นฐานทางคณิตศาสตร์หรือ CS อย่างจริงจัง แต่ฉันเป็นโปรแกรมเมอร์ซอฟต์แวร์ที่มีประสบการณ์ ฉันต้องการเรียนรู้ทฤษฎีหมวดหมู่เพื่อที่ฉันจะสามารถพัฒนาได้ดีขึ้นที่ Haskell ฉันควรเรียนรู้หัวข้อใดในทฤษฎีหมวดหมู่เพื่อเป็นพื้นฐานที่ดีสำหรับการทำความเข้าใจ Haskell

118 programming-languages  functional-programming  category-theory 

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

115 algorithms  formal-languages  finite-automata  regular-expressions  reference-question 

การเข้ารหัสของวันนี้ส่วนใหญ่เช่น RSA อาศัยการแยกตัวประกอบจำนวนเต็มซึ่งไม่เชื่อว่าเป็นปัญหา NP-hard แต่เป็นของ BQP ซึ่งทำให้เสี่ยงต่อคอมพิวเตอร์ควอนตัม ฉันสงสัยว่าทำไมไม่มีอัลกอริธึมการเข้ารหัสซึ่งมาจากปัญหา NP-hard ที่เป็นที่รู้จัก ฟังดู (อย่างน้อยก็ในทางทฤษฎี) เหมือนว่ามันจะสร้างอัลกอริธึมการเข้ารหัสที่ดีกว่าแบบที่ไม่ได้พิสูจน์ว่าเป็นแบบ NP-hard

109 complexity-theory  np-hard  encryption  cryptography 

ในการพยายามทดสอบว่าอัลกอริทึมสำหรับปัญหาบางอย่างถูกต้องหรือไม่จุดเริ่มต้นตามปกติคือลองใช้อัลกอริทึมด้วยมือในกรณีทดสอบง่ายๆ - ลองกับตัวอย่างกรณีปัญหารวมถึงกรณีมุมง่าย ๆ สองสามตัวอย่าง " นี่เป็นวิธีแก้ปัญหาที่ยอดเยี่ยม: มันเป็นวิธีที่ดีในการกำจัดความพยายามที่ไม่ถูกต้องอย่างรวดเร็วของอัลกอริทึมและเพื่อทำความเข้าใจเกี่ยวกับสาเหตุที่อัลกอริทึมไม่ทำงาน อย่างไรก็ตามเมื่อการเรียนรู้อัลกอริทึมนักเรียนบางคนถูกล่อลวงให้หยุดที่นั่น: หากอัลกอริทึมของพวกเขาทำงานอย่างถูกต้องกับตัวอย่างจำนวนหนึ่งรวมถึงกรณีมุมทั้งหมดที่พวกเขาสามารถคิดได้ลองพวกเขาสรุปว่าอัลกอริทึมต้องถูกต้อง มีนักเรียนคนหนึ่งที่ถามอยู่เสมอ: "ทำไมฉันต้องพิสูจน์อัลกอริทึมของฉันให้ถูกต้องถ้าฉันลองได้ในบางกรณีทดสอบ?" ดังนั้นคุณจะหลอก "ฮิวริสติกแบบทดสอบกรณี" ได้อย่างไร ฉันกำลังมองหาตัวอย่างที่ดีเพื่อแสดงว่าฮิวริสติกนี้ไม่เพียงพอ กล่าวอีกนัยหนึ่งฉันกำลังมองหาหนึ่งหรือมากกว่าหนึ่งตัวอย่างของอัลกอริทึมที่เผินๆดูเหมือนว่ามันอาจจะถูกต้องและผลลัพธ์ที่ได้คำตอบที่ถูกต้องในอินพุตขนาดเล็กทั้งหมดที่ทุกคนมีแนวโน้มที่จะเกิดขึ้น ไม่ทำงาน อัลกอริทึมอาจทำงานได้อย่างถูกต้องกับอินพุตขนาดเล็กทั้งหมดและล้มเหลวสำหรับอินพุตขนาดใหญ่เท่านั้นหรือล้มเหลวเฉพาะสำหรับอินพุตที่มีรูปแบบที่ผิดปกติ โดยเฉพาะฉันกำลังมองหา: อัลกอริทึม ข้อบกพร่องจะต้องอยู่ในระดับอัลกอริทึม ฉันไม่ได้กำลังมองหาข้อผิดพลาดในการใช้งาน (ตัวอย่างเช่นอย่างน้อยที่สุดตัวอย่างควรเป็นผู้ไม่เชื่อเรื่องภาษาและข้อบกพร่องควรเกี่ยวข้องกับความกังวลด้านอัลกอริทึมมากกว่าปัญหาด้านวิศวกรรมซอฟต์แวร์หรือปัญหาการใช้งาน) อัลกอริทึมที่บางคนอาจมีความน่าเชื่อถือ รหัสเทียมควรมีลักษณะที่ถูกต้องอย่างน้อยน่าจะเป็นไปได้ (เช่นรหัสที่ obfuscated หรือน่าสงสัยว่าไม่ได้เป็นตัวอย่างที่ดี) คะแนนโบนัสหากเป็นอัลกอริทึมที่นักเรียนบางคนคิดขึ้นมาเมื่อพยายามแก้ไขปัญหาการบ้านหรือการสอบ อัลกอริทึมที่จะผ่านกลยุทธ์การทดสอบด้วยตนเองอย่างสมเหตุสมผลด้วยความน่าจะเป็นสูง คนที่ลองใช้กรณีทดสอบเล็ก ๆ น้อย ๆ ด้วยมือไม่น่าจะค้นพบข้อบกพร่อง ตัวอย่างเช่น "จำลอง QuickCheck ด้วยมือในกรณีทดสอบขนาดเล็กโหล" ไม่น่าจะเปิดเผยว่าอัลกอริทึมไม่ถูกต้อง เป็นอัลกอริทึมที่กำหนดขึ้นโดยเฉพาะ ฉันเคยเห็นนักเรียนหลายคนคิดว่า "ลองใช้กรณีทดสอบด้วยมือ" เป็นวิธีที่สมเหตุสมผลในการตรวจสอบว่าอัลกอริธึมที่กำหนดขึ้นถูกต้องหรือไม่ แต่ฉันสงสัยว่านักเรียนส่วนใหญ่จะไม่คิดว่าการลองใช้กรณีทดสอบสองสามอันเป็นวิธีที่ดี อัลกอริทึม สำหรับอัลกอริธึมความน่าจะเป็นมักจะไม่มีวิธีที่จะบอกได้ว่าเอาต์พุตใด ๆ ที่ถูกต้องหรือไม่ …

105 algorithms  algorithm-analysis  education  correctness-proof  didactics 

ต้นไม้ดัชนีแบบไบนารีมีวรรณกรรมน้อยมากหรือค่อนข้างน้อยเมื่อเทียบกับโครงสร้างข้อมูลอื่น ๆ สถานที่เดียวซึ่งจะมีการเรียนการสอนเป็นTopCoder กวดวิชา แม้ว่าการสอนจะเสร็จสมบูรณ์ในคำอธิบายทั้งหมด แต่ฉันไม่สามารถเข้าใจสัญชาตญาณที่อยู่เบื้องหลังต้นไม้เช่นนั้นได้หรือไม่ มันถูกคิดค้นขึ้นมาได้อย่างไร? หลักฐานที่แท้จริงของความถูกต้องคืออะไร?

99 algorithms  binary-trees  trees 

มีความพยายามมากมายในการพิสูจน์หรือและโดยธรรมชาติแล้วหลายคนคิดเกี่ยวกับคำถามP ≠ N PP=NPP=NP\mathsf{P} = \mathsf{NP} P≠NPP≠NP\mathsf{P} \neq \mathsf{NP} ฉันรู้ว่ามีวิธีการที่พิสูจน์แล้วว่าไม่ได้ผลและอาจมีมากกว่านั้นที่มีประวัติความล้มเหลว ดูเหมือนจะมีอุปสรรคที่เรียกว่าการพิสูจน์หลายอย่างล้มเหลวในการเอาชนะ เราต้องการหลีกเลี่ยงการตรวจสอบถึงจุดจบดังนั้นอะไรคืออะไร

96 complexity-theory  reference-request  history  p-vs-np  reference-question