Nandgame प्रशंसकों के लिए: कृपया तर्क गेट्स में डीपीडी को दशमलव पर आज़माएं !

पृष्ठभूमि

घने पैक दशमलव (DPD) द्विआधारी में दशमलव अंकों को कुशलता से संग्रहीत करने का एक तरीका है। यह 10 दशमलव में तीन दशमलव अंक (000 से 999) संग्रहीत करता है, जो भोली बीसीडी (जो 4 अंकों में एक अंक संग्रहीत करता है) की तुलना में बहुत अधिक कुशल है।

अंकन

छोटे अक्षरों aको iबिट्स कि दशमलव प्रतिनिधित्व करने के लिए कॉपी कर रहे हैं कर रहे हैं।
0और 1इनपुट या आउटपुट बिट पैटर्न में सटीक बिट्स हैं।
x रूपांतरण में बिट्स को अनदेखा किया जाता है।

रूपांतरण तालिका

डीपीडी के 10 बिट्स से तीन दशमलव अंकों तक रूपांतरण तालिका निम्नलिखित है। प्रत्येक दशमलव अंक को 4-बिट बाइनरी (बीसीडी) के रूप में दर्शाया गया है। दोनों पक्षों को सबसे महत्वपूर्ण अंक से दाएं बाएं लिखा जाता है।

Bits                 =>  Decimal         (Digit range)
a b c d e f 0 g h i  =>  0abc 0def 0ghi  (0-7) (0-7) (0-7)
a b c d e f 1 0 0 i  =>  0abc 0def 100i  (0–7) (0–7) (8–9)
a b c g h f 1 0 1 i  =>  0abc 100f 0ghi  (0–7) (8–9) (0–7)
g h c d e f 1 1 0 i  =>  100c 0def 0ghi  (8–9) (0–7) (0–7)
g h c 0 0 f 1 1 1 i  =>  100c 100f 0ghi  (8–9) (8–9) (0–7)
d e c 0 1 f 1 1 1 i  =>  100c 0def 100i  (8–9) (0–7) (8–9)
a b c 1 0 f 1 1 1 i  =>  0abc 100f 100i  (0–7) (8–9) (8–9)
x x c 1 1 f 1 1 1 i  =>  100c 100f 100i  (8–9) (8–9) (8–9)

कार्य

DPD के 10 बिट्स को दशमलव के 3 अंको में बदलें।

परीक्षण के मामलों

DPD           Decimal
0000000101    005
0001100011    063
0001111001    079
0000011010    090
0001011110    098
1010111010    592
0011001101    941
1100111111    879
1110001110    986
0011111111    999
1111111111    999  * Output is same regardless of the `x` bits

इनपुट

डिफ़ॉल्ट इनपुट प्रारूप 10 बिट्स की एक सूची है। बिट्स को ऊपर दिए गए सटीक क्रम, या इसके विपरीत का पालन करना चाहिए। आप इसके बजाय एक समतुल्य स्ट्रिंग या पूर्णांक प्रतिनिधित्व का उपयोग करना चुन सकते हैं। मेरी अन्य चुनौतियों के विपरीत, नेस्टेड संरचनाओं को पुन: व्यवस्थित या उपयोग करने की अनुमति नहीं है ।

इनपुट के लिए [1, 1, 0, 0, 0, 1, 0, 1, 0, 0], निम्न स्वरूपों की अनुमति है:

बिट्स की सूची: [1, 1, 0, 0, 0, 1, 0, 1, 0, 0]
स्ट्रिंग: "1100010100"
बाइनरी पूर्णांक: 788या0b1100010100
दशमलव पूर्णांक: 1100010100
[0, 0, 1, 0, 1, 0, 0, 0, 1, 1]उल्टा : और ऊपर किसी अन्य प्रारूप में उलट

निम्नलिखित स्वरूपों की अनुमति नहीं है:

बिट्स का मनमाना पुनरावर्तन: [0, 0, 0, 0, 0, 1, 1, 1, 0, 1]
नेस्टेड संरचनाएँ: [[1, 1, 0], [0, 0, 1], [0, 1, 0, 0]]या[0b110, 0b001, 0b0100]

उत्पादन

डिफ़ॉल्ट आउटपुट स्वरूप 3 दशमलव अंकों की एक सूची है। प्रत्येक अंक को 0 से 9 के रूप में दर्शाया जाना चाहिए, या तो एक पूर्णांक या एक चरित्र। इनपुट के रूप में, आप स्ट्रिंग या पूर्णांक प्रतिनिधित्व चुन सकते हैं। यदि आप पूर्णांक प्रतिनिधित्व चुनते हैं, तो अग्रणी शून्य को छोड़ा जा सकता है।

स्कोरिंग और जीतने की कसौटी

मानक कोड-गोल्फ नियम लागू होते हैं। प्रत्येक भाषा के लिए बाइट्स में सबसे छोटा प्रोग्राम या फ़ंक्शन जीतता है।

code-golf binary conversion

— bubbler
स्रोत

12

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

इस छोटे संस्करण का सारा श्रेय @nwellnhof को जाता है।

एक पूर्णांक के रूप में इनपुट लेता है। तीन दशमलव अंकों की एक सरणी देता है।

n=>[(x=n>>4,y=x>>3,q=n/2&55,p=q%8)>5&&q-39?8|y&1:y,(p&5^5?x&6:q-23?8:y&6)|x&1,(p<5?p*2:p<6?x&6:p%q<7?y&6:8)|n&1]

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

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

एक पूर्णांक के रूप में इनपुट लेता है। तीन दशमलव अंकों की एक सरणी देता है।

n=>[(x=n>>4&7,y=n>>7,p=n/2&7)>5&&p<7|x/2^2?8|y&1:y,(p<7?p-5?x:8:x/2^1?8:y&6)|x&1,(p<5?p*2:p<6?x&6:p<7|x<2?y&6:8)|n&1]

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

कैसे?

'आधिकारिक' एल्गोरिदम को लागू करने की कोशिश करने के बजाय, यह कोड पैटर्न के कुछ प्रकार के रिवर्स-इंजीनियरिंग पर आधारित है जो अपेक्षित परिणामों में पाया जा सकता है।

इनपुट पूर्णांक $n$ को देखते हुए , हम गणना करते हैं:

\begin{aligned} x = ⌊ \frac{n}{16} ⌋ mod 8 \\ y = ⌊ \frac{n}{128} ⌋ \\ p = ⌊ \frac{n}{2} ⌋ mod 8 \end{aligned}

$\begin{align}&x=\left\lfloor\frac{n}{16}\right\rfloor \bmod 8\\ &y=\left\lfloor\frac{n}{128}\right\rfloor\\ &p=\left\lfloor\frac{n}{2}\right\rfloor \bmod 8\end{align}$

उदाहरण: पहला अंक (सैकड़ों)

x     | 0                | 1                | 2                | 3               
n & 1 | 0101010101010101 | 0101010101010101 | 0101010101010101 | 0101010101010101
p     | 0011223344556677 | 0011223344556677 | 0011223344556677 | 0011223344556677
------+------------------+------------------+------------------+-----------------
y = 0 | 0000000000008888 | 0000000000008888 | 0000000000008888 | 0000000000008888
y = 1 | 1111111111119999 | 1111111111119999 | 1111111111119999 | 1111111111119999
y = 2 | 2222222222228888 | 2222222222228888 | 2222222222228888 | 2222222222228888
y = 3 | 3333333333339999 | 3333333333339999 | 3333333333339999 | 3333333333339999
y = 4 | 4444444444448888 | 4444444444448888 | 4444444444448888 | 4444444444448888
y = 5 | 5555555555559999 | 5555555555559999 | 5555555555559999 | 5555555555559999
y = 6 | 6666666666668888 | 6666666666668888 | 6666666666668888 | 6666666666668888
y = 7 | 7777777777779999 | 7777777777779999 | 7777777777779999 | 7777777777779999

x     | 4                | 5                | 6                | 7               
n & 1 | 0101010101010101 | 0101010101010101 | 0101010101010101 | 0101010101010101
p     | 0011223344556677 | 0011223344556677 | 0011223344556677 | 0011223344556677
------+------------------+------------------+------------------+-----------------
y = 0 | 0000000000008800 | 0000000000008800 | 0000000000008888 | 0000000000008888
y = 1 | 1111111111119911 | 1111111111119911 | 1111111111119999 | 1111111111119999
y = 2 | 2222222222228822 | 2222222222228822 | 2222222222228888 | 2222222222228888
y = 3 | 3333333333339933 | 3333333333339933 | 3333333333339999 | 3333333333339999
y = 4 | 4444444444448844 | 4444444444448844 | 4444444444448888 | 4444444444448888
y = 5 | 5555555555559955 | 5555555555559955 | 5555555555559999 | 5555555555559999
y = 6 | 6666666666668866 | 6666666666668866 | 6666666666668888 | 6666666666668888
y = 7 | 7777777777779977 | 7777777777779977 | 7777777777779999 | 7777777777779999

कलन विधि:

यदि $p<6$ , हमारे पास $d=y$
यदि $p=6$ , हमारे पास $d=8+(y\bmod2)$
यदि $p=7\text{ AND }(x<4\text{ OR }x>5)$ , हमारे पास $d=8+(y\bmod2)$
यदि $p=7\text{ AND }(x=4\text{ OR }x=5)$ , तो हमारे पास $d=y$

जेएस कोड के रूप में:

p > 5 && p < 7 | x / 2 ^ 2 ? 8 | y & 1 : y

— Arnauld
स्रोत

1

आपका दृष्टिकोण मेरे सी उत्तर के समान है जो एक अन्य अस्थायी चर का उपयोग करता है। मेरे प्रारंभिक सी समाधान को थोड़ा और अधिक गोल्फिंग करने के बाद, जावास्क्रिप्ट के लिए एक बंदरगाह 112 बाइट्स में परिणाम देता है ।

— nwellnhof

10

पायथन 3 , 229 ... 97 96 बाइट्स

lambda a:[[a&6,a>>4&6,a>>7&6,8][b"  eW7B]Oys"[~a&8or~a&6or~6|a>>4]%x&3]|a>>x%9&1for x in[7,4,9]]

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

-4 बाइट्स @xnor द्वारा

-6 बाइट्स @nwellnhof द्वारा

प्रारूपित:

h = lambda a:[
    [a&6, a>>4&6, a>>7&6, 8][              List to take high bits from
        b"  eW7B]Oys"[                     10 char string; where to get high bits for
                                             indicator values 1-8. 0th,1st chars not used.
            ~a&8 or ~a&6 or ~6|a>>4]       Compute indicator (by @nwellnhof)
        %x&3]                              High bits of each digit
    | a >> x%9 & 1                         bitwise OR with low bit of each digit
    for x in [7,4,9]]

व्याख्या

क्योंकि मैं मूल रूप से जेली में इसे लागू करना चाहता था, इसलिए मैं यहां अधिकांश उत्तरों से अलग दृष्टिकोण लेता हूं, जो सरल और शायद एक गोल्फ भाषा के अनुकूल है। हालांकि गोल्फ फ़ंक्शन एक पूर्णांक लेता है, इनपुट को थोड़ी सूची के रूप में दें [a0,a1,...,a9]। फिर हम इनपुट से तीन मान प्राप्त कर सकते हैं

निम्न बिट्स [a2,a5,a9]: ये [d0,d1,d2]क्रमशः निम्न बिट्स होंगे।
उच्च बिट्स [2*a0a1,2*a3a4,2*a7a8,8]: प्रत्येक अंक के उच्च बिट्स इनमें से एक होंगे।
संकेतक बिट्स, [a3,a4,a5,a7,a8]यह निर्धारित करते हुए कि प्रत्येक अंक के उच्च बिट्स कैसे प्राप्त करें। हम निम्नानुसार (1 और 8 के बीच) संकेतक की गणना करते हैं:
- यदि a5 == 0 है, तो संकेतक 8 है (मूल रूप से 0, लेकिन 8 का उपयोग करके बाइट बचाता है)
- यदि a3 नंद a4, सूचक 6 - 2 * a3a4 है
- अन्यथा सूचक 2 * a7a8 + 1 है (वास्तव में एक नकारात्मक संख्या के रूप में गणना की जाती है)।

फिर nth अंक को high_bits[arr[indicator][n]] | low_bits[n]नीचे की तालिका के अनुसार सुरुचिपूर्ण ढंग से गणना की जा सकती है , जिसे एक स्ट्रिंग में संपीड़ित किया जाता है।

arr = [
    [0,1,2],
    [3,1,2],
    [1,3,2],
    [2,1,3],
    [2,3,3],
    [3,2,3],
    [3,3,2],
    [3,3,3]
]

— lirtosiast
स्रोत

1

आप के b"..."साथ परिवर्तित करने के लिए एक बाइटस्ट्रिंग का उपयोग कर सकते हैं ord।

— xnor

@nwellnhof हा, मुझे बस एक ही बात मिली! वैसे भी आपको श्रेय देगा।

— lirtosiast

b"$>6;-/'?"[a&8and(~a&6or a>>4&6|1)]एक और चार बाइट्स बचाता है।

— nwellnhof

@nwellnhof मुझे लगता है कि एक मॉडुलो चेन यहाँ जाने का रास्ता है, लेकिन अगर आपका नहीं तो ज़रूर काम आएगा।

— lirtosiast

9

जावास्क्रिप्ट (Node.js) , 126 119 117 112 111 बाइट्स

(a,b,c,d,e,f,g,h,i,j)=>[(g&h&i+(b+=a*4+b,e+=d*4+e)!=5?8:b)+c,(g&i?h+e-3?8:b:e)+f,(g?h<i?e:h>i*e?b:8:h*4+i*2)+j]

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

-5 बाइट्स धन्यवाद @tsh (और खुद से 2) तो lमैं उम्मीद से ज्यादा प्रयास कर सकता हूं।

@ टीश की तकनीक का उपयोग कर -2 अधिक बाइट्स!

-5 बाइट्स थैंक्स @Arnauld

-1 बाइट धन्यवाद @ नील

10 बिट्स की सूची के रूप में इनपुट (10 तर्क के रूप में), 3 अंकों की सूची के रूप में आउटपुट।

— शायरु असकोतो
स्रोत

1

(!i|!d|e)-> i+l!=5; (d|e|!h)->h+l!=1

— tsh

1

(g?h-i|h&!e?h?b:e:8:h*4+i*2)-> (g?h<i?e:h>i*e?b:8:h*4+i*2)एक और बाइट बचाता है। (मैंने इस बार की जाँच की ...)

— नील

8

सी (जीसीसी) , 138 129 बाइट्स

f(w){int t=w/2&55,s=t%8,v=w/16,u=v/8;w=((s<6|t==39?u:8|u%2)*10+v%2+(s&5^5?v&6:t-23?8:u&6))*10+w%2+(s<5?s*2:s<6?v&6:s%t<7?u&6:8);}

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

प्रथम चर में कुछ बिट्स निकालता है sऔर t, इसलिए कि रूपांतरण सारणी की आठ पंक्तियों से पहचाना जा सकता:

1.  s < 4              u v w¹
2.  s = 4              u v 8¹
3.  s = 5              u 8 v
4.  s = 6              8 v u
5.  s = 7, t =  7      8 8 u
6.  s = 7, t = 23      8 u 8
7.  s = 7, t = 39      u 8 8
8.  s = 7, t = 55      8 8 8

¹ Can be computed with s*2

फिर सेट अप uऔर vडिवीजनों (दाएं पारियों) के साथ, ताकि u, vऔर इनपुट wमें निम्न तीन बीसीडी बिट्स हों जो 0-2 स्थान पर हों। बाकी बिट के आधार पर फेरबदल किया गया है sऔर t। दो उल्लेखनीय तरकीबें हैं:

s&5^5  // Rows 1, 2 and 4.
s%t<7  // Rows 1-5.

Shieru Asakoto के जावास्क्रिप्ट समाधान का एक बंदरगाह केवल 124 बाइट्स है :

f(a,b,c,d,e,f,g,h,i,j){a=(((g&h&i+(b+=a*4+b,e+=d*4+e)!=5?8:b)+c)*10+(g&i?h+e-3?8:b:e)+f)*10+(g?h-i|h&!e?h?b:e:8:h*4+i*2)+j;}

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

— nwellnhof
स्रोत

मुझे लगता है कि इसे छोटा किया जा सकता है:

f(b){int a=b/2%8,e=b&110,c=b/16,d=c/8;b=10*(10*(d%2|(6>a|78==e?d:8))+c%2+(3<a&a%2?e-46?8:d&6:c&6))+b%2+(4>a?b&6:a-5?a-6&&e-14?8:d&6:c&6)};

— एमसीसीसीएस

@MCCCS आपका कोड 138 बाइट्स का लगता है।

— nwellnhof

5

रूबी , 153 ... 119 117 बाइट्स

->n{n+=n&896;a,b,c=n&1536,n&96,n&14;"%x"%n+=c<9?0:2036+[b/16-b-1918,r=a>>8,[r+126,a/16-26,a-1978,38][b/32]-a][c/2-5]}

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

यह काम किस प्रकार करता है:

->n{n+=n&896;

यह प्रारंभिक बिंदु है: 3 बिट्स को बाईं ओर स्थानांतरित करके बीसीडी में परिवर्तित करें, जो अधिकांश पैटर्न के लिए काम करता है।

a,b,c=n&1536,n&96,n&14;

प्रत्येक कुतरना (और तीसरे कुतरने का एक अतिरिक्त बिट, लेकिन कम से कम महत्वपूर्ण बिट मुखौटा) के मध्य बिट्स प्राप्त करें।

"%x"%n+=c<9?0

यदि तीसरा अंक 10 से कम है (9 से कम है क्योंकि हमने एलएसबी के लिए कभी भी परवाह नहीं की है), हम सेट हैं: यह सादा बीसीडी है, हम कुछ भी बदले बिना हेक्स का उत्पादन कर सकते हैं

:2036+[b/16-b-1918,r=a>>8,[r+126,a/16-26,a-1978,38][b/32]-a][c/2-5]}

अन्यथा बिट्स को इधर-उधर करके और जादुई संख्याओं को जोड़कर कुछ काला जादू करें, जब तक कि हमें वह परिणाम नहीं मिल जाता जो हम चाहते हैं।

— जीबी
स्रोत

5

रेटिना 0.8.2 , 191 181 बाइट्स

(...)(...)
:$1,$2;
..(.),11(.);111
100$1,100$2;100
(10|(..)(.,)01)(.);111
100$3$2$4;100
(..)(.),(00.);111
100$2,1$3;0$1
(..)((.{5});110|(.);101)
100$3$4;$1
1
01
+`10
011
.0+(1*)
$.1

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

(...)(...)
:$1,$2;

विभाजक सम्मिलित करें ताकि प्रत्येक अंक को अलग से दशमलव में परिवर्तित किया जा सके। यह प्रभावी रूप से रूपांतरण तालिका में पहले दो मामलों को संभालता है।

..(.),11(.);111
100$1,100$2;100

अंतिम (आठवें) मामले को रूपांतरण तालिका में संभालें।

(10|(..)(.,)01)(.);111
100$3$2$4;100

रूपांतरण तालिका में छठे और सातवें मामलों को संभालें।

(..)(.),(00.);111
100$2,1$3;0$1

पांचवें तालिका को रूपांतरण तालिका में संभालें।

(..)((.{5});110|(.);101)
100$3$4;$1

रूपांतरण तालिका में तीसरे और चौथे मामले को संभालें।

1
01
+`10
011
.0+(1*)
$.1

दशमलव रूपांतरण के लिए बाइनरी प्रदर्शन करें।

— नील
स्रोत

5

जेली , 51 48 40 39 बाइट्स

&\‘f4;s3ɓạ4ḅ-œ?µ/Ḥ
“MY-€-Y¤©¡‘Dịs3Ḅç+ƭ/

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

कलन विधि

^{सूची सूचकांकों के अपवाद के साथ, इस खंड के सभी पूर्णांक बाइनरी में लिखे गए हैं।}

$\alpha\beta\gamma\delta\varepsilon\zeta\eta\theta\iota\kappa$ $[\eta\eta, \theta\iota, \delta\varepsilon]$ $[\alpha\beta, \delta\varepsilon, \theta\iota]$ $[\gamma, \zeta, \kappa]$

$\eta\eta = 00$ $0000$ $0111$ )।
$\eta\eta = 11$ $\theta\iota < 11$ $1000$ $1001$ )।
$\eta\eta = \theta\iota = 11$ $\delta\varepsilon < 11$ , ठीक दो उत्पादन अंक अधिक हैं।
$\eta\eta = \theta\iota = \delta\varepsilon = 11$

यदि हम अग्रणी की संख्या की गणना करते हैं $11$ $[\eta\eta, \theta\iota, \delta\varepsilon]$ $100$ $[\alpha\beta, \delta\varepsilon, \theta\iota]$

$[[\alpha\beta, \delta\varepsilon, \theta\iota]]$
$[[100, \alpha\beta, \delta\varepsilon], [\theta\iota]]$
$[[100, 100, \alpha\beta], [\delta\varepsilon, \theta\iota]] = [[100, 100, \alpha\beta], [\delta\varepsilon, 11]]$
$[[100, 100, 100], [\alpha\beta, \delta\varepsilon, \theta\iota]] = [[100, 100, 100], [\alpha\beta, 11, 11]]$

$[\gamma, \zeta, \kappa]$ $[\alpha\beta\gamma, \delta\varepsilon\zeta, \theta\iota\kappa]$ $[100\gamma, 100\zeta, 100\kappa]$

$[100, \alpha\beta, \delta\varepsilon]$ $[100, 100, \alpha\beta]$ $[\theta\iota]$ $\delta\varepsilon$

$[100, \alpha\beta, \delta\varepsilon]$ $[100, \alpha\beta, \delta\varepsilon]$ $[100, \delta\varepsilon, \alpha\beta]$ $[\alpha\beta, 100, \delta\varepsilon]$ $[\alpha\beta, \delta\varepsilon, 100]$ , $[\delta\varepsilon, 100, \alpha\beta]$ , तथा $[\delta\varepsilon, \alpha\beta, 100]$ ।

कंप्यूटिंग करके $100-\theta\iota$ , हम नक्शा करते हैं $00$ , $01$ , तथा $10$ क्रमपरिवर्तन का चयन करते हुए चार से तीन और दो $[\alpha\beta, \delta\varepsilon, 100]$ , $[\alpha\beta, 100, \delta\varepsilon]$ , तथा $[100, \delta\varepsilon, \alpha\beta]$ ।

परिणाम के साथ ज़िप करने के बाद $[\gamma, \zeta, \kappa]$ , हमें मिला $[\alpha\beta\gamma, \delta\varepsilon\zeta, 100\kappa]$ , $[\alpha\beta\gamma, 100\zeta, \delta\varepsilon\kappa]$ , या $[100\gamma, \delta\varepsilon\zeta, \alpha\beta\kappa]$ ।

तीसरे मामले में, क्रमपरिवर्तन (डुप्लिकेट के साथ) $[100, 100, \alpha\beta]$ कर रहे हैं $[100, 100, \alpha\beta]$ , $[100, \alpha\beta, 100 ]$ , $[100, 100, \alpha\beta]$ , $[100, \alpha\beta, 100 ]$ , $[\alpha\beta, 100, 100]$ तथा $[\alpha\beta, 100, 100]$ ।

कंप्यूटिंग करके $(100 - \theta\iota) - (100 - \delta\varepsilon) = \delta\varepsilon - \theta\iota = \delta\varepsilon - 11$ , हम नक्शा करते हैं $00$ , $01$ , तथा $10$ क्रमपरिवर्तन का चयन करते हुए तीन से चार और पांच मोडुलो छह $[100, 100, \alpha\beta]$ , $[100, \alpha\beta, 100 ]$ , तथा $[\alpha\beta, 100, 100]$ ।

परिणाम के साथ ज़िप करने के बाद $[\gamma, \zeta, \kappa]$ , हमें मिला $[100\gamma, 100\zeta, \alpha\beta\kappa]$ , $[100\gamma, \alpha\beta\zeta, 100\kappa]$ , या $[\alpha\beta\gamma, 100\zeta, 100\kappa]$ ।

कोड

“MY-€-Y¤©¡‘Dịs3Ḅç+ƭ/  Main link. Argument: A (array of 10 bits)

“MY-€-Y¤©¡‘           Array literal; yield [77, 89, 45, 12, 45, 89, 3, 6, 0].
           D          Decimal; yield
                      [[7,7], [8,9], [4,5], [1,2], [4,5], [8,9], [3], [6], [0]].
            ị         Retrieve the elements of A at those indices.
                      Indexing is 1-based and modular, so 1 is the first index, while
                      0 is the last.
             s3       Split the results 2D array of bits into chunks of length 3.
               Ḅ      Convert the 9 arrays of bits from binary to integer.
                ç+ƭ/  Reduce the resulting array (length 3) once by the helper link,
                      then by addition.


&\‘f4;s3ɓạ4ḅ-œ?µ/Ḥ    Helper link. Arguments: B, C (arrays of three integers each)

&\                    Cumulatively reduce B by bitwise AND.
  ‘                   Increment the results by 1.
   f4                 Filter; keep only integers equal to 4.
     ;                Concatenate the result with C.
      s3              Split the result into (one or two) chunks of length 3.
        ɓ      µ/     Reduce the array of chunks by the following chain.
         ạ4               Take the absolute difference of the integers in the right
                          chunk and the integer 4.
           ḅ-             Convert the resulting array from base -1 to integer, i.e.,
                          map [x] to n = x and [x, y] to n = y - x.
             œ?           Take the n-th permutation of the left chunk.
                 Ḥ    Unhalve; multiply the resulting integers by 2.

— डेनिस
स्रोत

2

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

lambda a,b,c,d,e,f,g,h,i,j:[c+[a*4+b*2,8][g*h*~(d*~e*i)],f+[d*4+e*2,8,a*4+b*2][g*i+(d<e)*g*i*h],j+[h*4+i*2,[8,[a*4+b*2,d*4+e*2][h<i]][h^i or(h&i-(d|e))]][g]]

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

— TFeld
स्रोत

2

क्लीन , 238 ... 189 बाइट्स

-2 बाइट्स नील को धन्यवाद

import StdEnv
$a b c d e f g h i j=100*(c+2*b+4*a)+10*(f+2*e+4*d)+j+2*i+4*h-2*(h*(99*b+198*a-394)+i*(9*e+18*d+h*(e+2*d-4+(b+2*a-4)*(1-10*e-100*d+110*e*d))-35)-4)*g+0^(e+d)*(2*b+4*a-8*i*h*g)

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

परिणाम की गणना करने के लिए एक प्रत्यक्ष सूत्र का उपयोग करके, 10 तर्कों के रूप में 10 बिट्स की 'सूची' लेता है।

— Οurous
स्रोत

में i*(9*e+19*d+i*...), वह दूसरा i*अनावश्यक दिखता है।

— नील

@ नील तुम सही हो, यह धन्यवाद है।

— Οurous

1

पर्ल 5, 195 बाइट्स

sub f{$n=shift;@p=((map{($n>>$_&3)*2}(8,5,1)),8);for(16390,28935,29005,227791,29108,225788,226803,228863){return 2*$n&256|$n&17|$p[$_>>4&3]<<8|$p[$_/4&3]<<4|$p[$_&3]if($_>>12&$n/2)==($_>>6&63);}}

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

मुझे पता है कि 195 बाइट्स इस प्रतियोगिता के लिए बहुत ज्यादा हैं, लेकिन मुझे पता नहीं था कि पर्ल कोड को और कैसे कंप्रेस किया जाए। सुझाव?

कोड की व्याख्या

अधिक पठनीय संस्करण में, कोड का इरादा स्पष्ट हो जाना चाहिए:

sub dpd {
  my $n = shift;
  my $v=2*($n&128)|$n&17;
  my @p=((map{($n>>$_&3)*2}(8,5,1)),8);
  for (16390,28935,29005,227791,29108,225788,226803,228863) {
    return $v |$p[$_>>4&3]<<8|$p[$_>>2&3]<<4|$p[$_&3]
      if(($_>>12&$n/2)==($_>>6&63));
  }
}

DPD एन्कोडिंग के नियमों में, प्रत्येक पंक्ति को 18 बिट मान, सेगमेंटेशन (6,6, (2,2,2) बिट्स में एन्कोड किया गया है।

पहले 6 बिट्स इनपुट के लिए 1 (= h) से 6 (= d) के बिट्स के लिए एक उपयुक्त बिट मास्क हैं (बिट 4 = एफ बेमानी है, लेकिन यह मूल्यांकन कोड को शामिल करने के लिए सरल करता है)।
अगले 6 बिट्स इस बिट मास्क के लिए मूल्य बिट्स हैं। सभी स्थानों पर मानों की जांच की जाती है जहां बिट मास्क का 1 मान होता है।
निम्नलिखित 3 * 2 बिट्स में @p3-बिट अनुक्रमों के लिए सरणी के लिए सूचक होते हैं जो 11-9, 7-5 और परिणाम के 3-1 बिट्स में कटा हुआ होते हैं।
सरणी @pका निर्माण बिट्स 9-8, 6-5, इनपुट के 3-2 और 8चौथे सदस्य के रूप में संख्या से किया गया है
इनपुट की स्थिति 7,4 और 0 पर बिट्स सीधे परिणाम के 8,4 और 0 बिट्स में स्थानांतरित किए जाते हैं।

उदाहरण के लिए, सूची में पहला नंबर 16390, जो 100000000000110कि एक छोटे से क्षेत्र के रूप में है, निम्नलिखित जानकारी देता है:

000100 : bit mask says: only consider bit 3 of the input
000000 : bit values say: bit 3 should be 0
00     : use '0ab' as higher bits of first digit
01     : use '0de' as higher bits of second digit
10     : use '0gh' as higher bits of third digit

— rplantiko
स्रोत

1

05AB1E , 84 बाइट्स

पोर्ट ऑफ़ किमोहियस का जवाब 05AB1E।

•4’7þ2Ô€iΘEuĆΣk4Ð€:ΘΛs‡CaΔʒì₁3¶rdiMß¡þи иø-˜)Â∍DY—WûQ@—Mā}Γ¤ÒÙ]p•44в2ôvÐyèP≠«}4ôC3.£

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

रफ स्पष्टीकरण:

•yadayada•44в2ô   # encoded list of nand gates
v                 # for each gate
 ÐyèP≠            # compute the output of the gate
      «           # append it to the input
       }          # end of the loop
4ô                # split the list of bits in groups of 4
  C               # convert each from binary to decimal
   3.£            # keep the last 3 numbers
                  # implicit output

— ग्रिमी
स्रोत

0

05AB1E , 104 103 101 बाइट्स

•3γã•S£©4èUXтÌ‹XSPVY®2èDˆTQ*~i0®нëт}®1èY¯`*i0®нëY_Xт>Ê*i0¯`ëт]®3èY¯`_*X110Q~i0®нëXт›iYiтë0¯`ëX]®θJ4ôC

निश्चित रूप से इस तरह की चुनौती के लिए सही भाषा नहीं है, लेकिन अच्छी तरह से ..
स्ट्रिंग के रूप में इनपुट, तीन अंकों की सूची के रूप में आउटपुट।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

हमारे पास विचार करने के लिए निम्नलिखित आठ परिदृश्य हैं:

     1st 2nd 3rd 4th 5th 6th                          1st digit    2nd digit    3rd digit
1.   ab  c   de  f   0gh i   →   0abc 0def 0ghi   →   '0'+1st 2nd  '0'+3rd 4th  5th     6th
2.   ab  c   de  f   100 i   →   0abc 0def 100i   →   '0'+1st 2nd  '0'+3rd 4th  5th     6th
3.   ab  c   gh  f   101 i   →   0abc 100f 0ghi   →   '0'+1st 2nd  '100'   4th  '0'+3rd 6th
4.   gh  c   de  f   110 i   →   100c 0def 0ghi   →   '100'   2nd  '0'+3rd 4th  '0'+1st 6th
5.   gh  c   00  f   111 i   →   100c 100f 0ghi   →   '100'   2nd  '100'   4th  '0'+1st 6th
6.   de  c   01  f   111 i   →   100c 0def 100i   →   '100'   2nd  '0'+1st 4th  '100'   6th
7.   ab  c   10  f   111 i   →   0abc 100f 100i   →   '0'+1st 2nd  '100'   4th  '100'   6th
8.   xx  c   11  f   111 i   →   100c 100f 100i   →   '100'   2nd  '100'   4th  '100'   6th

मैंने पहली बार आकार में विखंडित (अंतर्निहित) इनपुट को विभाजित किया [2,1,2,1,3,1]और उस सूची को रजिस्टर में संग्रहीत किया:

•3γã•     # Push compressed integer 212131
     S    # Convert it to a list of digits
      £   # Split the (implicit) input in chunks of that size
       ©  # Store it in the register (without popping)

मेरा 05AB1E टिप देखें (यह समझने के लिए कि बड़े पूर्णांक को संपीड़ित कैसे करें? ) क्यों •3γã•है212131

अब हम सबसे पहले आउटपुट के पहले अंक के लिए 0s और 1s का निर्माण करने जा रहे हैं। परिदृश्य 1,2,3,7 उपयोग '0'+1st+2nd; और परिदृश्य 4,5,6,8 का उपयोग करें '100'+2nd:

4è                  # Take the 5th item of the list
  U                 # Pop and store it in variable `X`
XтÌ‹                #  Check if `X` is below 102
                ~   # OR
   XSP              #  `X` is equal to 111
      VY            #  And store that result in variable `Y`
               *    #  and
        ®2è         #  Get the 3rd item from the list of the register
           Dˆ       #  Push it to the global array
             TQ     #  And check if it's equal to 10
i                   # If the combined check above is truthy (exactly 1):
 0                  #  Push 0 to the stack
 ®н                 #  Push the 1st item of the list to the stack
ë                   # Else:
 т                  #  Push 100 to the stack
}                   # Close the if-else
®1è                 # And push the 2nd item of the list to the stack

फिर हम आउटपुट के दूसरे अंक के लिए 0s और 1s का निर्माण करने जा रहे हैं। परिदृश्य 1,2,4 उपयोग '0'+3rd+4th; परिदृश्य 3,5,7,8 उपयोग '100'+4th; और परिदृश्य 6 का उपयोग करता है '0'+1st+4th:

Y                # Push `Y` (check if `X` equals 111)
   *             # and
 ¯`              # Push the item from the global array (3rd item of the list)
i                # If both checks above are truthy (exactly 1):
 0               #  Push 0 to the stack
 ®н              #  Push the 1st item of the list to the stack
ë                # Else:
 Y_              #  Push inverted `Y` (check if `X` does NOT equal 111)
       *         #  and
   Xт>Ê          #  Check if `X` (5th item of the list) does NOT equal 101
 i               #  If both checks above are truthy (exactly 1):
  0              #   Push 0 to the stack
  ¯`             #   Push the item from the global array (3rd item of the list)
 ë               #  Else:
  т              #   Push 100 to the stack
]                # Close both if-else cases
®3è              # And push the 4th item of the list to the stack

फिर हम आउटपुट के तीसरे अंक के लिए 0s और 1s का निर्माण करने जा रहे हैं। परिदृश्य 1,2 उपयोग 5th+6th; परिदृश्य 3 का उपयोग करता है '0'+3rd+6th; परिदृश्य 4,5 उपयोग '0'+1st+6th; और परिदृश्य 6,7,8 का उपयोग करें '100'+6th:

Y           #  Push `Y` (check if `X` equals 111)
    *       #  and
 ¯`_        #  Check if the item from the global array (3rd item of the list) is exactly 0
         ~  # OR
    X110Q   #  Check if `X` (5th item of the list) equals 110
i           # If the combined check above is truthy (exactly 1):
 0          #  Push 0 to the stack
 ®н         #  Push the 1st item of the list to the stack
ë           # Else:
 Xт›i       #  If `X` (5th item of the list) is larger than 100 (so 101/110/111):
     Yi     #   If `Y` (if `X` equals 111):
       т    #    Push 100 to the stack
      ë     #   Else:
       0    #    Push 0 to the stack
       ¯`   #    Push the item from the global array (3rd item of the list)
    ë       #  Else:
     X      #   Push `X` (5th item of the list) to the stack
]           # Close all if-else cases
®θ          # And push the last (6th) item of the list to the stack

अब हमारे पास ढेर पर सभी 0s और 1s हैं, इसलिए हम इसे तीन आउटपुट अंकों में बदल सकते हैं:

J     # Join the entire stack together
 4ô   # Split it into parts of size 4
   C  # Convert each part from binary to an integer (and output implicitly)

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

डेन्सली दशमलव (DPD) को दशमलव में पैक किया

पृष्ठभूमि

अंकन

रूपांतरण तालिका

कार्य

परीक्षण के मामलों

इनपुट

उत्पादन

स्कोरिंग और जीतने की कसौटी

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

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

कैसे?

उदाहरण: पहला अंक (सैकड़ों)

पायथन 3 , 229 ... 97 96 बाइट्स

व्याख्या

जावास्क्रिप्ट (Node.js) , 126 119 117 112 111 बाइट्स

सी (जीसीसी) , 138 129 बाइट्स

रूबी , 153 ... 119 117 बाइट्स

यह काम किस प्रकार करता है:

रेटिना 0.8.2 , 191 181 बाइट्स

जेली , 51 48 40 39 बाइट्स

कलन विधि

कोड

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

क्लीन , 238 ... 189 बाइट्स

पर्ल 5, 195 बाइट्स

कोड की व्याख्या

05AB1E , 84 बाइट्स

05AB1E , 104 103 101 बाइट्स