No jogo de cartas Magic: the Gathering, existem cinco cores diferentes, que representam afiliações frouxas de cartões: Branco ( W), Azul ( U), Preto ( B), Vermelho ( R) e Verde ( G). Eles geralmente são organizados em um pentágono da seguinte maneira:

  W
G   U
 R B

Tanto no folclore do MtG quanto em muitas mecânicas de cartas, as cores adjacentes nesse pentágono são geralmente consideradas aliadas, e as cores não adjacentes (tipo opostas) são consideradas inimigas.

Nesse desafio, você terá duas cores e deve determinar o relacionamento delas.

O desafio

Você recebe dois caracteres distintos do conjunto BGRUW. Você pode tomá-los como uma cadeia de dois caracteres, uma cadeia com um delimitador entre os caracteres, dois valores de caracteres separados, duas cadeias singleton, dois inteiros representando seus pontos de código ou uma lista ou tipo de conjunto contendo dois caracteres / cadeias / números inteiros.

Sua saída deve ser um dos dois valores distintos e consistentes de sua escolha, um que indica que as duas cores são aliadas e outro que indica que são inimigos. Um desses dois valores pode não ter saída.

Você pode escrever um programa ou uma função e usar qualquer um dos nossos métodos padrão de recebimento de entrada e saída.

Você pode usar qualquer linguagem de programação , mas observe que essas brechas são proibidas por padrão.

Isso é código-golfe , então a resposta mais curta e válida - medida em bytes - vence.

Casos de teste

Existem apenas 20 entradas possíveis, então vou listar todas elas.

Amigos:

WU   UB   BR   RG   GW   UW   BU   RB   GR   WG

Inimigos:

WB   UR   BG   RW   GU   BW   RU   GB   WR   UG

JavaScript (ES6),  26 23 17 15  14 bytes

Recebe a entrada como dois códigos ASCII na sintaxe de currying (a)(b). Retorna 4para amigos ou 0inimigos.

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

Experimente online!

Quão?

Nota: apenas o quociente inteiro da divisão por 0,6 é mostrado abaixo.

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

Abordagem anterior, 15 bytes

Recebe a entrada como dois códigos ASCII na sintaxe de currying (a)(b). Retorna 0para amigos ou 1inimigos.

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

Experimente online!

Quão?

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

Abordagem inicial, 23 bytes

Recebe a entrada como uma sequência de 2 caracteres. Retorna truepara amigos ou falseinimigos.

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

Experimente online!

Gelatina , 6 bytes

ạg105Ị

Toma dois pontos de código como argumento. Rende 1 para amigos, 0 para inimigos.

Experimente online!

fundo

Seja n e m os pontos de código de dois caracteres de entrada. Tomando | n - m | , precisamos nos preocupar apenas com todas as 2 combinações de caracteres. A tabela a seguir mostra todas as 2 combinações de caracteres correspondentes às diferenças absolutas.

WU  2
UB 19
BR 16
RG 11
GW 16

WB 21
UR  3
BG  5
RW  5
GU 14

Todos inimigo combinações são divisível por 3 , 5 ou 7 , mas nenhum dos amigos combinações este, assim que os amigos são exatamente aquelas que são co-prime com 3 × 5 × 7 = 105 .

Como funciona

ạ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 bytes

"WUBRGWGRBUW".count

Experimente online!

Uma função anônima: retorna 1para amigos e 0inimigos.

Befunge-98, 13 12 bytes

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

Experimente online!

Impressões 0para amigos e 1inimigos

Isso usa a diferença entre os valores ASCII das letras.

Se pegarmos o (((ASCII difference % 9) % 5) % 3), os valores para os inimigos serão 0. Então, não o valor e o imprimiremos.

Obrigado a @Martin pelo golfe

Geléia , 8 7 bytes

Anda às costas da fabulosa resposta Befunge de Mistah Figgins !

Iị390B¤

Experimente online!

Quão?

Como Mistah Figgins observou, a decisão pode ser tomada tomando a diferença absoluta entre os valores ASCII mod 9 mod 5 mod 3 - 0s são amigos e 1s e 2s são inimigos.

Se usarmos o mod 9 de diferença (simples), descobrimos que amigos são 1s, 2s, 7s e 8s, enquanto os inimigos são 3s, 4s, 5s e 6s.

O código leva a diferença com Ie depois indexa a lista de comprimento 9 [1,1,0,0,0,0,1,1,0], que é 390 em binário 390B,. A indexação é modular (efetivamente, a indexação executa o mod 9 de graça) e baseada em 1 (daí o 1 à esquerda).

Metaprogramação de modelos C ++, 85 bytes

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

menos golfe:

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

Como essa é uma linguagem de metaprogramação, uma construção compilada ou não é uma saída possível.

Uma instância de f<'W','B'>compila se e somente se 'W'e 'B'são inimigos.

Matemática baseada na resposta Befunge .

Exemplo ao vivo .

Como a metaprogramação de modelos C ++ é uma das piores linguagens de golfe, qualquer pessoa pior do que isso deve se sentir envergonhada. ;)

Ruby, 22 19 bytes

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

Entrada: código ASCII dos 2 caracteres. Saída: 1 para aliados, 0 para inimigos.

Como funciona:

Obtenha a diferença entre os 2 números do módulo 9, use uma máscara de bits (390 é o binário 110000110) e obtenha um único bit usando o []operador.

CJam , 8 bytes

{*51%9>}

Um bloco sem nome que espera dois códigos de caracteres no topo da pilha e os substitui por 0(amigos) ou 1(inimigos).

Experimente online!

Explicação

Bem, já vimos muitas soluções aritméticas divertidas agora, então acho que tudo bem se eu apresentar a minha agora. O mais próximo disso que eu vi até agora é a solução C do Steadybox . Este foi encontrado com a ajuda de um forçador bruto do GolfScript que escrevi há algum tempo para o golfe da anarquia.

Aqui está o que este faz às várias entradas (ignorando a ordem, porque a multiplicação inicial é comutativa):

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

Podemos ver como a tomada do produto das entradas 51 separa bem as entradas em resultados grandes e pequenos, e podemos usar qualquer um dos valores intermediários para distinguir os dois casos.

Röda , 30 22 21 bytes

Bytes salvos graças a @fergusq usando _para obter os valores no fluxo como entrada

{[_ in"WUBRGWGRBUW"]}

Experimente online!

A função é executada como push "WU" | fapós atribuir um nome à função

Explicação

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

05AB1E , 10 bytes

Retorna 0 para amigo e 1 para inimigo.

‘Û‹BWR‘ûIå

Experimente online! ou como um conjunto de testes

Explicação

‘Û‹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 bytes

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

Retorna 1 se amigos, 0 se inimigos.

Vim, 22 21 bytes

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

Entrada: uma única linha contendo os dois caracteres.

Saída: buffer vazio se amigos, buffer contendo WUBRGWGRBUWinimigos.

Explicação

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

Japonês , 6 bytes

Inspirado na solução de @Martin Ender .

Toma uma matriz de dois códigos de caracteres como entrada.

×%51<9

Experimente online! | Suíte de teste

Retorna truepara amigos, falsepara inimigos.

Solução de 14 bytes:

Toma dois códigos de caracteres como entrada

nV a /3%3 f ¦1

Experimente online! | Suíte de teste

Explicação:

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

Solução de 12 bytes:

"WUBRGW"ê èU

Experimente online! | Suíte de teste

Explicação:

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

Retorna 1para amigos e 0inimigos.

Solução de 9 bytes :

Inspirado na solução da @ Arnauld .

*V%24%B%2

Suíte de teste

Retorna 1para amigos, 0para inimigos.

Solução de 11 bytes:

inspirado na solução de @Mistah Figgins .

nV %9%5%3¦0

Suíte de teste

Brain-Flak , 155, 147 , 135 bytes

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

Experimente online!

São 134 bytes de código mais uma penalidade de byte para o -asinalizador, o que permite a entrada ASCII.

Isso funciona encontrando a diferença absoluta entre as entradas e verificando se são iguais a 2, 11, 16 ou 19. Se isso acontecer, a entrada é um amigo e imprime um 1. Caso contrário, não imprime nada. Como nada no cérebro corresponde a uma pilha vazia, que é falsa, nenhuma saída é um valor falso. ( meta )

Uma coisa que eu particularmente gosto nessa resposta é que o snippet "diferença absoluta" (ou seja (([(({}[{}]))<>])){({}())<>}{}{}<>{}) não é limpo de pilha, mas ainda pode ser usado nessa resposta, pois não nos importamos com qual pilha vamos terminar antes da codificação as possíveis diferenças.

Em uma edição posterior, tirei vantagem disso ainda mais, abusando das sobras da pilha que não acabam com a diferença absoluta. Na primeira revisão, coloquei os dois para mantê-lo um pouco mais são. Não fazer isso dá dois grandes campos de golfe:

1. Obviamente, ele remove o código para exibi-los:, {}{}mas mais importante:

2. Permite-nos comprimir a 2, 11, 16, 19sequência de

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

   para

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

   Felizmente, não há código extra necessário para lidar com essas sobras mais tarde, então elas são deixadas na pilha alternativa.

Como a quebra cerebral é notoriamente difícil de entender, aqui está uma versão legível / comentada:

#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
{}

Gelatina , 14 bytes

“WUBRG”wЀIAÆP

Retorna 1para inimigos e 0amigos.

Conjunto de testes em Experimente online!

Quão?

“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 bytes

$Æ105¿Ö

Esta é uma porta da minha resposta Jelly . Leva uma lista de pontos de código como entrada. Imprime 1 para amigos, 0 para inimigos.

Experimente online!

Como funciona

$        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 bytes

Golpeou 4 bytes usando o algoritmo de Mistah Figgins

Guardado 1 byte graças a Lynn

l:m9%5%3%!

Saídas 1para cores inimigas, 0cores aliadas.

Experimente online! (Ou verifique todos os casos de teste )

Explicação

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

Retina , 18 bytes

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

Experimente online!

Bem direto: classifica a entrada e tenta combinar qualquer um dos pares de aliados classificados contra ela. Infelizmente, não acho que a natureza baseada em string de Retina permita que qualquer uma das abordagens mais interessantes seja competitiva.

Como uma prévia da próxima versão do Retina, estou planejando adicionar uma opção que troque regex e sequência de destino (para que a sequência atual seja usada como regex e você dê uma sequência para verificação); nesse caso, isso é mais curto solução funcionará (ou algo nesse sentido):

?`WUBRGWGRBUW

Java (OpenJDK 8) , 28 23 bytes

-5 bytes graças ao fergusq

"WUBRGWGRBUW"::contains

Experimente online!

Braquilog , 10 bytes

Uma solução direta, sem truques envolvidos.

p~s"WUBRGW

Experimente online!

Explicação

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

Gelatina , 6 bytes

ạ:3%3Ḃ

Pelo bem da integridade. Toma dois pontos de código como argumento. Rende 0 para amigos, 1 para inimigos.

Experimente online!

fundo

Seja n e m os pontos de código de dois caracteres de entrada. Tomando | n - m | , precisamos nos preocupar apenas com todas as 2 combinações de caracteres. A tabela a seguir mostra todas as 2 combinações de caracteres correspondentes às diferenças absolutas.

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

Se dividirmos esses números inteiros por 3 , obteremos os seguintes quocientes.

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

1 , 4 e 7 podem ser mapeados para 1 usando o módulo de resultados 3 .

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

Agora só temos que olhar para a paridade.

Como funciona

ạ: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 bytes

Uma implementação do Cubix da solução da Arnauld.

U%O@A*'g%2W

Uso

Digite os dois caracteres e será exibido 0para amigos e 1inimigos. Experimente aqui.

Explicação

O código pode ser expandido assim.

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

Os caracteres são executados nesta ordem (excluindo o fluxo de controle):

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 bytes

lambda a:a in"GWUBRGRBUWG"

Experimente online!

AWK, 23 bytes

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

Exemplo de uso: awk '{$ 0 = "WUBRGWGRBUW" ~ $ 1} 1' <<< UB

Imprime 1se o par for um amigo, 0caso contrário. Eu queria fazer algo inteligente, mas tudo que eu pensava seria mais longo.

Gelatina , 12 bytes

“WUBRGW”ŒBẇ@

Saídas 1para aliados, 0inimigos.

Experimente online!

Explicação

“WUBRGW”ŒBẇ@   Main link

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

Ruby, 28 bytes

Saídas true para friend, false para foe:

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

A versão ungolfed não é muito diferente:

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

05AB1E , 7 bytes

Adaptação do mod-trick da resposta de Jonathan's Jelly

Æ451bsè

Experimente online! ou como um conjunto de testes

Explicação

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

GolfScript , 7 bytes

~*51%9>

Toma dois pontos de código como entrada.

Experimente online! (Conjunto de testes que converte o formato de entrada por conveniência.)

Uma porta GolfScript da minha resposta CJam (que tecnicamente é uma porta CJam do resultado do meu forçador bruto GolfScript ... uhhh ...).

No entanto, como o GolfScript acerta o módulo com entradas negativas, existe uma solução alternativa divertida na mesma contagem de bytes que usa 4para inimigos em vez de 1:

~-)9%4&

Experimente online!

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 bytes

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

A porta da resposta Befunge-98 do @Mistah Figgins é a mais curta do Java 7 das respostas postadas até agora.
Quanto aos outros:

39 bytes: porta da resposta JavaScript (ES6) de @Arnauld .

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

39 bytes: Porto de @MartinEnder resposta CJam 's

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

47 bytes: porta da resposta C do @Steadybox '

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

52 bytes: porta da resposta Python 2 de @Lynn

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

NOTA: Respostas ignoradas que usam números primos / palíndromos e similares, porque essas não são nem um pouco curtas em Java. ;)
TODO: Apresentando minha própria resposta. Embora eu duvide que seja mais curto que a maioria delas.

Tente tudo aqui.

Edição: Ok, veio com algo que não é tão ruim:

50 bytes:

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

Explicação:

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

Todos os inimigos estão entre 4-6 (inclusive) ou 0.
EDIT2: Hmm .. Acabei de notar que é muito semelhante à resposta do @Steadybox .. :(

PHP, 31 bytes

echo!strstr(WBGURWRUGBW,$argn);

Corra com echo AB | php -nR '<code>, onde Ae Bsão as duas cores.

strtrretorna a string da posição em que a entrada é encontrada;
com WBGURWRUGBWcomo palheiro, isso retorna uma sequência verdadeira se as cores são inimigas; cadeia vazia, se não.

!transforma a sequência truthy em false, resultando em saída vazia
e a string vazia em true, resultando em saída 1.