एक से अधिक विकल्प परीक्षण धोखा


41

परिचय

अध्ययन करते समय, मैंने कई विकल्पों की परीक्षा को धोखा देने के कई तरीकों के साथ आने की कोशिश की। यह मूल रूप से बहुविकल्पी उत्तरों का संकुचित संस्करण है। विधि इस प्रकार है:

परीक्षण के उत्तर:

BCAABABA

इन्हें 3 अलग-अलग सरणियों में परिवर्तित किया जा सकता है, जो वर्तमान पत्र का उत्तर होने पर सही या गलत होने का संकेत देता है:

    B  C  A  A  B  A  B  A
A: [0, 0, 1, 1, 0, 1, 0, 1]
B: [1, 0, 0, 0, 1, 0, 1, 0]
C: [0, 1, 0, 0, 0, 0, 0, 0]

इन नंबरों की बाइनरी के रूप में व्याख्या करना इसे बहुत कम कर देगा। लेकिन यह वास्तव में थोड़ा और संकुचित हो सकता है। यदि आप A और B के पदों को जानते हैं, तो आपको C. के लिए पदों की आवश्यकता नहीं है। यह एक बिटवाइज़ नहीं ऑपरेटर के साथ किया जा सकता है:

A: [0, 0, 1, 1, 0, 1, 0, 1]
B: [1, 0, 0, 0, 1, 0, 1, 0]

A+B: [1, 0, 1, 1, 1, 1, 1, 1]
C:   [0, 1, 0, 0, 0, 0, 0, 0]

ए और बी को बाइनरी संख्या में परिवर्तित करने के परिणामस्वरूप होगा:

A: 00110101
B: 10001010

इसका मतलब है कि 8 बहुविकल्पी उत्तर दो बाइट्स के लिए संकुचित हो सकते हैं!


कार्य

बाइनरी में दो नंबरों को देखते हुए, या दो सरणियों में केवल 0 की और 1 की एक ही लंबाई के साथ, एकाधिक पसंद के उत्तर को आउटपुट करता है


नियम

  • इनपुट आपको किसी भी रूप में पसंद हो सकता है, जैसे [1, 0, 0, 1]या 1001
  • आप एक कार्यक्रम या एक समारोह प्रदान कर सकते हैं।
  • आप मान सकते हैं कि इनपुट हमेशा मान्य है।
  • आप एक सूची के रूप में भी उत्पादन कर सकते हैं, रिक्त स्थान के साथ अलग हो सकते हैं, आदि।
  • बहुविकल्पी उत्तरों में केवल A, B और C का समावेश होता है। आप इसके बजाय निचले मामले का उपयोग कर सकते हैं।
  • यह , इसलिए कम से कम बाइट्स जीत के साथ जमा करना!

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

Input: [1, 0, 0, 1, 0, 0, 1] [0, 1, 0, 0, 1, 0, 0]
Output: ABCABCA

Input: [0, 0, 0, 0, 1, 0, 1, 1] [1, 0, 1, 0, 0, 0, 0, 0]
Output: BCBCACAA

Input: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Output: CCCCCCCCCC

लीडरबोर्ड

var QUESTION_ID=69770,OVERRIDE_USER=34388;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important;font-family:Arial}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>


75
यहाँ मेरा समाधान है। यह अंग्रेजी में लिखा गया है (आप जहां भी हैं, स्वतंत्र रूप से उपलब्ध हैं), और है Study.। छह बाइट्स। को हराया।
कॉनर ओ'ब्रायन

58
@ C @O'Bʀɪᴇɴ अफसोस की बात यह है कि, अंग्रेजी एक प्रोग्रामिंग भाषा के हमारे मानकों को पूरा नहीं करती है और इसलिए यह एक मान्य सबमिशन नहीं है: p
अदनान

17
आप वास्तव में आधार 3 के रूप में उत्तरों की व्याख्या करके आठ बहुविकल्पीय प्रश्नों को 1.625 बाइट्स (13 बिट्स) तक संपीड़ित कर सकते हैं, इसलिए तकनीकी रूप से यह सबसे कुशल तरीका नहीं है। : पी
दरवाज़े

4
आप दो बिट्स, 00, 01, 10, 11 के सभी चार संयोजनों का उपयोग करके एक ही स्थान में एक और उत्तर जोड़ सकते हैं, उत्तर के लिए ए, बी, सी या डी। आप 11 का उपयोग नहीं कर रहे हैं
फिलिप हगलुंड

5
अंग्रेजी सभी मानदंडों को पूरा करती है। एकमात्र समस्या यह है कि इस सवाल के पूछे जाने से पहले कोई दुभाषिया उपलब्ध नहीं है।
jimmy23013

जवाबों:


50

जेली, 7 6 बाइट्स

_/ị“ḃ»

फोन पर टाइप करना। विवरण जोड़ देंगे।

(1,0)को जाता है A, (0,1)के लिए B, और (0,0)करने के लिए C। जेली में ऐरे 1-आधारित हैं, और अनुक्रमण समारोह चक्रीय रूप से काम करता है। इसलिए, हम केवल इनपुट पर घटाव को मोड़ सकते हैं।

_              [vectorized] subtraction
_/             Fold subtraction over the input
   “ḃ»         "ABC" compressed. '»' terminates a compressed string.
  ị            Vectorized cyclic index.

इसे यहाँ आज़माएँ ।


54
आपने फोन पर कैसे पृथ्वी पर टाइप किया? ऊ
कॉनर ओ'ब्रायन

34
सैमसंग का क्लिपबोर्ड इतिहास। यह आसान नहीं था।
lirtosiast

9
: -DD और 10k पर बधाई!
लुइस मेंडो

7
योग्य, अंग्रेजी के समान आकार @ CᴏɴᴏʀO'B R
RK।

13
मैंने "अध्ययन" के लिए अपना जवाब दिया; मैं एक दुभाषिया का उपयोग कर रहा हूं जो व्याकरण की गलतियों के साथ ठीक है। @RK।
कॉनर ओ'ब्रायन

12

रेटिना , 44 बाइट्स

T`d`BA
B(?=(.)* .*B(?<-1>.)*(?(1)!)$)
C
 .+

अनुगामी लाइनफीड महत्वपूर्ण है। इनपुट की तरह है

001101010 100010100

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

व्याख्या

T`d`BA

0एस Bऔर 1एस में बदलकर शुरू करो A। यह पहली छमाही को सही बनाता है, सिवाय इसके कि यह सूचीबद्ध करता है कि इसमें Bकब होना चाहिए C। हम Bजाँच कर सकते हैं कि Bदूसरे स्ट्रिंग की समान स्थिति में है या नहीं।

B(?=(.)* .*B(?<-1>.)*(?(1)!)$)
C

लुकहेड दो Bएस के पदों को मिलाने के लिए एक क्लासिक बैलेंसिंग ग्रुप काउंटिंग तकनीक है । (.)*मायने रखता है पहली बार तब जब प्रत्यय Bसमूह पर एक पर कब्जा धक्का द्वारा 1हर किरदार के लिए। फिर (?<-1>.)*उस समूह से फिर से चबूतरे। यह $सुनिश्चित करता है कि हम स्ट्रिंग के अंत तक पहुँच सकते हैं, और यह (?(1)!)सुनिश्चित करता है कि हमने वास्तव में पूरे समूह को समाप्त कर दिया है।

अंत में, हम अलग स्थान और दूसरी स्ट्रिंग से छुटकारा पा लेते हैं:

 .+


1
पोस्टिंग के पहले 15 सेकंड में 3 उत्थान; यह किसी प्रकार का रिकॉर्ड होना चाहिए।
कॉनर ओ'ब्रायन

8
@ C @O'Bʀɪᴇɴ चापलूसी, लेकिन मुझे आश्चर्य है कि उन 3 upvoters में से कितने वास्तव में 15 सेकंड में जवाब पढ़ा और समझा। : /
मार्टिन एंडर

4
मैंने किया। मैं रेगेक्स और रेटिना को पढ़ने के बजाय धाराप्रवाह हूं।
कोनोर ओ ब्रायन


11

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

(a,b)=>a.map((x,y)=>"CBA"[x*2+b[y]])

बहुत सरल, और शायद यह समझने के लिए पर्याप्त स्पष्ट है: प्रत्येक वस्तु और सूचकांक aको चार्ट पर स्थिति में ( x*2+ आइटम में सूचकांक yमें b) में मैप करें "CBA"


7
कृपया इसे अपने अनगढ़ संस्करण के रूप में जोड़ें : 3
कॉनर ओ'ब्रायन

2
@ C @O'Bʀɪᴇɴ वह CBAकरने के लिए। इसके अलावा, वह वैसे भी नहीं कर सकता, क्योंकि doएक आरक्षित कीवर्ड है, इसलिए यह अमान्य सिंटैक्स है।
पैट्रिक रॉबर्ट्स


11

MATL , 14 9 बाइट्स

2*+ 67w-c

वर्तमान संस्करण का उपयोग करता है (10.1.0)

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

व्याख्या

कोड क्या करता है इसका सारांश

2*       % implicitly input array and multiply it by 2
+        % implicitly input array and add it to the first one
67w-    % subtract from 67
c        % convert to char. Implicitly display

यह कैसे काम करता है, इसकी विस्तृत व्याख्या

2        % Push number 2 onto the stack
*        % Multiply the top two stack elements. Since there's only one
         % element, this triggers implicit input of a (yet inexistent)
         % element below the existing one. This is the first input array,
         % which will be called "A". Both "A" and number 2 are consumed,
         % and the array 2*A is left on the stack.
+        % Add the top two stack elements. Again, since there's only
         % one element (namely array 2*A) this triggers implicit input
         % of the second array, call it "B". Both 2*A and B are consumed
         % and 2*A+B is left on the stack
         % A blank space is needed after the "+" symbol to prevent it from
         % being interpreted as part of number "+67"
67       % Push number 67 onto the stack. The stack now contains, bottom
         % to top, 2*A+B and 67.
w        % Swap top two elements. The stack now contains 67 and 2*A+B
-        % Subtract top two elements. These are consumed and the result
         % 67-A*B is left on the stack
c        % Convert to char array, interpreting each number as ASCII code.
         % Number 67 corresponds to letter 'C'. Therefore at positions
         % where both arrays A and B were 0 this gives 'C' as result.
         % Where A was 1 and B was 0, i.e. 2*A+B is 2, this gives 'A'.
         % Where A was 0 and B was 1, i.e. 2*A+B is 1, this gives 'B'.
         % The stack contents, namely this char array, are implicitly
         % displayed at the end of the program.

ये अद्भुत है! क्या आप इस बारे में थोड़ा और लिख सकते हैं कि यह क्यों काम करता है? 67 क्यों? और इनपुट एरे को 2 से कैसे गुणा करें और फिर इनपुट ऐरे को 'मल्टीप्ल इनपुट ऐरे से 3' से अलग करें?
विंसेंट

1
@Vincent ज़रूर! मैं बाद में दिन में कुछ और विस्तृत विवरण
जोड़ूंगा

@ विंसेंट हो गया! मुझे बताएं कि क्या यह अभी स्पष्ट है
लुइस मेंडो

10

जावा, 81 बाइट्स

पहले से मौजूद जावा समाधान पर टिप्पणी करने के लिए कोई प्रतिष्ठा नहीं है, इसलिए यहां दिया गया है:

void x(int[]a,int[]b){int j=0;for(int i:a)System.out.printf("%c",67-2*i-b[j++]);}

1
यह स्मार्ट है। : मुझे पसंद है। मैं देखता हूं कि आपको प्रेरणा का एक छोटा सा हिस्सा मिला, हालांकि। ;)
Addison Crump

1
धिक्कार है, चतुर। मैं यह जानने की कोशिश कर रहा था कि मैं कैसे फिट होने के लिए एक
फॉरेस्ट

9

ब्रेनफक, 52 बाइट्स

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

एक दुभाषिया की आवश्यकता होती है जो आपको सेल 0 से बाईं ओर जाने देता है और इसमें 8-बिट रैपिंग सेल होते हैं। मेरे अधिकांश उत्तरों के विपरीत, EOF व्यवहार कोई मायने नहीं रखता है।

0xFFएक सीमांकक के रूप में , बाइट इनपुट लेता है। "परीक्षण मामलों" के तहत पहले इनपुट का प्रतिनिधित्व करने वाले बाइट्स की एक धारा इस तरह दिखाई देगी:

0x01 0x00 0x00 0x01 0x00 0x00 0x01 0xFF 0x00 0x01 0x00 0x00 0x01 0x00 0x00

मैं 0x00एक सीमांकक के रूप में एक सीमांकक और का उपयोग करके 0x01और 0x02क्रमशः 0 और 1 के रूप में बचा सकता है, लेकिन यह धोखा की तरह महसूस किया: P

एक बार जब मैंने अपनी रणनीति का पता लगा लिया, तो इस कार्यक्रम को लिखना बहुत आसान था। Nth अक्षर को आउटपुट में खोजने के लिए, 0x43(ASCII में कैपिटल C) से शुरू करें और घटाएं (पहले क्रम का nth तत्व) * दूसरे क्रम का 2 + nth तत्व)

इसके लायक क्या है, यहां 52 बाइट प्रोग्राम को 3 लाइनों में विभाजित किया गया है और उनके पास कुछ शब्द हैं:

Get input until hitting a 255 byte; put a 67 byte to the right of each one
,+[->>----[<--->----],+]

For each 67 byte: Subtract (value to the left)*2 from it
<[<[>--<-]<]

For each byte that used to contain 67: Subtract input and print result
>>[<,[>-<-]>.>>]

9

हास्केल, 29 बाइट्स

zipWith(\x y->"BCA"!!(x-y+1))

एक अनाम फ़ंक्शन। जैसे उपयोग करें:

>> zipWith(\x y->"BCA"!!(x-y+1)) [1, 0, 0, 1, 0, 0, 1] [0, 1, 0, 0, 1, 0, 0]
"ABCABCA"

मैंने फंक्शन को पॉइंट-फ्री बनाने की कोशिश की, लेकिन कुल गड़बड़ हो गई।


6
बराबर लंबाई का एक बिंदु मुक्त संस्करण:zipWith((!!).(["CB","AC"]!!))
नीमी

8

पायथ, 18 16 10 बाइट्स

3 आरडी प्रयास: 10 बाइट्स

FryAmTheEggman के अस्तित्व की याद दिलाने के लिए धन्यवाद G!

VCQ@<G3xN1

इनपुट फॉर्म [[0,0,1,1,0,1,0,1], [1,0,0,0,1,0,1,0]] का है, जो अनिवार्य रूप से एक मैट्रिक्स है: पंक्ति प्रश्न संख्या के लिए विकल्प और कॉलम के लिए।

हाथ से संकलित pythonic pseudocode:

              G = "abcdefghijklmnopqrstuvwxyz"    // preinitialized var
VCQ           for N in transpose(Q):    // implicit N as var; C transposes 2D lists
   @<G3           G[:3][                // G[:3] gives me "abc"
       xN1            N.index(1)        // returns -1 if no such element
                  ]

2 एन डी का प्रयास: 16 बाइट्स

VCQ?hN\A?.)N\B\C

इनपुट फॉर्म [[0,0,1,1,0,1,0,1], [1,0,0,0,1,0,1,0]] का है, जो अनिवार्य रूप से एक मैट्रिक्स है: पंक्ति प्रश्न संख्या के लिए विकल्प और कॉलम के लिए।

यह संकलन करता है

assign('Q',Pliteral_eval(input()))
for N in num_to_range(Pchr(Q)):
   imp_print(("A" if head(N) else ("B" if N.pop() else "C")))

ठीक है, मुझे पता है कि गन्दा लग रहा है, तो चलो pythonic pseudocode को हाथ से संकलन करते हैं

                 Q = eval(input())
VCQ              for N in range transpose(Q): // implicit N as var; transposes 2D lists
   ?hN               if head(N):              // head(N)=1st element of N
      \A                 print("A")           // implicit print for expressions
                     else:
        ?.)N             if pop(N):
            \B               print("B")
                         else:
              \C             print("C")

1 सेंट प्रयास: 18 बाइट्स

V8?@QN\A?@Q+8N\B\C

फॉर्म के इनपुट के साथ [0,0,1,1,0,1,0,1,0,0,0,0,1,0,1,0], अनिवार्य रूप से दो सूचियों का संघटन। यह संकलन करता है

assign('Q',Pliteral_eval(input()))
for N in num_to_range(8):
   imp_print(("A" if lookup(Q,N) else ("B" if lookup(Q,plus(8,N)) else "C")))

फिर से, हाथ से संकलन

                   Q = eval(input())
V8                 for N in range(8):
  ?@QN                 if Q[N]:
      \A                  print("A")
                       else:
        ?@Q+8N            if Q[N+8]:
              \B              print("B")
                          else:
                \C            print("C")

और मेरे जीवन में पहला कोडगोल्फ जाता है !!! मैंने कल ही पाइथ सीखा है, और यह पहली बार है जब मैंने कभी किसी कोड गोल्फ में भाग लिया।


प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यह पहली बार बहुत अच्छा लग रहा है, +1
अदनान

हमेशा किसी को पायथ सीखते हुए देखना अच्छा लगता है! आप .)होने के लिए गोल्फ कर सकते हैं e, और मुझे लगता है कि यह थोड़ा और अधिक गोल्फ हो सकता है । उस चर पर विचार करें Gजिसमें निचला केस वर्णमाला है, मेरा मानना ​​है कि आप इसका उपयोग करके लगभग 10 बाइट प्राप्त कर सकते हैं, खुश गोल्फ! :)
FryAmTheEggman

@FryAmTheEggman ओह ई! मैं कई मिनटों से इसे खोज रहा था! इसके अलावा, आपको जी की याद दिलाने के लिए धन्यवाद। आप सही हैं, 10 बाइट्स!
बुसुकुआन २ bus

7

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

FryAmTheEggman के लिए 1 बाइट धन्यवाद।
सेवित 2 बाइट्स हिस्टोक्रेट के लिए धन्यवाद।

थोड़ी देर में एक लाइनर के साथ हल करने में सक्षम नहीं है!

lambda*x:['CBA'[b-a]for a,b in zip(*x)]

यहाँ मेरे परीक्षण के मामले हैं। यह उस तरीके को भी दिखाता है जिस तरह से मैं इस फ़ंक्शन को मान रहा हूं।

assert f([1,0,0,1,0,0,1], [0,1,0,0,1,0,0]) == ['A', 'B', 'C', 'A', 'B', 'C', 'A']
assert f([0, 0, 0, 0, 1, 0, 1, 1], [1, 0, 1, 0, 0, 0, 0, 0]) == ['B', 'C', 'B', 'C', 'A', 'C', 'A', 'A']
assert f([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) == ['C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C']

यह zipसही जोड़े को लेने के लिए सरणियों युग्म के माध्यम से पुनरावृति करता है, और फिर एक स्ट्रिंग में अनुक्रमित करता है। यह सब एक सूची की समझ में होता है, इसलिए यह स्वचालित रूप से एक सूची बन जाता है। इस समाधान का मूल है कि केवल संभव संयोजनों aऔर bकर रहे हैं [0, 1], [1, 0], [0, 0]। इसलिए यदि हम उन्हें घटाते हैं, तो -1, 0, 1हमें वह मिलता है जो हमें क्रमशः अंतिम, पहला, मध्य तत्व मिलता है।



5

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

->a,b{a.zip(b).map{|x,y|:CAB[x-y]}}

उपयोग:

->a,b{a.zip(b).map{|x,y|:CAB[x-y]}}[[1,0,0],[0,1,0]]
=> ["A", "B", "C"]

"CAB" का शून्य (xy) वें शून्य-अनुक्रमित वर्ण लेता है। (1-0) 1 देता है, और इस प्रकार ए (0-0) 0 देता है, और इस प्रकार सी (0-1) -1 देता है, जो बी के चारों ओर लपेटता है।

निराई उत्पादन के साथ वैकल्पिक छोटा समाधान:

->a,b{a.zip(b){|x,y|p :CAB[x-y]}}

आउटपुट को नए सिरे से अलग किए गए स्ट्रिंग्स के रूप में उद्धृत किया जाता है, जो किसी भी तरह से बहुत दूर एक पुल लगता है।



4

ऑक्टेव, 19 बाइट्स

@(x,y)[67-y-2*x,'']

परीक्षा:

f([1 0 0 0 1 1],[0 1 0 0 0 0])
ans = ABCCAA

मैं बाद में एक स्पष्टीकरण जोड़ूंगा जब मेरे सामने एक कंप्यूटर होगा। यह मेरे सेल पर ऑक्टेव-ऑनलाइन पर लिखा और परीक्षण किया गया था ।


4

टीआई-बेसिक, 59 57 50 37 36 बाइट्स

से एक सूची लेता है Ans, और दूसरे से Prompt L₁। थॉमस क्व्वा के ब्रांचिंग से स्विच करने के सुझाव के लिए 13 बाइट्स का धन्यवाद sub(

Prompt X
For(A,1,dim(∟X
Disp sub("ACB",2+∟X(A)-Ans(A),1
End

मुझे यह देखना होगा कि थॉमस केवा ने कल क्या कहा था। ¯ \ _ (ツ) _ / ¯


आपको अभी भी कुछ बाइट्स बचानी हैं! के Prompt L₁साथ Prompt Xऔर L₁साथ बदलें ∟X। और भी बहुत कुछ है, लेकिन मैं आपको इसे ढूंढने दूंगा।
lirtosiast

@ThomasKwa L1 एक-एक बाइट टोकन है, आखिरी बार मैंने चेक किया था। सूची के साथ इसे फिर से संदर्भित करना + x दो बाइट्स होगा ... क्या मैं सही नहीं हूं?
कॉनर ओ'ब्रायन

L1 दो बाइट्स है।
lirtosiast

@ThomasKwa ओह। डैंग।
कॉनर ओ'ब्रायन

मैं 37 बाइट्स गिनता हूं क्योंकि यह वर्तमान में है। (आप 35 प्राप्त कर सकते हैं)
lirtosiast

4

जंग,, ९

Shepmaster के लिए 8 बाइट्स सहेजे गए।
23 बाइट्स केरी के लिए धन्यवाद बचा लिया।

मुझे लगता है कि यह सकारात्मक है कि इसे बहुत नीचे गिराया जा सकता है, लेकिन यह मेरा पहली बार एक पूर्ण रस्ट कार्यक्रम लिख रहा है।

fn b(a:&[&[u8]])->Vec<u8>{a[0].iter().zip(a[1]).map(|(c,d)|67-d-c*2).collect()}

यदि कोई भी इसे सिकोड़ने का प्रयास करना चाहता है, तो यहां असमतल कोड और परीक्षण मामले हैं।

fn b(a:&[&[u8]])->Vec<u8>{
    a[0].iter().zip(a[1]).map(|(c,d)|67-d-c*2).collect()
}
fn main() {
    assert_eq!("ABCABCA", b(&[&[1, 0, 0, 1, 0, 0, 1], &[0, 1, 0, 0, 1, 0, 0]]));
    assert_eq!("BCBCACAA", b(&[&[0, 0, 0, 0, 1, 0, 1, 1], &[1, 0, 1, 0, 0, 0, 0, 0]]));
    assert_eq!("CCCCCCCCCC", b(&[&[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]));
}

दृष्टिकोण मेरे पायथन उत्तर के समान है। मुख्य अंतर यह है कि मैं सीधे स्ट्रिंग्स को अनुक्रमित नहीं कर सकता, इसलिए मैं c-dचाल नहीं कर सकता ।


क्या फंक्शन के बजाय क्लोजर का इस्तेमाल करना कानूनी होगा? तब आप घोषणा में सभी प्रकारों को छोड़ सकते हैं और सिर्फ पास कर सकते हैं a[0]और a[1]दो अलग-अलग तर्क के रूप में।
oli_obk

64-y-2*xऑक्टेव समाधान से चाल का उपयोग करने से भी u8इसके बजाय उपयोग करने में सक्षम होने के कारण काफी कुछ बाइट्स की बचत होती है usize: is.gd/GNPK76
oli_obk

@ मैं एक बंद का उपयोग करने के बारे में पूरी तरह से निश्चित नहीं हूं। मुझे लगता है कि यह ठीक है, क्योंकि यह अनिवार्य रूप से एक अनाम कार्य है, है ना?
मॉर्गन थ्रैप

जब तक आप किसी भी परिवेश पर कब्जा नहीं करते हैं यह बिल्कुल एक अनाम फ़ंक्शन की तरह है।
oli_obk

@ @ फिर हाँ, बंद करना ठीक होना चाहिए।
मॉर्गन थ्रैप

4

विट्टी, 40 बाइट्स

आह मेरे बच्चे सरणी हेरफेर करने के लिए नहीं बनाया गया था।

एक प्रमुख के साथ STDIN (कुछ मैं कभी नहीं) के माध्यम से इनपुट की उम्मीद है "

WX&WXl\[68*-1+m]
?68*-2*"C"-i*O?
"B"O?X?

(जल्द ही उपलब्ध) क्रिया विधा में स्पष्टीकरण:

0:
STDIN;
remove top;
make new stack;
STDIN;
remove top;
push length of stack;
repeat next instruction set top times;
begin recursive area;
push 6;
push 8;
multiply top two;
subtract top two;
push 1;
add top two;
goto top method;
end recursive area;
1:
rotate right a stack;
push 6;
push 8;
multiply top two;
subtract top two;
push 2;
multiply top two;
toggle quote;
push cosine of top; // this is character literal "C"
toggle quote;
subtract top two;
push input item;
multiply top two;
output top as character;
rotate right a stack;
2:
toggle quote;
B;
toggle quote;
output top as character;
rotate right a stack;
remove top;
rotate right a stack;

यह लोगों को जल्द ही वास्तविक रूप से बेहतर बना रहा है। मुझे इसकी वर्तमान लंबाई के लिए खेद है।

मूल रूप से, मैं इनपुट को एक स्ट्रिंग के रूप में मानता हूं, और फिर वहां से हेरफेर करता हूं।

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


: ओ वर्बोस मोड तक इंतजार नहीं कर सकता। यह दिलचस्प होगा। के उपयोग की तरह W!
कॉनर ओ'ब्रायन

@ अदनान यह ट्रिपिटोनलाइन में इनपुट टैब है, लेकिन स्थानीय दुभाषिया पर, बस प्रोग्राम चलाएं और 0 और 1 के प्रत्येक सेट को एक अग्रणी के साथ इनपुट करें "और एक अनुगामी न्यूलाइन जबकि प्रोग्राम चल रहा है ( Wतकनीकी रूप से शीघ्र)।
एडिसन क्रम्प

आह, मैंने तर्क खंड में इनपुट दिया: पी। हालांकि अच्छा जवाब :)
अदनान

@ अदनान मुझे यह पता लगाने में थोड़ा समय लगा - विटी ऑटोपार्स इनपुट अगर यह पहचानता है कि यह एक डबल है। आप तकनीकी रूप से संख्याओं को छोड़कर कुछ भी अग्रणी हो सकते हैं, और यह समान काम करेगा।
Addison Crump

हेह, यह काफी अजीब है, लेकिन दूसरी तरफ यह उपयोगी हो सकता है।
अदनान

3

सीजाम, 10 बाइट्स

'Cq~z2fbf-

दो सूचियों की सूची के रूप में इनपुट, उदाहरण के लिए

[[1 0 0 1 0 0 1] [0 1 0 0 1 0 0]]

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

व्याख्या

एक आधार -2 संख्या के टुकड़े के रूप में जोड़े इलाज पर हम पाते हैं 2के लिए A, 1के लिए Bऔर 0के लिए C

'C  e# Push the character C.
q~  e# Read and evaluate input.
z   e# Transpose the pair of lists to get a list of pairs.
2fb e# Convert each pair from base 2.
f-  e# Subtract each result from the character C.

3

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

मुझे लगा कि मेरे पास एक सुंदर समाधान है, फिर मैंने @ मॉर्गन थ्रैप का उत्तर देखा ...

संपादित करें: उपर्युक्त के लिए तीन बाइट्स धन्यवाद सहेजा गया।

lambda*x:['A'*a+b*'B'or'C'for a,b in zip(*x)]

lambda *x:[a*'A'or b*'B'or'C'for a,b in zip(*x)]


बहुत सुंदर। नहीं देखा lamba*x:। मुझे हमेशा लगता है कि यह उतना ही कॉम्पैक्ट है जितना कि तब मुझे बताया जा सकता है / और भी अधिक तरकीबें मिल सकती हैं। मैं वास्तव में आपके समाधान को पसंद करता हूं, बहुत अच्छा।
ओगादे

3

जावा, 131 122 110 90 बाइट्स

EDIT: मदद और प्रेरणा के लिए बिफ्ज़ / फ्लैगशिपस्पैम का धन्यवाद

void x(int[]a,int[]b){int j=0;for(int i:a){System.out.print(i>0?"A":b[j]>0?"B":"C");j++;}}

पहला सबमिशन, भोला जावा समाधान। लगभग निश्चित रूप से सुधार किया जा सकता है :)

static String x(int[]a,int[]b){String o="";for(int i=0;i<a.length;i++)o+=a[i]>0?"A":b[i]>0?"B":"C";return(o);} 


==1हो सकता है >0; आपके लिए यह बेहतर होगा कि आप प्रिंटिंग के बजाय ओ वापस कर दें।
lirtosiast

कैसे के बारे में: void x(int[]a,int[]b){for(int i=0;i<a.length;i++)System.out.print(a[i]>0?"A":b[i]>0?"B":"C");}(94 बाइट्स)? आपको कार्यों पर स्थिर घोषणा की आवश्यकता नहीं है।
Addison Crump

आपको पहले I, +4 बाइट्स घोषित करना होगा: D
Bifz

3

आर 29 16 बाइट्स

LETTERS[3-2*A-B]

समारोह की घोषणा को हटा दिया क्योंकि मैंने देखा कि यह अन्य प्रतियोगिताओं में आम है।


2

पॉवरशेल, 40 बाइट्स

param($a,$b)$a|%{"CBA"[2*$_+$b[++$d-1]]}

दो स्पष्ट सरणियों के रूप में इनपुट लेता है, उदाहरण के लिए। PS C:\Tools\Scripts\golfing> .\cheating-a-multiple-choice-test.ps1 @(1,0,0,1,0,0,1) @(0,1,0,0,1,0,0), और उन्हें दुकानों में $aऔर $b। इसके बाद, के माध्यम से लूप $aके साथ $a|{...}। प्रत्येक लूप, हम स्ट्रिंग में अनुक्रमित एक चरित्र को आउटपुट करते हैं "CBA", जिसमें इंडेक्स वर्तमान मूल्य से दोगुना तय किया जाता है $_, साथ ही $bहमारे हेल्पर चर द्वारा अनुक्रमित मूल्य जो पहले जोड़ा गया है, फिर घटाया गया है।

एक उदाहरण के रूप में, पहले परीक्षण के मामले के लिए, $a = @(1,0,0,1,0,0,1)और $b = @(0,1,0,0,1,0,0)। पहला लूप पुनरावृत्ति है $_ = 1, $d = $null(क्योंकि $dपहले घोषित नहीं किया गया है)। हम $dअब $_ = 1और $d = 1(पॉवरशेल में $null + 1 = 1) पूर्व जोड़ते हैं , जिसका अर्थ है $b[1-1] = $b[0] = 0। तो 2 * 1 + 0 = 2, इसलिए हम सूचकांक "CBA"[2], या A



2

आर 36 34 बाइट्स

function(a,b)c('B','C','A')[a-b+2]

दो बाइट्स ने अनावश्यक ब्रेसिज़ को हटाने से बचाया


आप फ़ंक्शन परिभाषा में ब्रेस को हटाकर दो बाइट्स बचा सकते हैं। वे आवश्यक नहीं हैं क्योंकि फ़ंक्शन बॉडी में एकल स्टेटमेंट होते हैं।
एलेक्स ए।

2

पर्ल 5 - 47

पहले से ही 30 जवाब और कोई पर्ल? यहाँ एक भोली पहली कोशिश है तो :-) बस समारोह:

sub x{($g,$h)=@_;map{$_?a:$h->[$i++]?b:c}@{$g}}

उपयोग:

@f = (0, 0, 0, 0, 1, 0, 1, 1);
@s = (1, 0, 1, 0, 0, 0, 0, 0);

print x(\@f, \@s);

मुझे पूरा यकीन है कि regex के साथ कुछ बेहतर किया जा सकता है, लेकिन मैं ऐसा नहीं कर पाया।


1

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

मैं सरणी तर्कों के बजाय पूर्णांक तर्कों को स्वीकार करने के लिए अतिरिक्त मील गया।

(a,b)=>[...Array(8)].map((_,n)=>'CBA'[(a&(s=128>>n)*2+b&s)/s]).join('')

स्पष्टीकरण:

(a,b)=>              // input of two integers representing 8 answers (max value 255 each)
[...Array(8)]        // generates an array with 8 indices that allows .map() to work
.map((_,n)=>         // n is each index 0-7
'CBA'[...]           // reading character from string via index reference
      (...)          // grouping for division
       (a&...)       // AND operator to test if answer is A
          (s=128>>n) // calculating binary index in integer input and storing reference
       *2            // bias index in 'CBA' so truthy is 2 instead of 1
       +(b&s)        // AND operator to test if answer is B
      /s             // divide by binary index to convert AND operators to increments of 1
.join('')            // convert to string without commas

स्ट्रिंग अनुक्रमण तर्क के लिए @ETHproductions को श्रेय।

यहाँ टेस्ट करें

f=(a,b)=>[...Array(8)].map((_,n)=>'CBA'[((a&(s=128>>n))*2+(b&s))/s]).join('');

console.log(f(0b01001001, 0b00100100));
console.log(f(0b00001011, 0b10100000));
console.log(f(0b00000000, 0b00000000));
<!-- results pane console output; see http://meta.stackexchange.com/a/242491 -->
<script src="http://gh-canon.github.io/stack-snippet-console/console.min.js"></script>

Pssst

3 अतिरिक्त बाइट्स के लिए, यह 30 उत्तरों के लिए प्रतिनिधित्व प्रदर्शित कर सकता है:

(a,b)=>[...Array(30)].map((_,n)=>'CBA'[((a&(s=1<<30>>n))*2+(b&s))/s]).join('')


1

लुआ, 87 बाइट्स

बस सरणियों में मूल्यों का परीक्षण, और कंक्रीटिंग A, Bया C

function f(a,b)s=""for i=1,#a do s=s..(0<a[i]and"A"or 0<b[i]and"B"or"C")end print(s)end

1

एफ #, 33 बाइट्स

Seq.map2(fun a b->67-a*2-b|>char)

यह एक आंशिक रूप से लागू फ़ंक्शन है जो दो अंतर अनुक्रम लेता है - दो सरणियां ठीक काम करती हैं - और सही उत्तरों का प्रतिनिधित्व करने वाले पात्रों का एक नया अनुक्रम देता है। =)


1

गंभीरता से, 14 बाइट्स

,,Z`i-"CBA"E`M

यह ऑनलाइन की कोशिश करो

संभवतः दुभाषिया के सुरक्षित मोड संस्करण में एक बग के कारण, आपको Xइसे ऑनलाइन संस्करण में सही काम करने के लिए जोड़ना होगा । उपरोक्त प्रोग्राम को ठीक से काम करने के लिए स्थानीय संस्करण डाउनलोड करें।

एक पूर्ण विवरण को वारंट करना बहुत कम है, इसलिए मैं सिर्फ इतना कहूंगा: यह जेली उत्तर के समान एल्गोरिथ्म का उपयोग करता है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.