Introdução

Enquanto estudava, tentei encontrar várias maneiras de enganar um teste de múltipla escolha. Basicamente, é uma versão compactada das respostas de múltipla escolha. O método é o seguinte:

As respostas para o teste:

BCAABABA

Eles podem ser convertidos em três matrizes diferentes, o que indica verdadeiro ou falso se a letra atual for a resposta:

    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]

Interpretar esses números como binários comprimiria muito isso. Mas isso pode realmente ser compactado um pouco mais. Se você conhece as posições de A e B, não precisa das posições de C. Isso pode ser feito com um operador 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]

A conversão das matrizes A e B em números binários resultaria em:

A: 00110101
B: 10001010

Isso significa que 8 respostas de múltipla escolha podem ser compactadas para dois bytes!

Tarefa

Dados dois números em binário, ou duas matrizes que consistem em apenas 0 e 1 com o mesmo comprimento, produzem as respostas de múltipla escolha

Regras

• A entrada pode estar na forma que você quiser, como [1, 0, 0, 1]ou 1001.
• Você pode fornecer um programa ou uma função.
• Você pode assumir que a entrada é sempre válida.
• Você também pode imprimir como uma lista, separada por espaços, etc.
• As respostas de múltipla escolha consistem apenas em A, B e C. No entanto, você pode usar letras minúsculas.
• Isso é código-golfe , então a submissão com a menor quantidade de bytes ganha!

Casos de teste

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

Entre os melhores

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>

Geléia, 7 6 bytes

_/ị“ḃ»

Digitando no telefone. Irá adicionar descrição.

(1,0)vai para A, (0,1)para Be (0,0)para C. As matrizes no Jelly são baseadas em 1 e a função de indexação funciona ịciclicamente. Portanto, podemos apenas dobrar a subtração sobre a entrada.

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

Experimente aqui .

Retina , 44 bytes

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

O avanço de linha à direita é significativo. Entrada é como

001101010 100010100

Experimente online!

Explicação

T`d`BA

Comece ligando 0s para Be 1é em A. Isso corrige a primeira metade, exceto que lista Bquando deve conter C. Podemos identificar esses Bs errados , verificando se há um Bna mesma posição da segunda string:

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

O lookahead é uma técnica clássica de contagem de grupos para equilibrar as posições dos dois Bsegundos. A (.)*contagem do sufixo após a primeira é Binserida uma captura no grupo 1para cada personagem. Em seguida, (?<-1>.)*aparece a partir desse grupo novamente. Os $garante que podemos chegar ao final da string como essa, e as (?(1)!)garante que nós realmente esgotado todo o grupo.

Finalmente, nos livramos do espaço de separação e da segunda string:

 .+

J, 8 bytes

'CAB'{~-

Uso:

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

Experimente online aqui.

JavaScript ES6, 36 bytes

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

Muito simples e provavelmente óbvio o suficiente para entender: Mapeie cada item e indexe apara o char na posição ( x*2+ item no index yin b) em "CBA".

MATL , 14 9 bytes

2*+ 67w-c

Usa a versão atual (10.1.0)

Experimente online!

Explicação

Resumo do que o código faz

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

Explicação detalhada de como funciona

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

Sem reputação de comentar a solução Java já existente, então aqui vai:

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

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

Requer um intérprete que permite ir para a esquerda da célula 0 e possui células de quebra automática de 8 bits. Ao contrário da maioria das minhas respostas, o comportamento da EOF não importa.

Recebe entrada de bytes, com 0xFFcomo delimitador. Um fluxo de bytes representando a primeira entrada em "Casos de teste" seria assim:

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

Eu poderia salvar alguns bytes tendo 0x00como delimitador e usando 0x01e 0x02como 0 e 1 respectivamente, mas isso parecia trapaça: P

Depois que eu descobri minha estratégia, escrever este programa foi muito fácil. Para encontrar a enésima letra da saída, comece com 0x43(capital C em ASCII) e subtraia ((enésimo elemento da primeira sequência) * 2 + enésimo elemento da segunda sequência)

Para o que vale a pena, aqui está o programa de 52 bytes dividido em 3 linhas e com algumas palavras ao lado:

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

Uma função anônima. Use como:

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

Tentei deixar a função livre de pontos, mas fiquei totalmente confusa.

Pitão, 18 16 10 bytes

3 ^RD tentar: 10 bytes

Agradeço a FryAmTheEggman por me lembrar da existência de G!

VCQ@<G3xN1

A entrada é do formato [[0,0,1,1,0,1,0,1], [1,0,0,0,1,0,1,0]], que é essencialmente uma matriz: linha para escolha e coluna para número da pergunta.

Pseudocódigo pitônico compilado à mão:

              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 tentativa: 16 bytes

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

A entrada é do formato [[0,0,1,1,0,1,0,1], [1,0,0,0,1,0,1,0]], que é essencialmente uma matriz: linha para escolha e coluna para número da pergunta.

Isso compila para

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, eu sei que isso parece confuso, então vamos compilar manualmente com o pseudocódigo python

                 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 tentativa: 18 bytes

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

Com entrada do formulário [0,0,1,1,0,1,0,1,1,0,0,0,1,0,1,0], essencialmente concatenação de duas listas. Isso compila para

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

Mais uma vez, compilando manualmente

                   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 lá vai o primeiro codegolf da minha vida !!! Eu aprendi Pyth ontem, e é a primeira vez que participei de um código de golfe.

Python 3, 39 bytes.

Guardou 1 byte graças a FryAmTheEggman.
Economizou 2 bytes graças ao histocrat.

Não foi possível resolver com um forro há algum tempo!

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

Aqui estão os meus casos de teste. Também mostra como estou assumindo que essa função é chamada.

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

Ele usa zippara percorrer as matrizes em pares e, em seguida, indexa em uma sequência para escolher a letra correta. Tudo isso acontece na compreensão de uma lista, tornando-se automaticamente uma lista. O núcleo desta solução é que as únicas combinações possíveis de ae bsão [0, 1], [1, 0], [0, 0]. Portanto, se subtraímos eles, obtemos um deles, -1, 0, 1o último, primeiro, elemento do meio, respectivamente.

Mathematica, 30 24 22 19 bytes

^{3 bytes salvos devido a @alephalpha .}

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

Bem simples.

Ruby, 35 bytes

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

Obtém o (xy) th caractere zero indexado de "CAB". (1-0) fornece 1 e, portanto, A. (0-0) fornece 0 e, portanto, C. (0-1) fornece -1, que envolve B.

Solução mais curta alternativa com saída mais estranha:

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

A saída é citada por seqüências de caracteres separadas por novas linhas, o que parece ser uma ponte longe demais.

Japonês, 13 bytes

¡#C-X*2-VgY)d

Experimente online!

Como funciona

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

Oitava, 19 bytes

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

Teste:

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

Acrescentarei uma explicação mais tarde quando tiver um computador na minha frente. Isso foi escrito e testado em oitava on-line no meu celular.

TI-BASIC, 59 57 50 37 36 bytes

Retira uma lista de Anse a outra de Prompt L₁. Economizou 13 bytes graças à sugestão de Thomas Kwa de mudar de ramificação para sub(.

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

Vou ter que procurar o que Thomas Kwa disse que encontrou nos comentários amanhã. ¯ \ _ (ツ) _ / ¯

Ferrugem, 79

Economizou 8 bytes graças ao Shepmaster.
Economizou 23 bytes graças a ker.

Estou certo de que isso poderia ser muito praticado, mas esta é a primeira vez que escrevo um programa completo de Rust.

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

Aqui está o código não-protegido e os casos de teste, caso alguém queira tentar reduzi-lo.

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

A abordagem é bastante semelhante à minha resposta em Python. A principal diferença é que não posso indexar diretamente as strings, portanto não posso fazer o c-dtruque.

Vitsy, 40 bytes

suspiro Meu bebê não foi feito para manipular array.

Espera entrada através do STDIN (algo que eu nunca faço) com uma liderança ".

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

Explicação no modo detalhado (em breve disponível):

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;

Isso está ficando melhor em breve, pessoal. Sinto muito pelo tamanho atual.

Basicamente, trato a entrada como uma string e manipulo a partir daí.

Experimente online!

CJam, 10 bytes

'Cq~z2fbf-

Introduza como uma lista de duas listas, por exemplo

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

Teste aqui.

Explicação

Tratando os pares como bits de um número de base 2, obtemos 2para A, 1para Be 0para 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

Eu pensei que tinha uma solução elegante, então eu vi a resposta de @Morgan Thrapp ...

editar: salvou três bytes graças ao mencionado acima.

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: Agradecimentos a Bifz / FlagAsSpam pela ajuda e inspiração

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

Primeira submissão, solução Java ingênua. Quase certamente pode ser melhorado :)

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]

removi a declaração de função desde que vi que é comum em outros concursos.

PowerShell, 40 bytes

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

Recebe entrada como duas matrizes explícitas, por exemplo. 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 os armazena em $ae $b. Em seguida, faça um loop $acom $a|{...}. A cada loop, produzimos um caractere indexado na string "CBA", com o índice decidido pelo dobro do valor atual $_, mais o valor $bindexado pela nossa variável auxiliar que foi pré-adicionada e subtraída.

Como exemplo, para o primeiro caso de teste, $a = @(1,0,0,1,0,0,1)e $b = @(0,1,0,0,1,0,0). A primeira iteração do loop tem $_ = 1, $d = $null(já que $dnão tenha sido previamente declarado). Nós pré-adicionamos $dagora $_ = 1e $d = 1(no PowerShell $null + 1 = 1), o que significa isso $b[1-1] = $b[0] = 0. Então 2 * 1 + 0 = 2, indexamos "CBA"[2], ou A.

, 12 caracteres / 22 bytes

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

Try it here (Firefox only).

Explicação

Traduz para Javascript ES6 como

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

R 36 34 bytes

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

Dois bytes salvos removendo chaves desnecessárias

Perl 5-47

Já tem 30 respostas e nenhum perl? Aqui está uma primeira tentativa ingênua :-) Apenas a função:

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

Tenho certeza de que algo melhor poderia ser feito com regex, mas não consegui descobrir como.

JavaScript ES6, 75 bytes

Eu fui a milha extra para aceitar argumentos inteiros em vez de argumentos de matriz.

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

Explicação:

(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

Crédito para @ETHproductions pela lógica de indexação de string.

Teste aqui

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

Para 3 bytes extras, ele pode exibir a representação para até 30 respostas:

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

Retina, 46 bytes

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

Mescla as duas strings e escolhe as letras de acordo com os pares de dígitos.

Experimente online aqui.

Lua, 87 bytes

Simplesmente testando os valores nas matrizes, e concatenar A, Bou 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)

Essa é uma função parcialmente aplicada que utiliza duas seqüências int - duas matrizes funcionam bem - e retorna uma nova sequência de caracteres representando as respostas corretas. =)

Sério, 14 bytes

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

Experimente Online

Provavelmente devido a um erro na versão de segurança do interpretador, você deve adicionar um Xpara que ele funcione corretamente na versão online. Baixe a versão local para obter o programa acima funcionando corretamente como está.

É muito curto para justificar uma explicação completa, então vou apenas dizer: ele usa o mesmo algoritmo que a resposta Jelly.