คำถามติดแท็ก complexity

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

18 object-oriented  complexity 

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

18 object-oriented  complexity 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา นี่คือมากตัวอย่างง่าย นี่ไม่ใช่คำถามเฉพาะภาษาและฉันขอให้คุณเพิกเฉยต่อวิธีการอื่น ๆ ที่สามารถเขียนฟังก์ชันและการเปลี่ยนแปลงที่เกิดขึ้นได้ . สีเป็นประเภทที่ไม่ซ้ำกัน string CanLeaveWithoutUmbrella() { if(sky.Color.Equals(Color.Blue)) { return "Yes you can"; } else { return "No you can't"; } } ผู้คนจำนวนมากที่ฉันได้พบ ReSharper และผู้ชายคนนี้ (ซึ่งความคิดเห็นเตือนฉันฉันกำลังมองหาที่จะถามในขณะนี้) จะแนะนำการ refactoring รหัสเพื่อลบelseบล็อกออกจากนี้: (ฉันจำไม่ได้ว่าคนส่วนใหญ่พูดอะไรฉันอาจไม่ได้ถามอย่างอื่น) string CanLeaveWithoutUmbrella() { if(sky.Color.Equals(Color.Blue)) { return "Yes you can"; } return …

18 coding-style  code-quality  coding-standards  complexity  clean-code 

สมมติว่าเราต้องการวิเคราะห์เวลาทำงานของอัลกอริทึม บางครั้งเราบอกว่าเราต้องการหาเวลาทำงานของอัลกอริทึมเมื่อขนาดอินพุตเป็น n และสำหรับกรณีที่แย่ที่สุดที่เป็นไปได้มันแสดงว่า O (n) บางครั้งฉันเห็นหนังสือ / กระดาษบอกว่าเราต้องหาเวลาที่คาดหวังของอัลกอริทึม นอกจากนี้บางครั้งเวลาทำงานเฉลี่ยจะใช้ "เวลาที่คาดหวัง" คืออะไร ในกรณีใดบ้างที่มีประโยชน์ในการค้นหาเวลาที่คาดหวังแทนเวลาที่เลวร้ายที่สุด? แก้ไข : ฉันคิดว่ามีความแตกต่างเล็กน้อยระหว่างเวลาทำงานที่คาดหวังและเวลาทำงานเฉลี่ยแต่ฉันไม่แน่ใจ ผ่านโพสต์นี้ฉันต้องการทราบความแตกต่างที่แน่นอนถ้ามี

17 algorithms  terminology  performance  complexity 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ฉันเป็นโปรแกรมเมอร์ฝั่งเซิร์ฟเวอร์สำหรับอาชีพส่วนใหญ่ของฉันและเพิ่งเริ่มใช้เวลาในการพัฒนาเว็บไซต์มากขึ้น ฉันประหลาดใจกับจำนวนสิ่งที่ฉันต้องการเป็นหลักในการเขียนเว็บแอปพลิเคชันที่เหมาะสม เพื่อทำรายการเครื่องมือ / เทคโนโลยีที่ฉันต้องเรียนรู้ ภาษาโปรแกรมฝั่งเซิร์ฟเวอร์ (Java / JSP, ASP, PHP, Ruby หรืออย่างอื่น) กรอบเว็บที่เหมาะสม (สำหรับแอปพลิเคชันขนาดกลางถึงขนาดใหญ่) HTML & CSS จาวาสคริ ไลบรารี Javascript (JQuery / ExtJS ฯลฯ เป็นหลักสำหรับ AJAX) ดีที่จะรู้แม้ว่าไม่จำเป็น อย่างน้อยความรู้พื้นฐานการออกแบบเว็บ - เลย์เอาต์, สี, แบบอักษร ฯลฯ ความเข้าใจที่ดีเกี่ยวกับความปลอดภัยของเว็บ ความเข้าใจที่ดีของปัญหาด้านประสิทธิภาพ / ความสามารถในการปรับขยายได้ การทดสอบปัญหาความเข้ากันได้ของเบราว์เซอร์ ฯลฯ รายการดำเนินต่อไป ดังนั้นคำถามของฉันสำหรับนักพัฒนาเว็บไซต์ที่มีประสบการณ์คือ - …

17 learning  web-development  complexity 

ฉันต้องเขียน RandomQueue ที่อนุญาตให้ผนวกและลบแบบสุ่มใน Constant Time (O (1)) ความคิดแรกของฉันคือการสำรองข้อมูลด้วย Array บางประเภท (ฉันเลือก ArrayList) เนื่องจากอาร์เรย์มีการเข้าถึงอย่างต่อเนื่องผ่านดัชนี เมื่อมองไปที่เอกสารแม้ว่าฉันรู้ว่าการเพิ่มเติมของ ArrayLists ถือเป็น Amortized Constant Time เนื่องจากการเพิ่มอาจต้องมีการจัดสรรใหม่ของอาเรย์พื้นฐานซึ่งก็คือ O (n) Amortized Constant Time และ Constant Time มีประสิทธิภาพเหมือนกันหรือไม่หรือฉันต้องดูโครงสร้างบางอย่างที่ไม่ต้องการการจัดสรรใหม่อย่างสมบูรณ์ในทุก ๆ การเติม ฉันถามสิ่งนี้เพราะโครงสร้างแบบอาเรย์กัน (ซึ่งเท่าที่ฉันรู้จะมีการเพิ่มค่าคงที่ตลอดเวลา) ฉันไม่สามารถคิดอะไรที่ตรงตามข้อกำหนด: ต้นไม้ใดก็ตามที่มีการเข้าถึง O (log n) จะดีที่สุด รายการที่เชื่อมโยงอาจมีการเพิ่ม O (1) (ถ้าการอ้างอิงไปยังหางถูกเก็บไว้) แต่การลบแบบสุ่มควรจะดีที่สุด O (n) นี่คือคำถามเต็ม ในกรณีที่ฉันเคลือบรายละเอียดที่สำคัญบางอย่าง: ออกแบบและใช้งาน RandomQueue …

16 algorithms  complexity 

เมื่อประเมินโครงการที่มีศักยภาพในที่ทำงานฉันแนะนำว่าอาจเป็นประโยชน์ในการใช้วิธีการออกแบบโดยใช้โดเมนเป็นโมเดลวัตถุ โครงการไม่มีโดเมนที่ซับซ้อนมากนักดังนั้นเพื่อนร่วมงานของฉันก็โยนเรื่องนี้มาให้ฉัน: มีการกล่าวกันว่า DDD นั้นเป็นที่นิยมในกรณีที่มีรูปแบบโดเมนที่ซับซ้อน (“ ... มันใช้เมื่อใดก็ตามที่เราทำงานในโดเมนที่ซับซ้อนและซับซ้อน” Eric Evans) สิ่งที่ฉันทำคือ - คุณกำหนดความซับซ้อนของโดเมนได้อย่างไร สามารถกำหนดจำนวนรากรวมในรูปแบบโดเมนได้หรือไม่ ความซับซ้อนของโดเมนในการโต้ตอบของวัตถุหรือไม่ โดเมนที่เรากำลังประเมินนั้นเกี่ยวข้องกับการเผยแพร่ออนไลน์และการจัดการเนื้อหา

16 complexity  domain-driven-design 

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

14 design-patterns  complexity  customer-relations 

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

14 programming-languages  c++  complexity  game-development 

ดูเหมือนว่าจะมีประสบการณ์ไม่บ่อยนัก แต่บ่อยครั้งที่บางครั้งคุณกำลังทำโปรเจ็กต์และมีบางอย่างเกิดขึ้นโดยไม่คาดคิดขว้างประแจขนาดใหญ่ในงานและเพิ่มความซับซ้อนให้มากขึ้น ตัวอย่างเช่นฉันทำงานกับแอพพลิเคชั่นที่คุยกับบริการ SOAP ในเครื่องอื่น ๆ ฉันสร้างต้นแบบที่ใช้งานได้ดีจากนั้นก็พัฒนาส่วนหน้าเป็นประจำและโดยทั่วไปจะทำให้ทุกอย่างทำงานในแบบที่ดีค่อนข้างง่ายและง่ายต่อการติดตามแฟชั่น มันใช้งานได้ดีจนกระทั่งเราเริ่มทดสอบในเครือข่ายที่กว้างขึ้นและทันใดนั้นหน้าเว็บก็เริ่มหมดเวลาเนื่องจากเวลาแฝงของการเชื่อมต่อและเวลาที่ต้องใช้ในการคำนวณบนเครื่องระยะไกลส่งผลให้คำขอบริการสบู่หมดเวลา ปรากฎว่าเราจำเป็นต้องเปลี่ยนสถาปัตยกรรมเพื่อหมุนคำขอออกไปยังเธรดของตัวเองและแคชข้อมูลที่ส่งคืนเพื่อให้สามารถอัปเดตอย่างต่อเนื่องในพื้นหลังแทนที่จะทำการคำนวณตามคำขอตามคำขอ รายละเอียดของสถานการณ์นั้นไม่สำคัญเกินไป - แน่นอนว่ามันไม่ใช่ตัวอย่างที่ดีเนื่องจากค่อนข้างมองเห็นได้และผู้ที่เขียนแอพประเภทนี้จำนวนมากสำหรับสภาพแวดล้อมประเภทนี้อาจคาดการณ์ไว้ - ยกเว้นว่ามันแสดงวิธีที่ หนึ่งสามารถเริ่มต้นด้วยหลักฐานที่เรียบง่ายและรูปแบบและทันใดนั้นมีการเพิ่มความซับซ้อนในการพัฒนาโครงการ คุณมีกลยุทธ์อะไรในการจัดการกับการเปลี่ยนแปลงการทำงานประเภทนี้ซึ่งความต้องการเกิดขึ้นบ่อยครั้งซึ่งเป็นผลมาจากปัจจัยด้านสิ่งแวดล้อมมากกว่าการเปลี่ยนแปลงรายละเอียดในภายหลังในกระบวนการพัฒนาหรือจากการทดสอบ คุณจะทำอย่างไรความสมดุลระหว่างการหลีกเลี่ยงการเพิ่มประสิทธิภาพก่อนวัยอันควร / YAGNI / overengineering ความเสี่ยงของการออกแบบโซลูชันที่ช่วยลดผลกระทบกับความเป็นไปได้ แต่ไม่จำเป็นต้องน่าจะเป็นปัญหาที่ตรงข้ามกับการพัฒนาโซลูชั่นที่ง่ายและง่ายที่น่าจะเป็นที่มีประสิทธิภาพ แต่ไม่ได้รวมการเตรียมความพร้อมสำหรับ ทุกเหตุการณ์ที่เป็นไปได้? แก้ไข: คำตอบของ Crazy Eddie รวมถึง "คุณดูดมันและหาวิธีที่แพงที่สุดในการใช้ความซับซ้อนใหม่" นั่นทำให้ฉันคิดถึงบางสิ่งที่แฝงอยู่ในคำถาม แต่ฉันไม่ได้เจาะจงเฉพาะ เมื่อคุณกดปุ่มนั้นและคุณรวมการเปลี่ยนแปลงที่จำเป็น คุณทำสิ่งที่จะทำให้โครงการใกล้เคียงกับกำหนดเวลามากที่สุด แต่อาจส่งผลต่อการบำรุงรักษาหรือคุณกลับไปที่สถาปัตยกรรมของคุณและนำกลับมาทำใหม่ในระดับที่มีรายละเอียดมากขึ้นซึ่งอาจบำรุงรักษาได้มากกว่า

13 development-process  complexity  change 

ฉันกำลังสร้างแบบจำลองระบบเคมีและฉันมีปัญหากับการตั้งชื่อองค์ประกอบ / รายการของฉันภายใน Enum ฉันไม่แน่ใจว่าฉันควรใช้: สูตรอะตอม ชื่อทางเคมี ชื่อทางเคมีแบบย่อ ตัวอย่างเช่นกรดซัลฟูริกคือ H2SO4 และกรดไฮโดรคลอริกคือ HCl ด้วยสองอย่างนั้นฉันอาจจะใช้สูตรปรมาณูเนื่องจากมันเป็นเรื่องธรรมดา อย่างไรก็ตามฉันมีคนอื่น ๆ เช่นโซเดียม hexafluorosilicate ซึ่งก็คือ Na2SiF6 ในตัวอย่างที่สูตรอะตอมไม่เป็นที่เห็นได้ชัด (กับผม) myEnum.SodiumHexaFluoroSilicateแต่ชื่อทางเคมีคือน่ากลัวยาว: ฉันไม่แน่ใจว่าฉันจะสามารถสร้างชื่อทางเคมีอย่างย่อได้อย่างปลอดภัยซึ่งจะมีรูปแบบการตั้งชื่อที่สอดคล้องกันอย่างไร มีปัญหาสองสามข้อที่ฉันพยายามแก้ไขด้วยการตั้งชื่อองค์ประกอบ enum วิธีแรกคือความสามารถในการอ่านโดยมีชื่อยาวกว่าที่แสดงถึงปัญหา ข้อที่สองคือความง่ายในการหยิบรหัสสำหรับผู้ดูแลใหม่และที่นี่ชื่อที่สั้นกว่าจะแสดงปัญหา ปัญหาต่อไปคือเจ้าของธุรกิจมักจะอ้างถึงชื่อเคมีแบบเต็ม แต่ไม่เสมอไป สารเคมี "คำหนึ่ง" ถูกอ้างถึงโดยสูตรของพวกเขา ข้อกังวลสุดท้ายคือทำให้แน่ใจว่ามันสอดคล้องกัน ฉันไม่ต้องการใช้การตั้งชื่อแบบผสมเนื่องจากจะไม่สามารถจำได้ว่าควรใช้แบบใด จากมุมมองการบำรุงรักษาตัวเลือกการตั้งชื่อใดที่คุณต้องการดูและเพราะเหตุใด หมายเหตุ: ทุกอย่างที่นี่ด้านล่างบรรทัดเป็นส่วนเสริม | ชี้แจงวัสดุ โปรดอย่าจมดิ่งลงไป คำถามหลักเกี่ยวกับการตั้งชื่อวัตถุที่น่าอึดอัดใจ ตัวเลือกอะตอม สาธารณะ myEnum.ChemTypes { H2SO4, HCl, Na2SiF6 } ตัวเลือกชื่อเคมี …

12 naming  complexity 

ฉันกำลังทำงานกับความสัมพันธ์แบบ 2 มิติสำหรับเทคนิคการประมวลผลภาพ (การจดจำรูปแบบ ฯลฯ ) ฉันสงสัยว่ามีวิธีการทางทฤษฎีเกี่ยวกับวิธีบอกเมื่อใช้การคูณในพื้นที่ความถี่เหนือความสัมพันธ์ในอวกาศ สำหรับขนาดของพื้นที่2 xความถี่นั้นเร็วขึ้นอย่างเห็นได้ชัด แต่ขนาดเล็กเช่น Prime 11 นั้นเป็นอย่างไร

12 complexity  image-processing 

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

12 performance  exceptions  code-smell  complexity  workaround 

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

11 complexity  large-scale-project 

ฉันเคยค้นหาสัญกรณ์ Landau (Big O, Theta ... ) ของอัลกอริทึมของฉันด้วยมือเพื่อให้แน่ใจว่าพวกเขาได้รับการปรับให้เหมาะสมที่สุดเท่าที่จะเป็นไปได้ แต่เมื่อฟังก์ชั่นมีขนาดใหญ่และซับซ้อนจริงๆ เวลามากเกินไปที่จะทำด้วยมือ นอกจากนี้ยังมีแนวโน้มที่จะเกิดข้อผิดพลาดของมนุษย์ ฉันใช้เวลากับ Codility (แบบฝึกหัดการเข้ารหัส / อัลโก) และสังเกตว่าพวกเขาจะให้สัญกรณ์ Landau สำหรับการแก้ปัญหาที่คุณส่ง (ทั้งในเวลาและการใช้หน่วยความจำ) ฉันสงสัยว่าพวกเขาทำได้อย่างไร ... คุณจะทำอย่างไร มีวิธีอื่นนอกเหนือจากการวิเคราะห์คำศัพท์หรือการแยกรหัส? คำถามนี้เกี่ยวกับ PHP และหรือ JavaScript เป็นหลัก แต่ฉันเปิดรับทุกภาษาและทุกทฤษฎี

11 algorithms  complexity  big-o  static-analysis  big-theta