ซานต้าต้องใช้เวลานานแค่ไหนในการส่งมอบของขวัญของเขา?

12

ฉันโพสต์ความท้าทายนี้เมื่อไม่นานมานี้ซึ่งเกี่ยวข้องกับจำนวนเอลฟ์ซานต้าที่ต้องส่งของขวัญ

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

น้ำหนักของถ่านหินไม่เปลี่ยนแปลงในช่วงสองปีที่ผ่านมา - มันยังหนักกว่าของขวัญดังนั้นซานต้าต้องการสามเอลฟ์ต่อคนซนในบ้านและอีกสองเอลฟ์ต่อคนดีในบ้าน

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

เอลฟ์ที่ส่งมอบของขวัญจะต้องใช้เวลาสี่วินาที*แต่ละครั้งที่ส่งมอบและเอลฟ์ที่ส่งมอบต้องใช้เวลาห้าวินาที*ในการส่งแต่ละครั้ง (ตามระเบียบของ Santa Aviation Administration ถุงมือที่มีฝุ่นถ่านหินจะต้องถูกเผาทันทีเมื่อ ขึ้นเลื่อนซึ่งใช้เวลาพอสมควร) นอกจากนี้บ้านต้องเข้าเยี่ยมชมตามลำดับที่อยู่บนแผนที่จากซ้ายไปขวาและเอลฟ์ไม่สามารถเริ่มส่งของขวัญไปยังบ้านอื่น ๆ ได้จนกว่าของขวัญทั้งหมดจะถูกส่งไปยังบ้านที่พวกเขาอยู่ในปัจจุบัน

หากเราสันนิษฐานว่าซานต้ามีเอลฟ์มากพอสำหรับภูมิภาคนี้จะใช้เวลาเพียงตราบเท่าที่ส่งมอบของขวัญให้ใครบางคนในรายการที่ซุกซน 5 วินาทีต่อบ้านหรือ 4 วินาทีต่อบ้านถ้าทุกคนดี

แต่เมื่อเทียบกับฤดูกาลที่ผ่านมาคริสต์มาสซานต้าที่มาถึงนี้อาจมีเอลฟ์ไม่มากพอสำหรับแต่ละภูมิภาคดังนั้น 4 วินาทีจึงเป็นเวลาขั้นต่ำ*ที่จะส่งมอบของขวัญให้บ้านใด ๆ เว้นแต่ว่ามี 0 คนดีและ 0 คนซนซึ่งในกรณีนี้จะใช้เวลา 0 วินาที

นอกจากนี้หากแม้แต่บ้านหลังหนึ่งมีคนอยู่ในรายชื่อที่ซุกซนซานต้าจะต้องการเอลฟ์อย่างน้อยสาม ถ้าอย่างน้อยหนึ่งในบ้านมีใครสักคนอยู่ในรายชื่อที่ดีและไม่มีใครอยู่ในรายชื่อที่ซุกซนซานต้าจะต้องมีเอลฟ์อย่างน้อยสองคน หากไม่มีบ้านอยู่ในจิตวิญญาณคริสต์มาสเอลฟ์จำนวนใด (รวมถึง 0) จะใช้เวลา 0 วินาที

บนแผนที่ของซานต้าบ้านเป็นตัวแทนจากและบ้านแต่ละหลังถูกแบ่งออกโดย* +ซานต้ายังคงใช้แผนที่แบบเดียวกันกับความท้าทายอื่น ๆแต่ฉันจะใส่เอกสารเกี่ยวกับพวกเขาที่นี่

จะมีตัวเลขอยู่ด้านใดด้านหนึ่งของบ้าน - ด้านซ้ายแสดงถึงจำนวนคนซุกซนในบ้านและอีกคนด้านขวาแสดงจำนวนคนดีในบ้าน หากไม่มีหมายเลขในด้านใดด้านหนึ่งมันจะตีความว่าเป็น 0

ฉันรู้ว่ามันอาจฟังดูบ้า แต่บางคน "ไม่ชอบคริสต์มาส" ดังนั้นบางครั้งบ้านอาจไม่มีตัวเลขอยู่สองข้าง

หนึ่งในแผนที่ของซานต้าอาจมีลักษณะเช่นนี้

1*3+2*+*5+*+4*7

สมมติว่าซานต้ามีเก้าเอลฟ์ในเลื่อนของเขา

  1. (0s) บ้านหลังแรกมี 1 คนซนและ 3 คนที่ดี เอลฟ์สามคนส่งถ่านหินใช้เวลาห้าวินาทีและอีกหกส่งของขวัญใช้เวลาสี่วินาที หลังจากห้าวินาทีเลื่อนเลื่อนซานต้าจะย้ายไปที่บ้านถัดไป

  2. (5s) บ้านหลังที่สองมี 2 คนซนและเป็นคนดี 0 คน เอลฟ์หกคนส่งถ่านหินใช้เวลาห้าวินาที หลังจากห้าวินาทีเลื่อนเลื่อนซานต้าจะย้ายไปที่บ้านถัดไป

  3. (10s) บ้านหลังที่สามมี 0 คนซนและเป็นคนดี 5 คน พวกเอลฟ์แปดคนไปส่งของขวัญสี่ชิ้น (อันที่ถูกทิ้งไว้ข้างหลังไม่สามารถส่งของขวัญ) หลังจากสี่วินาทีเหล่าเอลฟ์ทุกคนจะกลับมาและอีกสองคนไปส่งของขวัญอีกครั้ง (ผู้เลื่อนต้องรอให้พวกเอลฟ์กลับไปก่อนที่จะไปบ้านหลังถัดไป) ใช้เวลาอีกสี่วินาที

  4. (18s) บ้านหลังที่สี่ไม่ได้อยู่ในจิตวิญญาณคริสมาสต์ดังนั้นมี 0 คนซนและคนดี 0 คนและถูกข้ามไป

  5. (18s) บ้านหลังที่ห้ามีคนซน 4 คนและเป็นคนดี 7 คน มันซับซ้อนเล็กน้อย ...

    I. พวกเอลฟ์ทั้งเก้าไปส่งของขวัญสามถ่านหิน (ปล่อยให้ t + 0, ส่งคืน t + 5s) II หลังจาก 5 วินาทีพวกมันก็กลับมาที่เลื่อนและสามคนไปส่งมอบของขวัญสุดท้ายของถ่านหิน (ทิ้ง t + 5s, กลับ t + 10s) ในขณะที่อีกหกคนไปส่งของขวัญที่ดีสามรายการ (ปล่อยให้ T + 5 วินาทีส่งคืน t + 9s)

    สาม. หลังจากสี่วินาทีเอลฟ์หกคนกลับมาแล้วไปมอบของขวัญที่ดีอีกสามรายการ (ปล่อยให้ t + 9s กลับไปที่ t + 13s)

    IV หนึ่งวินาทีหลังจากที่พวกเขาจากไปพวกเอลฟ์ทั้งสามที่ส่งมอบถ่านหินจะได้รับกลับคืนและอีกสองคนออกไปเพื่อส่งของขวัญที่ดีครั้งสุดท้าย (ลา + 10 วินาทีกลับ t + 14

  6. (18 +14 = 32 วินาที ) ซานต้าส่งของขวัญให้ภูมิภาคนั้นเสร็จแล้ว

อย่างที่เราเห็นมันใช้เวลาทั้งสิ้นซานต้า32 วินาทีในการส่งของขวัญไปยังภูมิภาคนี้ นั่นเป็นแผนที่ที่ง่ายกว่าฉบับหนึ่งในแผนที่ของซานต้า โดยปกติแผนที่ของซานต้าจะมีหลายบรรทัดและอยู่ในรูปทรงสี่เหลี่ยมเพื่อให้พอดีกับรายการของเขา แผนที่ปกติอาจมีลักษณะเช่นนี้ (a \nที่ส่วนท้ายของแต่ละบรรทัด)

1*2+*+*4+1*
2*4+3*+1*6+*
*+*+4*2+1*1
*4+*3+1*+2*3
3*10+2*+*5+*

กับ26 เอลฟ์ (หรือจำนวนเงินใด ๆ สูงกว่า) ก็จะใช้เวลาซานตา71 วินาที
กับ20 แถนก็จะใช้เวลาซานตา76 วินาที
กับ15 แถนก็จะใช้เวลาซานตา80 วินาที
ด้วย3 แถนก็จะใช้เวลาซานตา288 วินาที
ด้วย2 เอลฟ์ (หรือจำนวนที่ต่ำกว่า) มันจะเป็นไปไม่ได้

โอ้และอีกสิ่งหนึ่ง - ลำดับที่เอลฟ์ส่งมอบเรื่องของขวัญ (เนื่องจากความแตกต่างของเวลาในการส่งของขวัญคนซุกซน / คนดี) ดังนั้นโค้ดของคุณควรแสดงเวลาน้อยที่สุดที่เอลฟ์สามารถนำเสนอของขวัญได้

ท้าทาย

ช่วยซานต้าให้ทราบว่าจะใช้เวลานานเท่าใดในการส่งมอบเอลฟ์จำนวนหนึ่ง

บ้าน

  • บ้านเป็นตัวแทนจาก *
  • บ้านแบ่งออกเป็น +
  • หมายเลขทางด้านซ้ายของบ้านเป็นสัญลักษณ์ของจำนวนคนแก่น (ไม่มีหมายถึงเลข 0)
  • หมายเลขด้านขวาเป็นสัญลักษณ์ของจำนวนคนดี (ไม่มีตัวเลขหมายถึง 0)
  • อาจมีการขึ้นบรรทัดใหม่ ( \n) ในอินพุตซึ่งควรจัดการเป็นแยก

แถน

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

ซานตา

  • ซานต้าต้องส่งของขวัญไปที่บ้านทีละคน
  • ซานต้าไม่สามารถเคลื่อนย้ายไปยังบ้านหลังถัดไปจนกว่าพวกเอลฟ์ทุกคนจะกลับมาเลื่อนบนและของขวัญทั้งหมดได้ถูกส่งไปที่บ้านหลังนั้น (เราไม่ต้องการที่จะทิ้งพวกเอลฟ์ไว้ข้างหลังตอนนี้เรา?)
  • เลื่อนซานต้าไม่ได้ใช้เวลาเดินทางจากบ้านสู่บ้าน (อีกครั้งด้วยเหตุผลที่ฉันไม่ได้มีอิสระที่จะแบ่งปัน)

สิ่งที่ต้องทำ

ให้แผนที่บ้านและเอลฟ์จำนวนหนึ่งพิมพ์เวลาที่ซานต้าใช้ในการส่งของขวัญไปที่บ้านบนแผนที่

* (ฉันไม่สามารถแบ่งปันระยะเวลาที่เอลฟ์ใช้เพื่อส่งของขวัญฉันไม่สามารถยืนยันหรือปฏิเสธว่าเวลาที่รวมอยู่ในการท้าทายนี้ถูกต้อง)

กฎระเบียบ

  • มีสองอินพุต - แผนที่และจำนวนเอลฟ์ อินพุตสามารถนำมาเป็นอาร์กิวเมนต์ให้กับฟังก์ชันหรือจากSTDINหรือเทียบเท่า หากการป้อนสองอินพุตเป็นไปไม่ได้ในภาษาของคุณคุณอาจยอมรับอินพุตทั้งสองเป็นสตริงอินพุตเดียวโดยคั่นด้วยอักขระบางตัวที่ไม่ปกติในอินพุต (ไม่ใช่หนึ่ง+*\nหรือ0-9- สตริงอินพุตไม่สามารถคลุมเครือ) ,เช่น
  • จำนวนเอลฟ์จะเป็นจำนวนเต็มแบบไม่ลบเสมอ (0 ใช้ได้)
  • เอาต์พุตสามารถเป็นค่าส่งคืนของฟังก์ชันหรือพิมพ์เป็นSTDOUTหรือเทียบเท่า หากเป็นไปไม่ได้ที่ซานต้าจะส่งของขวัญไปยังภูมิภาคที่กำหนดด้วยจำนวนเอลฟ์ที่กำหนดคุณต้องส่งออกจำนวนลบที่สอดคล้องกันหรือข้อความที่สอดคล้องกันโดยไม่มีตัวเลขใด ๆ อยู่ในนั้น
  • ทุกสิ่งที่พิมพ์ไปยังSTDERRจะถูกละเว้นดังนั้นคุณอาจไม่พิมพ์ผลลัพธ์หรือข้อความแสดงข้อผิดพลาดไปยังSTDERR
  • โปรแกรมของคุณต้องไม่ผิดพลาดเนื่องจากจำนวนแถนที่ไม่ถูกต้องในแต่ละภูมิภาค
  • การส่งออกควรเป็นจำนวนเวลาทั้งหมดเท่านั้นที่จะใช้เวลาในการส่งมอบของขวัญซานต้าด้วยจำนวนเอลฟ์ที่กำหนด
  • ผลลัพธ์ควรเป็นจำนวนเวลาน้อยที่สุดที่เอลฟ์ใช้ในการส่งของขวัญ
  • ข้อมูลที่ป้อนจะมีเพียงตัวเลข, +และ*, ขึ้นบรรทัดใหม่\n(เว้นแต่คุณจะระบุอักขระอื่นซึ่งข้อมูลนั้นจะรวมหากภาษาของคุณไม่สามารถรับสองอินพุตได้(ดูที่กฎข้อแรก) )
  • ช่องโหว่มาตรฐานใช้

กรณีทดสอบ

"1*1", 5 elves => 5
"1*1", 3 elves => 9
"1*2", 7 elves => 5
"1*2", 5 elves => 10
"1*2", 3 elves => 13
"2*1", 8 elves => 5
"2*1", 5 elves => 9
"2*1", 3 elves => 14
"1*" , 3 elves => 5
"1*" , 2 elves => (error message)
"*1" , 2 elves => 4
"*1" , 0 elves => (error message)
"*"  , 0 elves => 0

"1*1+1*1",   5 elves => 10
"1*1+1*1",   3 elves => 18
"1*1+*+1*1", 3 elves => 18
"1*2+2*1",   8 elves => 10
"1*2+2*1",   7 elves => 14
"1*2+2*1",   6 elves => 18
"1*2+2*1",   3 elves => 27
"1*2+2*1",   2 elves => (error message)
"*+*+*+*",   2 elves => 0
"*+*+*+*",   0 elves => 0

"1*3+2*+*5+*+4*7", 9 elves => 32

(หวังว่าฉันจะได้รับสิ่งที่ถูกต้องทั้งหมด)

เกณฑ์การให้คะแนน

ซานตาใช้เวลาทุกวันเดียวมักจะมองที่มากของสิ่ง - ทุกของขวัญเขาจะส่งมอบทั้งหมดของเอลฟ์ที่เขามีทุกบ้านที่เขาส่งมอบของขวัญให้กับ ... สำหรับซานตาคริสต์มาสที่ดีที่สุดในปัจจุบันจะมีความเป็นอยู่ สามารถเห็นบางสิ่งเล็กน้อย ด้วยเหตุนี้การส่งสั้นที่สุดในไบต์ชนะ

ลีดเดอร์บอร์ด

นี่คือตัวอย่างข้อมูลสแต็กที่สร้างทั้งกระดานผู้นำและภาพรวมของผู้ชนะตามภาษา

เพื่อให้แน่ใจว่าคำตอบของคุณปรากฏขึ้นโปรดเริ่มคำตอบด้วยบรรทัดแรกโดยใช้เทมเพลต Markdown ต่อไปนี้

## Language Name, N bytes

โดยที่ N คือขนาดไบต์ของการส่งของคุณ

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

## Language Name, <s>K</s> X + 2 = N bytes

แสดงตัวอย่างรหัส

code-golf  string 
— Jojodmo
แหล่งที่มา
ฉันคิดว่า288ควรอ่าน281 : (1+0+0+1+2+3+1+0+0+0+4+1+0+0+1+2+3+2+0+0)*5+(2+0+4+0+4+0+6+0+0+0+2+1+4+3+0+3+10+0+5+0)*4=21*5+44*4=105+176=281(แม้ว่าฉันต้องบอกว่าฉันยังไม่ได้อ่าน "เรียงความ" ทั้งหมด)
— Jonathan Allan
@JanathanAllan ใช่ฉันตั้งใจใช้เวลามากเกินไปในการเขียนความท้าทาย ... อุ๊ป ... ยังไงก็ตามสิ่งสำคัญที่ขาดหายไปก็คือเลื่อนของซานต้าต้องรอเอลฟ์ทุกคนก่อนที่จะกลับไป บ้านหลังถัดไปดังนั้นแม้ว่าการเพิ่มตัวเลขทั้งหมดและการคูณอาจทำงานได้ในบางกรณี แต่อาจไม่ได้ผลมากที่สุด ตัวอย่างเช่นเมื่อมี 9 เอลฟ์บ้าน4*7จะใช้เวลา 14 วินาที (ซึ่งครอบคลุมประมาณครึ่งทางใน "เรียงความ" ก่อนที่จะมีการนำแผนที่ 2D มาใช้) แต่ (4 * 5) + (7 * 4) = (48
— Jojodmo)
ค่า 288 นั้นมีไว้สำหรับตัวอย่างที่มี 3 เอลฟ์ดังนั้นพวกเขาจะต้องทำการทดลองอย่างเต็มรูปแบบnaughty*5+nice*4ที่บ้านแต่ละหลังใช่มั้ย (โปรดสังเกตว่าไม่มี4*7ในตัวอย่างนั้น)
— Jonathan Allan
พวกเอลฟ์นำถ่านหินออกไปให้พ้นก่อนเสมอ (อย่างเช่นในตัวอย่างของคุณ) หรือพวกมันจัดตารางเวลาอย่างมีประสิทธิภาพหรือไม่? ตัวอย่างเช่นหากแผนที่เป็น5*15และมี9เอลฟ์จะใช้เวลา (น้อยที่สุด) 20 วินาทีหรือ 22 วินาทีหรือไม่ ดูการแสดงที่เป็นข้อความเหล่านี้เพื่อดูภาพประกอบของตัวอย่างนั้น
— Jonathan Allan
แก้ไขข้างต้นควรอ่าน5*15 4*15
— Jonathan Allan

คำตอบ:

4

ทับทิม , 433 400 ไบต์

ทีนี้อันนี้ยากจริงๆเพราะมันทำให้การจัดตารางเอลฟ์เป็นเรื่องยาก

นอกจากนี้โปรดดีนี่คือการส่งครั้งแรกของฉันดังนั้นฉันอาจพลาดการปรับปรุงที่ชัดเจน:

->e,h{h.split(/\+|\n/).map{|h|n,g=h.split(?*).map(&:to_i)+[0,0];return-1if(g>0&&e<2)||(n>0&&e<3);([[3,5]]*n+[[2,4]]*g).permutation.map{|j|c=[0]*e;j.map{|q|w,y=q;k=l=0;r=c.map{|x|a=b=0;c[k..e].map{|r|r<=x ?a+=1:break};(t=k+=1).times{c[t-=1]<=x ?b+=1:break};[a,b]};d=r.inject([]){|v,x|v<<l if x[0]>=w;l+=1;v}.min{|a,b|c[a]<=>c[b]};b=d-r[d][1]+1;z=c[d]+y;(b..(b+w-1)).map{|x|c[x]=z}};c.max}.min||0}.sum}

ลองออนไลน์!

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

— elyalvarado
แหล่งที่มา
2
ยินดีต้อนรับสู่ PPCG! คุณเลือกความท้าทายที่ยากสำหรับคำตอบแรกของคุณ
— Jo King
2

Java (OpenJDK 8) , 344 ไบต์

การจัดตารางเอลฟ์นั้นยากกว่าที่ฉันคิดดังนั้นมันใช้เวลาสักครู่และค่อนข้างยาว

แม้จะเป็นเช่นนั้นนี่เป็นความท้าทายที่ฉันโปรดปรานในการเขียนโปรแกรมกอล์ฟ! 

(e,d)->{int r=0,x,y,c,p,b,g,m;for(String h:d[0].split("\\+")){d=h.split("\\*",-1);b=new Byte("0"+d[0]);g=new Byte("0"+d[1]);m=-1>>>1;for(y=1;y<=e/3&(x=(e-y*3)/2)>0;c=b/y+(b%y++<1?0:1),p=g/x+(g%x<1?0:1),x=c*5>p*4?c*5:p*4,m=x<m?x:m);for(y=0;b+g>0;b-=c,g-=p){c=e/3<b?e/3:b;x=(e-c*3)/2;p=x<g?x:g;if(c+p<1)return-1;y+=c>0?5:4;}r+=m<y?m:y;}return r;}

ลองออนไลน์ (พร้อมการทดสอบทั้งหมด)!

คำอธิบาย;

รั้งตัวเอง: มันยาวไปหน่อย

    int r=0,x,y,c,p,b,g,m;               // Define all the variables I need

    for(String h:d[0].split("\\+")){     // Split houses on '+' and loop through them

        d=h.split("\\*",-1);             // Split the current house on '*' using the limit
                                         // to preserve empty strings.

        b=new Byte("0"+d[0]);            // Parse the naughty (b) and nice (g) people
        g=new Byte("0"+d[1]);

        m=-1>>>1;                        // Initialise minimum time as max integer using
                                         // overflow

        for(y=1;y<=e/3&(x=(e-y*3)/2)>0;  // For each number of elves that can concurrently
                                         // deliver coal, and still leave enough elves to
                                         // deliver presents

            c=b/y+(b%y++<1?0:1),         // Determine the number of runs needed to deliver
                                         // all coal using this number of elves

            p=g/x+(g%x<1?0:1),           // Determine the number of runs needed to deliver
                                         // all presents using this number of elves

            x=c*5>p*4?c*5:p*4,           // Get the maximum time required for the
                                         // delivery of coal or presents

            m=x<m?x:m);                  // If this is less than the current minimum time,
                                         // set it as the minimum time


        for(y=0;b+g>0;b-=c,g-=p){        // While there are still people to deliver to;

            c=e/3<b?e/3:b;               // Determine the max amount of coal to deliver

            x=(e-c*3)/2;                 // Determine how many presents can be
                                         // delivered with the remaining elves.

            p=x<g?x:g;                   // If this number is more than nice people
                                         // remaining, just use the nice people remaining

            if(c+p<1)return-1;           // If no presents can be delivered, return the
                                         // error code (-1)

            y+=c>0?5:4;                  // Increase the time by 5 if coal was
                                         // delivered, and 4 if only presents

        }                                // At the end of each loop (see above)
                                         // remove the presents and coal delivered
                                         // from the number of naughty and nice houses

        r+=m<y?m:y;                      // Increment the total time by which ever
                                         // is smaller of the calculated times
    }
    return r;                            // Return the total time

หมายเหตุ: คำตอบนี้ขึ้นอยู่กับการแก้ไขของฉันในกรณีทดสอบที่ถูกต้อง

— ลุคสตีเวนส์
แหล่งที่มา
ฉันคิดว่า(e-y*3)/2-> e-y*3>>1บันทึกเป็นไบต์ (เป็นไปได้มากเช่น(e-c*3)/2กัน)
— Jonathan Frech
runTest("1*4",5,12);ล้มเหลว (คุณเข้าใจ"1*4", 5 elves => 13 FAILEDฉันประหลาดใจมากที่อัลกอริทึมของคุณดีมากในการกำหนดตารางเวลาในไม่กี่ไบต์ดังนั้นฉันจึงเรียกใช้ชุดค่าผสมที่เป็นไปได้ทั้งหมดตั้งแต่ 0 ถึง 7 (เอลฟ์ซนและดี) และพบเพียงไม่กี่ที่ ให้เวลาที่ดีที่สุดนี่คือชุดค่าผสมที่เล็กที่สุดหากมันล้มเหลว BTW ตรรกะที่น่าทึ่งในการกำหนดเวลาเป็นเวลานานในขณะที่ฉันไม่มีความคิดใด ๆ ว่าคุณทำได้อย่างไร
— elyalvarado
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.