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

อะไรทั่วไป¹คุณเคล็ดลับสำหรับการเป็นตัวแทนมีตัวเลขยาวรัดกุมในรหัส?

กรุณาโพสต์หนึ่งเคล็ดลับต่อคำตอบ

¹ด้วยโดยทั่วไปผมหมายถึงเคล็ดลับที่สามารถนำไปใช้มากกว่าภาษาเดียว สำหรับเคล็ดลับเฉพาะภาษาให้โพสต์ในกระทู้ที่เกี่ยวข้อง

ระวังหมายเลขพิเศษ

บางภาษามีฟังก์ชั่นในตัวสำหรับกำลังสองการยกกำลังด้วยฐาน 2, n- th ไพรม์, แฟคทอเรียลหรือขั้นตอนอื่น ๆ ที่สามารถสร้างจำนวนมากได้ ตรวจสอบว่าคุณมีหมายเลขอยู่ในหมวดหมู่ใด ๆ หรือไม่

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

ใช้ตัวดำเนินการบูลีน bitwise

บางภาษามีระดับบิตและ AND, หรือ, แฮคเกอร์และบางครั้งก็ไม่

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

ตัวอย่างเช่น2147483722คือ 10 ไบต์ แต่2<<30^74(2 ^ 31 bitwise-XORed กับ 74) มีเพียง 8

ใช้สตริงเพื่อหมายเลขซ้ำ

สำหรับตัวเลขที่ซ้ำซ้อนมากในธรรมชาติคุณสามารถใช้ Strings และส่งไปยัง Integer ตัวอย่างเช่นใน JavaScript

+"1".repeat(100) // returns 100 1s (saves 84 bytes!)

ใช้สัญลักษณ์ทางวิทยาศาสตร์

สัญลักษณ์ทางวิทยาศาสตร์สามารถบันทึกไบต์ในกรณีของตัวเลขที่ยาว ตัวอย่างเช่น:

3564e-8 // returns 0.00003564 (saves 3 bytes!)

ค้นหาหมายเลขอื่นเพื่อใช้แทน

สิ่งนี้อาจฟังดูเหมือนไม่ใช่คำตอบ แต่ไม่ชัดเจนเสมอไปว่าจำนวนที่มากขึ้นสามารถคำนวณได้ด้วยรหัสที่สั้นกว่า ตัวอย่างที่ผมจำได้ว่าเป็นขาออกสำเนา googol ของสตริงที่คำตอบที่ชัดเจนต้องใช้การคำนวณ 10 100 ตามที่ปรากฎการคำนวณหลาย ๆ 10 ¹⁰⁰นำไปสู่การที่ถูกต้องเท่ากัน แต่ในบางภาษาคำตอบที่สั้นกว่า คำตอบที่เดนนิสมีใช้ 100 ¹⁰⁰ , การใช้งานของตัวเอง 250 255

การบีบอัดฐาน

รหัสการคลายการบีบอัดฐานอาจมีความซับซ้อนพอสมควร แต่ถ้าคุณมีจำนวนมหาศาลจริง ๆ บางครั้งมันสามารถช่วยบีบอัดในบางฐานที่สูงกว่า 10

นอกจากนี้ยังช่วยในบางภาษารหัสการบีบอัดฐานง่ายมาก ตัวอย่างเช่น PHP มีbase64_decode(_), Python มีint(_,36), JavaScript มีparseInt(_,36)และหลายภาษาที่เล่นกอล์ฟมีฐานการบีบอัดในตัว ตัวอย่างเช่นใน CJam:

"+ÜTbô±"256b

สิ่งนี้มี unprintable ลองออนไลน์!

อัตราผลตอบแทนนี้:

12345678987654321

ใช้เศษส่วนเลขชี้กำลังสำหรับจำนวนซ้ำจำนวนมาก

สมมติว่าคุณต้องการสร้างจำนวนที่ทำจาก 100 1 คุณสามารถใช้int("1"*100), +"1".repeat(100)ฯลฯ แต่คุณยังสามารถใช้ประโยชน์จากความจริงที่ว่ามันเป็นมากใกล้เคียงกับ

1e100/9

วิธีนี้ทำงานได้ดีที่สุดสำหรับตัวเลขซ้ำ ๆ เช่นตัวเลขที่ทำจากตัวเลขหลักเดียว ตัวเลขสองหลักซ้ำยังใช้งานได้ดี:

12e100/99  // Generates 121212121212... (100 digits)

ในบางครั้งคุณจะพบลวดลายแปลก ๆ บางอย่างซึ่งยังสามารถใช้แทนวิธีนี้ได้ค่อนข้างแน่น หากคุณต้องการint("123456790"*11)เช่น:

1e100/81

ระวังด้วย: ตัวเลขเช่นint("1234567890"*10)ไม่มีการแทนค่าแบบง่าย

ใช้ปุ่ม Shift ซ้ายซ้ายเพื่อยกกำลัง 2

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

แต่คุณสามารถบันทึกไบต์บางอย่างเมื่อคุณจำเป็นต้องเพิ่ม 2 ถึงอำนาจnโดยใช้ผู้ประกอบการกดปุ่ม Shift Bitwise ซ้ายเป็น<< 1<<nโปรดทราบว่าการทำเช่นนี้จะช่วยให้คุณประหยัดได้เพียงไบต์เท่านั้นหากnมากกว่าหรือเท่ากับ 17 อย่างไรก็ตามสิ่งนี้จะช่วยให้คุณประหยัดไบต์ได้เสมอหากnเป็นแบบไดนามิก ตัวอย่างน้อย:

1<<2 // returns 4 (3 bytes more :( )
1<<3 // returns 8 (3 bytes more :( )
1<<6 // returns 64 (2 bytes more :( )
1<<14 // returns 16384 (no bytes saved)
1<<17 // returns 131072 (saves 1 byte!)
1<<18 // returns 262114 (saves 1 byte!)

ทฤษฏีส่วนที่เหลือของจีน

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

เลือกจำนวนเต็มที่ค่อนข้างสำคัญจำนวนคู่ m _i > = 2 และคุณสามารถแสดงจำนวนมากจาก 0 ถึง lcm (m ₁ , m ₂ , ... , m _i ) -1

ตัวอย่างเช่นฉันเลือก 2, 3, 5, 11, 79, 83, 89, 97 จากนั้นฉันสามารถแสดงหมายเลขน้อยกว่า 18680171730 โดยไม่ซ้ำกัน 10000000000 (1e10) สามารถแสดงเป็น 0,1,0,1,38,59,50,49 (1e10 mod 2, 3 ... , 97) ซึ่งไม่จำเป็นต้องแสดงเป็นคลาส / โครงสร้าง Big Integer พิเศษซึ่งอาจประหยัด บางไบต์ในภาษาการเขียนโปรแกรมบางอย่าง

การเพิ่มและการลบสามารถทำได้โดยตรงโดยใช้การเป็นตัวแทนนี้ ตัวอย่าง:

(0,1,0,1,38,59,50,49)+(0,2,0,6,23,20,16,53) = 1e10 + 5000 
                                            = (0+0 mod 2, 1+2 mod 3, 0+0 mod 5, 1+6 mod 11, 38+23 mod 79, 59+20 mod 83, 50+16 mod 89, 49+53 mod 97)

ใช้การเสริมสาย (ที่เป็นไปได้)

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

ตัวอย่าง

วิธีสร้างหมายเลข1111111111111111111111112(25 ไบต์) ใน JavaScript (ES8):

+"2".padStart(25,1) // 19 bytes

ใช้เลขชี้กำลัง

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

ตัวอย่าง

จำนวนเต็มปลอดภัยสูงสุดใน JavaScriptเป็น9007199254740991ซึ่งเป็น 16 หลักยาว ใน ES7 สามารถคำนวณได้ด้วย 7 ไบต์ต่อไปนี้:

2**53-1

เทียบเท่าใน ES6 และก่อนหน้านี้ในขณะที่ความยาวเท่ากับจำนวนเต็มในตัวอย่างนี้แสดงให้เห็นว่าการใช้วิธีการ verbose มากขึ้นอาจไม่จำเป็นต้องเสียค่าใช้จ่ายใด ๆ ไบต์

Math.pow(2,53)-1

แม้ว่าข้างต้นอาจทำงานสั้นลงหากยกตัวอย่างเช่นคุณได้ใช้Mathนามแฝงเป็นอักขระตัวเดียวในรหัสของคุณ

ใช้เศษส่วนในสถานที่ของการลอย

ตัวอย่าง: 1./3แทนที่0.333333333