introduction

Pendant mes études, j'ai essayé de trouver plusieurs façons de tromper un test à choix multiples. Il s’agit essentiellement d’une version comprimée des réponses à choix multiples. La méthode va comme suit:

Les réponses au test:

BCAABABA

Ceux-ci peuvent être convertis en 3 tableaux différents, ce qui indique vrai ou faux si la lettre actuelle est la réponse:

    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]

Interpréter ces nombres en tant que données binaires le compresserait beaucoup. Mais cela peut en fait être un peu plus compressé. Si vous connaissez les positions de A et B, vous n’avez pas besoin des positions pour C. Cela peut être fait avec un opérateur NOT au niveau du 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 conversion des tableaux A et B en nombres binaires entraînerait:

A: 00110101
B: 10001010

Cela signifie que 8 réponses à choix multiples peuvent être compressées en deux octets!

Tâche

Étant donné deux nombres en binaire ou deux tableaux composés uniquement de 0 et de 1 de même longueur, affiche les réponses à choix multiples

Règles

• La saisie peut se faire sous la forme de votre choix, comme [1, 0, 0, 1]ou 1001.
• Vous pouvez fournir un programme ou une fonction.
• Vous pouvez supposer que la saisie est toujours valide.
• Vous pouvez également sortir sous forme de liste, séparés par des espaces, etc.
• Les réponses à choix multiples consistent uniquement en A, B et C. Vous pouvez toutefois utiliser des minuscules à la place.
• C'est du code-golf , donc la soumission avec le moins d'octets gagne!

Cas de 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

Classement

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ée, 7 à 6 octets

_/ị“ḃ»

Taper au téléphone. Va ajouter une description.

(1,0)va à A, (0,1)à Bet (0,0)à C. Les tableaux dans Jelly sont basés sur 1 et la fonction d'indexation fonctionne de manière ịcyclique. Par conséquent, nous pouvons simplement replier la soustraction sur l’entrée.

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

Essayez ici .

Retina , 44 octets

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

Le retour à la ligne est important. L'entrée est comme

001101010 100010100

Essayez-le en ligne!

Explication

T`d`BA

Commencez par transformer 0en Bet 1en A. Cela rend la première moitié correcte, sauf qu'elle indique Bquand elle devrait contenir C. Nous pouvons identifier ces erreurs Ben vérifiant s’il existe une Bposition identique dans la deuxième chaîne:

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

Le lookahead est une technique classique de comptage de groupe équilibrant permettant d’aligner les positions des deux B. Le (.)*compte le suffixe après le premier Ben poussant une capture sur le groupe 1pour chaque personnage. Puis (?<-1>.)*apparaît à nouveau de ce groupe. Les $assure que nous pouvons atteindre la fin de la chaîne comme ça, et les (?(1)!)assure que nous avons effectivement épuisé l'ensemble du groupe.

Enfin, nous nous débarrassons de l’espace séparateur et de la deuxième chaîne:

 .+

J, 8 octets

'CAB'{~-

Usage:

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

Essayez-le en ligne ici.

JavaScript ES6, 36 octets

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

Très simple, et probablement assez évident pour être compris: mappez chaque élément et index dans le caractère aà la position ( x*2+ élément à l’index ydans b) dans "CBA".

MATL , 14 à 9 octets

2*+ 67w-c

Utilise la version actuelle (10.1.0)

Essayez-le en ligne!

Explication

Résumé de ce que fait le code

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

Explication détaillée de son fonctionnement

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 octets

Aucune réputation pour commenter la solution Java existante, alors voici:

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

brainfuck, 52 octets

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

Nécessite un interprète qui vous permet d'aller à gauche de la cellule 0 et dispose de cellules d'habillage de 8 bits. Contrairement à la plupart de mes réponses, le comportement EOF n'a pas d'importance.

Prend entrée octet, avec 0xFF comme délimiteur. Un flux d'octets représentant la première entrée sous "Tests" ressemblerait à ceci:

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

Je pourrais économiser quelques octets en ayant 0x00 comme séparateur et en utilisant 0x01et 0x02comme 0 et 1 respectivement, mais on se sent comme la tricherie: P

Une fois que j'ai compris ma stratégie, écrire ce programme était très facile. Pour trouver la nième lettre à afficher, commencez par 0x43(C majuscule en ASCII) et soustrayez ((nième élément de la première séquence) * 2 + nième élément de la deuxième séquence)

Pour ce que cela vaut, voici le programme de 52 octets divisé en 3 lignes et avec quelques mots à côté:

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 octets

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

Une fonction anonyme. Utilisez comme:

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

J'ai essayé de rendre la fonction sans point, mais j'ai eu un désordre total.

Pyth, 18 16 10 octets

3 ^ème tentative: 10 octets

Merci FryAmTheEggman de me rappeler l'existence de G!

VCQ@<G3xN1

La saisie est de la forme [[0,0,1,1,0,1,0,1], [1,0,0,0,1,0,1,0]], qui est essentiellement une matrice: rangée pour choix et colonne pour numéro de question.

Pseudocode pythonique compilé à la main:

              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 ^e tentative: 16 octets

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

La saisie est de la forme [[0,0,1,1,0,1,0,1], [1,0,0,0,1,0,1,0]], qui est essentiellement une matrice: rangée pour choix et colonne pour numéro de question.

Cela compile à

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, je sais que ça a l'air malpropre, alors compilons à la main en pseudocode pythonique

                 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 ^ère tentative: 18 octets

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

Avec la saisie du formulaire [0,0,1,1,0,1,0,1,1,0,0,0,1,0,1,0], essentiellement concaténation de deux listes. Cela compile à

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

Encore une fois, compiler à la main

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

Et voilà le premier codegolf de ma vie !!! Je viens d'apprendre Pyth hier, et c'est la première fois que je participe à un code de golf.

Python 3, 39 octets.

Sauvé 1 octet grâce à FryAmTheEggman.
Sauvegardé 2 octets grâce à histocrat.

N'a pas été en mesure de résoudre avec un one-liner depuis un moment!

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

Voici mes cas de test. Cela montre également comment je suppose que cette fonction est appelée.

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

Il utilise zippour parcourir les tableaux par paires, puis indexe dans une chaîne pour sélectionner la lettre correcte. Tout cela se passe dans une compréhension de liste, il devient donc automatiquement une liste. Le cœur de cette solution est que les seules combinaisons possibles de aet bsont [0, 1], [1, 0], [0, 0]. Donc, si nous les soustrayons, nous obtenons l’un d’eux -1, 0, 1qui nous donne respectivement le dernier, premier élément intermédiaire.

Mathematica, 30 24 22 19 octets

^{3 octets enregistrés à cause de @alephalpha .}

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

Assez facile.

Ruby, 35 octets

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

Usage:

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

Prend le (xy) ème caractère zéro indexé de "CAB". (1-0) donne 1, et donc A. (0-0) donne 0, et donc C. (0-1) donne -1, ce qui revient à B.

Solution alternative plus courte avec une sortie plus étrange:

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

La sortie est constituée de chaînes de caractères séparées par des nouvelles lignes, ce qui semble être un pont trop éloigné.

Japt, 13 octets

¡#C-X*2-VgY)d

Essayez-le en ligne!

Comment ça marche

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

Octave, 19 octets

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

Tester:

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

J'ajouterai une explication plus tard lorsque j'aurai un ordinateur devant moi. Cela a été écrit et testé sur octave-online sur mon portable.

TI-BASIC, 59 57 50 37 36 octets

Prend une liste de Ans, et l'autre de Prompt L₁. Économisé 13 octets grâce à la suggestion de Thomas Kwa de passer de branches à sub(.

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

Je vais devoir chercher ce que Thomas Kwa a dit avoir trouvé dans les commentaires de demain. ¯ \ _ (ツ) _ / ¯

Rouille, 79

Sauvegardé 8 octets grâce à Shepmaster.
23 octets sauvés grâce à ker.

Je suis persuadé que cela pourrait être joué au golf, mais c’est la première fois que j’écris un programme complet Rust.

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

Voici le code et les cas de test non-golfés au cas où quelqu'un voudrait essayer de le réduire.

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'approche est assez similaire à ma réponse en Python. La principale différence étant que je ne peux pas indexer directement les chaînes, je ne peux donc pas faire l' c-daffaire.

Vitsy, 40 octets

soupir Mon bébé n'a pas été fait pour manipuler un tableau.

Attend l'entrée via STDIN (quelque chose que je ne fais jamais) avec un leader ".

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

Explication en mode verbeux (bientôt 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;

Cela va mieux jouer au golf très vite, les gens. Je suis tellement désolé pour sa longueur actuelle.

Fondamentalement, je traite l'entrée comme une chaîne, puis je la manipule à partir de là.

Essayez-le en ligne!

CJam, 10 octets

'Cq~z2fbf-

Saisie sous forme de liste de deux listes, par exemple

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

Testez-le ici.

Explication

Traiter les paires comme des bits d’un nombre base 2, nous obtenons 2pour A, 1pour Bet 0pour 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 octets

Je pensais avoir une solution élégante, puis j'ai vu la réponse de @Morgan Thrapp ...

edit: Sauvegardé de trois octets grâce à ce qui précède.

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 octets

EDIT: Merci à Bifz / FlagAsSpam pour l'aide et l'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++;}}

Première soumission, solution Java naïve. Peut presque certainement être amélioré :)

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 octets

LETTERS[3-2*A-B]

déclaration de fonction supprimée depuis que j'ai vu qu'il est commun dans d'autres concours.

PowerShell, 40 octets

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

Prend les entrées sous forme de deux tableaux explicites, par exemple. 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)et les stocke dans $aet $b. Ensuite, passez en boucle $aavec $a|{...}. A chaque boucle, nous sortons un caractère indexé dans la chaîne "CBA", l'index étant déterminé par deux fois la valeur actuelle $_, plus la valeur de$b indexée par notre variable d'assistance pré-ajoutée puis soustraite.

Par exemple, pour le premier cas de test, $a = @(1,0,0,1,0,0,1)et $b = @(0,1,0,0,1,0,0). La première itération de boucle a $_ = 1, $d = $null( $dn'a pas été déclarée depuis). Nous pré-ajoutons à $dso now $_ = 1et $d = 1(dans PowerShell $null + 1 = 1), ce qui signifie que $b[1-1] = $b[0] = 0. ensuite2 * 1 + 0 = 2 , alors on indexe "CBA"[2], ou A.

, 12 caractères / 22 octets

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

Try it here (Firefox only).

Explication

Traduit en Javascript ES6 comme

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

R 36 34 octets

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

Deux octets enregistrés en supprimant les accolades inutiles

Perl 5 - 47

Déjà 30 réponses et pas de Perl? Voici une première tentative naïve alors :-) Juste la fonction:

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

Usage:

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

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

Je suis à peu près sûr que quelque chose de mieux pourrait être fait avec regex, mais je n'ai pas trouvé comment.

JavaScript ES6, 75 octets

J'ai fait un effort supplémentaire pour accepter des arguments entiers au lieu d'arguments de tableau.

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

Explication:

(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édit à @ETHproductions pour la logique d’indexation des chaînes.

Testez ici

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

Pour 3 octets supplémentaires, il peut afficher la représentation pour un maximum de 30 réponses:

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

Retina, 46 octets

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

Fusionne les deux chaînes et choisit les lettres en fonction des paires de chiffres.

Essayez-le en ligne ici.

Lua, 87 octets

Tout simplement tester les valeurs dans les tableaux et concaténer 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 octets

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

Il s’agit d’une fonction partiellement appliquée qui prend deux séquences int (deux tableaux fonctionnent bien) et renvoie une nouvelle séquence de caractères représentant les réponses correctes. =)

Sérieusement, 14 octets

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

Essayez-le en ligne

Probablement à cause d’un bogue dans la version en mode sans échec de l’interprète, vous devez ajouter un X pour qu'il fonctionne correctement dans la version en ligne. Téléchargez la version locale pour que le programme ci-dessus fonctionne correctement tel quel.

C'est trop court pour justifier une explication complète, alors je dirai simplement: il utilise le même algorithme que la réponse de Jelly.