介绍

在学习期间，我试图提出几种欺骗多选测试的方法。它基本上是多项选择答案的压缩版本。该方法如下：

测试答案：

BCAABABA

这些可以转换为3个不同的数组，如果当前字母是答案，则表示true或false：

    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]

将这些数字解释为二进制会压缩很多。但这实际上可以进一步压缩。如果知道A和B的位置，则不需要C的位置。这可以通过按位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]

将数组A和B转换为二进制数将导致：

A: 00110101
B: 10001010

这意味着可以将8个多项选择答案压缩为两个字节！

任务

给定二进制中的两个数字，或给定长度相同的两个仅包含0和1的数组，输出选择题答案

规则

• 输入可以采用您喜欢的任何形式，例如[1, 0, 0, 1]或1001。
• 您可以提供程序或功能。
• 您可以假设输入始终有效。
• 您也可以将其输出为列表，并以空格等分隔。
• 多项选择答案仅包含A，B和C。但是，您可以改用小写字母。
• 这是代码高尔夫球，因此以最少的字节提交为准！

测试用例

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

排行榜

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>

果冻，7 6个字节

_/ị“ḃ»

在电话上打字。将添加说明。

(1,0)去A，(0,1)去B和(0,0)去C。Jelly中的数组是基于1的，并且索引功能会ị循环工作。因此，我们只需要对输入进行折减即可。

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

在这里尝试。

视网膜，44字节

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

尾随换行很重要。输入就像

001101010 100010100

在线尝试！

说明

T`d`BA

首先将0s B和1变成A。这使前半部分正确，但它列出B了应包含的时间C。我们可以B通过检查B第二个字符串的相同位置来识别那些错误的：

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

前瞻是一种经典的平衡组计数技术，可以使两个位置匹配B。通过在每个字符的组(.)*中将B一个捕获推送到组中1，该计数对第一个后缀进行计数。然后(?<-1>.)*再次从该组弹出。将$确保我们能够达到这样的字符串的结束，以及(?(1)!)确保我们实际上已经耗尽了整个集团。

最后，我们摆脱了分隔空间和第二个字符串：

 .+

J，8个字节

'CAB'{~-

用法：

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

在这里在线尝试。

JavaScript ES6，36个字节

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

非常简单，也许足够明显地理解：将每个项目和索引映射a到char中位置处的字符（x*2+索引处y中的项目b）"CBA"。

MATL，14 9字节

2*+ 67w-c

使用当前版本（10.1.0）

在线尝试！

说明

代码摘要

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

有关其工作原理的详细说明

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个字节

没有信誉来评论已经存在的Java解决方案，因此，这里是：

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

Brainfuck，52个字节

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

需要一个解释器，该解释器可让您从单元格0左移，并具有8位换行单元格。与我的大多数答案不同，EOF行为无关紧要。

接受字节输入，并0xFF用作分隔符。代表“测试用例”下的第一个输入的字节流如下所示：

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

我可以通过0x00使用定界符并分别使用0x01和0x02分别作为0和1 来节省几个字节，但是感觉就像作弊：P

一旦我弄清楚了自己的策略，编写此程序就非常容易。要找到要输出的第n个字母，请以0x43（ASCII中的大写C 开头）并减去（（第一个序列的第n个元素）* 2 +第二个序列的第n个元素）

值得一提的是，这是一个52字节的程序，分为3行，并在其中加上一些单词：

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个字节

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

匿名函数。使用方式如下：

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

我试图使该函数无指向性，但一团糟。

Pyth，18 16 10字节

3 ^RD尝试：10个字节

感谢FryAmTheEggman让我想起了G！

VCQ@<G3xN1

输入的形式为[[0,0,1,1,0,1,0,1]，[1,0,0,0,1,0,1,0]]，其本质上是一个矩阵：行选择，问题编号列。

手工编译的pythonic伪代码：

              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 ^次尝试：16个字节

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

输入的形式为[[0,0,1,1,0,1,0,1]，[1,0,0,0,1,0,1,0]]，其本质上是一个矩阵：行选择，问题编号列。

这编译为

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

好的，我知道这看起来很乱，所以让我们手动编译为pythonic伪代码

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

第^一次尝试：18个字节

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

输入形式为[0,0,1,1,0,1,0,1,1,0,0,0,1,0,1,0]，实际上是两个列表的串联。这编译为

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

再次，手工编译

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

这是我生命中的第一个代码高尔夫！！！我昨天才刚学Pyth，这是我第一次参加标准高尔夫。

Python 3，39个字节。

感谢FryAmTheEggman，节省了1个字节。
多亏了histocrat，节省了2个字节。

一段时间以来无法用一个衬板解决！

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

这是我的测试案例。它还显示了我假设调用此函数的方式。

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

它用于zip成对地遍历数组，然后索引到字符串中以选择正确的字母。这一切都是在列表理解中发生的，因此它会自动成为列表。这种解决方案的核心是唯一的可能的组合a和b是[0, 1], [1, 0], [0, 0]。因此，如果减去它们，我们将得到其中一个，-1, 0, 1分别获取最后一个，第一个，中间元素。

Mathematica，30 24 22 19字节

^{由于@alephalpha节省了3个字节。}

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

非常简单。

Ruby，35个字节

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

用法：

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

取“ CAB”的第（xy）个零索引字符。（1-0）给出1，因此A.（0-0）得到0，因此C.（0-1）得到-1，该结果回绕到B.

带有古怪输出的替代较短解决方案：

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

输出是用引号引起来的用换行符分隔的字符串，这似乎有点过分了。

Japt，13个字节

¡#C-X*2-VgY)d

在线尝试！

这个怎么运作

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

八度，19字节

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

测试：

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

稍后当我面前有计算机时，我将添加说明。这是在我的手机上通过八度在线编写和测试的。

TI-BASIC，59 57 50 37 36字节

需要从一个列表Ans，并从其他Prompt L₁。由于Thomas Kwa的建议从分支切换到，节省了13个字节sub(。

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

我必须寻找托马斯·夸（Thomas Kwa）所说的他明天在评论中发现的内容。¯\ _（ツ）_ /¯

鲁斯特，79

感谢Shepmaster，节省了8个字节。
多亏了ker，节省了23个字节。

我很肯定这可能会失败很多，但这是我第一次编写完整的Rust程序。

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

如果有人想缩小它的大小，这里是未发布的代码和测试用例。

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

该方法与我的Python答案非常相似。主要区别在于我无法直接为字符串编制索引，因此无法做到这一点c-d。

Vitsy，40个字节

叹气我的宝宝没有做阵列操作。

期望通过STDIN进行输入（我从未做过），并且带有Leading "。

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

（很快可用）详细模式下的解释：

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;

人们很快就会打高尔夫。很抱歉，目前的长度。

基本上，我将输入视为字符串，然后从那里进行操作。

在线尝试！

CJam，10个字节

'Cq~z2fbf-

输入为两个列表的列表，例如

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

在这里测试。

说明

治疗对作为基础-2位数的，我们得到2了A，1对于B和0为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字节

我以为我有一个优雅的解决方案，然后我看到了@Morgan Thrapp的答案...

编辑：由于上述原因，节省了三个字节。

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字节

编辑：感谢Bifz / FlagAsSpam的帮助和启发

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

初次提交，天真的Java解决方案。几乎可以肯定可以改善:)

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字节

LETTERS[3-2*A-B]

删除了功能声明，因为我发现它在其他比赛中很常见。

PowerShell，40字节

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

将输入作为两个显式数组，例如。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)并将它们存储在$a和中$b。接下来，通过循环$a使用$a|{...}。在每个循环中，我们输出一个索引到字符串中的字符"CBA"，其索引由当前值的两倍决定$_，加上$b由我们的辅助变量（已预先添加然后减去）所索引的值。

例如，对于第一个测试用例，$a = @(1,0,0,1,0,0,1)和$b = @(0,1,0,0,1,0,0)。第一次循环迭代具有$_ = 1，$d = $null（因为$d以前尚未声明）。我们预先添加到$d所以现在$_ = 1并$d = 1（在PowerShell中$null + 1 = 1），这意味着$b[1-1] = $b[0] = 0。然后2 * 1 + 0 = 2，我们索引"CBA"[2]或A。

𝔼𝕊𝕄𝕚𝕟，12个字符/ 22个字节

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

Try it here (Firefox only).

说明

转换为Javascript ES6

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

R 36 34字节

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

保存了两个字节，删除了不必要的花括号

Perl 5-47

已经有30个答案，没有perl？这是天真的尝试，然后:-)只是函数：

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

用法：

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

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

我很确定使用正则表达式可以做得更好，但是我找不到方法。

JavaScript ES6，75个字节

我付出了更多的努力来接受整数参数而不是数组参数。

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

说明：

(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

感谢@ETHproductions提供字符串索引逻辑。

在这里测试

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>

st

对于3个额外的字节，它最多可以显示30个答案的表示形式：

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

视网膜，46字节

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

合并两个字符串，然后根据数字对选择字母。

在这里在线尝试。

Lua，87个字节

简单地在阵列测试值，并且链接A，B或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个字节

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

这是部分应用的函数，需要两个int序列-两个数组可以正常工作-并返回代表正确答案的新字符序列。=）

严重的是14个字节

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

在线试用

可能是由于解释器的安全模式版本中的错误所致，您必须添加X使其在在线版本中正常工作。下载本地版本以使上述程序按原样正常工作。

它太短了，无法给出完整的解释，所以我只想说：它使用与Jelly答案相同的算法。