Introducción

Mientras estudiaba, traté de encontrar varias formas de hacer trampa en una prueba de opción múltiple. Básicamente es una versión comprimida de las respuestas de opción múltiple. El método es el siguiente:

Las respuestas a la prueba:

BCAABABA

Estos se pueden convertir en 3 matrices diferentes, lo que indica verdadero o falso si la letra actual es la respuesta:

    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 estos números como binarios comprimiría esto mucho. Pero esto en realidad se puede comprimir un poco más. Si conoce las posiciones de A y B, no necesita las posiciones para C. Esto se puede hacer con un operador NO 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 conversión de las matrices A y B a números binarios daría como resultado:

A: 00110101
B: 10001010

¡Eso significa que 8 respuestas de opción múltiple se pueden comprimir a dos bytes!

Tarea

Dados dos números en binario, o dos matrices que consisten en solo 0 y 1 con la misma longitud, genera las respuestas de opción múltiple

Reglas

• La entrada puede estar en la forma que desee, como [1, 0, 0, 1]o 1001.
• Puede proporcionar un programa o una función.
• Puede suponer que la entrada siempre es válida.
• También puede generar una lista, separada por espacios, etc.
• Las respuestas de opción múltiple solo consisten en A, B y C. Sin embargo, puede utilizar minúsculas en su lugar.
• Este es el código de golf , por lo que gana el envío con la menor cantidad de bytes.

Casos de prueba

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

Tabla de clasificación

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 bytes

_/ị“ḃ»

Escribiendo por teléfono. Agregará la descripción.

(1,0)va a A, (0,1)a By (0,0)a C. Las matrices en Jelly están basadas en 1, y la función de indexación funciona ịcíclicamente. Por lo tanto, simplemente podemos plegar la resta sobre la entrada.

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

Probarlo aquí .

Retina , 44 bytes

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

El avance de línea final es significativo. La entrada es como

001101010 100010100

Pruébalo en línea!

Explicación

T`d`BA

Comience por convertir 0s en By 1s en A. Eso hace que la primera mitad sea correcta, excepto que enumera Bcuándo debe contener C. Podemos identificar esos Bs erróneos comprobando si hay un Ben la misma posición de la segunda cadena:

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

La búsqueda anticipada es una técnica clásica de conteo de grupos de equilibrio para unir las posiciones de los dos Bs. Los (.)*conteos El sufijo después de la primera Bempujando una adquisición sobre el grupo 1para cada personaje. Luego (?<-1>.)*aparece de nuevo ese grupo. Las $asegura que podemos llegar a la final de la cadena como esa, y los (?(1)!)asegura que en realidad hemos agotado todo el grupo.

Finalmente, nos deshacemos del espacio de separación y la segunda cadena:

 .+

J, 8 bytes

'CAB'{~-

Uso:

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

Pruébelo en línea aquí.

JavaScript ES6, 36 bytes

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

Lo suficientemente muy simple, y probablemente obvio para comprender: Mapa cada elemento e índice en ael carbón de leña en la posición ( x*2+ elemento en la posición yen b) en "CBA".

MATL , 14 9 bytes

2*+ 67w-c

Utiliza la versión actual (10.1.0)

Pruébalo en línea!

Explicación

Resumen de lo que hace el código

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

Explicación detallada de cómo 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

Sin reputación para comentar la solución Java ya existente, así que aquí va:

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

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

Requiere un intérprete que le permite ir a la izquierda desde la celda 0 y tiene celdas de ajuste de 8 bits. A diferencia de la mayoría de mis respuestas, el comportamiento EOF no importa.

Toma entrada de byte, con 0xFFcomo delimitador. Una secuencia de bytes que representa la primera entrada en "Casos de prueba" se vería así:

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

Podría guardar un par de bytes teniendo 0x00como delimitador y usando 0x01y 0x02como 0 y 1 respectivamente, pero eso parecía una trampa: P

Una vez que descubrí mi estrategia, escribir este programa fue muy fácil. Para encontrar la enésima letra de salida, comience con 0x43(C mayúscula en ASCII) y reste ((enésimo elemento de la primera secuencia) * 2 + enésimo elemento de la segunda secuencia)

Para lo que vale, aquí está el programa de 52 bytes dividido en 3 líneas y con algunas palabras a su 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))

Una función anónima. Usar como:

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

Intenté hacer que la función no tuviera puntos, pero tuve un desastre total.

Pyth, 18 16 10 bytes

3 ^er intento: 10 bytes

¡Gracias a FryAmTheEggman por recordarme la existencia de G!

VCQ@<G3xN1

La entrada tiene la forma [[0,0,1,1,0,1,0,1], [1,0,0,0,1,0,1,0]], que es esencialmente una matriz: fila para elegir y columna para el número de pregunta.

Pseudocódigo pitónico compilado 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 ^nd intento: 16 bytes

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

La entrada tiene la forma [[0,0,1,1,0,1,0,1], [1,0,0,0,1,0,1,0]], que es esencialmente una matriz: fila para elegir y columna para el número de pregunta.

Esto 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, sé que se ve desordenado, así que compilemos a mano con el pseudocódigo pitónico

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

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

Con entrada de la forma [0,0,1,1,0,1,0,1,1,0,0,0,1,0,1,0], esencialmente concatenación de dos listas. Esto 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")))

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

¡Y ahí va el primer codegolf de mi vida! Ayer aprendí Pyth, y esta es la primera vez que participo en un código de golf.

Python 3, 39 bytes.

Guardado 1 byte gracias a FryAmTheEggman.
Guardado 2 bytes gracias a histocrat.

¡No he podido resolver con un solo trazo en mucho tiempo!

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

Aquí están mis casos de prueba. También muestra la forma en que supongo que se llama a esta función.

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

Se utiliza zippara iterar a través de las matrices por pares, y luego se indexa en una cadena para elegir la letra correcta. Todo esto sucede en una comprensión de la lista, por lo que automáticamente se convierte en una lista. El núcleo de esta solución es que las únicas combinaciones posibles de ay bson [0, 1], [1, 0], [0, 0]. Entonces, si los restamos, obtenemos uno de los -1, 0, 1cuales nos da el último, primer elemento medio, respectivamente.

Mathematica, 30 24 22 19 bytes

^{3 bytes guardados debido a @alephalpha .}

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

Bastante sencillo.

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

Toma el carácter (xy) de índice cero de "CAB". (1-0) da 1 y, por lo tanto, A. (0-0) da 0 y, por lo tanto, C. (0-1) da -1, que se ajusta a B.

Solución alternativa más corta con salida más extraña:

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

La salida es cadenas citadas separadas por líneas nuevas, lo que de alguna manera parece un puente demasiado lejos.

Japt, 13 bytes

¡#C-X*2-VgY)d

Pruébalo en línea!

Cómo 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.

Octava, 19 bytes

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

Prueba:

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

Agregaré una explicación más tarde cuando tenga una computadora frente a mí. Esto fue escrito y probado en octave-online en mi celular.

TI-BASIC, 59 57 50 37 36 bytes

Toma una lista de Ansy la otra de Prompt L₁. Ahorró 13 bytes gracias a la sugerencia de Thomas Kwa de cambiar de ramificación a sub(.

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

Tendré que buscar lo que Thomas Kwa dijo que encontró en los comentarios mañana. ¯ \ _ (ツ) _ / ¯

Óxido, 79

Guardado 8 bytes gracias a Shepmaster.
Guardado 23 bytes gracias a ker.

Estoy seguro de que esto podría reducirse mucho, pero esta es la primera vez que escribo un programa completo de Rust.

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

Aquí está el código no protegido y los casos de prueba en caso de que alguien quiera tratar de reducirlo.

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

El enfoque es bastante similar a mi respuesta de Python. La principal diferencia es que no puedo indexar cadenas directamente, por lo que no puedo hacer el c-dtruco.

Vitsy, 40 bytes

suspiro Mi bebé no fue hecho para manipular la matriz.

Espera entrada a través de STDIN (algo que nunca hago) con un líder ".

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

Explicación en el modo detallado (pronto disponible):

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;

Esto se está mejorando mucho en el golf muy pronto, gente. Lo siento mucho por su longitud actual.

Básicamente, trato la entrada como una cadena, y luego manipulo desde allí.

Pruébalo en línea!

CJam, 10 bytes

'Cq~z2fbf-

Ingrese como una lista de dos listas, por ej.

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

Pruébalo aquí.

Explicación

Tratando los pares como bits de un número de base 2, obtenemos 2para A, 1para By 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

Pensé que tenía una solución elegante, luego vi la respuesta de @Morgan Thrapp ...

editar: Guardado tres bytes gracias a lo anterior.

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

EDITAR: Gracias a Bifz / FlagAsSpam por la ayuda y la inspiración.

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

Primera presentación, ingenua solución Java. Es casi seguro que se puede mejorar :)

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]

Se eliminó la declaración de función ya que vi que es común en otros concursos.

PowerShell, 40 bytes

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

Toma datos como dos matrices explícitas, por ejemplo. 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), y los almacena en $ay $b. A continuación, repita $acon $a|{...}. En cada bucle, mostramos un carácter indexado en la cadena "CBA", con el índice decidido por el doble del valor actual $_, más el valor de $bindexado por nuestra variable auxiliar que se ha agregado previamente y luego se ha restado.

Como ejemplo, para el primer caso de prueba, $a = @(1,0,0,1,0,0,1)y $b = @(0,1,0,0,1,0,0). La primera iteración del ciclo tiene $_ = 1, $d = $null(ya que $dno se ha declarado previamente). Agregamos previamente a $dso now $_ = 1y $d = 1(en PowerShell, $null + 1 = 1), lo que significa que $b[1-1] = $b[0] = 0. Entonces 2 * 1 + 0 = 2, entonces indexamos "CBA"[2], o A.

𝔼𝕊𝕄𝕚𝕟, 12 caracteres / 22 bytes

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

Try it here (Firefox only).

Explicación

Se traduce a Javascript ES6 como

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

R 36 34 bytes

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

Dos bytes guardados eliminando llaves innecesarias

Perl 5-47

¿Ya tienes 30 respuestas y no tienes perl? Aquí hay un primer intento ingenuo entonces :-) Solo la función:

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

Estoy bastante seguro de que se podría hacer algo mejor con regex, pero no pude encontrar cómo.

JavaScript ES6, 75 bytes

Hice un esfuerzo adicional para aceptar argumentos enteros en lugar de argumentos de matriz.

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

Explicación:

(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 a @ETHproductions por lógica de indexación de cadenas.

Prueba aquí

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 adicionales, puede mostrar la representación de hasta 30 respuestas:

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

Fusiona las dos cadenas y elige las letras de acuerdo con los pares de dígitos.

Pruébelo en línea aquí.

Lua, 87 bytes

Simplemente probando los valores en las matrices, y 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 bytes

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

Esa es una función parcialmente aplicada que toma dos secuencias int (dos matrices funcionan bien) y devuelve una nueva secuencia de caracteres que representan las respuestas correctas. =)

En serio, 14 bytes

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

Pruébalo en línea

Probablemente debido a un error en la versión en modo seguro del intérprete, debe agregar un Xpara que funcione correctamente en la versión en línea. Descargue la versión local para que el programa anterior funcione correctamente tal cual.

Es demasiado corto para garantizar una explicación completa, por lo que solo diré: utiliza el mismo algoritmo que la respuesta de Jelly.