बहुविकल्पी परीक्षा में भाग लेना, भाग 2

Question

यह अदनान की इस चुनौती की अगली कड़ी है । यदि आप इस चुनौती को पसंद करते हैं, तो संभावना है कि आप दूसरे को भी पसंद करेंगे। इसकी जांच - पड़ताल करें!

---

4 विकल्पों में से प्रत्येक के साथ 8 प्रश्नों के साथ एक बहु विकल्प परीक्षा के उत्तर हो सकते हैं BCADBADA:। चार अलग-अलग सरणियों में परिवर्तित, सही और गलत के साथ यदि वर्तमान पत्र का उत्तर है, तो यह इस तरह दिखेगा

Q#: 1  2  3  4  5  6  7  8
    B  C  A  D  B  A  D  A
A: [0, 0, 1, 0, 0, 1, 0, 1]
B: [1, 0, 0, 0, 1, 0, 0, 0]
C: [0, 1, 0, 0, 0, 0, 0, 0]
D: [0, 0, 0, 1, 0, 0, 1, 0]

यह थोड़ा तर्क का उपयोग करके संपीड़ित किया जा सकता है। विकल्पों में से प्रत्येक A, B, Cऔर Dदो सही / गलत मूल्यों द्वारा दर्शाया जा सकता नीचे दिखाया गया है:

A: 1 0
B: 0 1
C: 0 0
D: 1 1

इस तर्क का उपयोग करते हुए, हम ऊपर के चार वैक्टर को केवल दो तक संपीड़ित कर सकते हैं:

 1  2  3  4  5  6  7  8
 B  C  A  D  B  A  D  A
[0, 0, 1, 1, 0, 1, 1, 1]
[1, 0, 0, 1, 1, 0, 1, 0]

यही है, आपके परीक्षण का समाधान बस है: 00110111, 10011010। इन्हें समेट कर, हमें बाइनरी नंबर मिलता है 0011011110011010, या 14234दशमलव में। अपने परीक्षण पर धोखा देने के लिए इस दशमलव मान का उपयोग करें!

चुनौती

N(इनक्लूसिव) रेंज में एक नंबर लें [0, 65535], और मल्टीपल चॉइस टेस्ट के उत्तर के साथ एक स्ट्रिंग आउटपुट करें।

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

14234
BCADBADA

38513
ABBDCAAB    

0
CCCCCCCC

120
CBBBBCCC

65535
DDDDDDDD

39253
ABCDABCD

आउटपुट ऊपरी या निचले मामले के अक्षरों में हो सकता है, लेकिन आप अन्य प्रतीकों का उपयोग नहीं कर सकते।

Comments

क्या आउटपुट को स्ट्रिंग के रूप में दिखाया जाना चाहिए, या पत्र अलग-अलग लाइनों पर हो सकते हैं, एक सूची में, आदि?

— xnor

@ एक्सनॉर ऑप्शनल :-)

— स्टेवी ग्रिफिन

स्पष्ट A = 00, B = 01, C = 10, D = 11 क्यों नहीं?

— user253751 1

इसका कारण मैं पहले अदनान की चुनौती से प्रेरित था A=10, B=01, फिर C=nor(A,B), और D=and(A,B)। दृष्टिहीनता में, इसे दूसरे तरीके से करना बेहतर हो सकता है, लेकिन अच्छी तरह से ... अभी बहुत देर हो चुकी है ...

— स्टीवी ग्रिफिन

Answer 1

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

d⁹+⁹BZḄḊị“BADC

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

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

d⁹+⁹BZḄḊị“BADC  Main link. Argument: n

d⁹              Divmod 256; yield [n : 256, n % 256].
  +⁹            Add 256; yield [n : 256 + 256, n % 256 + 256].
    B           Binary; convert both integers to base 2.
     Z          Zip; group the quotient bits with corresponding remainder bits.
      Ḅ         Unbinary; convert from base 2 to integer.
       Ḋ        Dequeue; discard the first integer, which corresponds to the
                dummy value introduced by adding 256 to quotient and remainder.
        ị“BADC  Index into that string, mapping [1, 2, 3, 0] to "BADC".

Answer 2

05AB1E , 19 18 16 बाइट्स

कोड:

žH+b¦2äøC’c‰±’sè

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

सबसे पहले, हम 65536संख्या में जोड़ते हैं ( žHएक स्थिर परिभाषित है 65536), जो कि 10000000000000000बाइनरी में भी है। यह शून्य के साथ संख्या को पैड करना है। 14234एक उदाहरण के रूप में संख्या लेते हैं । 14234 + 65536के बराबर है 79770। बाइनरी में कौन सा है:

10011011110011010

हम पहला वर्ण हटाते हैं, जिसके परिणामस्वरूप:

0011011110011010

हमने स्ट्रिंग को दो टुकड़ों में विभाजित किया है 2ä:

00110111, 10011010

उसके बाद, हम ऐरे को ज़िप करते हैं ø:

01, 00, 10, 11, 01, 10, 11, 10

उन्हें दशमलव में वापस लाकर (उपयोग करके C) परिणाम:

1, 0, 2, 3, 1, 2, 3, 2

अब, हमें केवल इसे स्ट्रिंग के साथ अनुक्रमित करने की आवश्यकता है cbad। इस स्ट्रिंग के लिए संपीड़ित संस्करण है ’c‰±’, जिसे यहां परीक्षण भी किया जा सकता है । अंत में, हम पात्रों को उपरोक्त सरणी के सूचकांक में प्राप्त करते हैं। उपरोक्त उदाहरण के लिए, इसमें परिणाम है:

1, 0, 2, 3, 1, 2, 3, 2
b  c  a  d  b  a  d  a

Answer 3

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

f=(n,i=8)=>i--?"CBAD"[n>>i&1|n>>i+7&2]+f(n,i):''

console.log(f(14234)); // BCADBADA
console.log(f(38513)); // ABBDCAAB
console.log(f(0));     // CCCCCCCC
console.log(f(120));   // CBBBBCCC
console.log(f(65535)); // DDDDDDDD
console.log(f(39253)); // ABCDABCD

गैर-पुनरावर्ती संस्करण (55 बाइट्स)

एक नियमित अभिव्यक्ति का उपयोग करते हुए, हम कर सकते हैं:

n=>"76543210".replace(/./g,i=>"CBAD"[n>>i&1|n>>+i+7&2])

Comments

आपने बिटवाइज़ ऑपरेशन करने के बारे में कैसे सोचा?

— ericw31415

@ ericw31415 - यहां तक कि अगर यह इतना स्पष्ट रूप से नहीं कर रहा है, चुनौती वास्तव में इन बिटवाइज़ संचालन उलटे क्रम में वर्णन है (पर शुरू "यह तर्क का एक सा का उपयोग कर संकुचित किया जा सकता है।" )

— Arnauld

... थोड़ा सा तर्क ...

— नील

Answer 4

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

f=lambda n,k=8:k*'_'and f(n/2,k-1)+'CBAD'[n>>7&2|n&1]

Ideone पर इसका परीक्षण करें ।

Comments

मैं उपयोग करने की कोशिश कर रहा था, (n&257)%127लेकिन यह अधिक लंबा है। बहुत बुरा 127 प्रमुख है। शायद आप इसे अनुकूलित करने का एक तरीका सोच सकते हैं।

— xnor

Answer 5

CP-1610 विधानसभा, 24 DECLE (30 बाइट्स)

इस कोड को एक Intellivision पर चलाने का इरादा है । ⁽¹⁾

CP-1610 ओपकोड को 10-बिट मान के साथ एन्कोड किया गया है, जिसे 'DECLE' के रूप में जाना जाता है। वास्तविक कार्य 24 DECLE से लंबा है, जो शुरू $4809और अंत में है $4820।

CPU रजिस्टरों, 16-बिट विस्तृत तथापि हैं तो यह किसी भी इनपुट मूल्य समर्थन करेंगे 0x0000.. 0xFFFF।

                            ROMW  10            ; use 10-bit ROM
                            ORG   $4800         ; start program at address $4800
4800 0002                   EIS                 ; enable interrupts (to enable display)

                    ;; ---- usage example
4801 0001                   SDBD                ; load parameter in R0
4802 02B8 009A 0037         MVII  #14234, R0    ;
4805 0004 0148 0009         CALL  cheat         ; call function
4808 0017                   DECR  PC            ; infinite loop

                    ;; ---- 'Cheat Your Test' function
                    cheat   PROC  

4809 0082                   MOVR  R0,     R2    ; copy R0 to R2
480A 0040                   SWAP  R0            ; swap LSB/MSB in R0
480B 02BC 0214              MVII  #$214,  R4    ; R4 = pointer to 2nd row of screen memory

480D 01DB           @@loop  CLRR  R3            ; clear R3
480E 0052                   RLC   R2            ; extract highest bit of R2 to carry
480F 0053                   RLC   R3            ; inject carry into R3
4810 0050                   RLC   R0            ; extract highest bit of R0 to carry
4811 0053                   RLC   R3            ; inject carry into R3
4812 0001                   SDBD                ; add pointer to lookup table to R3
4813 02FB 001D 0048         ADDI  #@@tbl, R3    ;
4816 029B                   MVI@  R3,     R3    ; read character value
4817 0263                   MVO@  R3,     R4    ; write it to screen memory (also does R4++)
4818 037C 021C              CMPI  #$21C,  R4    ; 8 characters written? ...
481A 0225 000E              BLT   @@loop        ; ... if not, jump to @@loop

481C 00AF                   JR    R5            ; return

481D 011F 0117      @@tbl   DECLE $11F, $117    ; characters 'B', 'C', 'A' and 'D'
481F 010F 0127              DECLE $10F, $127    ; in white, using the built-in font

                            ENDP

उत्पादन

---

_{(1) दी गई कि कम से कम एक कंपाइलर, कई एमुलेटर और कॉपीराइट-फ्री रिप्लेसमेंट ROM फाइलें आसानी से उपलब्ध हैं, मुझे लगता है कि यह किसी भी PPCG सबमिशन नियम का उल्लंघन नहीं करता है। लेकिन कृपया मुझे बताएं कि क्या मैं गलत हूं।}

Comments

हम बाइट्स में स्कोर करते हैं, इसलिए कुल बिट्स को जोड़ते हैं, और आपका स्कोर उस मान को आठ से विभाजित करने का दशमलव (फ्लोट) परिणाम है। इस मामले में, 27.5 बाइट्स।

— mbomb007

Answer 6

सीजेएम , 22 बाइट्स

ri2bG0e[8/:.{1$=)^'A+}

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

व्याख्या

जादू से संचालित ...

इस चुनौती में अक्षरों के लिए बिट जोड़े की मैपिंग थोड़ी मनमानी है। अगर हम प्रतिनिधित्व ABCDद्वारा 0, 1, 2, 3(ताकि हम सिर्फ चरित्र में जोड़ सकते हैं A) तो हम निम्नलिखित मानचित्रण हैं:

i1   i2   o
0    0    2
0    1    1
1    0    0
1    1    3

इस मैपिंग को एक जादुई छोटे सूत्र के साथ गणना की जा सकती है: ((i1 == i2) + 1) ^ i1जहां समानता चेक रिटर्न 0या 1। निम्नलिखित तालिका देखें, जहां प्रत्येक स्तंभ एक इनपुट से मेल खाता है, प्रत्येक पंक्ति एक ऑपरेशन से मेल खाती है, और प्रत्येक सेल उस बिंदु पर स्टैक दिखाएगा:

[i1, i2]:  [0, 0]     [0, 1]     [1, 0]     [1, 1]
copy i1:   [0, 0, 0]  [0, 1, 0]  [1, 0, 1]  [1, 1, 1]
equals:    [0, 1]     [0, 0]     [1, 0]     [1, 1]
inc:       [0, 2]     [0, 1]     [1, 1]     [1, 2]
xor:       [2]        [1]        [0]        [3]

इसके साथ यहाँ स्रोत कोड का पूर्ण विराम है:

ri     e# Read input, convert to integer.
2b     e# Get binary representation.
G0e[   e# Pad to 16 bits with zeros.
8/     e# Split into two halves of 8 bits each.
:.{    e# For each pair of bits, i1 and i2...
  1$   e#   Copy i1.
  =    e#   Check equality with i2.
  )    e#   Increment.
  ^    e#   Bitwise XOR.
  'A+  e#   Add to 'A'
}

एक ही बाइट गिनती के साथ एक वैकल्पिक समाधान जो निश्चित रूप से कम जादुई है:

ri2bG0e[8/z2fb"CBAD"f=

और यदि यह किसी और के लिए उपयोगी है, तो यदि आप इसे i1और i2बिट्स को एक ही संख्या में बदल देते हैं (यानी जब आप मैपिंग चाहते हैं 0 -> 2, 1 -> 1, 2 -> 0, 3 -> 3) तो इसे और भी आसानी से गणना की जा सकती है (~n - 1) & 3या (~n - 1) % 4यदि आपकी भाषा सही मानों पर मोडुलो हो जाती है। मुझे लगता है कि इसे 3&~-~nकई भाषाओं में संक्षिप्त रूप से लिखा जा सकता है । बेस 2 से अतिरिक्त रूपांतरण के कारण CJam में यह लंबे समय तक एक बाइट के रूप में बदल जाता है।

Answer 7

PHP, 57 बाइट्स

for($i=8;$i--;)echo CBAD[($n=$argv[1])>>$i+7&2|$n>>$i&1];

बिटवाइज़ ऑपरेटरों के बिना संस्करण 70 बाइट्स

for(;$i<8;)echo CABD[($s=sprintf("%016b",$argv[1]))[$i]+$s[8+$i++]*2];

Comments

चर को कहाँ $iपरिभाषित किया गया है?

— ericw31415

@ ericw31415 एक चर के पहले उपयोग में आरंभीकृत किया जाता है और स्वचालित रूप से PHP को एक शून्य संदर्भ के साथ इस चर को घोषित किया जाता है

— Jörg Hülsermann

वह PHP (tm) है

— tomsmeding'

Answer 8

गणितज्ञ, 75 73 68 66 बाइट्स

StringPart["CBAD",#+##+1]&@@IntegerDigits[#,2,16]~Partition~8<>""&

2 बाइट बचाने के लिए @MartinEnder को धन्यवाद।

Comments

@MartinEnder #+##और Infixकार्य, लेकिन इसका प्रयोग StringPartअपरिहार्य है क्योंकि इसका प्रमुख "C"["B","A","D"][[#+##]]है "C", नहीं List; StringJoinकाम नहीं करता है।

— जुंगवान मिन सिप

ओह, मुझे लगता है कि नहीं पता था #और #2पूरे सूचियों थे।

— मार्टिन एंडर

Answer 9

पर्ल, 42 बाइट्स

के लिए +1 शामिल है -n

STDIN पर इनपुट दें:

perl -nE 'say+(A..D)[2-($`>>8-$_&257)%127]for/$/..8' <<< 39253

बस कोड:

say+(A..D)[2-($`>>8-$_&257)%127]for/$/..8

Answer 10

जावास्क्रिप्ट, 113 93 90 88 बाइट्स

20 बाइट बचाने में मेरी मदद करने के लिए @Neil को एक बड़ा धन्यवाद!
-3 बाइट्स @Cyoce को धन्यवाद

n=>{r="";b=("0".repeat(15)+n.toString(2)).slice(-16);for(i=0;i<8;i++)r+="CBAD"[parseInt(b[i]+b[i+8],2)];return r}

n=>{r="";b=(65536+n).toString(2).slice(1);for(i=0;i<8;i++)r+="CBAD"[+b[i+8]+2*b[i]];return r}

n=>eval('r="";b=(65536+n).toString(2).slice(1);for(i=0;i<8;i++)r+="CBAD"[+b[i+8]+2*b[i]]')

n=>eval('r="";b=n.toString(2).padStart(16,0);for(i=0;i<8;i++)r+="CBAD"[+b[i+8]+2*b[i]]')

दुख की बात है, जावास्क्रिप्ट जैसे कार्यों का अभाव है decbin, bindecऔर str_padपीएचपी है।

Comments

(65536+n).toString(2).slice(1)और [+b[i+8]+2*b[i]]कम हो सकता है, उदाहरण के लिए।

— नील

padStart, यह ECMAscript के भविष्य के संस्करण में स्वीकार किया जाना चाहिए, एक बड़ी बचत होगी।

— नील

इसके बजाय {…;return }, उपयोग करेंeval("…")

— साइओस

@ नील ऐसा लगता है कि padStartअब ईसीएमएस्क्रिप्ट में मौजूद है।

— ericw31415

Answer 11

MATL, 16 बाइट्स

16&B8eXB'BADC'w)

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

या सभी परीक्षण मामलों को सत्यापित करें

व्याख्या

        % Implicitly grab input
16&B    % Convert to binary string with at least 16 bits
8e      % Reshape the resulting string to have 8 rows and 2 columns
XB      % Convert each row from binary to decimal
'BADC'  % Push this string literal
w)      % Use the decimal numbers to index into this string (modular indexing)
        % Implicitly display the resulting string

Answer 12

जूलिया, 73 बाइट्स

N को इनपुट के रूप में एक फंक्शन देता है और स्ट्रिंग के रूप में उत्तर देता है।

f(N)=(b=bin(N,16);join(["CBAD"[parse("0b$(b[i])$(b[i+8])")+1]for i=1:8]))

कोशिश करो

यदि एक चार सरणी स्ट्रिंग के रूप में गिना जाता है, तो निर्भर करता है कि कोई भी ज्वाइन ( 67 बाइट ) छोड़ सकता है

f(N)=(b=bin(N,16);["CBAD"[parse("0b$(b[i])$(b[i+8])")+1]for i=1:8])

कोशिश करो

Answer 13

आर, 110 बाइट्स

आर में एक वेक्टरकृत समाधान के साथ आया था। यह शायद बाइनरी रूपांतरण के लिए एक उत्कृष्ट रूपांतरण इंट के साथ आने से गोल्फ द्वारा किया जाना चाहिए।

x=as.integer(intToBits(scan()));cat(LETTERS[1:4][match(paste0(x[16:9],x[8:1]),c("10","01","00","11"))],sep="")