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

โปรดระบุคำอธิบายสั้น ๆ ของfและgและเหตุผลว่าทำไมพวกเขาถึงมีคุณสมบัติที่ต้องการ

^{เครดิต:ความท้าทายนี้ได้รับแรงบันดาลใจจากปัญหาในการแข่งขันคณิตศาสตร์ระดับปริญญาโทสาขาคณิตศาสตร์โรมาเนียปี 2011 (ซึ่งถามในสิ่งเดียวกัน แต่ตามจำนวนจริงแทนที่จะเป็นจำนวนเต็ม) หากคุณต้องการสปอยเลอร์จริงๆตอนนี้คุณรู้ว่าจะค้นหาอะไร}

กฎระเบียบ

• คำว่า "ฟังก์ชั่น" ในการท้าทายนี้ควรนำมาใช้ในเชิงคณิตศาสตร์ในการทำแผนที่จำนวนเต็มหนึ่งไปยังอีกจำนวนหนึ่ง: คุณอาจเขียนโปรแกรมสองโปรแกรมหรือสองฟังก์ชั่นและใช้วิธีการมาตรฐานใด ๆ ในการรับอินพุต คุณอาจใช้การแทนค่าสตริงของจำนวนเต็มแทนที่จะเป็นตัวแปรจำนวนเต็มจริง แต่ประเภทของอินพุตและเอาต์พุตควรเหมือนกันดังนั้นฟังก์ชันสามารถประกอบได้โดยไม่ต้องแปลงประเภทด้วยตนเองในระหว่างนั้น โปรดจำไว้ว่าในทางแนวคิดแล้วfและgยังคงต้องมีฟังก์ชั่นใน can't ดังนั้นคุณจึงไม่สามารถโกงได้โดยใช้การแทนค่าสตริงสองแบบที่มีหมายเลขเดียวกันหรืออะไรทำนองนั้น

• โปรดจำไว้ว่าฟังก์ชั่นอาจไม่ได้ตั้งชื่อตราบเท่าที่ไม่จำเป็นต้องใช้ชื่อของตัวเองหรือฟังก์ชั่นอื่นที่คุณกำหนด หากคุณตั้งชื่อฟังก์ชั่นหนึ่งหรือทั้งสองอย่างคุณอาจสันนิษฐานว่ามันมีอยู่ในโปรแกรมเดียวกันเพื่อให้สามารถอ้างถึงฟังก์ชั่นอื่น ๆ (เช่นdef f(x): return -g(x)ใน Python)

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

• คุณอาจใช้ภาษาการเขียนโปรแกรมใด ๆแต่โปรดทราบว่าช่องโหว่เหล่านี้เป็นสิ่งต้องห้ามตามค่าเริ่มต้น

• นี่คือโค้ดกอล์ฟดังนั้นคะแนนของคุณคือผลรวมของจำนวนไบต์ของทั้งฟังก์ชันและคำตอบที่สั้นที่สุดที่ชนะ

Python 68 ตัวอักษร

f=lambda x:(1-x%2*2)*(2*x*x+(x<0))
g=lambda x:(1-x%2*2)*(2*x*x+(x>0))

f แมปตัวเลขเชิงลบกับตัวเลขคี่และตัวเลขบวกกับตัวเลขคู่และเลขคู่กับตัวเลขบวกและตัวเลขคี่กับจำนวนลบด้วยขนาดเอาต์พุตที่เพิ่มขึ้นอย่างเคร่งครัดกับขนาดอินพุต

g ทำเช่นเดียวกันยกเว้นจะแม็พตัวเลขเชิงลบกับตัวเลขคู่และตัวเลขบวกกับตัวเลขคี่

f ∘ g แผนที่ลบ→แม้→บวกและบวก→คี่→ลบ
แผนที่ g ∘ f เป็นลบ→แปลก→ลบและบวก→แม้→เป็นบวก

ดังนั้น f และ g มีคุณสมบัติที่ต้องการ

Pythonขนาด 40 ไบต์

f=lambda x:x*(-1)**x
g=lambda x:3*f(x)+1

ลองออนไลน์! เอาท์พุทบางอย่างเป็นจำนวนเต็มเท่ากันเพราะ(-1)**(-3)ให้ผลลอยตัวเช่น

ตามออกความคิดจากปีเตอร์เทย์เลอร์ ฟังก์ชั่นfคัดค้านตัวเลขคี่และออกแม้กระทั่งคนที่ไม่เปลี่ยนแปลง ฟังก์ชั่นgทำเช่นเดียวกันจากนั้นใช้แผนที่สลับความเท่าเทียมกันแบบโมโนโทx -> 3*x + 1นิก

เนื่องจากf(f(x)) = xเราg(f(x)) = 3*f(f(x))+1 = 3*x+1เพิ่มมากขึ้น

สำหรับf(g(x)) = f(3*f(x)+1)ความคิดคือว่าหนึ่งในfสัญญาณพลิกด้านในและด้านนอกทำให้มันลดลง

• แม้x, f(x) = xแต่f(3*x+1) = -3*x-1เพราะ3*x+1เป็นเลขคี่
• สำหรับคี่x, f(x) = -xและf(-3*x+1) = -3*x+1เพราะ-3*x+1แม้แต่

ตอนนี้เราต้องการแค่อินเทอร์รัปต์คู่และคี่ในวิธีที่ลดลงซึ่งเก็บไว้เพราะ-3*x±1ลดลงโดยไม่คำนึงถึงวิธีการเลือกสัญญาณ นี่คือเหตุผลที่3*จำเป็น

พอร์ต Haskell คือ 25 ไบต์:

f x=x*(-1)**x
g x=1+3*f x

ลองออนไลน์!

CJam (17 ไบต์)

ฟังก์ชั่น f (ตั้งชื่อFเพราะ CJam อนุญาตเฉพาะชื่อตัวพิมพ์ใหญ่เท่านั้น):

{W1$2b,#*}:F

ฟังก์ชั่น g (ไม่ระบุชื่อ):

{F2*}

การสาธิตออนไลน์

สิ่งนี้จะช่วยประหยัดไบต์โดยอาศัยรายละเอียดการใช้งานของ CJam ซึ่งเป็นจุดบกพร่องของเนื้อหา: เมื่อทำการแปลงฐานจะใช้ค่าสัมบูรณ์ 2b,ดังนั้นให้จำนวนบิตในค่าสัมบูรณ์ของการโต้แย้งดังนั้น f จึงคัดค้านตัวเลขเหล่านั้นอย่างแม่นยำซึ่งค่าสัมบูรณ์มีจำนวนบิตแปลก ๆ g ใช้ f แล้วจึงเพิ่มเป็นสองเท่า (เปลี่ยนพาริตีของจำนวนบิต)

ดังนั้นการใช้ฉแล้วใบกรัมลงชื่อไม่เปลี่ยนแปลงและคู่ผสมทำแผนที่ไปx 2xการใช้กรัมแล้วฉเปลี่ยนแปลงสัญญาณว่าครั้งเดียวและคู่ทำแผนที่ไปx-2x

Pyth, 34 ไบต์

นี่เป็นเพียงคำแปลโดยตรงของคำตอบของฉันหลาม

*-1*2%Q2+*2*QQ<Q0
*-1*2%Q2+*2*QQ>Q0