En el juego de cartas Magic: the Gathering hay cinco colores diferentes, que representan afiliaciones sueltas de cartas, Blanco ( W), Azul ( U), Negro ( B), Rojo ( R) y Verde ( G). A menudo se organizan en un pentágono de la siguiente manera:

  W
G   U
 R B

Tanto en la tradición de MtG como en muchas mecánicas de cartas, los colores adyacentes en este pentágono generalmente se consideran aliados, y los colores no adyacentes (más o menos opuestos) se consideran enemigos.

En este desafío, se te darán dos colores y deberías determinar su relación.

El reto

Te dan dos caracteres distintos del conjunto BGRUW. Puede tomarlos como una cadena de dos caracteres, una cadena con un delimitador entre los caracteres, dos valores de caracteres separados, dos cadenas de un solo tono, dos enteros que representan sus puntos de código o una lista o tipo de conjunto que contiene dos caracteres / cadenas / enteros.

Su salida debe ser uno de los dos valores distintos y consistentes de su elección, uno que indique que los dos colores son aliados y otro que indique que son enemigos. Uno de esos dos valores puede no tener salida.

Puede escribir un programa o una función y utilizar cualquiera de nuestros métodos estándar para recibir entradas y proporcionar salidas.

Puede usar cualquier lenguaje de programación , pero tenga en cuenta que estas lagunas están prohibidas de forma predeterminada.

Este es el código de golf , por lo que gana la respuesta válida más corta, medida en bytes .

Casos de prueba

Solo hay 20 entradas posibles, así que las enumeraré todas.

Amigos:

WU   UB   BR   RG   GW   UW   BU   RB   GR   WG

Enemigos:

WB   UR   BG   RW   GU   BW   RU   GB   WR   UG

JavaScript (ES6),  26 23 17 15  14 bytes

Toma datos como dos códigos ASCII en la sintaxis de curry (a)(b). Devoluciones 4para amigos o 0para enemigos.

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

Pruébalo en línea!

¿Cómo?

NB: solo se muestra a continuación el cociente entero de la división por 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

Enfoque anterior, 15 bytes

Toma datos como dos códigos ASCII en la sintaxis de curry (a)(b). Devoluciones 0para amigos o 1para enemigos.

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

Pruébalo en línea!

¿Cómo?

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

Enfoque inicial, 23 bytes

Toma la entrada como una cadena de 2 caracteres. Devoluciones truepara amigos o falsepara enemigos.

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

Pruébalo en línea!

Jalea , 6 bytes

ạg105Ị

Toma dos puntos de código como argumento. Rinde 1 para amigos, 0 para enemigos.

Pruébalo en línea!

Antecedentes

Deje n y m ser los puntos de código de dos caracteres de entrada. Al tomar | n - m | , solo debemos ocuparnos de todas las 2 combinaciones de caracteres. La siguiente tabla muestra todas las combinaciones de 2 caracteres de las diferencias absolutas correspondientes.

WU  2
UB 19
BR 16
RG 11
GW 16

WB 21
UR  3
BG  5
RW  5
GU 14

Todos enemigo combinaciones son divisibles por 3 , 5 o 7 , pero ninguno de los amigos combinaciones de estos, por lo que los amigos son exactamente los que están co-prime con 3 x 5 x 7 = 105 .

Cómo 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

Pruébalo en línea!

Una función anónima: regresa 1para amigos y 0enemigos.

Befunge-98, 13 12 bytes

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

Pruébalo en línea!

Impresiones 0para amigos y 1enemigos.

Esto usa la diferencia entre los valores ASCII de las letras.

Si tomamos el (((ASCII difference % 9) % 5) % 3), los valores para los enemigos serán 0. Entonces, no tomamos el valor y lo imprimimos.

Gracias a @ Martin por el golf

Jalea , 8 7 bytes

¡Aprovecha la fabulosa respuesta Befunge de Mistah Figgins !

Iị390B¤

Pruébalo en línea!

¿Cómo?

Como señaló Mistah Figgins, la decisión se puede tomar tomando la diferencia absoluta entre los valores ASCII mod 9 mod 5 mod 3 - 0s son amigos y 1s y 2s son enemigos.

Si en cambio tomamos la diferencia (simple) mod 9, encontramos que los amigos son 1s, 2s, 7s y 8s, mientras que los enemigos son 3s, 4s, 5s y 6s.

El código toma la diferencia con Iy luego índices en la lista de longitud 9 [1,1,0,0,0,0,1,1,0], que es 390 en binario, 390B. La indexación es tanto modular (de manera tan efectiva que realiza el mod 9 de forma gratuita) y basada en 1 (de ahí el 1 a la izquierda).

Metaprogramación de plantilla 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 golf:

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 se trata de un lenguaje de metaprogramación, una compilación de compilación o no es una salida posible.

Una instancia de f<'W','B'>compilaciones si y solo si 'W'y 'B'son enemigos.

Matemáticas basadas en la respuesta Befunge .

Ejemplo en vivo .

Como la metaprogramación de plantillas C ++ es uno de los peores lenguajes de golf, cualquiera que sea peor que esto debería sentirse avergonzado. ;)

Ruby, 22 19 bytes

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

Entrada: código ASCII de los 2 caracteres. Salida: 1 para aliados, 0 para enemigos.

Cómo funciona:

Obtenga la diferencia entre los 2 números del módulo 9, use una máscara de bits (390 es binario 110000110) y obtenga un solo bit con el []operador.

CJam , 8 bytes

{*51%9>}

Un bloque sin nombre que espera dos códigos de caracteres en la parte superior de la pila y los reemplaza con 0(amigos) o 1(enemigos).

Pruébalo en línea!

Explicación

Bueno, hemos visto muchas soluciones aritméticas divertidas ahora, así que supongo que está bien si presento la mía ahora. Lo más cercano a esto que he visto hasta ahora es la solución C de Steadybox . Este fue encontrado con la ayuda de un forzador bruto de GolfScript que escribí hace algún tiempo para anarchy golf.

Esto es lo que este le hace a las diversas entradas (ignorando el orden, porque la multiplicación inicial es conmutativa):

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 cómo tomar el producto de las entradas del módulo 51 separa bien las entradas en resultados grandes y pequeños, y podemos usar cualquiera de los valores intermedios para distinguir entre los dos casos.

Röda , 30 22 21 bytes

Bytes guardados gracias a @fergusq al usar _para tomar los valores en la secuencia como entrada

{[_ in"WUBRGWGRBUW"]}

Pruébalo en línea!

La función se ejecuta como push "WU" | fdespués de asignar un nombre a la función.

Explicación

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

05AB1E , 10 bytes

Devuelve 0 para amigo y 1 para enemigo.

‘Û‹BWR‘ûIå

Pruébalo en línea! o como un conjunto de pruebas

Explicación

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

Devuelve 1 si son amigos, 0 si son enemigos.

Vim, 22 21 bytes

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

Entrada: una sola línea que contiene los dos caracteres.

Salida: búfer vacío si amigos, búfer que contiene WUBRGWGRBUWsi enemigos.

Explicación

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 bytes

Inspirado en la solución de @Martin Ender .

Toma una matriz de dos códigos char como entrada.

×%51<9

Pruébalo en línea! El | Banco de pruebas

Devoluciones truepara amigos, falsepara enemigos.

Solución de 14 bytes:

Toma dos códigos char como entrada

nV a /3%3 f ¦1

Pruébalo en línea! El | Banco de pruebas

Explicación:

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

Solución de 12 bytes:

"WUBRGW"ê èU

Pruébalo en línea! El | Banco de pruebas

Explicación:

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

Devoluciones 1para amigos y 0enemigos.

Solución de 9 bytes :

Inspirado en la solución de @ Arnauld .

*V%24%B%2

Banco de pruebas

Devoluciones 1para amigos, 0para enemigos.

Solución de 11 bytes:

inspirado en la solución de @Mistah Figgins .

nV %9%5%3¦0

Banco de pruebas

Brain-Flak , 155, 147 , 135 bytes

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

Pruébalo en línea!

Esto es 134 bytes de código más una penalización de byte para el -aindicador que permite la entrada ASCII.

Esto funciona al encontrar la diferencia absoluta entre las entradas y verificar si son iguales a 2, 11, 16 o 19. Si lo hace, la entrada es un amigo e imprime un 1. Si no lo es, no imprime nada. Como nada en brain-flak corresponde a una pila vacía, lo cual es falso, ninguna salida es un valor falso. ( meta )

Una cosa que me gusta especialmente de esta respuesta es que el fragmento de "diferencia absoluta" (es decir, (([(({}[{}]))<>])){({}())<>}{}{}<>{}) no está limpio de pila, pero aún puede usarse en esta respuesta ya que no nos importa en qué pila terminamos antes de codificar Las posibles diferencias.

En una edición posterior, aproveché esto aún más al abusar de las sobras en la pila que no termina con la diferencia absoluta. En la primera revisión, los saqué a ambos para mantenerlo un poco más cuerdo. No hacer esto da dos grandes campos de golf:

1. Obviamente, elimina el código para hacerlos explotar: {}{}pero, lo que es más importante:

2. Nos permite comprimir la 2, 11, 16, 19secuencia de

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

   a

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

   Afortunadamente, no se necesita código adicional para manejar estas sobras más adelante, por lo que solo se dejan en la pila alternativa.

Como Brain Flak es notoriamente difícil de entender, aquí hay una versión legible / 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
{}

Jalea , 14 bytes

“WUBRG”wЀIAÆP

Devoluciones 1para enemigos y 0amigos.

Test suite en Pruébelo en línea!

¿Cómo?

“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¿Ö

Este es un puerto de mi respuesta Jelly . Toma una lista de puntos de código como entrada. Imprime 1 para amigos, 0 para enemigos.

Pruébalo en línea!

Cómo 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

Golfó 4 bytes usando el algoritmo de Mistah Figgins

Guardado 1 byte gracias a Lynn

l:m9%5%3%!

Salidas 1para colores enemigos, 0para colores aliados.

Pruébalo en línea! (O verificar todos los casos de prueba )

Explicación

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

Pruébalo en línea!

Muy sencillo: ordena la entrada e intenta hacer coincidir cualquiera de los pares de aliados ordenados contra ella. Desafortunadamente, no creo que la naturaleza basada en cadenas de Retina permita que ninguno de los enfoques más interesantes sea competitivo.

Como adelanto de la próxima versión de Retina, planeo agregar una opción que intercambie la expresión regular y la cadena de destino (por lo que la cadena actual se usará como expresión regular y le dará una cadena para verificar), en cuyo caso este es más corto la solución funcionará (o algo por el estilo):

?`WUBRGWGRBUW

Java (OpenJDK 8) , 28 23 bytes

-5 bytes gracias a fergusq

"WUBRGWGRBUW"::contains

Pruébalo en línea!

Brachylog , 10 bytes

Una solución sencilla, sin trucos involucrados.

p~s"WUBRGW

Pruébalo en línea!

Explicación

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

Jalea , 6 bytes

ạ:3%3Ḃ

Por el bien de la integridad. Toma dos puntos de código como argumento. Rinde 0 para amigos, 1 para enemigos.

Pruébalo en línea!

Antecedentes

Deje n y m ser los puntos de código de dos caracteres de entrada. Al tomar | n - m | , solo debemos ocuparnos de todas las 2 combinaciones de caracteres. La siguiente tabla muestra todas las combinaciones de 2 caracteres de las diferencias absolutas correspondientes.

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

Si dividimos estos enteros por 3 , obtenemos los siguientes cocientes.

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

1 , 4 y 7 pueden asignarse a 1 tomando los resultados del módulo 3 .

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

Ahora solo tenemos que mirar la paridad.

Cómo 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

Una implementación de Cubix de la solución de Arnauld.

U%O@A*'g%2W

Uso

Ingrese los dos caracteres, y sale 0para amigos y 1enemigos. Pruébalo aquí.

Explicación

El código se puede expandir así.

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

Los caracteres se ejecutan en este orden (excluyendo el flujo de control):

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"

Pruébalo en línea!

AWK, 23 bytes

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

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

Esto se imprime 1si la pareja es un amigo, de lo 0contrario. Quería hacer algo inteligente, pero todo lo que pensaba sería más largo.

Jalea , 12 bytes

“WUBRGW”ŒBẇ@

Salidas 1para aliados, 0para enemigos.

Pruébalo en línea!

Explicación

“WUBRGW”ŒBẇ@   Main link

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

Rubí, 28 bytes.

Salidas verdadero para amigo, falso para enemigo:

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

La versión sin golf no es muy diferente:

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

05AB1E , 7 bytes

Adaptación del truco mod de la respuesta de Jonathan Jelly

Æ451bsè

Pruébalo en línea! o como un conjunto de pruebas

Explicación

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

GolfScript , 7 bytes

~*51%9>

Toma dos puntos de código como entrada.

Pruébalo en línea! (Conjunto de pruebas que convierte el formato de entrada para mayor comodidad).

Un puerto GolfScript de mi respuesta CJam (que técnicamente es un puerto CJam del resultado de mi fuerza bruta GolfScript ... uhhh ...).

Sin embargo, dado que GolfScript obtiene un módulo con entradas negativas correctas, hay una solución alternativa divertida en el mismo conteo de bytes que usa 4para enemigos en lugar de 1:

~-)9%4&

Pruébalo en línea!

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

El puerto de la respuesta Befunge-98 de @Mistah Figgins es el más corto en Java 7 de las respuestas publicadas hasta ahora.
En cuanto a los demás:

39 bytes: puerto de la respuesta de JavaScript de @Arnauld (ES6) .

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

39 bytes: puerto desde @MartinEnder Cjam respuesta 's

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

47 bytes: puerto de la respuesta C de @Steadybox

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

52 bytes: puerto de la respuesta Python 2 de @Lynn

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

NOTA: Se omitieron las respuestas que usan primos / palíndromos y similares, ya que en Java no se encuentran muy lejos. ;)
TODO: Propongo mi propia respuesta ... Aunque dudo que sea más corta que la mayoría de estas.

Intenta todo aquí.

EDITAR: Ok, se me ocurrió algo que no está tan mal:

50 bytes:

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

Explicación:

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 los enemigos están en el rango 4-6 (inclusive) o en 0.
EDIT2: Hmm .. Acabo de notar que es muy similar a la respuesta de @Steadybox ':(

PHP, 31 bytes

echo!strstr(WBGURWRUGBW,$argn);

Corre con echo AB | php -nR '<code>, donde Ay Bson los dos colores.

strtrdevuelve la cadena desde la posición donde se encuentra la entrada;
con WBGURWRUGBWcomo pajar, esto devuelve una cadena verdadera si los colores son enemigos; cadena vacía si no.

!convierte la cadena verdadera en false, dando como resultado una salida vacía
y la cadena vacía en true, dando como resultado la salida 1.