ข้อมูลการ์ดเล่น

ฉันมีข้อมูลจริงที่ฉันใช้สำหรับเกมไพ่จำลอง ฉันสนใจเฉพาะอันดับของการ์ดไม่ใช่ชุดสูท อย่างไรก็ตามมันเป็นสำรับไพ่มาตรฐาน$52$ใบดังนั้นจึงมีเพียง$4$ของแต่ละอันดับที่เป็นไปได้ในสำรับ สำรับถูกสับสำหรับแต่ละมือดีแล้วจากนั้นฉันเอาท์พุทเด็คทั้งหมดไปยังไฟล์ ดังนั้นจึงมีเพียง$13$สัญลักษณ์เป็นไปได้ในไฟล์ที่ส่งออกซึ่งเป็น$2,3,4,5,6,7,8,9,T,J,Q,K,A$( $T$= สิบอันดับ) แน่นอนว่าเราสามารถบิตแพ็คเหล่านี้โดยใช้$4$บิตต่อสัญลักษณ์ แต่แล้วเราก็สิ้นเปลืองการเข้ารหัส$3$จาก$16$เป็นไปได้ ที่เราสามารถทำได้ดีกว่าถ้าเรากลุ่ม$4$สัญลักษณ์ที่เวลาและจากนั้นบีบอัดพวกเขาเพราะ$13^4$ = $28,561$และที่สามารถใส่ค่อนข้าง "อบอุ่น" ใน$15$บิตแทน16$16$ข้อ จำกัด ทางทฤษฎีของ bitpacking คือ log ( $13$ ) / log ( $2$ ) = $3.70044$สำหรับข้อมูลที่มี$13$สัญลักษณ์สุ่มสำหรับแต่ละการ์ดที่เป็นไปได้ อย่างไรก็ตามเราไม่สามารถมี$52$ยกตัวอย่างเช่นกษัตริย์ในเด็คนี้ เราจะต้องมีเพียง$4$ของแต่ละตำแหน่งในแต่ละดาดฟ้าเพื่อการเข้ารหัสเอนโทรปีลดลงประมาณครึ่งหนึ่งบิตต่อสัญลักษณ์ประมาณ3.2$3.2$

ตกลงดังนั้นนี่คือสิ่งที่ฉันคิด ข้อมูลนี้ไม่ได้สุ่มทั้งหมด เรารู้ว่ามี$4$ของแต่ละอันดับดังนั้นในแต่ละบล็อกของ$52$ใบ (เรียกว่าสำรับสับไพ่) ดังนั้นเราจึงสามารถตั้งสมมติฐานและเพิ่มประสิทธิภาพได้หลายอย่าง หนึ่งในนั้นคือเราไม่ต้องเข้ารหัสการ์ดใบสุดท้ายเพราะเราจะรู้ว่ามันควรจะเป็นอะไร การออมอีกอย่างก็คือถ้าเราจบอันดับหนึ่ง ตัวอย่างเช่นหากไพ่$3$ใบสุดท้ายในเด็คเป็น$777$เราจะไม่ต้องเข้ารหัสเหล่านั้นเพราะตัวถอดรหัสจะนับไพ่จนถึงจุดนั้นและดูว่าตำแหน่งอื่นทั้งหมดได้รับการเติมและจะถือว่า$3$ " การ์ด "ที่หายไปทั้งหมด$7$วินาที

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

เมื่อฉันใช้โปรแกรมประเภท ZIP (ตัวอย่างเช่น WinZip) ฉันเห็นเฉพาะการบีบอัดซึ่งบอกฉันว่ามันกำลังทำ bitpack "สันหลังยาว" ถึงบิต ถ้าฉัน "บีบอัดข้อมูลล่วงหน้า" โดยใช้การบรรจุบิตข้อมูลของฉันเองดูเหมือนว่าจะดีกว่าเพราะเมื่อฉันเรียกใช้โปรแกรม zip แล้วฉันจะได้รับการบีบอัดมากกว่าเล็กน้อย สิ่งที่ฉันคิดคือทำไมไม่บีบตัวเองทั้งหมด (เพราะฉันมีความรู้มากกว่าข้อมูลที่โปรแกรม Zip ทำ) ฉันสงสัยว่าฉันสามารถเอาชนะ "จำกัด " ของบันทึก ( ) / บันทึก ( ) =4 2 : 1 13 2 $2:1$$4$$2:1$$13$$2$$3.70044$. ฉันสงสัยว่าฉันสามารถใช้กลอุบาย "ไม่กี่" ที่ฉันพูดถึงและอีกไม่กี่อย่างที่ฉันสามารถหาได้ ไฟล์ที่ส่งออกของหลักสูตรไม่จำเป็นต้องเป็น "มนุษย์สามารถอ่านได้" ตราบใดที่การเข้ารหัสไม่สูญเสียมันก็จะถูกต้อง

นี่คือลิงค์ไปยังดาดฟ้าสับแบบคนอ่านได้ล้านเส้น(ต่อบรรทัด) ทุกคนสามารถ "ฝึกหัด" บนชุดย่อยเล็ก ๆ ของบรรทัดเหล่านี้และปล่อยให้มันฉีกไฟล์ทั้งหมด ฉันจะอัปเดตขนาดไฟล์ (เล็กที่สุด) ให้ดีที่สุดตามข้อมูลนี้$3$$1$

https://drive.google.com/file/d/0BweDAVsuCEM1amhsNmFITnEwd2s/view

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

/math/1882705/probability-2-player-card-game-with-multiple-patterns-to-win-who-has-the-advant

ฉันมีอัลกอริทึมที่ดีซึ่งแสดงบิตเพื่อเข้ารหัสเด็คแรกในข้อมูลตัวอย่างของฉัน ข้อมูลนี้สร้างขึ้นแบบสุ่มโดยใช้อัลกอริทึมสลับแบบ Fisher-Yates มันเป็นข้อมูลสุ่มจริงดังนั้นอัลกอริทึมที่เพิ่งสร้างใหม่ของฉันดูเหมือนจะทำงานได้ดีมากซึ่งทำให้ฉันมีความสุข$168$

เกี่ยวกับการบีบอัด "ความท้าทาย" ตอนนี้ฉันอยู่ที่ประมาณ 160 บิตต่อเด็ค ฉันคิดว่าฉันสามารถลงไปได้ถึง 158 ใช่ฉันลองแล้วได้ 158.43 บิตต่อเด็ค ฉันคิดว่าฉันเข้าใกล้ขีด จำกัด ของอัลกอริทึมของฉันดังนั้นฉันจึงประสบความสำเร็จในการลดลงต่ำกว่า 166 บิตต่อเด็ค แต่ฉันไม่สามารถรับ 156 บิตซึ่งจะเป็น 3 บิตต่อการ์ด แต่มันก็สนุกดี บางทีในอนาคตฉันจะนึกถึงบางสิ่งบางอย่างที่จะลดแต่ละสำรับโดยเฉลี่ย 2.43 บิตหรือมากกว่า

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

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

ฉันโชคไม่ดีที่ไม่รู้ว่าคณิตศาสตร์นี้จะช่วยคุณบีบอัดเท่าไหร่ แต่คิดว่าความคิดนี้อาจเป็นประโยชน์ในการพิจารณา

นี่คืออัลกอริธึมที่สมบูรณ์ซึ่งถึงขีด จำกัด ทางทฤษฎี

อารัมภบท: การเข้ารหัสลำดับเลขจำนวนเต็ม

13 จำนวนเต็มลำดับ "จำนวนเต็มมีขีด จำกัด บน- 1จำนวนเต็มมีขีด จำกัด บนข- 1 'จำนวนเต็มมีขีด จำกัด บนค- 1จำนวนเต็มมีขีด จำกัด บนd - 1 , ... จำนวนเต็มมีขีด จำกัด บนม. - 1 ' สามารถเข้ารหัสด้วยประสิทธิภาพที่สมบูรณ์แบบได้ตลอดเวลา$a-1$$b-1$$c-1$$d-1$$m-1$

1. ใช้จำนวนเต็มแรกคูณด้วย , เพิ่มวินาที, คูณผลลัพธ์ด้วยc , เพิ่มที่สาม, คูณผลลัพธ์ด้วยd , …คูณผลลัพธ์ด้วยm , เพิ่มสิบสาม - และที่จะสร้างตัวเลขเฉพาะระหว่าง0และขคงจฉชซฌญk ลิตรเมตร- 1$b$$c$$d$$m$$0$$abcdefghijklm-1$
2. เขียนตัวเลขนั้นเป็นเลขฐานสอง

การย้อนกลับทำได้ง่ายเช่นกัน หารด้วยและส่วนที่เหลือคือจำนวนเต็มสิบสาม หารผลลัพธ์ด้วยlและส่วนที่เหลือคือจำนวนเต็มสิบสอง ดำเนินการต่อไปจนกว่าคุณจะหารด้วยb : ส่วนที่เหลือเป็นจำนวนเต็มที่สองและความฉลาดทางเป็นจำนวนเต็มแรก$m$$l$$b$

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

นี่คือวิธีที่จะทำ

ความสอดคล้องระหว่างการสับเปลี่ยนและลำดับเลขจำนวนเต็ม

เริ่มต้นด้วยลำดับไพ่ 0 ใบบนโต๊ะข้างหน้าคุณ

ขั้นตอนที่ 1

ใช้เวลาสี่วินาทีในแพ็คของคุณและวางไว้บนโต๊ะ

คุณมีทางเลือกอะไรบ้าง? การ์ดหรือการ์ดอาจวางไว้ที่จุดเริ่มต้นของลำดับที่มีอยู่แล้วบนโต๊ะหรือหลังจากการ์ดใด ๆ ในลำดับนั้น ในกรณีนี้หมายความว่ามีเป็นไปได้สำหรับใส่ไพ่$1+0=1$

จำนวนรวมของวิธีการของการวางไพ่ 4 ใบใน 1 ตำแหน่งคือ1เข้ารหัสแต่ละวิธีเหล่านั้นเป็นตัวเลขระหว่าง0และ1 - 1 มี 1 หมายเลขดังกล่าว$1$$0$$1-1$

ฉันได้ 1 โดยพิจารณาวิธีการเขียน 0 เป็นผลรวมของจำนวนเต็ม 5 ตัว: มันคือ.$\frac{4\times 3\times 2 \times 1}{4!}$

ขั้นตอนที่ 2

ใช้สี่ 3s ในแพ็คของคุณและวางไว้บนโต๊ะ

คุณมีทางเลือกอะไรบ้าง? การ์ดหรือการ์ดอาจวางไว้ที่จุดเริ่มต้นของลำดับที่มีอยู่แล้วบนโต๊ะหรือหลังจากการ์ดใด ๆ ในลำดับนั้น ในกรณีนี้หมายความว่ามีเป็นไปได้สำหรับใส่ไพ่$1+4=5$

จำนวนรวมของวิธีการของการวางไพ่ 4 ใบใน 5 สถานคือ70เข้ารหัสแต่ละวิธีเหล่านั้นเป็นตัวเลขระหว่าง0และ70 - 1 มี 70 หมายเลขดังกล่าว$70$$0$$70-1$

ฉันได้ 70 โดยพิจารณาวิธีการเขียน 4 เป็นผลรวมของจำนวนเต็ม 5: .$\frac{8\times 7\times 6 \times 5}{4!}$

ขั้นตอนที่ 3

นำสี่ 4s ในชุดของคุณแล้ววางลงบนโต๊ะ

คุณมีทางเลือกอะไรบ้าง? การ์ดหรือการ์ดอาจวางไว้ที่จุดเริ่มต้นของลำดับที่มีอยู่แล้วบนโต๊ะหรือหลังจากการ์ดใด ๆ ในลำดับนั้น ในกรณีนี้หมายความว่ามีเป็นไปได้สำหรับใส่ไพ่$1+8=9$

จำนวนรวมของวิธีการของการวางไพ่ 4 ใบใน 9 ตำแหน่งคือ495เข้ารหัสแต่ละวิธีเหล่านั้นเป็นตัวเลขระหว่าง0และ495 - 1 มี 495 ตัวเลขดังกล่าว$495$$0$$495-1$

ฉันได้ 495 โดยพิจารณาวิธีการเขียน 8 เป็นผลรวมของจำนวนเต็ม 5 ตัว: มันคือ.$\frac{12\times 11\times 10 \times 9}{4!}$

เป็นต้นจนกระทั่ง ...

ขั้นตอนที่ 13

นำเอซทั้งสี่มาใส่ในแพ็คของคุณแล้ววางลงบนโต๊ะ

คุณมีทางเลือกอะไรบ้าง? การ์ดหรือการ์ดอาจวางไว้ที่จุดเริ่มต้นของลำดับที่มีอยู่แล้วบนโต๊ะหรือหลังจากการ์ดใด ๆ ในลำดับนั้น ในกรณีนี้หมายความว่ามีเป็นไปได้สำหรับใส่ไพ่$1+48=49$

จำนวนรวมของวิธีการของการวางไพ่ 4 ใบใน 49 ตำแหน่งคือ270725เข้ารหัสแต่ละวิธีเหล่านั้นเป็นตัวเลขระหว่าง0และ270725 - 1 มีตัวเลขดังกล่าว 270725$270725$$0$$270725-1$

ฉันได้ 270,725 โดยพิจารณาวิธีการเขียน 48 เป็นผลรวมของจำนวนเต็ม 5: .$\frac{52\times 51\times 50 \times 49}{4!}$

ขั้นตอนนี้ให้ผล 1-to-1 การติดต่อระหว่าง (a) การสับไพ่ที่คุณไม่สนใจเกี่ยวกับชุดสูทและ (b) ลำดับของจำนวนเต็มโดยที่ค่าแรกอยู่ระหว่างถึง1 - 1ส่วนที่สองอยู่ระหว่าง0และ70 - 1สามอยู่ระหว่าง0และ495 - 1 , และอื่น ๆ จนสิบสามซึ่งอยู่ระหว่าง0และ270725 - 1$0$$1-1$$0$$70-1$$0$$495-1$$0$$270725-1$

หมายถึง "การเข้ารหัสลำดับจำนวนเต็ม" คุณสามารถเห็นว่าลำดับดังกล่าวของจำนวนเต็มอยู่ใน 1-1 ติดต่อกับตัวเลขระหว่างและ( 1 × 70 × 495 × ... × 270725 ) - 1 หากคุณดูที่ "ผลคูณหารด้วยแฟคทอเรียล" ของแต่ละจำนวนเต็ม ( ดังที่อธิบายไว้ในตัวเอนในตอนท้ายของแต่ละขั้นตอน ) คุณจะเห็นว่านี่หมายถึงตัวเลขระหว่าง0ถึง52 $0$$(1\times 70\times 495\times … \times 270725)-1$$0$ซึ่งคำตอบของฉันก่อนหน้าแสดงให้เห็นว่าเป็นคนที่ดีที่สุด

ดังนั้นเราจึงมีวิธีที่สมบูรณ์แบบสำหรับการบีบอัดไพ่แบบสับของคุณ

อัลกอริทึม

คำนวณรายการของวิธีการเขียน 0 เป็นผลรวมของจำนวนเต็ม 5 ตัวจากการเขียน 4 เป็นผลรวมของจำนวนเต็ม 5 จำนวนจากการเขียน 8 เป็นผลรวมของจำนวนเต็ม 5 จำนวน ... เขียน 48 เป็นผลรวมของจำนวนเต็ม 5 รายการที่ยาวที่สุดมีองค์ประกอบ 270725 จึงไม่ใหญ่โดยเฉพาะ (การคำนวณล่วงหน้าไม่จำเป็นอย่างยิ่งเพราะคุณสามารถสังเคราะห์แต่ละรายการได้อย่างง่ายดายตามที่คุณต้องการ: ลองใช้ Microsoft QuickBasic แม้จะผ่านรายการองค์ประกอบ 270725 ก็เร็วกว่าที่ตาเห็น)

ในการรับจากการสับเป็นลำดับของจำนวนเต็ม:

The 2s ไม่ได้มีส่วนอะไรเลยดังนั้นเราจะไม่สนใจมัน เขียนตัวเลขระหว่าง 0 ถึง 1-1

The 3s: 2s มีกี่ก่อนหน้า 3 แรก? กี่ครั้งก่อนวินาที? ที่สาม? ที่ 4 หลังจากวันที่ 4 คำตอบคือ 5 จำนวนเต็มซึ่งเพิ่มขึ้นอย่างชัดเจนถึง 4 ดังนั้นค้นหาลำดับของ 5 จำนวนเต็มในรายการ "เขียน 4 เป็นผลรวมของ 5 จำนวนเต็ม" และบันทึกตำแหน่งในรายการนั้น นั่นจะเป็นตัวเลขระหว่าง 0 ถึง 70-1 เขียนมันลง.

4s:มี 2 ​​หรือ 3 กี่ก่อนหน้า 4 แรก? กี่ครั้งก่อนวินาที? ที่สาม? ที่ 4 หลังจากวันที่ 4 คำตอบคือ 5 จำนวนเต็มซึ่งเพิ่มขึ้นอย่างชัดเจนถึง 8 ดังนั้นค้นหาลำดับของ 5 จำนวนเต็มในรายการ "เขียน 8 เป็นผลรวมของ 5 จำนวนเต็ม" และบันทึกตำแหน่งในรายการนั้น นั่นจะเป็นตัวเลขระหว่าง 0 ถึง 495-1 เขียนมันลง.

เป็นต้นจนกระทั่ง ...

เอซ:มีการ์ดที่ไม่ใช่เอซกี่ใบก่อนเอซตัวแรก? กี่ครั้งก่อนวินาที? ที่สาม? ที่ 4 หลังจากวันที่ 4 คำตอบคือ 5 จำนวนเต็มซึ่งเพิ่มขึ้นอย่างชัดเจนถึง 48 ดังนั้นค้นหาลำดับของ 5 จำนวนเต็มในรายการ "เขียน 48 เป็นผลรวมของ 5 จำนวนเต็ม" และบันทึกตำแหน่งในรายการนั้น นั่นจะเป็นตัวเลขระหว่าง 0 ถึง 270725-1 เขียนมันลง.

ตอนนี้คุณได้เขียนจำนวนเต็ม 13 ตัว เข้ารหัสพวกเขา (ตามที่อธิบายไว้ก่อนหน้า) เป็นหมายเลขเดียวระหว่างถึง52 $0$ . เขียนตัวเลขนั้นเป็นเลขฐานสอง จะใช้เวลาน้อยกว่า 166 บิต$\frac{52!}{(4!)^{13}}$

นี่คือการบีบอัดที่ดีที่สุดที่เป็นไปได้เพราะถึงขีด จำกัด ข้อมูล - ทฤษฎี

การบีบอัดทำได้ง่าย: จากจำนวนมากไปสู่ลำดับของจำนวนเต็ม 13 ตัวจากนั้นใช้พวกมันเพื่อสร้างลำดับของไพ่ตามที่อธิบายไว้แล้ว

แทนที่จะพยายามเข้ารหัสแต่ละการ์ดแยกกันเป็น 3 หรือ 4 บิตฉันขอแนะนำให้คุณเข้ารหัสสถานะของสำรับทั้งหมดเป็น 166 บิต ดังที่ Martin Kochanski อธิบายว่ามีการจัดเรียงไพ่น้อยกว่าชุดโดยไม่สนใจดังนั้นนั่นหมายความว่าสถานะของสำรับทั้งหมดสามารถเก็บไว้ใน 166 บิต$2^{166}$

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

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

หากต้องการขยายขนาดให้ใช้การค้นหาแบบไบนารี ได้รับหมายเลขคุณต้องการค้นหาดาดฟ้าลำดับที่nในการเรียงลำดับพจนานุกรมของทุกชั้น คุณสามารถทำได้โดยใช้ขั้นตอนตามสายของการค้นหาไบนารี: เลือกดาดฟ้าD 0 , นับจำนวนของชั้นก่อนD 0และเปรียบเทียบกับn นั่นจะบอกคุณว่าจะปรับD $n$$n$$D_0$$D_0$$n$$D_0$ที่จะมาก่อนหรือหลัง ฉันขอแนะนำให้คุณลองซ้ำ ๆ เพื่อให้ได้สัญลักษณ์ที่ถูกต้อง: ถ้าคุณต้องการกู้คืนสตริงเช่น 22223333444455556666777788889999TTTTTJJJJJQQQQQKKKAAAAAA, อันดับแรกลองค้นหาสิ่งที่จะใช้เป็นสัญลักษณ์แรกในสตริง ) จากนั้นเมื่อคุณพบมูลค่าที่เหมาะสมสำหรับสัญลักษณ์แรกแล้วให้ค้นหาเพื่อค้นหาสัญลักษณ์ที่สองและอื่น ๆ

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

จำนวนการจัดการที่เป็นไปได้ของการ์ดโดยไม่สนใจชุดคือที่มี 2 ฐานลอการิทึมคือ 165.976 หรือ 3.1919 บิตต่อบัตรซึ่งจะดีกว่าขีด จำกัด ที่คุณให้

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

วิธีที่ดีที่สุดในการบีบอัดข้อมูลคือการหาข้อมูลอื่น ๆ 59 บิตที่คุณต้องการบรรจุด้วยข้อมูลบัตรของคุณต่อไป (จริง ๆ แล้ว 59.6 บิต) และเขียน 59 บิตเหล่านั้นเป็นโมดูโลตัวเลข 13 หลัก 13 (= ) กำหนดสูทให้กับไพ่แต่ละใบ (หนึ่งหลักเลือกระหว่าง4 !วิธีในการกำหนดชุดสูทให้กับเอซอีกชุดหนึ่งทำเช่นเดียวกันสำหรับกษัตริย์และอื่น ๆ ) จากนั้นคุณมีไพ่ 52 ใบที่แตกต่างกันทั้งหมด 52 ! ความเป็นไปได้สามารถเข้ารหัสใน 225.58 บิตได้อย่างง่ายดายอย่างแน่นอน$4!$$4!$$52!$

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

นี่เป็นปัญหาที่แก้ไขได้นาน

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

https://en.wikipedia.org/wiki/Arithmetic_coding

ทั้ง DW และ Martin Kochanski ได้อธิบายอัลกอริธึมสำหรับการสร้าง bijection ระหว่างดีลและจำนวนเต็มในช่วงแต่ดูเหมือนว่าพวกเขาไม่ได้ลดปัญหาลงในรูปแบบที่ง่ายที่สุด (หมายเหตุ 1)$[0, {52!\over(4!)^{13}})$

สมมติว่าเรามี (บางส่วน) ดาดฟ้าอธิบายโดยรายการสั่งซื้อที่ฉันคือจำนวนของบัตรประเภทฉัน ใน OP นั้นเด็คเริ่มต้นถูกอธิบายโดยรายการของ 13 อิลิเมนต์แต่ละตัวมีค่า 4 จำนวนของการสับที่แตกต่างกันของเด็คนั้น$a$$a_i$$i$

ซึ่งเป็นลักษณะทั่วไปของสัมประสิทธิ์ทวินามและสามารถพิสูจน์ได้โดยการจัดเรียงวัตถุเพียงชนิดเดียวในเวลาเดียวตามที่ Martin Kochanski แนะนำ (ดูด้านล่างหมายเหตุ 2)

ตอนนี้สำหรับเช่นดาดฟ้าใด ๆ (บางส่วน) เราสามารถเลือกสับเปลี่ยนบัตรเดียวที่เวลาใช้ใด ๆที่ฉัน > 0 จำนวนของการโยนเฉพาะที่ขึ้นต้นด้วยiคือ$i$$a_i>0$$i$

และจากสูตรข้างต้นเรามี

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

ฉันเขียนสิ่งนี้ใน Python เพื่อแสดงขั้นตอนวิธี Python เป็น pseudocode ที่สมเหตุสมผล โปรดทราบว่าส่วนใหญ่ของเลขคณิตเกี่ยวข้องกับความแม่นยำขยาย; ค่า (แสดงลำดับของการสุ่ม) และn (จำนวนสับทั้งหมดที่เป็นไปได้สำหรับสำรับบางส่วนที่เหลืออยู่) เป็น bignums 166 บิต ในการแปลรหัสเป็นภาษาอื่นจำเป็นต้องใช้ไลบรารี bignum บางประเภท$k$$n$

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

ในการเข้ารหัสการสลับเราเดินผ่านการสับเปลี่ยนโดยการสะสมจำนวนการสับที่เริ่มต้นด้วยการ์ดขนาดเล็กโดยใช้สูตรข้างต้นแต่ละจุด:

from math import factorial
T = factorial(52) // factorial(4) ** 13

def encode(vec):
    a = [4] * 13
    cards = sum(a)
    n = T
    k = 0
    for idx in vec:
        k += sum(a[:idx]) * n // cards
        n = a[idx] * n // cards
        a[idx] -= 1
        cards -= 1
    return k

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

def decode(k):
    vec = []
    a = [4] * 13
    cards = sum(a)
    n = T
    while cards > 0:
        i = cards * k // n
        accum = 0
        for idx in range(len(a)):
            if i < accum + a[idx]:
                k -= accum * n // cards
                n = a[idx] * n // cards
                a[idx] -= 1
                vec.append(idx)
                break
            accum += a[idx]
        cards -= 1
    return vec

ฉันไม่ได้พยายามเพิ่มประสิทธิภาพของโค้ดด้านบน ฉันรันไฟล์กับไฟล์ 3mil.TXT ทั้งหมดตรวจสอบว่าencode(decode(line))มีการเข้ารหัสดั้งเดิม ใช้เวลาน้อยกว่า 300 วินาที (สามารถเห็นเจ็ดบรรทัดในการทดสอบออนไลน์บนideone ) การเขียนซ้ำในภาษาระดับต่ำกว่าและการเพิ่มประสิทธิภาพการแบ่ง (ซึ่งเป็นไปได้) อาจลดเวลาในการจัดการบางอย่าง

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

อย่างไรก็ตามเป็นเรื่องที่น่าสังเกตว่าในแอปพลิเคชั่นที่ใช้งานได้จริงมันไม่จำเป็นที่จะต้องเข้ารหัสการสับเปลี่ยน การสุ่มแบบสุ่มสามารถสร้างได้โดยการสร้างหมายเลข 166 บิตแบบสุ่มและถอดรหัส และไม่จำเป็นจริงๆที่ 166 บิตทั้งหมดจะถูกสุ่ม มันจะเป็นไปได้เช่นเริ่มต้นด้วยจำนวนเต็มแบบสุ่ม 32 บิตแล้วกรอก 166 บิตโดยใช้ RNG มาตรฐานใด ๆ ที่ seeded ด้วยหมายเลข 32 บิต ดังนั้นหากเป้าหมายคือเพียงเพื่อให้สามารถเก็บสุ่มสับจำนวนมากได้คุณสามารถลดความต้องการพื้นที่จัดเก็บต่อดีลได้มากหรือน้อยตามอำเภอใจ

หากคุณต้องการการเข้ารหัสจำนวนมากข้อเสนอที่เกิดขึ้นจริง (สร้างขึ้นในแฟชั่นอื่น ๆ บางคน) แต่ไม่สนใจเกี่ยวกับคำสั่งของข้อเสนอที่คุณสามารถเดลต้าเข้ารหัสรายการที่เรียงลำดับของตัวเลขประหยัดประมาณเข้าสู่ระบบ2 Nบิตสำหรับแต่ละ จำนวน. (การออมเป็นผลมาจากความจริงที่ว่าลำดับที่เรียงไว้มีค่าเอนโทรปีน้อยกว่าลำดับที่ไม่เรียงลำดับและจะไม่ลดค่าเอนโทรปีของค่าเดียวในลำดับนั้น)$N$$\log_2 N$

สมมติว่าเราจำเป็นต้องเข้ารหัสรายการที่เรียงลำดับของตัวเลขk -bit เราสามารถดำเนินการดังนี้:$N$ $k$

1. เลือกเป็นจำนวนเต็มใกล้กับบันทึก2 N (ไม่ว่าพื้นหรือเพดานจะใช้งานได้ฉันมักจะไปหาเพดาน)$p$$\log_2 N$

2. เราปริยายแบ่งช่วงของตัวเลขลงในช่วงเวลาโดยคำนำหน้าไบนารี แต่ละkจำนวนบิตแบ่งออกเป็นพีบิตคำนำหน้าและk - พีบิตต่อท้าย; เราเขียนเฉพาะคำต่อท้าย (ตามลำดับ) ต้องใช้บิตN ∗ ( k - p $2^p$$k$$p$$k-p$$N*(k-p)$

3. นอกจากนี้เรายังสร้างบิตลำดับ: สำหรับแต่ละคำนำหน้า (ยกเว้นคำนำหน้า0 ) เราเขียนออกมาเป็น0สำหรับแต่ละหมายเลขที่มีคำนำหน้าว่า (ถ้ามี) ตามมาด้วย1 เห็นได้ชัดว่าลำดับนี้มี2 p + Nบิต: 2 p 1 s และN 0 s$2^p$$0$$0$$1$$2^p+N$$2^p$ $1$$N$ $0$

ในการถอดรหัสตัวเลขเราจะเริ่มตัวนับคำนำหน้าที่ 0 และดำเนินการตามลำดับบิต เมื่อเราเห็นเราจะแสดงคำนำหน้าปัจจุบันและคำต่อท้ายถัดไปจากรายการคำต่อท้าย เมื่อเราเห็น 1เราจะเพิ่มส่วนนำหน้าปัจจุบัน$0$$1$

ความยาวรวมของการเข้ารหัสคือซึ่งอยู่ใกล้กับN ∗ ( k - p ) + N + NหรือN ∗ ( k - p + 2 )โดยเฉลี่ย ของk - p + 2บิตต่อมูลค่า$N*(k-p) + N + 2^p$$N*(k-p) + N + N$$N*(k-p+2)$$k-p+2$

หมายเหตุ

1. คือ92024242230271040357108320801872044844750000000000และล็อก252$52!\over(4!)^{13}$$92024242230271040357108320801872044844750000000000$จะอยู่ที่ประมาณ165.9765 ในข้อความฉันทำท่าเป็นครั้งคราวว่าลอการิทึมฐาน 2 เป็น166จริง ๆ; ในกรณีของการสร้าง ordinals สุ่มภายในช่วงอัลกอริทึมการปฏิเสธสามารถใช้ซึ่งจะไม่ค่อยปฏิเสธหมายเลขสุ่มที่สร้างขึ้น$\log_2 {52!\over(4!)^{13}}$$165.9765$$166$
2. เพื่อความสะดวกฉันเขียนสำหรับn ∑ i = k a i ; แล้ว1วัตถุประเภท1สามารถอยู่ใน( S $S_k$$\sum\limits_{i=k}^n a_i$$a_1$$1$วิธีและจากนั้นวัตถุประเภท2สามารถวางใน(S$S_1 \choose a_1$$2$วิธีการและอื่น ๆ ตั้งแต่ ( S$S_2 \choose a_2$ซึ่งนำไปสู่การนับทั้งหมด${S_i \choose a_i}={S_i! \over a_i!(S_i - a_i)!}={S_i!\over {a_i!S_{i+1}!}}$

ซึ่งลดความซับซ้อนของสูตรด้านบน

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

ภาพรวมของอัลกอริทึมของฉันคือมันใช้การรวมกันของกลุ่มของการ์ดและการเข้ารหัสเศษส่วนแบบเศษส่วน ยกตัวอย่างเช่นในการทดสอบของฉันไฟล์ร่วมกันของล้านชั้นสับคนแรกที่มีคนแรกที่7ไพ่54 236 J เหตุผลที่ฉันเลือกขนาดบล็อกการ์ด7ใบเมื่อมี13การ์ดที่เป็นไปได้คือเพราะ13 7 "รองเท้า" (พอดีอย่างอบอุ่น) เป็น26บิต (ตั้งแต่13 7 = 62 , 748 , 517และ2 26 = 67 , 108 $3$$7$$54A236J$$7$$13$$13^7$$26$$13^7$$62,748,517$$2^{26}$ ) โดยหลักการแล้วเราต้องการให้ตัวเลขทั้งสองนั้นใกล้เคียงที่สุดเท่าที่จะเป็นไปได้ (แต่ด้วยพลังของตัวเลข 2 สูงกว่าเล็กน้อย) ดังนั้นเราจึงไม่ต้องเสียเศษน้อยไปกว่าเศษบิตเล็กน้อยในกระบวนการบรรจุบิต หมายเหตุ: ฉันจะได้รับการแต่งตั้งยัง groupsize 4เมื่อการเข้ารหัส 13ตำแหน่งตั้งแต่ 13 4 = 28 , 561และ 2 15 = 32 , 768 มันไม่ได้เป็นแบบที่แน่นตั้งแต่ 15 / 4 = 3.75แต่ 26 / 7 = $67,108,864$$2$$4$$13$$13^4$$28,561$$2^{15}$$32,768$$15/4 = 3.75$$26/7 = 3.714$. ดังนั้นจำนวนบิตต่อบัตรเป็นลดลงเล็กน้อยต่อบัตรถ้าเราใช้วิธีการบรรจุ$26/7$

ดูที่เราแค่ค้นหาตำแหน่งอันดับของตำแหน่งเหล่านั้นในรายการหลักของเรา " 23456789 T J Q K A " ของอันดับที่เรียงลำดับ ยกตัวอย่างเช่นอันดับบัตรแรกที่เกิดขึ้นจริงของ5มีตำแหน่งการค้นหาในสตริงอันดับการค้นหาของ4 เราปฏิบัติต่อตำแหน่ง7อันดับเหล่านี้เป็นฐาน13หมายเลขเริ่มต้นด้วย 0 (ดังนั้นตำแหน่ง 4 ที่เราได้รับก่อนหน้านี้จะเป็น 3) แปลงกลับไปที่ฐาน10 (สำหรับการตรวจสอบวัตถุประสงค์) เราได้รับ15 , 565 , 975 ใน$54A236J$$23456789TJQKA$$5$$4$$7$$13$$10$$15,565,975$$26$บิตไบนารีที่เราได้รับ00111011011000010010010111$00111011011000010010010111$

ตัวถอดรหัสทำงานในลักษณะที่คล้ายกันมาก มันใช้เวลา (ตัวอย่าง) สตริงที่บิตและแปลงกลับเป็นทศนิยม (ฐาน 10) เพื่อรับ15 , 565 , 975จากนั้นแปลงเป็นฐาน13เพื่อให้ออฟเซ็ตเป็นสตริงการค้นหาอันดับจากนั้นจะจัดลำดับใหม่ ในช่วงเวลาหนึ่งและได้รับเดิม54 236 Jแรก7บัตร โปรดทราบว่าขนาดบล็อกของบิตจะไม่เป็น 26 แต่จะเริ่มต้นที่ 26 ในแต่ละสำรับเสมอ เข้ารหัสและถอดรหัสทั้งสองมีข้อมูลที่สำคัญบางอย่างเกี่ยวกับข้อมูลสำรับแม้กระทั่งก่อนที่พวกเขาทำงาน นั่นเป็นสิ่งที่ดีเป็นพิเศษเกี่ยวกับอัลกอริทึมนี้$26$$15,565,975$$13$$54A236J$$7$

แต่ละ # ของการจัดอันดับที่เหลือ (เช่นมี groupsize ของตัวเองและค่าใช้จ่าย (# บิตต่อบัตร) เหล่านี้ถูกพบเพียงการทดลองเล่นรอบกับอำนาจของ13 , 12 , 11 ...และอำนาจของ2 ฉันอธิบายแล้วว่าฉันจะได้รับการจัดกลุ่มเมื่อเราสามารถดู13อันดับได้อย่างไรแล้วเมื่อเราไปถึง12อันดับที่ไม่สำเร็จ วิธีเดียวกัน ดูพลังของ12และหยุดเมื่อหนึ่งในนั้นเข้ามาใกล้กับพลังของ2แต่เพียงเล็กน้อยภายใต้มัน $13, 12, 11 ..., 2, 1)$$13,12,11...$$2$$13$$12$$12$$2$ = 248 , 832และ 2 18 = 262 , 144 นั่นเป็นแบบที่ค่อนข้างแน่น จำนวนบิตการเข้ารหัสกลุ่มนี้คือ 18 / 5 =3.6 ใน 13กลุ่มยศมันเป็น 26 / 7 = 3.714เพื่อที่คุณสามารถดูจำนวนของการจัดอันดับที่ไม่สำเร็จลดลง (การจัดอันดับจะเติมขึ้นเช่น 5555 , 3333 ), จำนวนบิตการเข้ารหัสบัตรลดลง$12^5$$248,832$$2^{18}$$262,144$$18/5$$3.6$$13$$26/7$$3.714$$5555$$3333$

นี่คือรายการค่าใช้จ่ายทั้งหมดของฉัน (จำนวนบิตต่อบัตร) สำหรับอันดับที่เป็นไปได้ทั้งหมด:

12 18 / 5 = 3.600 = 3 3 / 5 11 7 / 2 = 3.500 = 3 1 / 2 10 10 / 3 = 3.333 = 3 1 / 3 9 16 / 5 = 3.200 = 3 1 / 5 8 3 /$13~~~~26/7 = 3.714 = 3~~5/7$
$12~~~~18/5 = 3.600 = 3~~3/5$
$11~~~~~~7/2 = 3.500 = 3~~1/2$
$10~~~~10/3 = 3.333 = 3~~1/3$
$~~9~~~~16/5 = 3.200 = 3~~1/5$
7 17 / 6 = 2.833 = 2 5 / 6 6 13 / 5 = 2.600 = 2 3 / 5 5 7 / 3 = 2.333 = 2 1 / 3 4 2 / 1 = 2.000 = 2 3 5 / 3 = 1.667 = 1 2 / 3 2 1 $~~8~~~~~~3/1 = 3.000 = 3$
$~~7~~~~17/6 = 2.833 = 2~~5/6$
$~~6~~~~13/5 = 2.600 = 2~~3/5$
$~~5~~~~~~7/3 = 2.333 = 2~~1/3$
$~~4~~~~~~2/1 = 2.000 = 2$
$~~3~~~~~~5/3 = 1.667 = 1~~2/3$
1 0 / 1..4 = 0.0 = $~~2~~~~~~1/1 = 1.000 = 1$
$~~1~~~~~~0/1..4 = 0.0 = 0$

ดังนั้นอย่างที่คุณสามารถเห็นได้อย่างชัดเจนว่าจำนวนการจัดอันดับที่ไม่สำเร็จลดลง (ซึ่งจะทำทุกสำรับ) จำนวนของบิตที่จำเป็นในการเข้ารหัสบัตรแต่ละใบก็ลดลงเช่นกัน คุณอาจสงสัยว่าเกิดอะไรขึ้นถ้าเราเติมอันดับ แต่เรายังไม่ได้ทำกลุ่ม ตัวอย่างเช่นหากไพ่ใบแรกในเด็คมี5 , 6 , 7 , 7 , 7 , 7 , Kเราควรทำอย่างไร ง่าย ๆปกติKจะปล่อยตัวเข้ารหัสจากโหมดการเข้ารหัส13อันดับไปเป็นโหมดการเข้ารหัส12อันดับ อย่างไรก็ตามเนื่องจากเรายังไม่ได้กรอกบล็อกแรกของ7ใบใน$7$$5,6,7,7,7,7,K$$K$$13$$12$$7$$13$อันดับการเข้ารหัสโหมดเรารวมในบล็อกนั้นเพื่อให้เสร็จสมบูรณ์ มีขยะน้อยมากด้วยวิธีนี้ นอกจากนี้ยังมีบางกรณีที่เราพยายามเติมบล็อกหมายเลข # ของอันดับที่เต็มไปด้วย2หรือมากกว่านั้น นั่นก็ไม่มีปัญหาเมื่อเราเติมบล็อกในโหมดการเข้ารหัสปัจจุบันจากนั้นเราเลือกโหมดการเข้ารหัสใหม่ซึ่งอาจเป็น1 , 2 , 3 ...น้อยลงหรือแม้กระทั่งอยู่ในโหมดเดียวกัน (เช่นกรณี ในสำรับแรกใน datafile เนื่องจากมี3บล็อกเต็มในโหมดการเข้ารหัส13อันดับ) นี่คือเหตุผลว่าทำไมจึงสำคัญที่จะต้องทำการบล็อกบล็อคอย่างสมเหตุสมผลเช่นระหว่างขนาด1ถึง$K$$2$$1,2,3...$$3$$13$$1$$7$. ถ้าเราทำให้มันมีขนาดเราจะต้องเติมบล็อกนั้นด้วยอัตราบิตที่สูงกว่าถ้าเราปล่อยให้การเปลี่ยนเอ็นโค้ดเดอร์เข้าสู่โหมดการเข้ารหัสที่มีประสิทธิภาพมากขึ้น$20$

เมื่อฉันใช้อัลกอริธึมนี้ (ด้วยมือ) บนสำรับแรกของไฟล์ข้อมูล (ซึ่งสร้างขึ้นโดยใช้การสุ่มแบบไม่เอนเอียงของ Fisher-Yates) ฉันได้รับบิตที่น่าประทับใจในการเข้ารหัสซึ่งเกือบจะเหมือนกับการเข้ารหัสแบบไบนารีที่เหมาะสมที่สุด ความรู้เกี่ยวกับตำแหน่งลำดับของสำรับที่เป็นไปได้ทั้งหมดไม่มีจำนวนมากและไม่มีการค้นหาแบบไบนารี อย่างไรก็ตามมันต้องการการผสมแบบไบนารี่และเรเดียนซ์ (พลังของ13 , 12 , 11 ... )$168$$13, 12, 11$

$1$$0$$7777$$48$$7$$4$$7$s หากเด็คจบลงด้วยการเป็นคู่ (เช่น 77), สามคน / เซ็ต (เช่น 777) หรือรูปสี่เหลี่ยม (เช่น 7777) เราจะได้รับส่วนลดเพิ่มเติมสำหรับเด็คนั้นโดยใช้อัลกอริทึมของฉัน

$32$$2^{26}$$13$$16$$32$$32$

ในสำรับแรกในดาต้าไทล์การเข้ารหัสของการ์ดมีดังต่อไปนี้ (แผนภาพจะมาภายหลัง) รูปแบบคือ (จัดกลุ่ม, บิต, โหมดเข้ารหัสอันดับ):

$7,26,13$$7$$26$$13$
$7,26,13$
$7,26,13$
$5,18,12$
$5,18,12$
$3,10,10$
$3,~~9,~~8$
$6,17,~~7$
$5,13,~~6$
$3,~~5,~~3$
$1,~~0,~~1$

$52$$168$$3.23$

$18$$1/3$$3.2$$3.2$$54545454722772277...$$3$$22223333444455556666777788889999TTTTJJJJQQQQKKKKAAAA$$4$$0$

$1$$10$$3,7$$K$$8$$10$$1$บัตรที่เหลืออยู่ สิ่งนี้มีความสำคัญเนื่องจากทำให้กระบวนการเข้ารหัสมีประสิทธิภาพมากขึ้นเมื่อตัวถอดรหัสสามารถกำหนดสมมติฐานที่ถูกต้องได้โดยไม่ต้องใช้ตัวเข้ารหัสเพื่อส่งข้อความพิเศษให้

$3$$13$$12$$11$$10$

54 236 J 87726 Q 3 3969 Q J K 7 T 9292 Q 36 K J 57 T 8 T K J 4 48 Q 8 T 55 K $~~~~~~~~~26~~~~~~~~~~~~~26~~~~~~~~~~~~~26~~~~~~~~~~~~18~~~~~~~~~18~~~~~~~10~~~~~~9~~~~~~~~~~17~~~~~~~~~~~13~~~~~~~~5~~~~~0$
$~~~~54A236J~~87726Q3~~3969AAA~~QJK7T~~9292Q~~36K~~J57~~~T8TKJ4~~48Q8T~~55K~~4$
$13~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~12~~~~~~~~~~~~~~~~~~~~xy~~~~~98~~~~~~~~~7~~~~~~~~~~~~~~6~~~~~~~~543~~~~~2~1~~0$

$2$$166$$175$$168$เกร็ด โปรดทราบว่าเรามี 4 อันเดียวที่ตอนท้ายของสำรับ แต่ถ้าเรามี 4s ทั้งสี่ที่นั่นนั่นเป็นกรณีที่ดีกว่าและเราต้องการเพียง 161 บิตในการเข้ารหัสสำรับนั้นกรณีที่การบรรจุจริง ๆ เอนโทรปีของการเข้ารหัสเลขฐานสองตรงของตำแหน่งลำดับของมัน

ตอนนี้ฉันมีรหัสที่ใช้ในการคำนวณความต้องการบิตและมันแสดงให้ฉันโดยเฉลี่ยประมาณ 175 บิตต่อเดสก์ที่ต่ำ 155 และสูง 183 สำหรับไฟล์ทดสอบเด็ค 3 ล้าน อัลกอริทึมของฉันดูเหมือนว่าจะใช้ 9 บิตเพิ่มเติมต่อหนึ่งดาดฟ้าเทียบกับการเข้ารหัสไบนารี่ไบน์โดยตรงของวิธีการหาตำแหน่งแบบเลขลำดับ ไม่เลวเกินไปที่ต้องใช้พื้นที่เก็บข้อมูลเพิ่มเติมเพียง 5.5% 176 บิตเท่ากับ 22 ไบต์ดังนั้นจึงค่อนข้างดีกว่า 52 ไบต์ต่อเด็ค เด็คเคสที่ดีที่สุด (ไม่แสดงในไฟล์ทดสอบเด็ค 3 ล้าน) แพ็คเป็น 136 บิตและเด็คเคสที่แย่ที่สุด (แสดงใน testfile 8206 ครั้ง) คือ 183 บิต การวิเคราะห์แสดงให้เห็นว่ากรณีที่เลวร้ายที่สุดคือเมื่อเราไม่ได้รับรูปสี่เหลี่ยมแรกจนกระทั่งใกล้กับ (หรือที่) การ์ด 40 จากนั้นเมื่อโหมดการเข้ารหัสต้องการที่จะลดลงอย่างรวดเร็วเราจึง "บล็อก" บรรจุอยู่ โหมดการเข้ารหัสบิตที่สูงขึ้น บางคนอาจคิดว่าการไม่ได้รับการแจ้งเตือนใด ๆ จนกว่าการ์ด 40 จะค่อนข้างหายากโดยใช้สำรับที่สับ แต่โปรแกรมของฉันบอกฉันว่ามันเกิดขึ้น 321 ครั้งใน testfile 3 ล้านสำรับเพื่อให้ประมาณ 1 ออกจาก 9346 สำรับ นั่นบ่อยกว่าที่ฉันคาดไว้ ฉันสามารถตรวจสอบกรณีนี้และจัดการกับบิตน้อย แต่มันหายากมากที่มันจะไม่ส่งผลกระทบต่อบิตเฉลี่ยพอ

นอกจากนี้ที่นี่เป็นอย่างอื่นที่น่าสนใจมาก หากฉันจัดเรียงเด็คบนข้อมูลเด็คดิบความยาวของคำนำหน้าที่ทำซ้ำ # จำนวนครั้งที่สำคัญจะมีความยาวประมาณ 6 เท่านั้น (เช่น 222244) อย่างไรก็ตามด้วยข้อมูลที่บรรจุความยาวนั้นเพิ่มขึ้นถึง 16 นั่นหมายความว่าถ้าฉันเรียงลำดับข้อมูลที่บรรจุฉันควรจะได้รับการประหยัดที่สำคัญโดยเพียงแค่ระบุตัวถอดรหัสคำนำหน้า 16 บิตแล้วนำออกส่วนที่เหลือของสำรับ (ลบด้วยคำนำหน้าซ้ำ) ที่มีคำนำหน้าเหมือนกันจากนั้นไปยังคำนำหน้าถัดไปและทำซ้ำ สมมติว่าฉันบันทึกแม้แต่ 10 บิตต่อเด็คในแบบนี้ฉันควรเอาชนะ 166 บิตต่อเด็ค ด้วยเทคนิคการแจงนับที่ระบุโดยคนอื่นฉันไม่แน่ใจว่าคำนำหน้าจะยาวเท่ากับอัลกอริทึมของฉันหรือไม่ ความเร็วในการบรรจุและการเปิดออกโดยใช้อัลกอริทึมของฉันก็ดีเช่นกัน

เกี่ยวกับการบีบอัดระดับที่ 2 ที่ฉันเรียงลำดับ bitstrings เอาท์พุทของอัลกอริทึมของฉันจากนั้นใช้การเข้ารหัส "ความแตกต่าง": วิธีการที่ง่ายมากคือการเข้ารหัสคำนำหน้า 16 บิต 61,278 เฉพาะที่แสดงอย่างน้อยสองครั้งในข้อมูลเอาต์พุต จาก 89 ครั้งที่รายงาน) เพียงแค่นำหน้า 0 ในผลลัพธ์เพื่อบ่งบอกถึง decompressor ระดับที่ 2 ที่เรากำลังเข้ารหัสคำนำหน้า (เช่น 0000111100001111) แล้วสำรับใด ๆ ที่บรรจุด้วยคำนำหน้าเดียวกันนั้นจะตามด้วย 1 บิตนำไป ระบุส่วนที่ไม่ใช่คำนำหน้าของสำรับที่บรรจุ ค่าเฉลี่ย # ของสำรับที่บรรจุด้วยคำนำหน้าเหมือนกันคือประมาณ 49 สำหรับแต่ละคำนำหน้าไม่รวมถึงจำนวนเล็กน้อยที่ไม่ซ้ำกัน (เฉพาะ 1 สำรับเท่านั้นที่มีคำนำหน้านั้น) ดูเหมือนว่าฉันสามารถบันทึกประมาณ 15 บิตต่อเด็คโดยใช้กลยุทธ์ง่ายๆนี้ (เก็บคำนำหน้าร่วมกันหนึ่งครั้ง)

หลังจากการบีบอัดระดับที่ 2 โดยใช้การเข้ารหัส (prefix) ความแตกต่างของเอาต์พุต bitstring ที่เรียงลำดับแล้วของตัวเข้ารหัสแรกตอนนี้ฉันได้รับประมาณ 160 บิตต่อเด็ค ฉันใช้คำนำหน้าความยาว 18 และเก็บไว้เหมือนเดิม เนื่องจากเกือบทั้งหมด (245013 จาก 262144 = 93.5%) ของคำนำหน้า 18 บิตที่เป็นไปได้เหล่านั้นปรากฏขึ้นจึงเป็นการดีกว่าถ้าจะเข้ารหัสส่วนนำหน้า บางทีฉันสามารถใช้ 2 บิตเพื่อเข้ารหัสประเภทข้อมูลที่ฉันมี 00 = ความยาวปกติ 18 คำนำหน้าเก็บไว้ 01 = "คำนำหน้า 1 ขึ้น" (เหมือนกับคำนำหน้าก่อนหน้ายกเว้น 1 เพิ่ม), 11 = การเข้ารหัสแบบตรงจากการบรรจุระดับที่ 1 (ประมาณ 175 บิตโดยเฉลี่ย) 10 = การขยายตัวในอนาคตเมื่อฉันคิดถึงการเข้ารหัสที่จะประหยัดบิต

มีใครชนะ 160 บิตต่อเด็คหรือยัง ฉันคิดว่าฉันสามารถลดลงได้เล็กน้อยด้วยการทดลองและใช้ตัวอธิบาย 2 บิตที่ฉันได้กล่าวถึงข้างต้น บางทีมันอาจจะถึงจุดต่ำสุดที่ 158ish เป้าหมายของฉันคือรับไปที่ 156 บิต (หรือดีกว่า) เพราะนั่นจะเป็น 3 บิตต่อบัตรหรือน้อยกว่า ที่น่าประทับใจมาก. มีการทดลองมากมายที่จะทำให้มันลงมาถึงระดับนั้นเพราะถ้าฉันเปลี่ยนการเข้ารหัสระดับแรกฉันต้องทดสอบอีกครั้งซึ่งเป็นการเข้ารหัสระดับที่ดีที่สุดอันดับ 2 และมีชุดค่าผสมมากมายให้ลอง การเปลี่ยนแปลงบางอย่างที่ฉันทำอาจจะดีสำหรับข้อมูลแบบสุ่มอื่นที่คล้ายคลึงกัน แต่บางคนอาจมีอคติกับชุดข้อมูลนี้ ไม่แน่ใจจริงๆ แต่ถ้าฉันได้รับการกระตุ้นฉันสามารถลองชุดข้อมูลสำรับอีก 3 ล้านชุดเพื่อดูว่าเกิดอะไรขึ้นถ้าฉันได้ผลลัพธ์ที่คล้ายกัน

$10^{50}$

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

อีก 2 สิ่ง: 1) ฉันค่อนข้างผิดหวังที่มีผู้คนจำนวนมากที่ไม่ได้แก้ปัญหาของฉันซึ่งแม้ว่าจะไม่เหมาะกับพื้นที่ แต่ก็ยังดีและใช้งานได้ง่าย (ฉันทำงานได้ดี) 2) ฉันทำการวิเคราะห์ดาต้ามาล์เด็ล 3 ล้านของฉันและสังเกตว่าการ์ดที่เกิดขึ้นบ่อยที่สุดที่อันดับที่ 1 (เช่น 4444) อยู่ที่การ์ด 26 ซึ่งเกิดขึ้นประมาณ 6.711% ของเวลา (สำหรับ 201322 ของ 3 ล้านเด็ค ) ฉันหวังว่าจะใช้ข้อมูลนี้เพื่อบีบอัดเพิ่มเติมเช่นเริ่มต้นในโหมดเข้ารหัสสัญลักษณ์ 12 เนื่องจากเรารู้โดยเฉลี่ยเราจะไม่เห็นทุกระดับจนกระทั่งเกี่ยวกับ middeck แต่วิธีนี้ล้มเหลวในการบีบอัดใด ๆ เป็นค่าใช้จ่ายเกินออม ฉันกำลังมองหาการปรับแต่งอัลกอริทึมของฉันที่สามารถบันทึกบิต

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

นอกจากนี้ FYI ฉันสร้างการสุ่ม 10 ล้านครั้งและเก็บไว้ในฐานข้อมูลเพื่อการวิเคราะห์ที่ง่าย มีเพียง 488 คนที่อยู่ในรูปสี่เหลี่ยม (เช่น 5555) หากฉันแพ็คเฉพาะผู้ที่ใช้อัลกอริทึมของฉันฉันจะได้รับ 165.71712 บิตโดยเฉลี่ยที่ 157 บิตต่ำและ 173 บิตสูง ต่ำกว่า 166 บิตเล็กน้อยโดยใช้วิธีการเข้ารหัสอื่น ฉันค่อนข้างประหลาดใจที่กรณีนี้ไม่บ่อยนัก (เฉลี่ยประมาณ 1 จากทุก ๆ 20,492 shuffles)