introduzione

Durante lo studio, ho cercato di trovare diversi modi per imbrogliare un test a scelta multipla. Fondamentalmente è una versione compressa delle risposte a scelta multipla. Il metodo è il seguente:

Le risposte al test:

BCAABABA

Questi possono essere convertiti in 3 matrici diverse, che indicano vero o falso se la lettera corrente è la risposta:

    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]

L'interpretazione di questi numeri come binari lo comprimerebbe molto. Ma questo può effettivamente essere compresso un po 'di più. Se conosci le posizioni di A e B, non hai bisogno delle posizioni per C. Questo può essere fatto con un operatore NOT bit a bit:

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]

La conversione delle matrici A e B in numeri binari comporterebbe:

A: 00110101
B: 10001010

Ciò significa che 8 risposte a scelta multipla possono essere compresse in due byte!

Compito

Dati due numeri in binario o due matrici costituite solo da 0 e 1 con la stessa lunghezza, genera le risposte a scelta multipla

Regole

• L'input può essere nella forma che preferisci, come [1, 0, 0, 1]o 1001.
• È possibile fornire un programma o una funzione.
• Si può presumere che l'input sia sempre valido.
• È inoltre possibile generare un elenco, separato da spazi, ecc.
• Le risposte a scelta multipla sono costituite solo da A, B e C. È possibile tuttavia utilizzare lettere minuscole.
• Questo è code-golf , quindi vince l'invio con il minor numero di byte!

Casi test

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

Classifica

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>

Gelatina, 7 6 byte

_/ị“ḃ»

Digitando sul telefono. Aggiungerà una descrizione.

(1,0)va a A, (0,1)a Be (0,0)a C. Le matrici in Jelly sono basate su 1 e la funzione di indicizzazione funziona ịciclicamente. Pertanto, possiamo semplicemente piegare la sottrazione sull'input.

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

Provalo qui .

Retina , 44 byte

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

L'alimentazione di linea finale è significativa. L'input è come

001101010 100010100

Provalo online!

Spiegazione

T`d`BA

Inizia trasformando 0s in Be 1s in A. Ciò rende la prima metà corretta, tranne per il fatto che elenca Bquando dovrebbe contenere C. Siamo in grado di identificare quegli errori Bcontrollando se c'è un Bnella stessa posizione della seconda stringa:

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

Il lookahead è una classica tecnica di conteggio dei gruppi di bilanciamento per abbinare le posizioni delle due Bs. I (.)*conteggi il suffisso dopo il primo Bspingendo un'acquisizione sul gruppo 1per ogni personaggio. Quindi (?<-1>.)*esce di nuovo da quel gruppo. Le $garantisce di raggiungere la fine della stringa così, e le (?(1)!)assicura che abbiamo effettivamente esaurite dell'intero gruppo.

Infine, ci liberiamo dello spazio di separazione e della seconda stringa:

 .+

J, 8 byte

'CAB'{~-

Uso:

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

Provalo online qui.

JavaScript ES6, 36 byte

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

Molto semplice e probabilmente abbastanza ovvio da capire: mappare ogni elemento e indicizzare ail carattere nella posizione ( x*2+ elemento nell'indice yin b) in "CBA".

MATL , 14 9 byte

2*+ 67w-c

Utilizza la versione corrente (10.1.0)

Provalo online!

Spiegazione

Riepilogo di ciò che fa il codice

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

Spiegazione dettagliata di come funziona

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 byte

Nessuna reputazione per commentare la soluzione Java già esistente, quindi ecco qui:

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

Brainfuck, 52 byte

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

Richiede un interprete che ti consente di andare a sinistra dalla cella 0 e ha celle a capo a 8 bit. A differenza della maggior parte delle mie risposte, il comportamento di EOF non ha importanza.

Accetta input di byte, con 0xFFcome delimitatore. Un flusso di byte che rappresentano il primo input in "Casi di prova" sarebbe simile al seguente:

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

Potrei salvare un paio di byte avendo 0x00come delimitatore e usando 0x01e rispettivamente 0x02come 0 e 1, ma mi è sembrato di imbrogliare: P

Una volta che ho capito la mia strategia, scrivere questo programma è stato molto semplice. Per trovare l'ennesima lettera da emettere, inizia con 0x43(maiuscola C in ASCII) e sottrai ((ennesimo elemento della prima sequenza) * 2 + ennesimo elemento della seconda sequenza)

Per quello che vale, ecco il programma da 52 byte suddiviso in 3 righe e con alcune parole accanto:

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 byte

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

Una funzione anonima. Usa come:

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

Ho provato a rendere la funzione priva di punti ma ho avuto un casino totale.

Pyth, 18 16 10 byte

3 ^° tentativo: 10 byte

Grazie a FryAmTheEggman per avermi ricordato dell'esistenza di G!

VCQ@<G3xN1

L'input ha la forma [[0,0,1,1,0,1,0,1], [1,0,0,0,1,0,1,0]], che è essenzialmente una matrice: riga per scelta e colonna per numero di domanda.

Pseudocodice pythonic compilato a mano:

              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 ^° tentativo: 16 byte

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

L'input ha la forma [[0,0,1,1,0,1,0,1], [1,0,0,0,1,0,1,0]], che è essenzialmente una matrice: riga per scelta e colonna per numero di domanda.

Questo si compila a

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, lo so che sembra disordinato, quindi compiliamo a mano in pseudocodice pitonico

                 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 tentativo: 18 byte

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

Con input del modulo [0,0,1,1,0,1,0,1,1,0,0,0,1,0,1,0], essenzialmente concatenazione di due elenchi. Questo si compila a

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

Ancora una volta, compilando a mano

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

E arriva il primo codegolf della mia vita !!! Ho appena imparato Pyth ieri, e questa è la prima volta che ho mai partecipato a un golf di codice.

Python 3, 39 byte.

Salvato 1 byte grazie a FryAmTheEggman.
Salvato 2 byte grazie all'istocratico.

Non sono stato in grado di risolvere con un solo liner da un po '!

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

Ecco i miei casi di test. Mostra anche il modo in cui suppongo che questa funzione sia chiamata.

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

Viene utilizzato zipper scorrere le matrici in modo accoppiato, quindi si indicizza in una stringa per selezionare la lettera corretta. Tutto ciò accade nella comprensione di un elenco, quindi diventa automaticamente un elenco. Il nucleo di questa soluzione è che le uniche combinazioni possibili di ae bsono [0, 1], [1, 0], [0, 0]. Quindi, se li sottraggiamo, ne otteniamo uno dei -1, 0, 1quali ci dà rispettivamente l'ultimo, primo, medio elemento.

Mathematica, 30 24 22 19 byte

^{3 byte salvati grazie a @alephalpha .}

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

Abbastanza semplice.

Rubino, 35 byte

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

Uso:

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

Accetta il carattere (xy) esadecimale di "CAB". (1-0) dà 1, e quindi A. (0-0) dà 0, e quindi C. (0-1) dà -1, che si avvolge attorno a B.

Soluzione alternativa più breve con output più strano:

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

L'output è rappresentato da stringhe separate da newline, che in qualche modo sembra un ponte troppo lontano.

Japt, 13 byte

¡#C-X*2-VgY)d

Provalo online!

Come funziona

¡#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.

Ottava, 19 byte

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

Test:

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

Aggiungerò una spiegazione in seguito quando avrò un computer davanti a me. Questo è stato scritto e testato su ottava-online sul mio cellulare.

TI-BASIC, 59 57 50 37 36 byte

Prende un elenco da Anse l'altro da Prompt L₁. Salvato 13 byte grazie al suggerimento di Thomas Kwa di passare dalla ramificazione a sub(.

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

Dovrò cercare ciò che Thomas Kwa ha detto di aver trovato nei commenti domani. ¯ \ _ (ツ) _ / ¯

Rust, 79

Risparmiato 8 byte grazie a Shepmaster.
Salvato 23 byte grazie a Ker.

Sono convinto che questo potrebbe essere risolto molto, ma questa è la prima volta che scrivo un programma Rust completo.

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

Ecco il codice non archiviato e i casi di test nel caso in cui qualcuno voglia provare a ridurlo.

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

L'approccio è abbastanza simile alla mia risposta Python. La differenza principale è che non posso indicizzare direttamente le stringhe, quindi non posso fare il c-dtrucco.

Vitsy, 40 byte

sospiro Il mio bambino non è stato fatto per manipolare l'array.

Si aspetta input da STDIN (cosa che non faccio mai) con un vantaggio ".

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

Spiegazione nella modalità dettagliata (presto disponibile):

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;

La gente sta migliorando molto presto il golf. Mi dispiace molto per la sua lunghezza attuale.

Fondamentalmente, tratto l'input come una stringa e quindi manipolo da lì.

Provalo online!

CJam, 10 byte

'Cq~z2fbf-

Immettere come elenco di due elenchi, ad es

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

Provalo qui.

Spiegazione

Considerando le coppie come bit di un numero base-2, otteniamo 2per A, 1per Be 0per 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 byte

Pensavo di avere una soluzione elegante, poi ho visto la risposta di @Morgan Thrapp ...

modifica: salvato tre byte grazie a quanto sopra.

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 byte

EDIT: Grazie a Bifz / FlagAsSpam per l'aiuto e l'ispirazione

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

Prima presentazione, ingenua soluzione Java. Quasi certamente può essere migliorato :)

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 byte

LETTERS[3-2*A-B]

rimosso la dichiarazione di funzione da quando ho visto che è comune in altri concorsi.

PowerShell, 40 byte

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

Accetta input come due array espliciti, ad es. 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)e li memorizza in $ae $b. Quindi, scorrere $acon $a|{...}. Ad ogni ciclo, viene emesso un carattere indicizzato nella stringa "CBA", con l'indice deciso dal doppio del valore corrente $_, più il valore di$b indicizzato dalla nostra variabile helper che è stata pre-aggiunta e sottratta.

Ad esempio, per il primo caso di prova $a = @(1,0,0,1,0,0,1)e $b = @(0,1,0,0,1,0,0). La prima iterazione del ciclo ha $_ = 1, $d = $null(poiché $dnon precedentemente dichiarato). Pre-aggiungiamo a $dcosì ora $_ = 1e $d = 1(in PowerShell, $null + 1 = 1), nel senso che $b[1-1] = $b[0] = 0. Quindi 2 * 1 + 0 = 2, quindi indicizziamo "CBA"[2], o A.

𝔼𝕊𝕄𝕚𝕟, 12 caratteri / 22 byte

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

Try it here (Firefox only).

Spiegazione

Traduce in Javascript ES6 come

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

R 36 34 byte

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

Due byte salvati rimuovendo le parentesi graffe non necessarie

Perl 5 - 47

Hai già 30 risposte e nessun perl? Ecco un primo tentativo ingenuo quindi :-) Solo la funzione:

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

Uso:

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

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

Sono abbastanza sicuro che si possa fare qualcosa di meglio con regex, ma non sono riuscito a trovare il modo.

JavaScript ES6, 75 byte

Ho fatto il possibile per accettare argomenti interi anziché argomenti array.

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

Spiegazione:

(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

Ringraziamo @ETHproductions per la logica di indicizzazione delle stringhe.

Prova qui

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

Per 3 byte extra, può visualizzare la rappresentazione per un massimo di 30 risposte:

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

Retina, 46 byte

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

Unisce le due stringhe e sceglie le lettere in base alle coppie di cifre.

Provalo online qui.

Lua, 87 byte

Semplicemente testando i valori negli array e concatenando A, Bo 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 byte

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

Questa è una funzione parzialmente applicata che accetta due sequenze int - due matrici funzionano bene - e restituisce una nuova sequenza di caratteri che rappresentano le risposte corrette. =)

Scherzi a parte, 14 byte

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

Provalo online

Probabilmente a causa di un bug nella versione in modalità provvisoria dell'interprete, è necessario aggiungere un X per farlo funzionare correttamente nella versione online. Scarica la versione locale per far funzionare il programma sopra così com'è.

È troppo breve per giustificare una spiegazione completa, quindi dirò solo: utilizza lo stesso algoritmo della risposta Jelly.