Einführung

Während des Studiums habe ich versucht, mehrere Möglichkeiten zu finden, um einen Multiple-Choice-Test zu betrügen. Es ist im Grunde eine komprimierte Version der Multiple-Choice-Antworten. Die Methode sieht wie folgt aus:

Die Antworten zum Test:

BCAABABA

Diese können in 3 verschiedene Arrays konvertiert werden, was "wahr" oder "falsch" anzeigt, wenn der aktuelle Buchstabe die Antwort ist:

    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]

Das Interpretieren dieser Zahlen als binär würde dies sehr komprimieren. Dies kann aber tatsächlich etwas mehr komprimiert werden. Wenn Sie die Positionen von A und B kennen, brauchen Sie die Positionen für C nicht. Dies kann mit einem bitweisen NOT-Operator erfolgen:

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]

Das Konvertieren der Arrays A und B in Binärzahlen würde ergeben:

A: 00110101
B: 10001010

Das bedeutet, dass 8 Multiple-Choice-Antworten auf zwei Bytes komprimiert werden können!

Aufgabe

Bei zwei binären Zahlen oder zwei Arrays, die nur aus Nullen und Einsen mit derselben Länge bestehen, werden die Multiple-Choice-Antworten ausgegeben

Regeln

• Die Eingabe kann in jeder beliebigen Form erfolgen, wie [1, 0, 0, 1]oder 1001.
• Sie können ein Programm oder eine Funktion bereitstellen.
• Sie können davon ausgehen, dass die Eingabe immer gültig ist.
• Sie können auch eine Liste ausgeben, die durch Leerzeichen usw. getrennt ist.
• Die Multiple-Choice-Antworten bestehen nur aus A, B und C. Sie können jedoch stattdessen Kleinbuchstaben verwenden.
• Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!

Testfälle

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

Bestenliste

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>

Gelee, 7 6 Bytes

_/ị“ḃ»

Tippen am Telefon. Beschreibung wird hinzugefügt.

(1,0)geht zu A, (0,1)zu Bund (0,0)zu C. Arrays in Jelly basieren auf 1, und die Indexierungsfunktion ịarbeitet zyklisch. Deshalb können wir die Subtraktion einfach über die Eingabe klappen.

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

Probieren Sie es hier aus .

Retina , 44 Bytes

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

Der Zeilenvorschub am Ende ist signifikant. Eingabe ist wie

001101010 100010100

Probieren Sie es online!

Erläuterung

T`d`BA

Beginnen Sie, indem Sie 0s in Bund 1s in drehen A. Das macht die erste Hälfte richtig, abgesehen davon, dass es auflistet, Bwann es enthalten sollte C. Wir können diese fehlerhaften Bs identifizieren, indem wir prüfen, ob sich ein Bin derselben Position der zweiten Zeichenfolge befindet:

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

Der Lookahead ist eine klassische Zählmethode für Bilanzkreise, um die Positionen der beiden BSektoren abzugleichen. Das (.)*Suffix nach dem ersten Bwird gezählt, indem 1für jedes Zeichen ein Capture auf die Gruppe gedrückt wird. Dann (?<-1>.)*taucht die Gruppe wieder auf. Die $sorgt dafür , dass wir das Ende der Schnur so erreichen können, und die (?(1)!)sicherstellt , dass wir haben die ganze Gruppe tatsächlich erschöpft.

Zum Schluss werden der Trennungsraum und die zweite Zeichenkette entfernt:

 .+

J, 8 Bytes

'CAB'{~-

Verwendungszweck:

   0 0 1 0 0 1 ('CAB'{~-) 0 1 0 1 0 0
CBABCA

Probieren Sie es hier online aus.

JavaScript ES6, 36 Byte

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

Sehr einfach und wahrscheinlich verständlich genug: Ordnen Sie jedes Element und jeden Index adem Zeichen an der Position ( x*2+ Element am Index yin b) in zu "CBA".

MATL , 14 9 Bytes

2*+ 67w-c

Verwendet die aktuelle Version (10.1.0)

Probieren Sie es online!

Erläuterung

Zusammenfassung der Funktionen des Codes

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

Detaillierte Erklärung, wie es funktioniert

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.

Java, 81 Bytes

Kein Ruf, die bereits vorhandene Java-Lösung zu kommentieren, also hier geht's:

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

Brainfuck, 52 Bytes

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

Benötigt einen Interpreter, mit dem Sie von Zelle 0 nach links gehen können und der 8-Bit-Umbruchzellen hat. Im Gegensatz zu den meisten meiner Antworten spielt das EOF-Verhalten keine Rolle.

Übernimmt die Byteeingabe 0xFFals Begrenzer. Ein Bytestrom, der die erste Eingabe unter "Testfälle" darstellt, würde folgendermaßen aussehen:

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

Ich könnte ein paar Bytes sparen, indem ich 0x00als Begrenzer und mit 0x01und 0x02als 0 und 1, aber das fühlte sich an wie Betrug: P

Sobald ich meine Strategie herausgefunden hatte, war es sehr einfach, dieses Programm zu schreiben. Um den n-ten auszugebenden Buchstaben zu finden, beginnen Sie mit 0x43(Großbuchstaben C in ASCII) und subtrahieren Sie ((n-tes Element der ersten Folge) * 2 + n-tes Element der zweiten Folge).

Für das, was es wert ist, ist hier das 52-Byte-Programm, aufgeteilt in 3 Zeilen und mit einigen Wörtern daneben:

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
>>[<,[>-<-]>.>>]

Haskell, 29 Bytes

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

Eine anonyme Funktion. Verwenden Sie wie:

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

Ich habe versucht, die Funktion ohne Punkte zu machen, aber es gab ein totales Durcheinander.

Pyth, 18 16 10 Bytes

3 ^rd versuchen: 10 Bytes

Vielen Dank an FryAmTheEggman, der mich an die Existenz von erinnert hat G!

VCQ@<G3xN1

Die Eingabe hat die Form [[0,0,1,1,0,1,0,1], [1,0,0,0,1,0,1,0]], die im Wesentlichen eine Matrix: Zeile ist zur Auswahl und Spalte zur Fragennummer.

Handkompilierter pythonischer 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 ^nd Versuch: 16 Bytes

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

Die Eingabe hat die Form [[0,0,1,1,0,1,0,1], [1,0,0,0,1,0,1,0]], die im Wesentlichen eine Matrix: Zeile ist zur Auswahl und Spalte zur Fragennummer.

Dies kompiliert zu

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")))

Ok, ich weiß, dass das chaotisch aussieht, also lassen Sie uns per Hand zu pythonischem Pseudocode kompilieren

                 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 ^st Versuch: 18 Bytes

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

Bei Eingabe der Form [0,0,1,1,0,1,0,1,1,0,0,1,0,1,0] im wesentlichen Verkettung zweier Listen. Dies kompiliert zu

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")))

Wieder von Hand kompilieren

                   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")

Und da geht der erste Codegolf in meinem Leben !!! Ich habe gestern gerade Pyth gelernt und dies ist das erste Mal, dass ich an einem Codegolf teilgenommen habe.

Python 3, 39 Bytes.

1 Byte dank FryAmTheEggman gespeichert.
2 Bytes dank Histokrat gespeichert.

Konnte seit einiger Zeit nicht mehr mit einem Einzeiler gelöst werden!

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

Hier sind meine Testfälle. Es zeigt auch, wie ich davon ausgehe, dass diese Funktion aufgerufen wird.

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']

Es wird verwendet zip, um die Arrays paarweise zu durchlaufen und dann in eine Zeichenfolge zu indexieren, um den richtigen Buchstaben auszuwählen. Dies alles geschieht in einem Listenverständnis, sodass es automatisch zu einer Liste wird. Der Kern dieser Lösung ist, dass die einzig möglichen Kombinationen von aund bsind [0, 1], [1, 0], [0, 0]. Wenn wir sie also subtrahieren, erhalten wir eines, -1, 0, 1das uns das letzte, erste bzw. mittlere Element gibt.

Mathematica, 30 24 22 19 Bytes

^{3 Bytes aufgrund von @alephalpha gespeichert .}

{A,B,C}[[3-2#-#2]]&

Ziemlich einfach.

Ruby, 35 Bytes

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

Verwendungszweck:

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

Nimmt das (xy) -te mit Nullen versehene Zeichen von "CAB". (1-0) ergibt 1 und damit A. (0-0) ergibt 0 und damit C. (0-1) ergibt -1, was sich um B dreht.

Alternative kürzere Lösung mit weirder Ausgabe:

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

Die Ausgabe erfolgt in Anführungszeichen, die durch Zeilenumbrüche getrennt sind, was irgendwie zu weit entfernt zu sein scheint.

Japt, 13 Bytes

¡#C-X*2-VgY)d

Probieren Sie es online!

Wie es funktioniert

¡#C-X*2-VgY)d  // Implicit: U, V = input lists
¡              // Map each item X and index Y in U to:
 #C-X*2        //  The char code of C (67), minus 2X,
       -VgY)   //  minus the item at index Y in V.
            d  //  Convert to a char code.

Oktave, 19 Bytes

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

Prüfung:

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

Ich werde später eine Erklärung hinzufügen, wenn ich einen Computer vor mir habe. Dies wurde auf meinem Handy auf octave-online geschrieben und getestet .

TI-BASIC, 59 57 50 37 36 Bytes

Nimmt eine Liste aus Ansund die andere aus Prompt L₁. 13 Bytes gespart dank des Vorschlags von Thomas Kwa, von der Verzweigung auf zu wechseln sub(.

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

Ich muss nach Thomas Kwa Ausschau halten, den er morgen in den Kommentaren gefunden hat. ¯ \ _ (ツ) _ / ¯

Rust, 79

8 Bytes dank Shepmaster eingespart.
23 Bytes dank Ker gespeichert.

Ich bin mir sicher, dass dies eine Menge Abstriche machen könnte, aber ich schreibe zum ersten Mal ein vollständiges Rust-Programm.

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

Hier ist der ungolfed Code und die Testfälle, falls jemand versuchen möchte, ihn zu verkleinern.

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]]));
}

Der Ansatz ist meiner Python-Antwort ziemlich ähnlich. Der Hauptunterschied besteht darin, dass ich Strings nicht direkt indizieren kann, also kann ich den c-dTrick nicht ausführen.

Vitsy, 40 Bytes

seufz Mein Baby wurde nicht dazu gebracht, Arrays zu manipulieren.

Erwartet eine Eingabe durch STDIN (was ich nie mache) mit einem Lead ".

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

Erklärung im (bald verfügbaren) ausführlichen Modus:

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;

Das wird bald besser, Leute. Es tut mir so leid für seine aktuelle Länge.

Grundsätzlich behandle ich die Eingabe als Zeichenfolge und bearbeite sie dann von dort aus.

Probieren Sie es online!

CJam, 10 Bytes

'Cq~z2fbf-

Eingabe als Liste von zwei Listen, z

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

Teste es hier.

Erläuterung

Wenn wir die Paare als Bits einer Basis-2-Zahl behandeln, erhalten wir 2für A, 1für Bund 0für 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.

Python 3, 48 45 Bytes

Ich dachte, ich hätte eine elegante Lösung, dann sah ich die Antwort von @ Morgan Thrapp ...

edit: Speichert drei Bytes dank der oben genannten.

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)]

Java, 131 122 110 90 Bytes

EDIT: Danke an Bifz / FlagAsSpam für die Hilfe und Inspiration

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++;}}

Erste Einreichung, naive Java-Lösung. Kann mit ziemlicher Sicherheit verbessert werden :)

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);} 

R 29 16 Bytes

LETTERS[3-2*A-B]

Die Funktionserklärung wurde entfernt, da ich sah, dass sie in anderen Wettbewerben üblich ist.

PowerShell, 40 Bytes

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

Nimmt Eingaben als zwei explizite Arrays an, z. 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)und speichert sie in $aund $b. Als nächstes durchschleifen $amit $a|{...}. In jeder Schleife wird ein in die Zeichenfolge indiziertes Zeichen ausgegeben "CBA", wobei der Index um das Zweifache des aktuellen Werts $_plus dem $bvon unserer Hilfsvariablen indizierten Wert , der vorab hinzugefügt und dann abgezogen wurde, festgelegt wird.

Als Beispiel für den ersten Testfall $a = @(1,0,0,1,0,0,1)und $b = @(0,1,0,0,1,0,0). Die erste Schleifeniteration $_ = 1wurde ausgeführt $d = $null(da $ddies zuvor nicht deklariert wurde). Wir fügen $ddies jetzt $_ = 1und $d = 1(in PowerShell $null + 1 = 1) vorab hinzu , was bedeutet, dass $b[1-1] = $b[0] = 0. Dann 2 * 1 + 0 = 2indizieren wir also "CBA"[2], oder A.

𝔼𝕊𝕄𝕚𝕟 12 Zeichen / 22 Bytes

Ⓒ…îⓜṃ-$*2-í_

Try it here (Firefox only).

Erläuterung

Übersetzt in Javascript ES6 als

String.fromCharCode(...input1.map(($,_)=>67-$*2-input2[_]))

R 36 34 Bytes

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

Zwei Bytes gespart, um unnötige Klammern zu entfernen

Perl 5 - 47

Schon 30 Antworten und kein Perl? Hier ist dann ein naiver erster Versuch :-) Nur die Funktion:

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

Verwendungszweck:

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

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

Ich bin mir ziemlich sicher, dass man mit Regex etwas Besseres machen kann, aber ich konnte nicht herausfinden, wie.

JavaScript ES6, 75 Byte

Ich habe mir die Mühe gemacht, Integer-Argumente anstelle von Array-Argumenten zu akzeptieren.

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

Erläuterung:

(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

Dank an @ETHproductions für die String-Indizierungslogik.

Hier testen

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

Für 3 zusätzliche Bytes kann die Darstellung für bis zu 30 Antworten angezeigt werden:

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

Netzhaut, 46 Bytes

^
%
+`%(.)(.* )(.)
$1$3,%$2
10
A
01
B
00
C
\W
[empty line]

Führt die beiden Zeichenfolgen zusammen und wählt die Buchstaben entsprechend den Ziffernpaaren aus.

Probieren Sie es hier online aus.

Lua, 87 Bytes

Testen einfach die Werte in den Arrays und Verketten A, Boder 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

F #, 33 Bytes

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

Dies ist eine teilweise angewendete Funktion, die zwei int-Sequenzen verwendet - zwei Arrays funktionieren einwandfrei - und eine neue Folge von Zeichen zurückgibt, die die richtigen Antworten darstellen. =)

Im Ernst, 14 Bytes

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

Probieren Sie es online

Wahrscheinlich aufgrund eines Fehlers in der abgesicherten Version des Interpreters müssen Sie eine hinzufügen X, damit dieser in der Online-Version ordnungsgemäß funktioniert. Laden Sie die lokale Version herunter, damit das obige Programm wie besehen funktioniert.

Es ist zu kurz, um eine vollständige Erklärung zu geben, daher sage ich nur: Es wird derselbe Algorithmus wie für die Gelee-Antwort verwendet.