एक 7-खंड प्रदर्शन को डिकोड करें

Question

आप शायद सभी 7-सेगमेंट के डिस्प्ले को जानते हैं, जो से सभी अंकों के बीच अन्य चीजों को प्रदर्शित कर सकते हैं :$0\dots 9$

चुनौती

हम केवल सेगमेंट , आपका कार्य एकल अंकों को डिकोड करना है, जो सेगमेंट चालू हैं।$\texttt{A}\dots\texttt{G}$

इसे 8-बिट पूर्णांक के रूप में एन्कोड किया जा सकता है, यहां प्रत्येक अंक की तालिका उनके द्विआधारी प्रतिनिधित्व और संबंधित छोटे-एंडियन और बड़े-एंडियन मूल्यों के साथ है:

$$\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}$$

नियम और मैं / हे

• इनपुट एक होगा
  • एकल पूर्णांक (दो दिए गए आदेशों में से एक के ऊपर तालिका में)
  • बिट्स की एक सूची / सरणी / ..
  • पात्रों से युक्त एक स्ट्रिंग ABCDEFG(आप मान सकते हैं कि इसे क्रमबद्ध किया गया है, उदाहरण के तौर परABC एन्कोड किया गया है ), उनका मामला आपकी पसंद है (मिश्रित-केस नहीं)$7$
• आउटपुट वह अंक होगा जो इसे एनकोड करता है
• आप कोई अमान्य इनपुट मान सकते हैं (अमान्य का अर्थ है कि कोई समान अंक नहीं है)

टेस्ट

चूंकि यह चुनौती कई अभ्यावेदन की अनुमति देती है, कृपया तालिका देखें।

Comments

संबंधित ।

— ।

क्या हम किसी निर्दिष्ट बिट-ऑर्डर या केवल दो में दिखाए गए एक पूर्णांक (या सरणी) को स्वीकार कर सकते हैं?

— जोनाथन एलन

@JonathanAllan: मैं स्पष्ट करूँगा, केवल पहले से ही दिखाए गए।

— ।

ओह बकवास, आपको सभी इनपुट प्रकारों को संभालने की आवश्यकता नहीं है? केवल एक? वूप्स ...

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn: हाँ वास्तव में :)

— '

Answer 1

जावास्क्रिप्ट (ईएस 6), 26 बाइट्स

थोड़ा एंडियन में इनपुट लेता है।

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

इसे ऑनलाइन आज़माएं!

Comments

मिशा लावरोव की विधि 25 के लिए बनाती है ।

— जोनाथन एलन

Answer 2

पायथन 3 , 18 बाइट्स

b'~0my3[_p{'.find

इसे ऑनलाइन आज़माएं!

छोटे-एंडियन इनपुट का उपयोग करता है। एक कच्चा \x7Fबाइट शामिल है ।

पायथन 2 , 27 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 3

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 41 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इनपुट के रूप में पूर्णांकों के लिटिल-एंडियन कॉलम का उपयोग करता है। वाक्यविन्यास चेतावनी पर ध्यान न दें।

एक इनपुट एक्स के लिए, हम पहले एक्स मॉड 41 लेते हैं और फिर परिणाम मॉड 11 लेते हैं। परिणाम अलग-अलग मॉड 11 हैं, इसलिए हम उन्हें एक टेबल से निकाल सकते हैं। उदाहरण के लिए, 126 मॉड 41 मॉड 11 3 है, इसलिए यदि हम स्थिति 3 को 0 के बराबर बनाते हैं, तो हमें 126 के इनपुट के लिए सही उत्तर मिलता है।

मेज है 9[,6,0,8,2,3,1,7,5,4]। भाग ० सिर है, जो है 9। भाग 1 गायब है, इसलिए यह Nullएक बाइट को बचाने के लिए है: हमें कभी भी भाग 1 लेने की आवश्यकता नहीं है। फिर भाग 2 है 6, भाग 3 है 0, और इसी तरह, हमेशा की तरह।

---

जोनाथन एलन का जवाब हमें देता है 1[4,9,8,6,2,0,5,3,7][[384~Mod~#~Mod~13]]&। यह कोई छोटा नहीं है, लेकिन यह वाक्यविन्यास चेतावनी से बचता है!

---

वोल्फ्राम भाषा (गणितज्ञ) , 27 25 बाइट्स

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

(यहाँ कुछ चरित्र है जो काफी दिखाई नहीं देता है, क्षमा करें। नीचे दिए गए लिंक पर क्लिक करें और आप इसे देखेंगे।

इसे ऑनलाइन आज़माएं!

यह सब ब्रूट-फोर्सिंग के बारे में है जो कुछ स्ट्रिंग को अंदर जाने के लिए है Hashताकि हैश अंत में सही मानों के साथ हो जाए। 11 अधिक ब्रूट फोर्सिंग शायद हमें और भी छोटे समाधान के लिए मिल सकती है।

Comments

क्या आप इस उत्तर को थोड़ा सा समझा सकते हैं, जो किसी ऐसे व्यक्ति के लिए है जो गणितज्ञ को नहीं जानता है।

— जिरोक

मैंने सोचा कि यह किसी के लिए भी पठनीय होगा, लेकिन ठीक है, मैं एक स्पष्टीकरण में संपादित करूँगा।

— मिशा लावरोव

बधाई; 41 बाइट के घोल ने मेरे मैथमेटिका कंप्रेसर को तोड़ दिया।

— lirtosiast

Answer 4

जेली , 12 बाइट्स

“0my3[_p¶{‘i

थोड़ा-सा एंडियन पूर्णांक स्वीकार करता है।

इसे ऑनलाइन आज़माएं!

यह अनुभवहीन कार्यान्वयन है, एक ट्रेजर कोड प्राप्त करने का एक तरीका हो सकता है।

Answer 5

पायथन 2 , 31 बाइट्स

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

इसे ऑनलाइन आज़माएं! थोड़ा-सा एंडियन के रूप में इनपुट लेता है।

Answer 6

जावा (JDK) , 32 बाइट्स

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

इसे ऑनलाइन आज़माएं!

क्रेडिट

• पोर्ट ऑफ Arnauld की जावास्क्रिप्ट उत्तर , इतिहास के पिछले प्रयास की तुलना में बहुत कम है।
• -1 बाइट धन्यवाद, जोनाथन एलन को , मिशा लावरोव के वुल्फ्राम लैंग्वेज (गणितज्ञ) उत्तर का उपयोग करते हुए ।

Comments

मिशा लावरोव की विधि 32 के लिए बनाती है ।

— जोनाथन एलन

धन्यवाद, @JonathanAllan! बहुत सराहना की!

— ओलिवियर ग्रेजायर 13

Answer 7

जावास्क्रिप्ट (Node.js) , 25 बाइट्स

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

थोड़ा-सा एंडियन पूर्णांक स्वीकार करता है।

इसे ऑनलाइन आज़माएं!

---

पायथन में 31 बाइट्स के लिए पोर्ट lambda n:'1498620537'[384%n%13]

Answer 8

व्हॉट्सएप , 152 बाइट्स

Obligatory "एस, टी, और एल वास्तव में वहाँ नहीं हैं, वे सिर्फ आदेशों के दृश्यमान हैं"।

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

Comments

आप 3 बाइट्स को बचाने के लिए तीन अनुगामी newlines निकाल सकते हैं। यह STDERR में एक त्रुटि देता है, लेकिन कार्यक्रम अभी भी काम करता है, और इसे मेटा-नियमों द्वारा अनुमति दी जाती है ।

— केविन क्रूज़सेन

Answer 9

ब्रेनफक , 474 176 154 151 149 137 बाइट्स

आठ के इनपुट स्ट्रिंग लेता है 0और दशमलव बिंदु के लिए 1पहले भी शामिल है 0।

(जैसे पोस्ट में तालिका के दूसरे कॉलम में)

आउटपुट अंक 0 से 9 तक।

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

इसे ऑनलाइन आज़माएं!

कलन विधि

किसी विशेष खंड की स्थिति का अवलोकन करके हम संभावित अंकों के एक सेट को छोटे उप-भागों में विभाजित कर सकते हैं। नीचे स्थिर बाइनरी सर्च ट्री का उपयोग मेरे कोड में किया गया है। लेफ्ट सबट्री सेगमेंट से संबंधित है, राइट सेगमेंट से ऑफ स्टेट से मेल खाती है।

                                         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. बिट्स सी और डी बेमानी हैं और इसे नजरअंदाज किया जा सकता है।
2. शून्य शून्य (दशमलव बिंदु के लिए बिट) मान (48) मूल्य के रूप में इस्तेमाल किया जा सकता है, इनपुट को पार्स करने और आउटपुट तैयार करने के लिए महत्वपूर्ण।
3. जब पत्ता पहुँच जाता है और अंक मुद्रित हो जाता है, तो हमें बस आगे की सभी शर्तों को छोड़ना होगा। यह ज़ीरो के क्षेत्र के लिए डेटा पॉइंटर को काफी आगे बढ़ाकर किया जा सकता है ताकि यह वापस न आ सके।
4. संगतता के लिए सही पर शून्य का उपयोग करना बेहतर है, क्योंकि कुछ बीएफ कार्यान्वयन नकारात्मक डेटा पॉइंटर्स का समर्थन नहीं करते हैं।
5. इसलिए सही सेल में आउटपुट वैल्यू स्टोर करना बेहतर होता है, इसलिए हम आसानी से ज़ीरो के क्षेत्र को दाईं ओर पहुंचा सकते हैं।
6. इसलिए बिट्स को बाएं से दाएं जांचना बेहतर है: ए, बी, ई, एफ, जी ताकि हम आउटपुट सेल तक आसानी से पहुंच सकें।
7. अलग-अलग अंक आउटपुट कोड साझा कर सकते हैं। उदाहरण के लिए, 5 और 6 एक ही उपप्रकार में हैं। हम +++++दोनों मूल्यों के लिए और फिर +केवल छह के लिए कर सकते हैं ।
8. +यदि हम आउटपुट में अग्रिम में 2 जोड़ते हैं तो हम कमांड की संख्या घटा सकते हैं । उस स्थिति में हमें इसे 0और 1केवल के लिए कम करने और अन्य अंकों के लिए लाभ प्राप्त करने की आवश्यकता है ।

Answer 10

रेटिना , 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

इसे ऑनलाइन आज़माएं! सबसे अच्छा तरीका नहीं हो सकता है, लेकिन यह रेटिना में प्रोग्रामिंग का एक दिलचस्प तरीका है। स्पष्टीकरण:

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

दिलचस्प मामलों को पकड़ने की कोशिश करता है। सकारात्मक कैप्चर केवल पत्र को कैप्चर करता है यदि यह मौजूद है। कब्जा की लंबाई इसलिए 1 है अगर यह मौजूद है और 0 अगर यह अनुपस्थित है। विशेष मामले 4 और 6 हैं जो केवल तभी मौजूद हैं जब डी या ई क्रमशः अनुपस्थित हैं। ये केवल के रूप में दशमलव में व्यक्त किया जा सकता $#4है और $#6लेकिन सभी हम यहाँ की जरूरत है कि। फिर कैप्चर को एक स्ट्रिंग में बनाया जाता है जिसकी लंबाई वांछित संख्या होती है। उदाहरण के लिए, यदि हम लिखते हैं 6*$1तो इस स्ट्रिंग की लंबाई 6 है यदि ए मौजूद है और 0 अनुपस्थित है। विभिन्न अभिव्यक्तियों के बीच चयन करने के लिए हम या तो $.(सकारात्मक कैप्चर के लिए) या $#(नकारात्मक कैप्चर के लिए) का उपयोग करते हैं जो या तो 0 या 1 का मूल्यांकन करते हैं और इसे तब तक स्ट्रिंग द्वारा गुणा किया जा सकता है।

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

F6 बार और Bदो बार दोहराया जाता है (जैसे कि यह गोल्फ खिलाड़ी है)। हालांकि, परिणाम दोनों जब तक नजरअंदाज कर दिया है Eऔर Gमौजूद हैं। इस के मामलों को संभालती है 2, 6और 8।

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

F5 बार दोहराया जाता है, और यदि Bमौजूद है, तो यह छठी बार जोड़ा जाता है और एक अतिरिक्त 3 (लंबाई 3 की एक निरंतर स्ट्रिंग द्वारा दर्शाया गया है)। हालांकि, परिणाम की अनदेखी तब तक की Dजाती है जब तक वह मौजूद न हो और Eअनुपस्थित हो। इस के मामलों को संभालती है 3, 5और 9।

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

A6 बार दोहराया जाता है, और G3 बार दोहराया जाता है, और एक अतिरिक्त 1जोड़ा जाता है (दोनों के बीच एक स्थिर चरित्र द्वारा प्रतिनिधित्व किया जाता है क्योंकि यह गोल्फ खिलाड़ी है)। जब तक Dअनुपस्थित है परिणाम को नजरअंदाज कर दिया जाता है। इस के मामलों को संभालती है 1, 4और 7।

$.(

इसके बाद के तारों को समतल किया जाता है और लंबाई ली जाती है। यदि उपरोक्त में से कोई भी लागू नहीं होता है, तो कोई स्ट्रिंग उत्पन्न नहीं होती है, और इसकी लंबाई इसलिए है0 ।

परिणामी तार (लंबाई से पहले लिया जाता है) इस प्रकार हैं:

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

Answer 11

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

Answer 12

पर्ल 5- पीपीएल, 24 बाइट्स

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

इसे ऑनलाइन आज़माएं!

छोटे-एंडियन पूर्णांक लेता है।

Answer 13

रूबी , 29 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 14

जाप, 15 बाइट्स

इनपुट के रूप में बिग-एंडियन मान लेता है।

"~¶ÌÚúþÞ"bUd

कोशिश करो

---

व्याख्या

स्ट्रिंग में बड़े-एंडियन मानों के प्रत्येक कोडपॉइंट पर वर्ण होते हैं; Udइनपुट के कोडपॉइंट पर कैरेक्टर bमिलता है और स्ट्रिंग में उस के इंडेक्स का पता चलता है।

Answer 15

नीम , 15 बाइट्स

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

स्पष्टीकरण:

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

इसे ऑनलाइन आज़माएं!

Answer 16

स्टैक्स , 12 बाइट्स

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

इसे चलाएं और डीबग करें

इनपुट थोड़ा एंडियन पूर्णांक है।

यह लुइस 'MATL समाधान के समान स्ट्रिंग स्थिरांक का उपयोग करता है।

Answer 17

TI-BASIC (TI-83 + / 84 + श्रृंखला), 15 बाइट्स

int(10fPart(194909642ln(Ans

छोटे-एंडियन इनपुट का उपयोग करता है। TI-BASIC में हैशिंग काफी सामान्य हैं, इसलिए मैंने इस तरह के मामलों के लिए हैश फंक्शन ब्रूट-फोरसर लिखा ।

हम यहां थोड़ा भाग्यशाली हैं, क्योंकि गुणक अपेक्षित 10 के बजाय 9 अंक लंबा है।

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

Answer 18

05AB1E , 17 16 15 12 बाइट्स

•NŽyf¯•I41%è

-1 बाइट के लिए @ErikTheOutgolfer का धन्यवाद ।
-1 बाइट @ 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।

Comments

16 बाइट्स ।

— आउटगॉल्फ

@EriktheOutgolfer आह, बिल्कुल .. संयोग से 128в। भूल गया कि वहाँ 128आधा होने के लिए एक भवन है 256। धन्यवाद!

— केविन क्रूज़सेन

मैं कुछ अजीब सामान भी 15 के तहत नहीं मिल सकता है की कोशिश की। Freakiest प्रयास: ¦C•26¤æÈÛµÀš•2ô₂+sk(19)।

— मैजिक ऑक्टोपस Urn

@ ग्रैमी थैंक्स! अब जब मैंने देखा कि यह स्पष्ट है, क्योंकि संपीड़ित पूर्णांक आकार 11 है और

— रैपराउंड

Answer 19

चारकोल, 17 बाइट्स

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

कोशिश करो!

जप उत्तर का बंदरगाह ।