在纸牌游戏《魔术：聚会》中，有五种不同的颜色，代表纸牌的松散隶属关系，白色（W），蓝色（U），黑色（B），红色（R）和绿色（G）。这些通常以五边形排列如下：

  W
G   U
 R B

在MtG的知识以及许多卡片机制中，此五边形中的相邻颜色通常被视为盟友，而不相邻（相反）的颜色则被视为敌人。

在此挑战中，将为您提供两种颜色，并应确定它们之间的关系。

挑战

您会从集合中获得两个不同的字符BGRUW。您可以将它们视为两个字符的字符串，在字符之间带有定界符的字符串，两个单独的字符值，两个单例字符串，两个代表其代码点的整数，或包含两个字符/字符串/整数的列表或集合类型。

您的输出应该是您选择的两个不同且一致的值之一，一个表示两种颜色是同盟，另一种表示它们是敌人。这两个值之一可能根本没有输出。

您可以编写程序或函数，并使用我们的任何标准方法来接收输入和提供输出。

您可以使用任何编程语言，但是请注意，默认情况下，这些漏洞是禁止的。

这是代码高尔夫球，因此以字节为单位的最短有效答案为准。

测试用例

只有20种可能的输入，因此我将全部列出。

好友：

WU   UB   BR   RG   GW   UW   BU   RB   GR   WG

敌人：

WB   UR   BG   RW   GU   BW   RU   GB   WR   UG

JavaScript（ES6）， 26 23 17 15  14字节

以currying语法将输入作为两个ASCII码(a)(b)。返回4给朋友还是0敌人。

a=>b=>a*b/.6&4

在线尝试！

怎么样？

注意：下面仅显示除以0.6的整数商。

Combo | a  | b  | a*b  | / 0.6 | AND 4
------+----+----+------+-------+------
  WU  | 87 | 85 | 7395 | 12325 |   4
  UB  | 85 | 66 | 5610 |  9350 |   4
  BR  | 66 | 82 | 5412 |  9020 |   4
  RG  | 82 | 71 | 5822 |  9703 |   4
  GW  | 71 | 87 | 6177 | 10295 |   4
  UW  | 85 | 87 | 7395 | 12325 |   4
  BU  | 66 | 85 | 5610 |  9350 |   4
  RB  | 82 | 66 | 5412 |  9020 |   4
  GR  | 71 | 82 | 5822 |  9703 |   4
  WG  | 87 | 71 | 6177 | 10295 |   4
------+----+----+------+-------+------
  WB  | 87 | 66 | 5742 |  9570 |   0
  UR  | 85 | 82 | 6970 | 11616 |   0
  BG  | 66 | 71 | 4686 |  7810 |   0
  RW  | 82 | 87 | 7134 | 11890 |   0
  GU  | 71 | 85 | 6035 | 10058 |   0
  BW  | 66 | 87 | 5742 |  9570 |   0
  RU  | 82 | 85 | 6970 | 11616 |   0
  GB  | 71 | 66 | 4686 |  7810 |   0
  WR  | 87 | 82 | 7134 | 11890 |   0
  UG  | 85 | 71 | 6035 | 10058 |   0

以前的方法，15个字节

以currying语法将输入作为两个ASCII码(a)(b)。返回0给朋友还是1敌人。

a=>b=>a*b%103%2

在线尝试！

怎么样？

Combo | a  | b  | a*b  | MOD 103 | MOD 2
------+----+----+------+---------+------
  WU  | 87 | 85 | 7395 |    82   |   0
  UB  | 85 | 66 | 5610 |    48   |   0
  BR  | 66 | 82 | 5412 |    56   |   0
  RG  | 82 | 71 | 5822 |    54   |   0
  GW  | 71 | 87 | 6177 |   100   |   0
  UW  | 85 | 87 | 7395 |    82   |   0
  BU  | 66 | 85 | 5610 |    48   |   0
  RB  | 82 | 66 | 5412 |    56   |   0
  GR  | 71 | 82 | 5822 |    54   |   0
  WG  | 87 | 71 | 6177 |   100   |   0
------+----+----+------+---------+------
  WB  | 87 | 66 | 5742 |    77   |   1
  UR  | 85 | 82 | 6970 |    69   |   1
  BG  | 66 | 71 | 4686 |    51   |   1
  RW  | 82 | 87 | 7134 |    27   |   1
  GU  | 71 | 85 | 6035 |    61   |   1
  BW  | 66 | 87 | 5742 |    77   |   1
  RU  | 82 | 85 | 6970 |    69   |   1
  GB  | 71 | 66 | 4686 |    51   |   1
  WR  | 87 | 82 | 7134 |    27   |   1
  UG  | 85 | 71 | 6035 |    61   |   1

初始方法，23字节

将输入作为2个字符的字符串。返回true给朋友还是false敌人。

s=>parseInt(s,35)%9%7<3

在线尝试！

果冻，6个字节

ạg105Ị

以两个代码点作为参数。好友收益1，敌人收益0。

在线尝试！

背景

令n和m为两个输入字符的代码点。通过取| n-m | ，我们只需要关心字符的所有2个组合。下表显示了所有2个字符的组合及其相应的绝对差。

WU  2
UB 19
BR 16
RG 11
GW 16

WB 21
UR  3
BG  5
RW  5
GU 14

所有敌人的组合是整除3，5，或7，但没有任何的朋友组合这一点，所以朋友们正是那些互质与3×5×7 = 105。

这个怎么运作

ạg105Ị  Main link. Left argument: n (code point). Right argument: m (code point)

ạ       Yield the absolute difference of n and m.
 g105   Compute the GCD of the result and 105.
     Ị  Insignificant; return 1 if the GCD is 1, 0 if not.

Python 2，19个字节

"WUBRGWGRBUW".count

在线尝试！

匿名函数：1为朋友和0敌人返回。

Befunge-98，13 个 12字节

~~-9%5%3%!.@

在线尝试！

0为朋友和1敌人打印

这使用字母的ASCII值之间的差异。

如果我们采用(((ASCII difference % 9) % 5) % 3)，则敌人的值将为0。然后，我们将不设置值并将其打印出来。

感谢@Martin参加高尔夫

果冻，8 7 字节

搭载Mistah Figgins 精彩的Befunge答案！

Iị390B¤

在线尝试！

怎么样？

正如Mistah Figgins指出的那样，可以通过采用ASCII值mod 9 mod 5 mod 3的绝对差值来做出决定-3s是朋友，而1s和2s是敌人。

如果我们改用（普通）差异mod 9，我们会发现朋友是1s，2s，7s和8s，而敌人是3s，4s，5s和6s。

代码采用的区别，I然后索引到长度为9的列表[1,1,0,0,0,0,1,1,0]，二进制形式为390 390B。索引既是模块化的（因此有效地索引是免费执行mod 9），又是基于1的（因此在最左边是1）。

C ++模板元编程，85字节

template<int A,int B,int=(A-B)%9%5%3>struct f;template<int A,int B>struct f<A,B,0>{};

少打高尔夫球：

template<int A, int B,int Unused=(((A-B)%9)%5)%3>
struct foe;
template<int A, int B>
struct foe<A,B,0>{};

由于这是一种元编程语言，因此是否编译的构造是一种可能的输出。

f<'W','B'>当且仅当'W'和'B'是敌人时，才作为编译实例。

基于Befunge答案的数学。

现场例子。

由于C ++模板元编程是最糟糕的高尔夫语言之一，因此任何比这更糟糕的人都应该感到羞耻。;）

Ruby，22个 19字节

->x,y{390[(x-y)%9]}

输入：2个字符的ASCII码。输出：同盟1，敌人0。

这个怎么运作：

获得两个数字模9之间的差，使用位掩码（390是二进制110000110），并使用[]运算符获得一位。

CJam，8个字节

{*51%9>}

一个未命名的块，在堆栈的顶部需要两个字符代码，并将其替换为0（friends）或1（敌人）。

在线尝试！

说明

好吧，我们现在已经看到了许多有趣的算术解决方案，所以我想如果我现在提出自己的解决方案就可以了。到目前为止，我所看到的最接近的是Steadybox的C解决方案。这个是在我前一段时间为无政府状态高尔夫写的GolfScript暴力破解工具的帮助下找到的。

这是此代码对各种输入所做的操作（忽略顺序，因为初始乘法是可交换的）：

xy   x    y    x*y   %51  >9

WU   87   85   7395    0   0
UB   85   66   5610    0   0
BR   66   82   5412    6   0
RG   82   71   5822    8   0
GW   71   87   6177    6   0
WB   87   66   5742   30   1
UR   85   82   6970   34   1
BG   66   71   4686   45   1
RW   82   87   7134   45   1
GU   71   85   6035   17   1

我们可以看到对输入乘积取51的模数如何很好地将输入分为大小结果，并且可以使用两者之间的任何值来区分这两种情况。

Röda，30 22 21字节

@fergusq通过使用_将流中的值作为输入节省了字节

{[_ in"WUBRGWGRBUW"]}

在线尝试！

该函数的运行方式类似于push "WU" | f为该函数分配名称之后

说明

{                      /* Declares an anonymous function */
 [                 ]   /* Push */
  _ in                 /* the boolean value of the value on the stream is in */
      "WUBRGWGRBUW"    /* this string */
}

05AB1E，10个字节

对朋友返回0，对敌人返回1。

‘Û‹BWR‘ûIå

在线尝试！ 或作为测试套件

说明

‘Û‹BWR‘     # push the string "RUGBWR"
       û    # palendromize (append the reverse minus the first char)
        Iå  # check if input is in this string

C，33 32 29 24 22字节

#define f(k,l)k*l%51<9

如果是朋友则返回1，如果是敌人则返回0。

Vim，22 21字节

CWUBRGWGRBUW<esc>:g/<c-r>"/d<cr>

输入：包含两个字符的一行。

输出：如果朋友为空缓冲区，WUBRGWGRBUW如果敌人为缓冲区。

说明

C                                 # [C]hange line (deletes line into " register and enters insert mode)
 WUBRGWGRBUW<esc>                 # insert this text and exit insert mode
                 :g/      /d<cr>  # delete all lines containing...
                    <c-r>"        # ... the previously deleted input

Japt，6个字节

受到@Martin Ender 解决方案的启发 。

将两个字符代码的数组作为输入。

×%51<9

在线尝试！| 测试套件

返回true的朋友，false对敌人。

14字节解决方案：

接受两个字符代码作为输入

nV a /3%3 f ¦1

在线尝试！| 测试套件

说明：

nV a /3%3 f ¦1
nV a             // Absolute value of: First input (implicit) - Second input
      /3%3 f     // Divide by 3, mod 3, then floor the result
             ¦1  // Return true if the result does not equals 1, otherwise return false

12字节解决方案：

"WUBRGW"ê èU

在线尝试！| 测试套件

说明：

"WUBRGW"ê èU
"WUBRGW"ê     // "WUBRGW" mirrored = "WUBRGWGRBUW"
          èU  // Returns the number of times U (input) is found

返回1给朋友和0敌人。

9字节解决方案：

受到@Arnauld 解决方案的启发。

*V%24%B%2

测试套件

返回1的朋友，0对敌人。

11字节解决方案：

受到@Mistah Figgins 解决方案的启发。

nV %9%5%3¦0

测试套件

Brain-Flak，155，147，135字节

(([(({}[{}]))<>])){({}())<>}(((([])[][][])[]())()()())<>{}<>{({}<><(({}))>)({}[{}]<(())>){((<{}{}>))}{}{{}({}<({}())>)(<()>)}{}<>}<>{}

在线尝试！

这是134字节的代码，外加用于-a启用ASCII输入的标志的1个字节的罚款。

这可以通过查找输入之间的绝对差并检查它们是否等于2、11、16或19来起作用。如果匹配，则输入为好友，并且输出1。否则，不输出任何内容。由于没有在脑防弹对应于空栈，这是falsy，无输出是一个falsy值。（元）

我特别喜欢这个答案的一件事是，“绝对差”代码段（即(([(({}[{}]))<>])){({}())<>}{}{}<>{}）不是堆栈干净的，但仍可以在此答案中使用，因为我们不在乎编码之前最终到达哪个堆栈可能的差异。

在以后的编辑中，我通过滥用堆栈上没有绝对差异的堆栈上的剩余内容，从而进一步利用了这一优势。在第一个修订版中，我将两者都弹出，以使其更加理智。不这样做会导致两个主要的高尔夫球：

1. 显然，它删除了将它们弹出的代码：{}{}，但更重要的是：

2. 它允许我们压缩2, 11, 16, 19序列

   (((((()()))[][][](){})[][]())[])
   

   至

   (((([])[][][])[]())()()())
   

   幸运的是，以后不需要处理这些剩余的额外代码，因此它们仅留在备用堆栈上。

由于众所周知，大脑皮屑难以理解，因此以下是可读/注释的版本：

#Push the absolute difference of the two input characters. It is unknown which stack the result will end on
(([(({}[{}]))<>])){({}())<>}

#Push 2, 11, 16, 19, while abusing the values left on the stack from our "Absolute value" calculation
(((([])[][][])[]())()()())

#Pop a zero from the other stack and toggle back
<>{}<>

#While True
{

    #Move top over and duplicate the other top
    ({}<><(({}))>)

    #Equals?
    ({}[{}]<(())>){((<{}{}>))}{}

    #If so:
    {

        #Increment the number under the stack
        {}({}<({}())>)
        #Push a zero
        (<()>)

    }

    #Pop the zero
    {}

    #Go back to the other stack
    <>

#Endwhile
}

#Toggle back
<>

#Pop a zero
{}

果冻，14字节

“WUBRG”wЀIAÆP

返回1敌人和0朋友。

在线测试套件！

怎么样？

“WUBRG”wЀIAÆP - Main link                                   e.g. WG
“WUBRG”        - ['W','U','B','R','G']
       wЀ     - first index of sublist mapped over the input     [1,5]
          I    - incremental differences                           -4
           A   - absolute value                                     4
            ÆP - is prime?                                          0

05AB1E，7个字节

$Æ105¿Ö

这是我对果冻的回答。将代码点列表作为输入。为朋友打印1，为敌人打印0。

在线尝试！

这个怎么运作

$        Push 1 and [n, m] (the input).
 Æ       Reduce [n, m] by subtraction, pushing n - m.
  105¿   Take the GCD of n - m and 105.
      Ö  Test if 1 is divisible by the GCD (true iff the GCD is ±1).

CJam，16 12 11 10字节

使用Mistah Figgins的算法获得4个字节

感谢Lynn，节省了1个字节

l:m9%5%3%!

1敌方颜色，0盟军颜色的输出。

在线尝试！（或验证所有测试用例）

说明

l           e# Push a line of input as a string
 :m         e# Reduce the string by subtraction (using the ASCII values)
   9%5%3%   e# Mod by 9, then by 5, then by 3. By doing this, enemy
            e#  pairs go to 0, and allies go to 1, 2, -1, or -2.
         !  e# Boolean negation

视网膜，18字节

O`.
BR|BU|GR|GW|UW

在线尝试！

非常简单：对输入进行排序，并尝试将任何已排序的盟友对与其匹配。不幸的是，我不认为Retina基于字符串的本质允许任何更有趣的方法具有竞争力。

作为下一个Retina版本的先睹为快，我打算添加一个选项来交换正则表达式和目标字符串（因此，当前字符串将用作正则表达式，并提供一个要检查的字符串），在这种情况下，此选项解决方案将起作用（或类似的方法）：

?`WUBRGWGRBUW

Java（OpenJDK 8），28 23字节

-5字节归功于fergusq

"WUBRGWGRBUW"::contains

在线尝试！

Brachylog，10个字节

一个简单的解决方案，不涉及任何技巧。

p~s"WUBRGW

在线尝试！

说明

p               A permutation of the input
 ~s             is a substring of
   "WUBRGW      this string

果冻，6个字节

ạ:3%3Ḃ

为了完整起见。以两个代码点作为参数。产量0朋友，1为敌人。

在线尝试！

背景

令n和m为两个输入字符的代码点。通过取| n-m | ，我们只需要关心字符的所有2个组合。下表显示了所有2个字符的组合及其相应的绝对差。

WU UB BR RG GW  WB UR BG RW GU
 2 19 16 11 16  21  3  5  5 14

如果将这些整数除以3，则将得到以下商。

WU UB BR RG GW  WB UR BG RW GU
 0  6  5  3  5   7  1  1  1  4

1，4和7可以被映射到1通过取模的结果3。

WU UB BR RG GW  WB UR BG RW GU
 0  0  2  0  2   1  1  1  1  1

现在我们只需要看一下平价。

这个怎么运作

ạ:3%3Ḃ  Main link. Left argument: n (code point). Right argument: m (code point)

ạ       Absolute difference; yield |n - m|.
 :3     Integer division by 3, yielding |n - m| / 3.
   %3   Modulo 3, yielding |n - m| / 3 % 3.
     Ḃ  Parity bit; yield |n - m| / 3 % 3 & 1.

Cubix，11个字节

Arnauld解决方案的Cubix实现。

U%O@A*'g%2W

用法

输入两个字符，然后输出0给朋友和1敌人。在这里尝试。

说明

可以像这样扩展代码。

    U %
    O @
A * ' g % 2 W .
. . . . . . . .
    . .
    . .

字符按以下顺序执行（控制流除外）：

A*'g%2%O@
A         # Read all input as character codes
 *        # Multiply the last two character codes
    %     # Modulo the result by
  'g      #     103
      %   # And modulo that by
     2    #     2
       O  # Output the result ...
        @ # ... and terminate

Python 2，26个字节

lambda a:a in"GWUBRGRBUWG"

在线尝试！

AWK，23字节

{$0="WUBRGWGRBUW"~$1}1

用法示例：awk'{$ 0 =“ WUBRGWGRBUW”〜$ 1} 1'<<< UB

1如果这对是朋友，0则打印此记录。我想做些聪明的事，但是我想到的一切都会更长。

果冻，12字节

“WUBRGW”ŒBẇ@

1盟友0和敌人的输出。

在线尝试！

说明

“WUBRGW”ŒBẇ@   Main link

“WUBRGW”       The string "WUBRGW"
        ŒB     Bounce; yields "WUBRGWGRBUW"
          ẇ@   Check if the input exists in that string

Ruby，28个字节

对朋友输出true，对敌人输出false：

p'WUBRGWGRBUW'.include?$**''

非高尔夫版本没有太大区别：

p 'WUBRGWGRBUW'.include?(ARGV.join(''))

05AB1E，7个字节

乔纳森（Jonathan）的果冻（Jelly）答案中的改装技巧改编

Æ451bsè

在线尝试！ 或作为测试套件

说明

 Æ        # reduced subtraction
  451b    # 451 to binary (111000011)
      sè  # index into this with the result of the reduced subtraction

GolfScript，7个字节

~*51%9>

以两个代码点作为输入。

在线尝试！（为方便起见，测试套件会转换输入格式。）

我的CJam答案的 GolfScript端口（从技术上讲，这是我的GolfScript蛮力...呃...的结果的CJam端口）。

但是，由于GolfScript可以正确地对负输入取模，因此在相同的字节数处有一个有趣的替代解决方案，它4用于对付而不是1：

~-)9%4&

在线尝试！

xy   x    y    x-y    +1  %9  &4

WU   87   85     2     3   3   0
UB   85   66    19    20   2   0
BR   66   82   -16   -15   3   0
RG   82   71    11    12   3   0
GW   71   87   -16   -15   3   0
WB   87   66    21    22   4   4
UR   85   82     3     4   4   4
BG   66   71    -5    -4   5   4
RW   82   87    -5    -4   5   4
GU   71   85   -14   -13   5   4

Java 7，38个字节

int b(int a,int b){return(a-b)%9%5%3;}

从港口@Mistah菲金斯 'Befunge-98的答案是迄今为止发布的答案在Java 7中最短的。
至于其他：

39个字节：@Arnauld的JavaScript（ES6）Answer中的端口。

int a(int a,int b){return a*b%24%11%2;}

39个字节：@MartinEnder的CJam答案的端口

Object e(int a,int b){return a*b%51>9;}

47个字节：@Steadybox的端口'C回答

Object d(int a,int b){return(a=a*b%18)>7|a==3;}

52个字节：@Lynn的Python 2答案的端口

Object c(String s){return"WUBRGWGRBUW".contains(s);}

注意：跳过的答案使用质数/回文数等，因为在Java中这远远不够。;）
TODO：提出我自己的答案。尽管我怀疑它比大多数答案都短。

在这里全部尝试。

编辑：好的，我自己想出了一些还不错的东西：

50个字节：

Object c(int a,int b){return(a=a*b%18)>3&a<7|a<1;}

说明：

ab  a   b   a*b     %18

WU  87  85  7395    15
UB  85  66  5610    12
BR  66  82  5412    12
RG  82  71  5822    8
GW  71  87  6177    3
UW  85  87  7395    15
BU  66  85  5610    12
RB  82  66  5412    12
GR  71  82  5822    8
WG  87  71  6177    3

WB  87  66  5742    0
UR  85  82  6970    4
BG  66  71  4686    6
RW  82  87  7134    6
GU  71  85  6035    5
BW  66  87  5742    0
RU  82  85  6970    4
GB  71  66  4686    6
WR  87  82  7134    6
UG  85  71  6035    5

所有的敌人，要么在4-6范围内（含）或0
EDIT2：嗯..我只注意到它非常类似于@Steadybox的回答.. :(

PHP，31字节

echo!strstr(WBGURWRUGBW,$argn);

与一起运行echo AB | php -nR '<code>，其中A和和B是两种颜色。

strtr 从找到输入的位置返回字符串；
与WBGURWRUGBW如大海捞针这将返回如果颜色是敌人一个truthy串; 如果不是，则为空字符串。

!将真字符串转换为false，导致空输出
，将空字符串转换为true，导致输出1。