魔术聚会:朋友还是敌人?


67

在纸牌游戏《魔术:聚会》中,有五种不同的颜色,代表纸牌的松散隶属关系,白色(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

33
接下来:执行核心规则:P
上尉曼·

12
@CaptainMan如果您可以将其放置在30k字符的帖子中,我会投票给您:)
Walfrat

@Walfrat 30k?应该有可能
并不是查尔斯(Charles)

2
来自最意外的联盟的@IvanKolmychek带来了最意外的结果。
aluriak

1
有趣的事实:魔术:聚会即将结束:)
马修·罗

Answers:


82

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

在线尝试!


10
啊,终于好玩了。:)
Martin Ender

4
很棒的发现!
格雷格·马丁

这里有我不知道的一些聪明的数学方法吗?或者您只是蛮力地使用了不同的模,直到您得到了有效的模?
FourOhFour

@FourOhFour这是蛮力的。我认为这是最小的双模解决方案。但是这个答案的端口(使用比较)实际上会短一个字节。
Arnauld

1
@OddDev我实际上测试了所有位,而不仅仅是最低有效位。例如,a*b%290&8将同样有效(0为朋友或8敌人生产)。
Arnauld

37

果冻,6个字节

ạg105Ị

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

在线尝试!

背景

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

WU  2
UB 19
BR 16
RG 11
GW 16

WB 21
UR  3
BG  5
RW  5
GU 14

所有敌人的组合是整除35,或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.

很好发现!为什么绝对值是必需的?(我在网上进行了尝试,但给出的答案没有正确;但是从数学上讲,这并不重要。)
Greg Martin

@GregMartin没必要;签署的差异同样适用。减法_是果冻。您还使用其他东西吗?
丹尼斯

我知道,我错误地理解为绝对值,而不是绝对差异。
格雷格·马丁


21

Befunge-98,13 12字节

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

在线尝试!

0为朋友和1敌人打印

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

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

感谢@Martin参加高尔夫


将Jelly用作9字节:IA%9%5%3¬编辑在线试用!
乔纳森·艾伦

@JonathanAllan我看到你已经做到了!真好
MildlyMilquetoast

实际上,我修改了您的方法(使用实际的而不是绝对的差异)mod 9 mod 6,并使用了Jelly模块化地索引到列表中以将其降至7的事实。我认可了您,并在此处链接。
乔纳森·艾伦,2017年

@JonathanAllan我也想出了mod 9 mod 6方法,但是Befunge没有实际差异或绝对值,因此它不可行
MildlyMilquetoast

18

果冻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)。


16

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 ++模板元编程是最糟糕的高尔夫语言之一,因此任何比这更糟糕的人都应该感到羞耻。;)


好像templates 内总共有两个冗余空白。
Yytsi

@TuukkaX已修复,d'oh
Yakk

14

Ruby,22个 19字节

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

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

这个怎么运作:

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


2
很好,我一直忘记可以对整数进行索引。+1
马丁·恩德

16个字节:->x,y{x*y%103%2}请注意,0和取1反。
埃里克·杜米尼尔

1
x*y%51>9其他人一样15字节。我认为现在如此激进地改变它对投票者是不公平的。
GB

10

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的模数如何很好地将输入分为大小结果,并且可以使用两者之间的任何值来区分这两种情况。


9

Röda30 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 */
}

o_O闪电速度
帕维尔(Pavel)

可以通过从流中读取输入值来节省5个字节,而不用采用parameter:,{[(_.._)in"WUBRGWGRBUW"]}但是必须像那样调用该函数[a, b] | f
fergusq

9

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

9

C,33 32 29 24 22字节

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

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


8

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

2
您可以C代替cw
Kritixi Lithos

8

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

测试套件


8

Brain-Flak155,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
{}

有一个推式弹出按钮,您可以将其删除,如果可以更有效地将其推到129,则可以按0:TIO
Riley

@Riley Cool,感谢您的提示!我喜欢有评论的版本,所以我将等到理解该版本后再进行更新。
DJMcMayhem

这只是两个小的更改。是重要的部分。我的评论全都用大写了,如果我在大喊大叫,对不起。
莱利

7

果冻,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

7

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

6

CJam16 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

不要试图变得太聪明!l:m9%5%3%!短一个字节。
林恩

@琳恩哇,是的。有点无聊。谢谢
商业猫

5

视网膜,18字节

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

在线尝试!

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

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

?`WUBRGWGRBUW


4

Brachylog,10个字节

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

p~s"WUBRGW

在线尝试!

说明

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

4

果冻,6个字节

ạ:3%3Ḃ

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

在线尝试!

背景

nm为两个输入字符的代码点。通过取| 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

147可以被映射到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.

4

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


2

AWK,23字节

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

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

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


2

果冻,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

2

Ruby,28个字节

对朋友输出true,对敌人输出false:

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

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

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


2

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

2

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的回答.. :(


2

PHP,31字节

echo!strstr(WBGURWRUGBW,$argn);

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

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

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

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.