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

ฉันดูที่http://programming.lispdream.com/blog/2011/06/recursion-vs-iteration/และฉันเห็นว่าการใช้งานแบบเรียกซ้ำและทำซ้ำของฟังก์ชันแฟคทอเรียลซ้ำแล้วซ้ำอีกจะใช้เวลานานกว่า รับ n = 1,000 ฉันไม่สามารถหาสาเหตุ (เขาไม่ได้อธิบาย แต่บอกว่ามันเป็นแบบฝึกหัดสำหรับผู้อ่าน) ขออภัยสำหรับความแปลกใหม่ของฉันทั้งหมดนี้

11 algorithms  lisp  recursion 

คำนำ นี่ไม่ใช่รหัสกอล์ฟ ฉันกำลังดูปัญหาที่น่าสนใจและหวังที่จะขอความคิดเห็นและข้อเสนอแนะจากเพื่อนของฉัน คำถามนี้ไม่เกี่ยวกับการนับบัตร (โดยเฉพาะ) แต่เป็นเรื่องเกี่ยวกับการพิจารณาตารางที่ดีที่สุดในการมีส่วนร่วมตามการสังเกต สมมติว่าคุณจะปลูกฝังสมองบางชนิดซึ่งทำให้เวลา / พื้นที่ในกรณีที่เลวร้ายที่สุด (บนสถาปัตยกรรมใดก็ตาม) พกพาไปสู่จิตใจมนุษย์ ใช่มันเป็นเรื่องส่วนตัว สมมติว่าสำรับฝรั่งเศสโดยไม่ต้องใช้ไพ่เสริม พื้นหลัง ฉันเพิ่งเยี่ยมชมคาสิโนและเห็นผู้ยืนดูมากกว่าผู้เล่นต่อโต๊ะและสงสัยว่ากระบวนการคัดเลือกใดกลายเป็นผู้เล่นการพนันเนื่องจากผู้ยืนดูส่วนใหญ่มีเงินทุนในการเล่น (ชิปในมือ) สถานการณ์ คุณเข้าสู่คาสิโน คุณจะเห็นตาราง n การเล่นที่แตกต่างกันของแบล็คแจ็กับปีของพวกเขาเล่นโป๊ะ แต่ละตารางเล่นกับจำนวนเงินที่ไม่แน่นอนของชั้นบัตรในความพยายามที่จะทำให้งงงวยได้เปรียบบ้าน แต่ละโต๊ะมีการเดิมพันขั้นต่ำที่แตกต่างกัน คุณมีสกุลเงิน Z กับคนของคุณ คุณต้องการค้นหาตารางที่: จำนวนที่น้อยที่สุดของสำรับไพ่ถูกใช้งาน เดิมพันขั้นต่ำสูงกว่าโต๊ะโดยใช้โต๊ะมากขึ้น แต่คุณต้องการเพิ่มจำนวนของเกมที่คุณสามารถเล่นกับ Z ได้ การสูญเสียสุทธิต่อผู้เล่นต่ำที่สุด (ฉันตระหนักว่านี่คือคำตอบส่วนใหญ่ซึ่งถือว่าเป็นเสียงรบกวนเล็กน้อย แต่มันอาจแสดงให้เห็นถึงนักสับที่เสียหาย) ปัญหา คุณสามารถสังเกตทุกตารางได้อย่างน่าอัศจรรย์ คุณมี X รอบตัวอย่างเพื่อเป็นฐานการตัดสินใจของคุณ เพื่อจุดประสงค์นี้ผู้เล่นทุกคนใช้เวลาไม่เกิน 30 วินาทีในการเล่น คุณจะใช้อัลกอริทึมแบบใดเพื่อแก้ปัญหานี้และความซับซ้อนของกรณีที่เลวร้ายที่สุดคืออะไร คุณ: เล่น Pontoon หรือ Blackjack? คุณเลือกโต๊ะอะไร …

11 algorithms 

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

11 algorithms 

เป็นทางการให้s ( U , Q ) = { V | V ∈ UและV ⊆ Q } โดยที่U , Q , และVทั้งหมดเป็นตัวแทนของชุดและUโดยเฉพาะเจาะจงมากขึ้นแสดงชุดของชุด เพื่อเป็นตัวอย่างคุณอาจเป็นชุดของส่วนผสม (ชุด) ที่จำเป็นสำหรับสูตรอาหารต่าง ๆ ในตำราอาหารที่มีQแทนชุดส่วนผสมที่ฉันมีVแทนสูตรที่ฉันสามารถทำกับส่วนผสมเหล่านั้นได้ แบบสอบถามs ( U , Q) สอดคล้องกับคำถาม "ฉันสามารถทำอะไรกับส่วนผสมเหล่านี้ได้บ้าง?" สิ่งที่ฉันกำลังมองหาคือการแสดงข้อมูลที่ดัชนีUในลักษณะที่สนับสนุนการสืบค้นที่มีประสิทธิภาพของs ( U , Q ) โดยที่Qและสมาชิกทั้งหมดของUจะมีขนาดเล็กเมื่อเทียบกับสหภาพของสมาชิกทั้งหมดของU . นอกจากนี้ฉันต้องการให้อัปเดตUอย่างมีประสิทธิภาพ(เช่นเพิ่มหรือลบสูตรอาหาร) ฉันไม่สามารถช่วยได้ แต่คิดว่าปัญหานี้ต้องเข้าใจดี แต่ฉันไม่สามารถหาชื่อหรือข้อมูลอ้างอิงได้ ใครบ้างรู้กลยุทธ์ในการแก้ปัญหานี้อย่างมีประสิทธิภาพหรือสถานที่ที่ฉันสามารถอ่านเพิ่มเติมเกี่ยวกับเรื่องนี้? เท่าที่ความคิดเกี่ยวกับการแก้ปัญหาหนึ่งคิดว่าผมคือการสร้างต้นไม้ตัดสินใจสำหรับชุดU ที่แต่ละโหนดในต้นไม้คำถาม "รายการส่วนผสมของคุณมีxหรือไม่" จะถูกถามด้วยx …

11 algorithms  data-structures 

ระบบที่ฉันสร้างประกอบด้วยชุดของตัวเลื่อน UI (จำนวนแตกต่างกัน) แต่ละตัวมีระดับ 0-100 โดยตัวเลื่อนฉันหมายถึง UI ที่คุณจับองค์ประกอบและลากขึ้นและลงเช่นการควบคุมระดับเสียง พวกเขาเชื่อมต่อกันด้วยอัลกอริทึมที่ช่วยให้มั่นใจว่าพวกเขาจะรวม 100 เสมอดังนั้นเมื่อเลื่อนหนึ่งเลื่อนขึ้นอื่น ๆ ทั้งหมดเลื่อนลงในที่สุดถึงศูนย์ เมื่อคนหนึ่งถูกเลื่อนลงคนอื่น ๆ ก็จะขยับขึ้น ทุกครั้งที่ผลรวมจะต้องเป็น 100 ดังนั้นที่นี่เลื่อนมีค่าต่าง ๆ แต่พวกเขารวม 100%: ----O------ 40 O---------- 0 --O-------- 20 --O-------- 20 --O-------- 20 หากตัวเลื่อนแรกเลื่อนขึ้นจาก 40 เป็น 70 ตัวเลื่อนอื่น ๆ จะต้องเลื่อนลงตามค่า (เนื่องจากตัวเลื่อนถูกลาก) หมายเหตุสามสไลเดอร์เปลี่ยนจาก 20 เป็น 10 และหนึ่งอยู่ที่ศูนย์เนื่องจากไม่สามารถลดลงได้ -------O--- 70 O---------- 0 -O--------- …

11 algorithms  gui  ui 

มีการอ้างอิงเหมือนCormenเกี่ยวกับแฮชและแฮชหรือไม่? โครงสร้างเฉพาะนี้ได้รับความสนใจเล็กน้อยในการศึกษา CS ของฉันด้วยเหตุผลบางอย่าง แต่ฉันต้องการเรียนรู้เพิ่มเติมเนื่องจากดูเหมือนว่าจะอยู่ทุกที่ ฉันรู้ว่า Cormen ครอบคลุม แต่ฉันกำลังมองหาบางสิ่งที่พิเศษและลึกซึ้งกว่านี้

11 algorithms  data-structures 

บางครั้งในการสัมภาษณ์ฉันอาจใช้การสอบถามซ้ำเพื่อแก้ปัญหา (เช่นการเพิ่ม1จำนวนเต็มความแม่นยำที่ไม่มีที่สิ้นสุด) หรือเมื่อปัญหานำเสนอตัวเองที่เหมาะสมในการใช้การสอบถามซ้ำ บางครั้งอาจเป็นเพราะการใช้การเรียกซ้ำหลายครั้งเพื่อแก้ปัญหาดังนั้นโดยไม่ต้องคิดมากการเรียกซ้ำจะใช้เพื่อแก้ปัญหา อย่างไรก็ตามสิ่งที่ต้องพิจารณาก่อนที่คุณจะสามารถตัดสินใจได้ว่าจะใช้การเรียกซ้ำเพื่อแก้ไขปัญหาได้อย่างไร ฉันมีความคิดบางอย่าง: หากเราใช้การเรียกซ้ำข้อมูลซึ่งลดลงครึ่งหนึ่งทุกครั้งดูเหมือนว่าไม่มีปัญหาในการเรียกซ้ำเนื่องจากข้อมูลทั้งหมดที่สามารถพอดีกับ RAM ขนาด 16GB หรือแม้กระทั่งฮาร์ดไดรฟ์ 8TB สามารถจัดการได้โดยการเรียกซ้ำเพียง 42 ระดับ (ดังนั้นจึงไม่มีการล้นสแต็ค (ฉันคิดว่าในสภาพแวดล้อมบางอย่างสแต็คอาจมีความลึก 4000 ระดับทางมากกว่า 42 แต่ในขณะเดียวกันก็ขึ้นอยู่กับว่าคุณมีตัวแปรเฉพาะที่คุณมีเท่าไรในแต่ละสแตกการโทร หากมีตัวแปรโลคัลจำนวนมากและเป็นขนาดหน่วยความจำไม่ใช่ระดับซึ่งกำหนดสแต็กโอเวอร์โฟลว์)) หากคุณคำนวณหมายเลขฟีโบนักชีโดยใช้การเรียกซ้ำแบบบริสุทธิ์คุณต้องกังวลเกี่ยวกับความซับซ้อนของเวลาเว้นแต่ว่าคุณจะแคชผลลัพธ์ระดับกลาง และวิธีการเกี่ยวกับการเพิ่ม1จำนวนเต็มความแม่นยำอนันต์? บางทีมันอาจจะเป็นที่ถกเถียงกันเช่นคุณจะทำงานกับตัวเลขที่มีความยาว 3000 หลักหรือยาว 4000 หลักใหญ่จนสามารถทำให้เกิดการล้นสแต็กหรือไม่ ฉันไม่ได้คิด แต่บางทีคำตอบคือไม่เราไม่ควรใช้การเรียกซ้ำ แต่ใช้ลูปธรรมดาเพราะถ้าในบางแอปพลิเคชันจำนวนจริง ๆ ต้องยาว 4000 หลักเพื่อตรวจสอบบางอย่าง คุณสมบัติของตัวเลขเช่นว่าเป็นจำนวนเฉพาะหรือไม่ คำถามสุดท้ายคือสิ่งที่ต้องพิจารณาก่อนที่คุณจะตัดสินใจใช้การเรียกซ้ำเพื่อแก้ไขปัญหา

10 algorithms  recursion 

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

10 algorithms  collections 

ฉันล้มเหลวในการทดสอบอัลกอริทึมกับ Codility เพราะฉันพยายามหาวิธีแก้ปัญหาที่ดีกว่าและในที่สุดฉันก็ไม่มีอะไรเลย ดังนั้นฉันคิดว่าถ้าฉันสามารถใช้วิธีการคล้ายกับ TDD เช่นถ้าฉันสามารถพัฒนาวิธีแก้ปัญหาแบบค่อยเป็นค่อยไปในแบบเดียวกันได้หรือไม่ หากฉันกำลังเขียนอัลกอริทึมการเรียงลำดับฉันสามารถย้ายจาก Bubblesort มาตรฐานไปเป็น Bubbleort แบบ 2 ทางได้ แต่จากนั้นบางสิ่งที่ก้าวหน้ากว่าอย่าง Quicksort จะเป็น "quantum leap" แต่อย่างน้อยฉันจะมี testdata ฉันสามารถตรวจสอบได้อย่างง่ายดาย เคล็ดลับอื่น ๆ สำหรับการทดสอบ? สิ่งหนึ่งที่ฉันจะทำในครั้งต่อไปคือการใช้วิธีการ / ฟังก์ชั่นมากกว่าห่วงภายใน ตัวอย่างเช่นในการเรียงลำดับคุณมักจะต้องสลับ หากเป็นวิธีฉันจะต้องแก้ไขรหัสโทร ฉันยังสามารถมีวิธีแก้ปัญหาขั้นสูงเพิ่มเติมเป็นคลาสที่ได้รับ ด้วยปัญหา "อัลกอริทึม" กับ "ปกติ" ฉันหมายถึงปัญหาที่ความซับซ้อนของเวลาเป็นสิ่งสำคัญ ดังนั้นแทนที่จะผ่านการทดสอบมากขึ้นเช่นเดียวกับใน TDD คุณจะทำให้ "ทำงานได้ดีขึ้น" ด้วย "Similar to TDD" ฉันหมายถึง: เขียนการทดสอบที่ค่อนข้างอัตโนมัติเพื่อประหยัดเวลาในการเพิ่มการทดสอบแบบแมนนวล การพัฒนาที่เพิ่มขึ้น การทดสอบการถดถอยความสามารถในการตรวจสอบว่าตัวแบ่งรหัสหรืออย่างน้อยถ้าฟังก์ชั่นการเปลี่ยนแปลงระหว่างการเพิ่มขึ้น ฉันคิดว่านี่น่าจะง่ายต่อการเข้าใจถ้าคุณเปรียบเทียบ เขียนเชลล์เรียงลำดับโดยตรง กระโดดจาก …

10 algorithms  tdd  self-improvement 

บทนำ เอ็นจิ้นการเรนเดอร์กราฟิกแบบเวกเตอร์หลายตัวมีข้อบกพร่องของอัลกอริทึมในตัว พวกมันแสดงรูปร่างแต่ละแบบแยกกันและ antialias โดยการคำนวณความครอบคลุมของพิกเซลแล้วประกอบมันไว้ที่ด้านบนของกันและกัน ใช่มันง่าย แต่การแก้ปัญหาที่ถูกต้องนั้นง่ายกว่า สิ่งนี้นำไปสู่ปัญหา conflation ในขณะที่ conflates ความคุ้มครองโดยความโปร่งใส การผสมอัลฟ่าเป็นไปตามกฎที่ไม่ได้เป็นตัวแทนของสถานการณ์อย่างถูกต้องตัวอย่างเช่นถ่ายภาพพิกเซลที่ครอบคลุม 50% ที่อยู่ใกล้เคียงกับพิกเซลที่ครอบคลุม 50% ไม่ได้จบลงด้วยการครอบคลุม 100% มันจบลงด้วยความครอบคลุม 75% . สิ่งที่ดูเหมือนจะขึ้นอยู่กับวิธีการปรับอัลกอริทึมและรายละเอียดอื่น ๆ แต่ในสาระสำคัญนี่เป็นข้อผิดพลาดที่ทราบ บางคนทำปัญหาการทำเอกสารข้อผิดพลาดของเครื่องยนต์แตกต่างกันไปรวมทั้งการเขียนบทความแสดงให้เห็นว่าสามารถทำได้ดีกว่า ภาพที่ 1 : ตัวอย่างที่ไม่ได้เป็นตัวแทนทั้งหมดของการเรนเดอร์รูปร่างที่ทำจากสามเหลี่ยมแสดงข้อผิดพลาดแบบขยายที่แถวบนสุด แหล่งที่มาของ SVG ปัญหามีวิธีแก้ปัญหาที่ไม่ยุ่งยากง่าย ๆ * เป็นเพียงตัวอย่างขั้นสูงโดยไม่ต้องคำนวณการครอบคลุมและกรองภาพลง เป็นโบนัสที่คุณจะได้ใช้อัลกอริธึมการสร้างภาพที่ดีกว่าการกรองแบบกล่อง (อ่านA Pixel ไม่ใช่สี่เหลี่ยมจัตุรัส3 ) มีแม้กระทั่งโซลูชันที่มีความเร็วเทียบเคียงได้กับโซลูชันปัจจุบันและวิธีแก้ปัญหาเหล่านี้ทำได้ง่ายกว่ามากในท่อส่งแรสเตอร์ฮาร์ดแวร์ นี่ไม่ใช่ปัญหาโดยไม่มีค่าใช้จ่าย มีหลายคนที่ทำงานด้านการออกแบบกราฟิกที่ใช้เวลาจำนวนเล็กน้อยในการพยายามหลีกเลี่ยงปัญหานี้ด้วยตนเองโดยทำให้แน่ใจว่ามีการทับซ้อนกันที่นี่และไม่มีการทับซ้อนกันเพื่อแก้ไขปัญหาที่คอมพิวเตอร์ควรทำเพื่อพวกเขา และล้มเหลวอย่างน่าทึ่งในหลายกรณี แต่ลูกค้าของพวกเขาไม่สนใจว่าทำไมข้อผิดพลาดอยู่ที่นั่นพวกเขาจะต้องแก้ไข คำถาม ข้อผิดพลาดเผยแพร่อย่างไร เนื่องจากพวกเขากำลังทำข้อผิดพลาดเดียวกันทั้งหมดจึงสามารถสรุปได้ว่าพวกเขาใช้แหล่งเดียวกันสำหรับอัลกอริทึมของพวกเขา สิ่งที่อาจทำให้นักออกแบบเลือกอัลกอริทึมนี้ เหตุใดโปรแกรมเมอร์ …

10 design  algorithms 

ฉันใช้อัลกอริทึมซึ่งค่อนข้างซับซ้อนในการคำนวณและต้องการพยายามทำให้แน่ใจว่าฉันไม่ได้ทำงานที่ไม่จำเป็น มีโครงตาข่ายลูกบาศก์ nxnxn เช่นถ้า n = 2 ประกอบด้วย (0,0,0), (0,1,0), (1,0,0), (1,1,0), (0, 1,1), (0,0,1), (1,0,1), (1,1,1) จากขัดแตะนี้ฉันจะสร้างจุด m ซ้ำซ้ำทุกอย่างเช่น: solve(set_of_points) { if set_of_points.size = m, finish do some useful computation here for each point in lattice not in set_of_points: solve(set_of_points + new_point); } ซึ่งสามารถเรียกได้ว่าเริ่มต้นด้วย set_of_point ที่ว่างเปล่า ลักษณะของปัญหาที่เกิดขึ้นเป็นเช่นนั้นฉันไม่จริงต้องทุกการเปลี่ยนแปลงของจุดเมตรเพียงแค่คนที่เป็นเอกลักษณ์ภายใต้ symmetries ธรรมชาติของลูกบาศก์ …

10 algorithms  recursion 

ฉันกำลังเรียนรู้เกี่ยวกับ quicksort และต้องการแสดงอาร์เรย์ที่แตกต่างกันซึ่ง quicksort จะมีช่วงเวลาที่ยากลำบาก Quicksort ที่ฉันมีอยู่ในใจไม่มีการสับสุ่มเริ่มต้นทำพาร์ติชัน 2 และไม่คำนวณค่ามัธยฐาน ฉันคิดถึงตัวอย่างสามตัวอย่าง: [1,2,3,4,5,6,7,8,9,10] - when the array is sorted [10,9,8,7,6,5,4,3,2,1] - when the array is reversed [1,1,1,1,1,1,1,1,1,1] - when the array is the same values [1,1,1,2,2,2,3,3,3,3] - when there are few and unique keys ตัวอย่างเช่นฉันไม่แน่ใจเกี่ยวกับสิ่งนี้: [1,3,5,7,9,10,8,6,4,2] ดังนั้นอะไรที่ทำให้อาร์เรย์ที่ quicksort มีความยากลำบากเมื่อเทียบกับที่มันเหมาะ (เกือบ)?

10 algorithms  sorting 

ฉันถูกถามคำถามนี้ในระหว่างการคัดกรองโทรศัพท์ทางเทคนิคเมื่อเร็ว ๆ นี้และทำไม่ดี คำถามรวมอยู่ด้วยคำต่อคำด้านล่าง สร้าง{2^i * 5^j | i,j >= 0}คอลเลกชันเรียง พิมพ์ค่าที่น้อยที่สุดถัดไปอย่างต่อเนื่อง ตัวอย่าง: { 1, 2, 4, 5, 8, 10...} "เล็กที่สุดถัดไป" ทำให้ฉันคิดว่ามีส่วนเกี่ยวข้องกับกอง - เล็ก ๆ น้อย ๆ แต่ฉันไม่รู้ว่าจะไปจากที่นั่นจริง ๆ และไม่มีการให้ความช่วยเหลือจากผู้สัมภาษณ์ ไม่มีใครมีคำแนะนำเกี่ยวกับวิธีการแก้ปัญหาดังกล่าวหรือไม่?

10 algorithms 

สำหรับผู้ที่ไม่ได้อยู่ในกลุ่มผู้ชม Brits มีกลุ่มของเกมโชว์กลางวันที่ผู้เข้าแข่งขันมีหมายเลข 6 ชุดและหมายเลขเป้าหมายที่สร้างแบบสุ่ม พวกเขาจะต้องไปให้ถึงหมายเลขเป้าหมายโดยใช้ตัวเลข 6 ตัว (แต่ไม่จำเป็นต้องทั้งหมด) โดยใช้ตัวดำเนินการทางคณิตศาสตร์เท่านั้น การคำนวณทั้งหมดจะต้องเป็นจำนวนเต็มบวก ตัวอย่างเช่นYoutube: Countdown - เกมหมายเลขพิเศษที่สุดที่เคยมีมา? มีคำอธิบายโดยละเอียดใน Wikipedia: Countdown (Game Show) ตัวอย่างเช่น: ผู้ให้ข้อมูลเลือก 6 หมายเลข - สองตัวใหญ่ (ความเป็นไปได้รวม 25, 50, 75, 100) และสี่ตัวเล็ก (หมายเลข 1 .. 10 แต่ละตัวรวมสองครั้งในสระว่ายน้ำ) ตัวเลขที่เลือกจะ75, 50, 2, 3, 8, จะได้รับมีจำนวนเป้าหมายของการ7812 หนึ่งครั้งคือ (75 + 50 - 8) * …

10 algorithms  arithmetic 

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

10 algorithms  strings