Wprowadzenie

Podczas nauki próbowałem wymyślić kilka sposobów, aby oszukać test wielokrotnego wyboru. Zasadniczo jest to skompresowana wersja odpowiedzi wielokrotnego wyboru. Metoda wygląda następująco:

Odpowiedzi na test:

BCAABABA

Można je przekonwertować na 3 różne tablice, co wskazuje prawda lub fałsz, jeśli bieżąca litera jest odpowiedzią:

    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]

Interpretacja tych liczb jako binarnych bardzo by to skompresowała. Ale można to nieco bardziej skompresować. Jeśli znasz pozycje A i B, nie potrzebujesz pozycji dla C. Można to zrobić za pomocą bitowego operatora NOT:

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]

Konwersja tablic A i B na liczby binarne spowoduje:

A: 00110101
B: 10001010

Oznacza to, że 8 odpowiedzi wielokrotnego wyboru można skompresować do dwóch bajtów!

Zadanie

Biorąc pod uwagę dwie liczby binarne lub dwie tablice składające się tylko z zer i jedynek o tej samej długości, wypisz odpowiedzi wielokrotnego wyboru

Zasady

• Dane wejściowe mogą mieć dowolną formę, taką jak [1, 0, 0, 1]lub 1001.
• Możesz podać program lub funkcję.
• Możesz założyć, że dane wejściowe są zawsze prawidłowe.
• Możesz również wyprowadzać dane jako listę, oddzielone spacjami itp.
• Odpowiedzi wielokrotnego wyboru składają się tylko z A, B i C. Zamiast tego możesz jednak użyć małych liter.
• To jest golf golfowy , więc wygrywanie z najmniejszą ilością bajtów wygrywa!

Przypadki testowe

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

Tabela liderów

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>

Galaretka, 7 6 bajtów

_/ị“ḃ»

Pisanie na telefonie. Dodanie opisu.

(1,0)idzie do A, (0,1)do Bi (0,0)do C. Tablice w galarecie są oparte na 1, a funkcja indeksowania ịdziała cyklicznie. Dlatego możemy po prostu złożyć odejmowanie na wejściu.

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

Wypróbuj tutaj .

Siatkówka , 44 bajty

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

Końcowe podawanie linii jest znaczące. Dane wejściowe są jak

001101010 100010100

Wypróbuj online!

Wyjaśnienie

T`d`BA

Zacznij od zamiany 0s na Bi 1s na A. To sprawia, że ​​pierwsza połowa jest poprawna, z wyjątkiem tego, że podaje, Bkiedy powinna ona zawierać C. Możemy zidentyfikować te błędne Bs, sprawdzając, czy jest Bw tej samej pozycji drugiego ciągu:

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

Lookahead to klasyczna technika liczenia grup bilansujących, która dopasowuje pozycje dwóch Bs. Do (.)*liczy przyrostek po pierwsze Bprzez naciśnięcie jednego wychwytywanie na grupy 1dla każdego znaku. Potem (?<-1>.)*znowu wyskakuje z tej grupy. W $gwarantuje, że możemy dotrzeć do końca łańcucha tak, i (?(1)!)zapewnia, że mamy rzeczywiście wyczerpany całą grupę.

Wreszcie pozbywamy się przestrzeni oddzielającej i drugiego ciągu:

 .+

J, 8 bajtów

'CAB'{~-

Stosowanie:

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

Wypróbuj online tutaj.

JavaScript ES6, 36 bajtów

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

Bardzo prosty i pewnie oczywiste, wystarczy, aby zrozumieć: Mapa każdy element i wskaźnik w ado char w pozycji ( x*2+ pozycja w indeksie yw b) w "CBA".

MATL , 14 9 bajtów

2*+ 67w-c

Wykorzystuje aktualną wersję (10.1.0)

Wypróbuj online!

Wyjaśnienie

Podsumowanie działania kodu

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

Szczegółowe wyjaśnienie, jak to działa

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 bajtów

Nie ma reputacji, aby komentować już istniejące rozwiązanie Java, więc oto:

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

pieprzenie mózgu, 52 bajty

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

Wymaga interpretera, który pozwala odejść w lewo od komórki 0 i ma 8-bitowe zawijanie komórek. W przeciwieństwie do większości moich odpowiedzi zachowanie EOF nie ma znaczenia.

Pobiera dane bajtowe, z 0xFFogranicznikiem. Strumień bajtów reprezentujących pierwsze dane wejściowe w „Przypadkach testowych” wyglądałby tak:

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

Mógłbym zaoszczędzić kilka bajtów przez posiadające 0x00jako ogranicznik i korzystania 0x01i 0x02jako 0 i 1, odpowiednio, ale czułem się jak oszukuje: P

Po opracowaniu strategii napisanie tego programu było bardzo łatwe. Aby znaleźć n-tą literę na wyjściu, zacznij od 0x43(duża C w ASCII) i odejmij ((n-ty element pierwszej sekwencji) * 2 + n-ty element drugiej sekwencji)

Oto, co warto, oto 52-bajtowy program podzielony na 3 linie i kilka słów obok nich:

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 bajtów

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

Anonimowa funkcja. Użyj jak:

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

Próbowałem sprawić, by funkcja nie była punktowa, ale dostałem totalny bałagan.

Pyth, 18 16 10 bajtów

3 ^rd próby: 10 bajtów

Dziękujemy FryAmTheEggman za przypomnienie mi o istnieniu G!

VCQ@<G3xN1

Dane wejściowe mają postać [[0,0,1,1,0,1,0,1], [1,0,0,0,1,0,1,0]], która jest zasadniczo macierzą: wiersz do wyboru i kolumna dla numeru pytania.

Ręcznie skompilowany pseudokod pythonowy:

              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 próba: 16 bajtów

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

Dane wejściowe mają postać [[0,0,1,1,0,1,0,1], [1,0,0,0,1,0,1,0]], która jest zasadniczo macierzą: wiersz do wyboru i kolumna dla numeru pytania.

To kompiluje się do

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, wiem, że to wygląda na bałagan, więc skompilujmy ręcznie do pseudokodu pythonowego

                 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 próba: 18 bajtów

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

Po wprowadzeniu formularza [0,0,1,1,0,1,0,1,1,0,0,0,1,0,1,0], zasadniczo połączenie dwóch list. To kompiluje się do

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

Ponownie, kompilacja ręcznie

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

I jest pierwszy codegolf w moim życiu !!! Właśnie wczoraj nauczyłem się Pyth i po raz pierwszy uczestniczyłem w golfie kodowym.

Python 3, 39 bajtów.

Zaoszczędzono 1 bajt dzięki FryAmTheEggman.
Zaoszczędzono 2 bajty dzięki histocratowi.

Od jakiegoś czasu nie byłem w stanie rozwiązać problemu za pomocą jednej wkładki!

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

Oto moje przypadki testowe. Pokazuje także sposób, w jaki zakładam, że ta funkcja jest wywoływana.

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

Używa zipdo iteracji parami tablic, a następnie indeksuje w łańcuch, aby wybrać odpowiednią literę. Wszystko to dzieje się na liście, więc automatycznie staje się listą. Rdzeniem tego rozwiązania jest to, że jedynymi możliwymi kombinacjami ai bsą [0, 1], [1, 0], [0, 0]. Więc jeśli je odejmiemy, otrzymamy jeden, -1, 0, 1który dostanie odpowiednio ostatni, pierwszy, środkowy element.

Mathematica, 30 24 22 19 bajtów

^{3 bajty zapisane z powodu @alephalpha .}

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

Całkiem proste.

Rubin, 35 bajtów

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

Stosowanie:

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

Pobiera (xy) znak „CAB” o indeksie zero. (1-0) daje 1, a zatem A. (0-0) daje 0, a zatem C. (0-1) daje -1, co otacza B.

Alternatywne krótsze rozwiązanie z wyjściem Weirdera:

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

Dane wyjściowe są cytowane ciągami oddzielonymi znakami nowej linii, co wydaje się w jakiś sposób za daleko pomostem.

Japt, 13 bajtów

¡#C-X*2-VgY)d

Wypróbuj online!

Jak to działa

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

Oktawa, 19 bajtów

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

Test:

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

Wyjaśnię to później, gdy będę miał przed sobą komputer. Zostało to napisane i przetestowane w oktawie online w mojej komórce.

TI-BASIC, 59 57 50 37 36 bajtów

Pobiera jedną listę z Ans, a drugą z Prompt L₁. Oszczędność 13 bajtów dzięki sugestii Thomasa Kwy, aby przejść z rozgałęzienia na sub(.

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

Muszę poszukać tego, co powiedział Thomas Kwa w komentarzach jutro. ¯ \ _ (ツ) _ / ¯

Rdza, 79

Zaoszczędzono 8 bajtów dzięki Shepmaster.
Zaoszczędzono 23 bajty dzięki ker.

Jestem przekonany, że można to bardzo pograć w golfa, ale po raz pierwszy piszę pełny program Rust.

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

Oto niepoznany kod i przypadki testowe na wypadek, gdyby ktoś chciał spróbować go zmniejszyć.

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

Podejście jest dość podobne do mojej odpowiedzi w Pythonie. Główną różnicą jest to, że nie mogę bezpośrednio indeksować ciągów, więc nie mogę tego zrobić c-d.

Vitsy, 40 bajtów

westchnienie Moje dziecko nie zostało stworzone do manipulacji tablicami.

Oczekuje wkładu poprzez STDIN (coś, czego nigdy nie robię) z prowadzeniem ".

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

Objaśnienie w (wkrótce dostępnym) trybie pełnym:

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;

Ludzie stają się coraz lepsi. Przykro mi z powodu jego obecnej długości.

Zasadniczo traktuję dane wejściowe jako ciąg, a następnie manipuluję stamtąd.

Wypróbuj online!

CJam, 10 bajtów

'Cq~z2fbf-

Wprowadź jako listę dwóch list, np

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

Sprawdź to tutaj.

Wyjaśnienie

Traktując pary jako bity liczby bazowej 2, otrzymujemy 2za A, 1za Bi 0za 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 bajtów

Myślałem, że mam eleganckie rozwiązanie, a potem zobaczyłem odpowiedź @ Organ Thrapp ...

edycja: Zapisano trzy bajty dzięki wyżej wymienionym.

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 bajtów

EDYCJA: Podziękowania dla Bifz / FlagAsSpam za pomoc i inspirację

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

Pierwsze przesłanie, naiwne rozwiązanie Java. Można prawie na pewno poprawić :)

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 bajtów

LETTERS[3-2*A-B]

usunąłem deklarację funkcji, ponieważ widziałem, że jest to powszechne w innych konkursach.

PowerShell, 40 bajtów

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

Pobiera dane wejściowe jako dwie wyraźne tablice, np. 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)i przechowuje je w $ai $b. Następnie pętli $az $a|{...}. W każdej pętli wyprowadzamy znak zindeksowany do łańcucha "CBA", przy czym indeks jest określany przez dwukrotność bieżącej wartości $_, plus wartość $bindeksowana przez naszą zmienną pomocniczą, która została dodana, a następnie odjęta.

Na przykład dla pierwszego przypadku testowego $a = @(1,0,0,1,0,0,1)i $b = @(0,1,0,0,1,0,0). Pierwsza pętla iteracji $_ = 1, $d = $null(ponieważ $dnie został wcześniej zadeklarowanej). Dodaliśmy do $dtego teraz $_ = 1i $d = 1(w PowerShell, $null + 1 = 1), co oznacza, że $b[1-1] = $b[0] = 0. Następnie 2 * 1 + 0 = 2indeksujemy "CBA"[2]lub A.

𝔼𝕊𝕄𝕚𝕟, 12 znaków / 22 bajty

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

Try it here (Firefox only).

Wyjaśnienie

Tłumaczy na Javascript ES6 as

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

R 36 34 bajtów

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

Zapisano dwa bajty, usuwając niepotrzebne nawiasy klamrowe

Perl 5–47

Masz już 30 odpowiedzi i żadnego perla? Oto naiwna pierwsza próba :-) Tylko funkcja:

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

Stosowanie:

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

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

Jestem prawie pewien, że przy pomocy wyrażeń regularnych można zrobić coś lepszego, ale nie mogłem znaleźć sposobu.

JavaScript ES6, 75 bajtów

Poszedłem o krok dalej, aby zaakceptować argumenty całkowite zamiast argumentów tablicowych.

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

Wyjaśnienie:

(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

Podziękowania dla @ETHproductions za logikę indeksowania ciągów.

Przetestuj tutaj

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

W przypadku 3 dodatkowych bajtów może wyświetlić reprezentację maksymalnie 30 odpowiedzi:

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

Siatkówka, 46 bajtów

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

Łączy dwa ciągi i wybiera litery zgodnie z parami cyfr.

Wypróbuj online tutaj.

Lua, 87 bajtów

Po prostu testujemy wartości w tablicach i łączymy A, Blub 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 bajtów

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

Jest to częściowo zastosowana funkcja, która pobiera dwie sekwencje int - dwie tablice działają dobrze - i zwraca nową sekwencję znaków reprezentujących poprawne odpowiedzi. =)

Poważnie, 14 bajtów

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

Wypróbuj online

Prawdopodobnie z powodu błędu w wersji interpretera w trybie awaryjnym, musisz dodać znak X, aby działał poprawnie w wersji online. Pobierz wersję lokalną, aby powyższy program działał poprawnie w obecnej postaci.

Jest za krótki, aby uzasadnić pełne wyjaśnienie, więc powiem tylko: używa tego samego algorytmu, co odpowiedź Jelly.