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

บางคนสามารถอธิบายวิธีที่มีประสิทธิภาพในการค้นหาปัจจัยทั้งหมดของตัวเลขใน Python (2.7) ให้ฉันได้ไหม ฉันสามารถสร้างอัลกอริทึมเพื่อทำสิ่งนี้ แต่ฉันคิดว่ามันเป็นรหัสที่ไม่ดีและใช้เวลานานเกินไปในการสร้างผลลัพธ์สำหรับจำนวนมาก

142 python  algorithm  python-2.7  performance  factorization 

วิธีที่ดีที่สุดในการสุ่มอาเรย์ของสตริงด้วย. NET คืออะไร? อาร์เรย์ของฉันมีสตริงประมาณ 500 รายการและฉันต้องการสร้างใหม่Arrayด้วยสตริงเดียวกัน แต่เรียงตามลำดับแบบสุ่ม กรุณาใส่ตัวอย่าง C # ในคำตอบของคุณ

141 c#  .net  algorithm  sorting  random 

a = [1, 2, 3, 1, 2, 3] b = [3, 2, 1, 3, 2, 1] a & b ควรได้รับการพิจารณาอย่างเท่าเทียมกันเพราะพวกเขามีองค์ประกอบเดียวกันทุกประการเท่านั้น สิ่งที่เป็นรายการจริงของฉันจะประกอบด้วยวัตถุ (อินสแตนซ์ชั้นเรียนของฉัน) ไม่ใช่จำนวนเต็ม

141 python  algorithm  list  comparison 

ดังนั้นถ้าฉันต้องเลือกระหว่างตารางแฮชหรือต้นไม้นำหน้าอะไรคือปัจจัยแบ่งแยกที่จะทำให้ฉันเลือกอย่างใดอย่างหนึ่ง จากมุมมองที่ไร้เดียงสาของฉันดูเหมือนว่าการใช้ Trie จะมีค่าใช้จ่ายพิเศษบางอย่างเนื่องจากไม่ได้จัดเก็บเป็นอาร์เรย์ แต่ในแง่ของเวลาทำงาน (สมมติว่าคีย์ที่ยาวที่สุดคือคำภาษาอังกฤษที่ยาวที่สุด) โดยพื้นฐานแล้วอาจเป็น O (1) (สัมพันธ์กับขอบเขตบน) บางทีคำภาษาอังกฤษที่ยาวที่สุดคือ 50 ตัวอักษร? ตารางแฮชมีรูปลักษณ์ทันทีขึ้นเมื่อคุณได้รับดัชนี การแฮ็กคีย์เพื่อรับดัชนี แต่ดูเหมือนว่าจะทำได้อย่างง่ายดายเกือบ 50 ขั้นตอน ใครช่วยให้มุมมองที่มีประสบการณ์มากกว่านี้แก่ฉันได้ไหม ขอบคุณ!

141 algorithm  data-structures  hashtable  trie 

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

140 algorithm  dynamic-programming  divide-and-conquer 

ฉันกำลังพยายามสร้างเกมไพ่ที่การ์ดจะเปิดออก ตอนนี้เพื่อแสดงมันโดยใช้ Allegro API ซึ่งมีฟังก์ชั่น: al_draw_rotated_bitmap(OBJECT_TO_ROTATE,CENTER_X,CENTER_Y,X ,Y,DEGREES_TO_ROTATE_IN_RADIANS); ดังนั้นด้วยสิ่งนี้ฉันสามารถทำให้เอฟเฟกต์แฟน ๆ ของฉันง่ายขึ้น ปัญหาคือรู้ว่าการ์ดใดอยู่ภายใต้เมาส์ เมื่อต้องการทำสิ่งนี้ฉันคิดถึงการทดสอบการชนกันของรูปหลายเหลี่ยม ฉันไม่แน่ใจว่าจะหมุน 4 จุดบนการ์ดเพื่อสร้างรูปหลายเหลี่ยมได้อย่างไร โดยทั่วไปฉันต้องดำเนินการเช่นเดียวกับ Allegro ตัวอย่างเช่น 4 คะแนนของการ์ดคือ: card.x card.y card.x + card.width card.y + card.height ฉันต้องการฟังก์ชั่นเช่น: POINT rotate_point(float cx,float cy,float angle,POINT p) { } ขอบคุณ

139 c++  algorithm 

ฉันได้สัมภาษณ์กับ บริษัท กองทุนป้องกันความเสี่ยงในนิวยอร์กเมื่อไม่กี่เดือนที่ผ่านมาและโชคไม่ดีที่ฉันไม่ได้รับการฝึกงานในฐานะวิศวกรข้อมูล / ซอฟต์แวร์ (พวกเขายังขอให้วิธีการแก้ปัญหาอยู่ในหลาม) ฉันเมามากขึ้นกับปัญหาการสัมภาษณ์ครั้งแรก ... คำถาม: รับสตริงเป็นล้านตัวเลข (เช่น Pi) เขียนฟังก์ชัน / โปรแกรมที่ส่งกลับตัวเลข 3 หลักซ้ำและจำนวนการทำซ้ำที่มากกว่า 1 ตัวอย่างเช่น: ถ้าสตริงเป็น: 123412345123456ดังนั้นฟังก์ชัน / โปรแกรมจะส่งคืน: 123 - 3 times 234 - 3 times 345 - 2 times พวกเขาไม่ได้ให้คำตอบกับฉันหลังจากที่ฉันสัมภาษณ์ล้มเหลว แต่พวกเขาบอกฉันว่าเวลาในการแก้ปัญหานั้นมีค่าคงที่ 1,000 เนื่องจากผลลัพธ์ที่เป็นไปได้ทั้งหมดอยู่ระหว่าง: 000 -> 999 ตอนนี้ฉันกำลังคิดเกี่ยวกับมันฉันไม่คิดว่ามันเป็นไปได้ที่จะเกิดอัลกอริธึมเวลาคงที่ ใช่ไหม?

137 python  algorithm  data-structures  number-theory 

หมายเลขคริสตจักรเป็นการเข้ารหัสตัวเลขธรรมชาติเป็นฟังก์ชัน (\ f x → (f x)) -- church number 1 (\ f x → (f (f (f x)))) -- church number 3 (\ f x → (f (f (f (f x))))) -- church number 4 อย่างเรียบร้อยคุณสามารถยกกำลัง 2 หมายเลขคริสตจักรได้โดยใช้มัน นั่นคือถ้าคุณใช้ 4-2 คุณจะได้รับจำนวนคริสตจักรหรือ16 2^4เห็นได้ชัดว่านั่นเป็นเรื่องที่ไม่สามารถเกิดขึ้นได้จริง จำนวนคริสตจักรต้องการหน่วยความจำเชิงเส้นและช้ามากจริงๆ การประมวลผลสิ่ง10^10ที่ GHCI ตอบได้อย่างรวดเร็วจะใช้เวลานานและไม่สามารถใส่หน่วยความจำบนคอมพิวเตอร์ของคุณได้ ฉันได้ทำการทดลองกับผู้ประเมินที่เหมาะสมที่สุดเมื่อเร็ว ๆ นี้ …

137 algorithm  haskell  functional-programming  lambda-calculus  modular-arithmetic 

อัลกอริทึมพื้นฐานสำหรับ BFS: set start vertex to visited load it into queue while queue not empty for each edge incident to vertex if its not visited load into queue mark vertex ดังนั้นฉันคิดว่าความซับซ้อนของเวลาจะเป็น: v1 + (incident edges) + v2 + (incident edges) + .... + vn + (incident edges) vจุดยอด1ถึงอยู่ที่ไหนn ประการแรกสิ่งที่ฉันพูดถูกต้องหรือไม่? ประการที่สองสิ่งนี้เป็นอย่างไรO(N …

137 algorithm  time-complexity  graph-theory  breadth-first-search 

ฉันเจอคำถามนี้ในหนังสืออัลกอริทึม ( อัลกอริทึมรุ่นที่ 4โดย Robert Sedgewick และ Kevin Wayne) คิวสามกอง ใช้คิวที่มีสามกองเพื่อให้การดำเนินการแต่ละคิวใช้จำนวนการดำเนินการสแต็กคงที่ (กรณีที่แย่ที่สุด) คำเตือน: ความยากระดับสูง ฉันรู้วิธีสร้างคิวด้วยสแต็ค 2 ชุด แต่ฉันไม่พบวิธีแก้ปัญหาด้วยสแต็ค 3 ตัว ความคิดใด ๆ (โอ้และนี่ไม่ใช่การบ้าน :))

136 algorithm  data-structures 

การเรียงลำดับใช้ O (n log n) ในกรณีอนุกรม หากเรามีโปรเซสเซอร์ O (n) เราหวังว่าจะได้รับการเร่งความเร็วเชิงเส้น O (log n) อัลกอริทึมแบบขนานมีอยู่ แต่มีค่าคงที่สูงมาก นอกจากนี้ยังไม่สามารถใช้ได้กับฮาร์ดแวร์สินค้าโภคภัณฑ์ซึ่งไม่มีที่ใดก็ได้ใกล้กับโปรเซสเซอร์ O (n) ด้วยโปรเซสเซอร์ p อัลกอริทึมที่เหมาะสมควรใช้เวลา O (n / p log n) ในกรณีอนุกรมการเรียงลำดับด่วนมีความซับซ้อนของรันไทม์โดยเฉลี่ยดีที่สุด อัลกอริธึมการเรียงลำดับด่วนแบบคู่ขนานนั้นใช้งานง่าย (ดูที่นี่และที่นี่ ) อย่างไรก็ตามมันทำงานได้ไม่ดีเนื่องจากขั้นตอนแรกคือการแบ่งพาร์ติชันคอลเลกชันทั้งหมดบนคอร์เดียว ฉันพบข้อมูลเกี่ยวกับอัลกอริทึมการจัดเรียงแบบขนานมากมาย แต่จนถึงขณะนี้ฉันยังไม่เห็นสิ่งใดที่ชี้ไปที่ผู้ชนะที่ชัดเจน ฉันต้องการจัดเรียงรายการ 1 ล้านถึง 100 ล้านองค์ประกอบในภาษา JVM ที่ทำงานบน 8 ถึง 32 คอร์

136 algorithm  sorting  concurrency 

คำถามเกี่ยวกับระเบิดซิปนี้ทำให้ฉันไปที่หน้า Wikipediaในหัวข้อนี้ บทความกล่าวถึงตัวอย่างของไฟล์ zip ขนาด 45.1 kb ที่ขยายขนาดเป็น 1.3 เอ็กซาไบต์ อะไรคือหลักการ / เทคนิคที่จะใช้ในการสร้างไฟล์ดังกล่าวตั้งแต่แรก? ฉันไม่ต้องการทำสิ่งนี้จริงๆสนใจคำอธิบาย "วิธีการทำงาน" ที่เรียบง่ายของแนวคิดที่เกี่ยวข้องมากกว่า PS บทความกล่าวถึงไฟล์ zip 9 ชั้นดังนั้นจึงไม่ใช่กรณีง่ายๆที่จะต้องใส่เลขศูนย์ ทำไม 9 ทำไมถึง 10 ไฟล์ในแต่ละไฟล์?

131 algorithm  compression 

สมมติว่าผมมี n เหลี่ยมตายโหลดที่แต่ละด้านมีบางส่วน k p น่าจะkของขึ้นมาเมื่อผมม้วน ฉันอยากรู้ว่ามีอัลกอริทึมที่ดีสำหรับการจัดเก็บข้อมูลนี้แบบคงที่ (เช่นสำหรับชุดของความน่าจะเป็นคงที่) เพื่อให้ฉันสามารถจำลองการหมุนของแม่พิมพ์แบบสุ่มได้อย่างมีประสิทธิภาพ ขณะนี้ฉันมีทางออก O (lg n) สำหรับปัญหานี้ ความคิดคือการเก็บตารางของความน่าจะเป็นสะสมของ k แรกสำหรับทุก k พวกเขาเพื่อสร้างจำนวนจริงแบบสุ่มในช่วง [0, 1) และทำการค้นหาแบบไบนารีเหนือตารางเพื่อให้ได้ดัชนีที่ใหญ่ที่สุดที่มีการสะสม ค่าไม่มากกว่าค่าที่เลือก ฉันชอบโซลูชันนี้ แต่ดูเหมือนแปลกที่รันไทม์ไม่ได้คำนึงถึงความน่าจะเป็น โดยเฉพาะอย่างยิ่งในกรณีที่สุดขั้วของด้านใดด้านหนึ่งขึ้นมาเสมอหรือค่าที่กระจายอย่างสม่ำเสมอเป็นไปได้ที่จะสร้างผลลัพธ์ของการหมุนใน O (1) โดยใช้วิธีการไร้เดียงสาแม้ว่าวิธีแก้ปัญหาของฉันจะยังคง ใครบ้างมีคำแนะนำสำหรับวิธีการแก้ปัญหานี้ในลักษณะที่ "ปรับตัว" อย่างใดในมัน runtime? แก้ไข : ตามคำตอบของคำถามนี้ฉันได้เขียนบทความที่อธิบายถึงวิธีการมากมายสำหรับปัญหานี้พร้อมกับการวิเคราะห์ของพวกเขา ดูเหมือนว่าการติดตั้งวิธีนามแฝงของ Vose จะให้เวลา process (n) เวลาในการประมวลผลล่วงหน้าและเวลา O (1) ต่อการหมุนตายซึ่งเป็นที่น่าประทับใจอย่างแท้จริง หวังว่านี่จะเป็นประโยชน์ต่อข้อมูลที่มีอยู่ในคำตอบ!

130 algorithm  language-agnostic  data-structures  random  probability 

ฟังก์ชันแฮชที่ดีคืออะไร ฉันเห็นฟังก์ชันแฮชและแอปพลิเคชันจำนวนมากในหลักสูตรโครงสร้างข้อมูลในวิทยาลัย แต่ส่วนใหญ่ฉันเข้าใจว่ามันยากที่จะสร้างฟังก์ชันแฮชที่ดี ตามกฎของหัวแม่มือเพื่อหลีกเลี่ยงการชนศาสตราจารย์ของฉันกล่าวว่า: function Hash(key) return key mod PrimeNumber end (mod คือตัวดำเนินการ% ในภาษา C และภาษาที่คล้ายคลึงกัน) โดยมีหมายเลขเฉพาะเป็นขนาดของตารางแฮช ฉันได้รับมันเป็นฟังก์ชั่นที่ค่อนข้างดีในการหลีกเลี่ยงการชนและสิ่งที่รวดเร็ว แต่ฉันจะทำให้ดีขึ้นได้อย่างไร มีฟังก์ชันแฮชที่ดีกว่าสำหรับปุ่มสตริงเทียบกับคีย์ตัวเลขหรือไม่?

130 algorithm  language-agnostic  hash 

ในชั้นเรียนเรากำลังทำอัลกอริทึมการเรียงลำดับและแม้ว่าฉันจะเข้าใจดีเมื่อพูดถึงพวกเขาและเขียนรหัสเทียม แต่ฉันก็มีปัญหาในการเขียนโค้ดจริงสำหรับพวกเขา นี่คือความพยายามของฉันใน Python: mylist = [12, 5, 13, 8, 9, 65] def bubble(badList): length = len(badList) - 1 unsorted = True while unsorted: for element in range(0,length): unsorted = False if badList[element] > badList[element + 1]: hold = badList[element + 1] badList[element + 1] = badList[element] badList[element] = hold …

130 python  algorithm  sorting  bubble-sort