คุณทุกคนอาจรู้จักจอแสดงผล 7 ส่วนซึ่งสามารถแสดงตัวเลขหลักทั้งหมดได้ตั้งแต่$0\dots 9$ :

ท้าทาย

เราพิจารณาเซ$\texttt{A}\dots\texttt{G}$เท่านั้นงานของคุณคือการถอดรหัสตัวเลขเดียวที่กำหนดว่าจะเปิดเซ็กเมนต์ใด

สิ่งนี้สามารถเข้ารหัสเป็นเลขจำนวนเต็ม 8 บิตนี่คือตารางของแต่ละหลักที่มีการแทนเลขฐานสองของพวกเขาและค่าน้อยที่สุดของ endian และ big-endian ที่สอดคล้องกัน:

$$\begin{array}{c|c|rr|rr} \text{Digit} & \texttt{.ABCDEFG} & \text{Little-endian} && \text{Big-endian} & \\ \hline 0 & \texttt{01111110} & 126 & \texttt{0x7E} & 126 & \texttt{0x7E} \\ 1 & \texttt{00110000} & 48 & \texttt{0x30} & 12 & \texttt{0x0C} \\ 2 & \texttt{01101101} & 109 & \texttt{0x6D} & 182 & \texttt{0xB6} \\ 3 & \texttt{01111001} & 121 & \texttt{0x79} & 158 & \texttt{0x9E} \\ 4 & \texttt{00110011} & 51 & \texttt{0x33} & 204 & \texttt{0xCC} \\ 5 & \texttt{01011011} & 91 & \texttt{0x5B} & 218 & \texttt{0xDA} \\ 6 & \texttt{01011111} & 95 & \texttt{0x5F} & 250 & \texttt{0xFA} \\ 7 & \texttt{01110000} & 112 & \texttt{0x70} & 14 & \texttt{0x0E} \\ 8 & \texttt{01111111} & 127 & \texttt{0x7F} & 254 & \texttt{0xFE} \\ 9 & \texttt{01111011} & 123 & \texttt{0x7B} & 222 & \texttt{0xDE} \end{array}$$

กฎ & I / O

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

การทดสอบ

เนื่องจากความท้าทายนี้อนุญาตให้มีการรับรองหลายรายการโปรดอ้างอิงจากตาราง

JavaScript (ES6), 26 ไบต์

ใช้อินพุตใน Endian น้อย

n=>'0958634172'[n*3%77%10]

ลองออนไลน์!

Python 3 , 18 ไบต์

b'~0my3[_p{'.find

ลองออนไลน์!

ใช้อินพุตแบบเอนด์น้อย มี\x7Fไบต์ดิบ

Python 2 , 27 ไบต์

map(ord,'~0my3[_p{').index

ลองออนไลน์!

ภาษา Wolfram (Mathematica) , 41 ไบต์

9[,6,0,8,2,3,1,7,5,4][[#~Mod~41~Mod~11]]&

ลองออนไลน์!

ใช้คอลัมน์เล็ก ๆ ของจำนวนเต็มเป็นอินพุต ละเว้นคำเตือนไวยากรณ์

สำหรับอินพุต X เราใช้ X mod 41 ก่อนแล้วจึงนำเอา mod mod 11 ผลลัพธ์นั้นเป็น mod ที่แตกต่างกัน 11 ดังนั้นเราจึงสามารถแยกมันออกจากตารางได้ ตัวอย่างเช่น 126 mod 41 mod 11 คือ 3 ดังนั้นหากเรากำหนดตำแหน่ง 3 เท่ากับ 0 เราจะได้คำตอบที่ถูกต้องสำหรับอินพุต 126

9[,6,0,8,2,3,1,7,5,4]ตารางเป็น 0 9ส่วนเป็นหัวหน้าซึ่งเป็น ส่วนที่ 1 หายไปดังนั้นNullเพื่อบันทึกไบต์: เราไม่จำเป็นต้องมีส่วนที่ 1 จากนั้นส่วนที่ 2 คือ6ส่วนที่ 3 คือ0และอื่น ๆ ตามปกติ

---

คำตอบที่โจนาธานอัลลัน1[4,9,8,6,2,0,5,3,7][[384~Mod~#~Mod~13]]&จะช่วยให้เรา สิ่งนี้ไม่ได้สั้นกว่านี้ แต่จะหลีกเลี่ยงคำเตือนทางไวยากรณ์!

---

ภาษา Wolfram (Mathematica) , 27 25 ไบต์

Mod[Hash[")dD}"#]+2,11]&

(มีตัวละครบางตัวที่นี่ซึ่งไม่ปรากฏขึ้นมาขอโทษคลิกที่ลิงค์ด้านล่างและคุณจะเห็นมัน)

ลองออนไลน์!

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

เยลลี่ 12 ไบต์

“0my3[_p¶{‘i

ยอมรับจำนวนเต็มเล็ก ๆ น้อย ๆ

ลองออนไลน์!

นี่เป็นการใช้งานแบบไร้เดียงสาอาจมีวิธีรับรหัส terser

Python 2 , 31 ไบต์

lambda n:'99608231754'[n%41%11]

ลองออนไลน์! รับอินพุตเป็น little-endian

Java (JDK) , 32 ไบต์

n->"99608231754".charAt(n%41%11)

ลองออนไลน์!

เครดิต

• ท่าเรือArnauld 's คำตอบ JavaScript , สั้นกว่าความพยายามก่อนหน้านี้ในประวัติศาสตร์การโพสต์
• -1 ขอบคุณไบต์โจนาธานอัลลันใช้Misha Lavrov 's วุลแฟรมภาษา (มาติกา) คำตอบ

JavaScript (Node.js)ขนาด 25 ไบต์

n=>'1498620537'[384%n%13]

ยอมรับจำนวนเต็มเล็ก ๆ น้อย ๆ

ลองออนไลน์!

---

พอร์ตสำหรับ 31 ไบต์ใน Python ด้วย lambda n:'1498620537'[384%n%13]

ช่องว่าง 152 ไบต์

ข้อผูกมัด "S, T และ L ไม่ได้อยู่ที่นั่นจริงๆ

S S S T	S S L
S S S T	S T	L
S S S T	T	T	L
S S S T	L
S S S T	T	L
S S S T	S L
S S S T	S S S L
S S S L
S S S T	T	S L
S S S L
S S S T	S S T	L
S S S L
S L
S T	L
T	T	T	T	T	S S S T	S T	S S T	L
T	S T	T	S S S T	S T	T	L
T	S T	T	L
S S L
S L
S L
T	S S L
S T	L
S T	L
S S S T	L
T	S S T	L
S L
L
L
S S S L
S L
L
T	L
S T	

ลองออนไลน์!

สิ้นสุดในข้อผิดพลาด

ไวยากรณ์เหมือนแอสเซมบลีที่เทียบเท่า:

	push 4
	push 5
	push 7
	push 1
	push 3
	push 2
	push 8
	push 0
	push 6
	push 0
	push 9
	push 0
	dup
	readi
	retrieve
	push 41
	mod
	push 11
	mod
slideLoop:
	dup
	jz .slideLoop
	slide 1
	push 1
	sub
	jmp slideLoop
.slideLoop:
	drop
	printi

brainfuck , 474 176 154 151 149 137 ไบต์

ใช้สตริงอินพุตแปด 0และ1รวมถึงสตริงแรก0สำหรับจุดทศนิยม

(เหมือนในคอลัมน์ที่สองของตารางในโพสต์)

เอาต์พุตตัวเลขตั้งแต่ 0 ถึง 9

,>,>,>,,,>,>,>+[[->]<++<<<<<<]>[>[>[>[->[>++++++<-<]>[--<]<]>>.>>]<[>
>[>->++<<-]>-[+>++++<]>+.>]]>[>>>+<<<-]>[>>+++.>]]>[>>>[>+++<-]>-.>]

ลองออนไลน์!

ขั้นตอนวิธี

โดยการสังเกตสถานะของกลุ่มเฉพาะเราสามารถแยกชุดของตัวเลขที่เป็นไปได้ออกเป็นชุดย่อยที่เล็กลง ด้านล่างนี้คือแผนผังการค้นหาไบนารีแบบคงที่ที่ใช้ในรหัสของฉัน ทรีย่อยทางซ้ายสอดคล้องกับสถานะเซ็กเมนต์ ON ด้านขวาสอดคล้องกับสถานะเซ็กเมนต์ OFF

                                         0,1,2,3,4,5,6,7,8,9
                                                  |    
                                         /-------[A]-------------------------\
                                 0,2,3,5,6,7,8,9                             1,4
                                        |                                     |
                         /-------------[B]----------------\             /----[G]----\
                   0,2,3,7,8,9                            5,6          4             1   
                        |                                  |
              /--------[E]--------\                  /----[E]----\    
            0,2,8                3,7,9              6             5
              |                    |
        /----[F]----\        /----[F]----\
      0,8            2      9            3,7   
       |                                  |
 /----[G]----\                      /----[G]----\
8             0                    3             7

ข้อสังเกตบางอย่างมีประโยชน์สำหรับการเล่นกอล์ฟ

1. บิต C และ D ซ้ำซ้อนและสามารถละเว้นได้
2. นำหน้าศูนย์ (บิตสำหรับจุดทศนิยม) สามารถใช้ (ab) เป็นค่า 48 ซึ่งสำคัญทั้งสำหรับการแยกวิเคราะห์อินพุตและเตรียมเอาต์พุต
3. เมื่อถึงลีฟแล้วพิมพ์ดิจิตเราต้องข้ามเงื่อนไขเพิ่มเติมทั้งหมด สามารถทำได้โดยการย้ายตัวชี้ข้อมูลไปยังพื้นที่ของศูนย์จนไม่สามารถกลับมาได้
4. สำหรับความเข้ากันได้จะเป็นการดีกว่าที่จะใช้ศูนย์ทางด้านขวาเนื่องจากการใช้งาน BF บางอย่างไม่สนับสนุนพอยน์เตอร์ข้อมูลเชิงลบ
5. ดังนั้นการเก็บค่าเอาท์พุทไว้ในเซลล์ด้านขวาสุดจะดีกว่าดังนั้นเราจึงสามารถเข้าถึงพื้นที่ของศูนย์ไปทางขวาได้อย่างง่ายดาย
6. ดังนั้นจึงเป็นการดีกว่าถ้าตรวจสอบบิตจากซ้ายไปขวา: A, B, E, F, G เพื่อให้เราสามารถเข้าถึงเซลล์เอาต์พุตได้ง่ายขึ้น
7. ตัวเลขที่ต่างกันอาจใช้รหัสเอาท์พุท ตัวอย่างเช่น 5 และ 6 อยู่ในทรีย่อยเดียวกัน เราอาจทำ+++++ทั้งสองค่าแล้ว+สำหรับหกเท่านั้น
8. เราอาจลดจำนวน+คำสั่งถ้าเราเพิ่ม 2 ถึงมูลค่าส่งออกล่วงหน้า ในกรณีที่เราจำเป็นต้องลดความมัน0และ1เพียงและได้รับประโยชน์สำหรับตัวเลขอื่น ๆ

เรติน่า 96 ไบต์

^(A)?(B)?C?(D|())(E|())(F)?(G)?
$.($.5*$.8*$(6*$7$2$2)$#6*$.3*$($.2*$(___$7)5*$7)$#4*$(6*$1_3*$8

ลองออนไลน์! อาจไม่ใช่วิธีที่ดีที่สุด แต่เป็นวิธีการเขียนโปรแกรมที่น่าสนใจใน Retina คำอธิบาย:

^(A)?(B)?C?(D|())(E|())(F)?(G)?

พยายามจับกรณีที่น่าสนใจ การจับในเชิงบวกเพียงจับจดหมายหากมีอยู่ ความยาวของการจับภาพจึงเป็น 1 หากมีอยู่และเป็น 0 หากไม่มี กรณีพิเศษคือการจับ 4 และ 6 ซึ่งมีอยู่เฉพาะในกรณีที่ D หรือ E จะหายไปตามลำดับ สิ่งเหล่านี้สามารถแสดงเป็นทศนิยมได้$#4และ$#6นั่นคือทั้งหมดที่เราต้องการที่นี่ การจับภาพจะถูกสร้างขึ้นเป็นสตริงที่มีความยาวเป็นจำนวนที่ต้องการ ตัวอย่างเช่นถ้าเราเขียน6*$1แล้วสตริงนี้มีความยาว 6 ถ้าเป็นปัจจุบันและ 0 ถ้ามันขาด ในการเลือกระหว่างนิพจน์ที่ต่างกันเราใช้$.(สำหรับการจับบวก) หรือ$#(สำหรับการลบเชิงลบ) ซึ่งประเมินเป็น 0 หรือ 1 และนี่จะสามารถคูณด้วยสตริงได้

$.5*$.8*$(6*$7$2$2)

Fทำซ้ำ 6 ครั้งและBสองครั้ง (โดยเรียงต่อกันขณะที่นักเล่นกอล์ฟ) อย่างไรก็ตามผลลัพธ์จะถูกละเว้นยกเว้นทั้งคู่EและGมีอยู่ นี้จัดการกับกรณีของ2, และ68

$#6*$.3*$($.2*$(___$7)5*$7)

Fถูกทำซ้ำ 5 ครั้งและหากBมีอยู่จะถูกเพิ่มเป็นครั้งที่หกบวกอีก 3 พิเศษ (แสดงด้วยสตริงที่มีความยาวคงที่ 3) อย่างไรก็ตามผลลัพธ์จะถูกละเว้นเว้นแต่Dจะมีอยู่และEไม่มีอยู่ นี้จัดการกับกรณีของ3, และ59

$#4*$(6*$1_3*$8

Aทำซ้ำ 6 ครั้งและGทำซ้ำ 3 ครั้งและมีการเพิ่มพิเศษ1(แสดงโดยอักขระคงที่ระหว่างทั้งสองเพราะมันเป็นนักกอล์ฟ) อย่างไรก็ตามผลลัพธ์จะถูกละเว้นหากDไม่ได้อยู่ นี้จัดการกับกรณีของ1, และ47

$.(

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

สตริงผลลัพธ์ (ก่อนที่จะมีการใช้ความยาว) มีดังนี้:

1   _
2   BB
3   ___
4   _GGG
5   FFFFF
6   FFFFFF
7   AAAAAA_
8   FFFFFFBB
9   ___FFFFFF

MATL , 14 ไบต์

'/lx2Z^o~z'Q&m

อินพุตเป็นตัวเลขที่แสดงถึงกลุ่มในรูปแบบของเอนด์น้อย

ลองออนไลน์!

คำอธิบาย

'/lx2Z^o~z'  % Push this string
Q            % Add 1 to the codepoint of each char. This gives the array
             % [48 109 ... 123], corresponding to numbers 1 2 ... 9. Note that
             % 0 is missing
&m           % Implicit input. Call ismember function with second output. This
             % gives the 1-based index in the array for the input, or 0 if the
             % input is not present in the array.
             % Implicit display

Perl 5 -pl, 24 ไบต์

$_=index'~0my3[_p{',chr

ลองออนไลน์!

ใช้จำนวนเต็มเล็กน้อย

Ruby , 29 ไบต์

->n{"0083416243795"[n%23-10]}

ลองออนไลน์!

Japt 15 ไบต์

รับค่า big-endian เป็นอินพุต

"~¶ÌÚúþÞ"bUd

ลองมัน

---

คำอธิบาย

สตริงมีอักขระที่ codepoints แต่ละค่าของ big-endian Udรับตัวอักษรที่ codepoint ของอินพุตและbค้นหาดัชนีของนั้นในสตริง

Neim , 15 ไบต์

&bᚫJ𝕂𝕨O𝐖𝐞ℤ£ᛖ𝕪)𝕀

คำอธิบาย:

&bᚫJ𝕂𝕨O𝐖𝐞ℤ£ᛖ𝕪)      create list [126 48 109 121 51 91 95 112 127 123]
                 𝕀     index of

ลองออนไลน์!

Stax , 12 ไบต์

å╬JÄk☺é[£¿⌐→

เรียกใช้และแก้ไขข้อบกพร่อง

อินพุตเป็นจำนวนเต็ม endian น้อย

มันใช้ค่าคงที่สตริงเดียวกับโซลูชันของ Luis MATL

TI-BASIC (TI-83 + / 84 + series), 15 ไบต์

int(10fPart(194909642ln(Ans

ใช้อินพุตเอนด์น้อย Hashes นั้นค่อนข้างธรรมดาใน TI-BASIC ดังนั้นฉันจึงเขียนhash function brute-forcerสำหรับกรณีเช่นนี้

เราโชคดีเล็กน้อยที่นี่เนื่องจากตัวคูณมีความยาว 9 หลักแทนที่จะเป็น 10 ที่คาดไว้

      fPart(194909642ln(Ans   hash function mapping onto [0,1)
int(10                        take first digit after decimal point

05AB1E , 17 16 15 12 ไบต์

•NŽyf¯•I41%è

-1 ไบต์ขอบคุณ @ErikTheOutgolfer
-1 ไบต์โดยการสร้างพอร์ตของ@MishaLavrov 'คำตอบ Mathematica
-3 ไบต์ขอบคุณที่@Grimy

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

•NŽyf¯•       # Push compressed integer 99608231754
       I41%   # Push the input modulo-41
           è  # Index this into the integer (with automatic wraparound)
              # (and output the result implicitly)

ดูเคล็ดลับเหมือง 05AB1E นี้ของคุณ (ส่วนจะบีบอัดจำนวนเต็มขนาดใหญ่ได้อย่างไร? )จะเข้าใจว่าทำไมเป็น•NŽyf¯•99608231754

ถ่าน 17 ไบต์

Ｉ⌕”y~¶ÌÚúþÞ”℅Ｎ

ลองมัน!

พอร์ตของคำตอบ Japt