Im Kartenspiel Magic: the Gathering gibt es fünf verschiedene Farben, die lose Zuordnungen von Karten darstellen: Weiß ( W), Blau ( U), Schwarz ( B), Rot ( R) und Grün ( G). Diese sind oft wie folgt in einem Fünfeck angeordnet:

  W
G   U
 R B

Sowohl in der Überlieferung von MtG als auch in vielen Kartenmechaniken werden benachbarte Farben in diesem Fünfeck gewöhnlich als Verbündete betrachtet, und nicht benachbarte (entgegengesetzte) Farben werden als Feinde betrachtet.

In dieser Herausforderung erhalten Sie zwei Farben und sollten deren Beziehung bestimmen.

Die Herausforderung

Sie erhalten zwei verschiedene Zeichen aus dem Satz BGRUW. Sie können diese als eine Zeichenfolge mit zwei Zeichen, eine Zeichenfolge mit einem Trennzeichen zwischen den Zeichen, zwei separate Zeichenwerte, zwei Singleton-Zeichenfolgen, zwei Ganzzahlen, die ihre Codepunkte darstellen, oder einen Listen- oder Settyp mit zwei Zeichen / Zeichenfolgen / Ganzzahlen verwenden.

Ihre Ausgabe sollte einen von zwei unterschiedlichen und konsistenten Werten Ihrer Wahl enthalten, einer, der angibt, dass die beiden Farben Verbündete sind, und einer, der angibt, dass sie Feinde sind. Einer dieser beiden Werte wird möglicherweise überhaupt nicht ausgegeben.

Sie können ein Programm oder eine Funktion schreiben und eine unserer Standardmethoden zum Empfangen und Bereitstellen von Eingaben verwenden.

Sie können jede Programmiersprache verwenden , beachten Sie jedoch, dass diese Lücken standardmäßig verboten sind.

Das ist Code-Golf , also gewinnt die kürzeste gültige Antwort - gemessen in Bytes .

Testfälle

Es gibt nur 20 mögliche Eingaben, deshalb liste ich sie alle auf.

Freunde:

WU   UB   BR   RG   GW   UW   BU   RB   GR   WG

Feinde:

WB   UR   BG   RW   GU   BW   RU   GB   WR   UG

JavaScript (ES6),  26 23 17 15  14 Byte

Übernimmt die Eingabe als zwei ASCII-Codes in der aktuellen Syntax (a)(b). Kehrt 4für Freunde oder 0für Feinde zurück.

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

Probieren Sie es online!

Wie?

Anmerkung: Im Folgenden ist nur der ganzzahlige Quotient der Division durch 0,6 angegeben.

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

Vorheriger Ansatz, 15 Bytes

Übernimmt die Eingabe als zwei ASCII-Codes in der aktuellen Syntax (a)(b). Kehrt 0für Freunde oder 1für Feinde zurück.

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

Probieren Sie es online!

Wie?

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

Anfänglicher Ansatz, 23 Bytes

Übernimmt die Eingabe als 2-stellige Zeichenfolge. Kehrt truefür Freunde oder falsefür Feinde zurück.

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

Probieren Sie es online!

Gelee , 6 Bytes

ạg105Ị

Nimmt zwei Codepunkte als Argument. Ergibt 1 für Freunde, 0 für Feinde.

Probieren Sie es online!

Hintergrund

Sei n und m der Codepunkt zweier eingegebener Zeichen. Mit | n - m | Wir müssen uns nur mit allen 2-Zeichen-Kombinationen befassen. Die folgende Tabelle zeigt für alle 2 Zeichenkombinationen die entsprechenden absoluten Unterschiede.

WU  2
UB 19
BR 16
RG 11
GW 16

WB 21
UR  3
BG  5
RW  5
GU 14

Alle Feindkombinationen sind durch 3 , 5 oder 7 teilbar , aber keine der Freundkombinationen. Freunde sind also genau diejenigen, die mit 3 × 5 × 7 = 105 co-prime sind .

Wie es funktioniert

ạ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

Probieren Sie es online!

Eine anonyme Funktion: Kehrt 1für Freunde und 0für Feinde zurück.

Befunge-98, 13 12 Bytes

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

Probieren Sie es online!

Drucke 0für Freunde und 1für Feinde

Hierbei wird die Differenz zwischen den ASCII-Werten der Buchstaben verwendet.

Wenn wir das nehmen (((ASCII difference % 9) % 5) % 3), werden die Werte für die Feinde 0 sein. Dann werden wir nicht den Wert und drucken es.

Vielen Dank an @Martin für das Golfen

Gelee , 8 7 Bytes

Huckepack von Mistah Figgins ' fabelhafter Befunge-Antwort !

Iị390B¤

Probieren Sie es online!

Wie?

Wie Mistah Figgins feststellte, kann die Entscheidung getroffen werden, indem der absolute Unterschied zwischen den ASCII-Werten mod 9 mod 5 mod 3 - 0s sind dann Freunde und 1s und 2s sind Feinde.

Wenn wir stattdessen den (einfachen) Differenz-Mod 9 nehmen, stellen wir fest, dass Freunde 1, 2, 7 und 8 sind, während Feinde 3, 4, 5 und 6 sind.

Der Code nimmt die Differenz mit Iund indiziert dann in die Liste der Länge 9 [1,1,0,0,0,0,1,1,0], die 390 in binär ist 390B. Die Indizierung ist sowohl modular (so dass die Indizierung die Mod 9 kostenlos durchführt) als auch 1-basiert (daher die 1 ganz links).

Metaprogrammierung von C ++ - Vorlagen, 85 Byte

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

weniger golfen:

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

Da dies eine Metaprogrammiersprache ist, ist ein kompiliertes Konstrukt eine mögliche Ausgabe.

Eine Instanz von f<'W','B'>kompiliert genau dann, wenn 'W'und 'B'sind Feinde.

Mathe basiert auf Befunge Antwort .

Live-Beispiel .

Da die Metaprogrammierung von C ++ - Vorlagen eine der schlimmsten Golfsprachen ist, sollte sich jeder schämen, der schlimmer ist als diese. ;)

Ruby, 22 19 Bytes

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

Eingabe: ASCII-Code der 2 Zeichen. Ausgang: 1 für Verbündete, 0 für Feinde.

Wie es funktioniert:

Holen Sie sich die Differenz zwischen den 2 Zahlen Modulo 9, verwenden Sie eine Bitmaske (390 ist binär 110000110) und erhalten Sie ein einzelnes Bit mit dem []Operator.

CJam , 8 Bytes

{*51%9>}

Ein unbenannter Block, der zwei Zeichencodes auf dem Stapel erwartet und diese durch 0(Freunde) oder 1(Gegner) ersetzt.

Probieren Sie es online!

Erläuterung

Nun, wir haben jetzt eine Menge lustiger arithmetischer Lösungen gesehen. Ich denke, es ist in Ordnung, wenn ich jetzt meine eigene präsentiere. Das nächstliegende, was ich bisher gesehen habe, ist die C-Lösung von Steadybox . Dieser wurde mit Hilfe eines GolfScript-Brute-Forcers gefunden, den ich vor einiger Zeit für Anarchy-Golf geschrieben habe.

Hier ist, was dieser mit den verschiedenen Eingaben macht (wobei die Reihenfolge ignoriert wird, da die anfängliche Multiplikation kommutativ ist):

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

Wir können sehen, wie das Produkt aus den Eingaben modulo 51 die Eingaben in große und kleine Ergebnisse trennt, und wir können jeden der dazwischen liegenden Werte verwenden, um zwischen den beiden Fällen zu unterscheiden.

Röda , 30 22 21 Bytes

Dank @fergusq gespeicherte Bytes, indem _die Werte im Stream als Eingabe verwendet werden

{[_ in"WUBRGWGRBUW"]}

Probieren Sie es online!

Die Funktion wird ausgeführt, push "WU" | fnachdem der Funktion ein Name zugewiesen wurde

Erläuterung

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

05AB1E , 10 Bytes

Gibt 0 für Freund und 1 für Feind zurück.

‘Û‹BWR‘ûIå

Probieren Sie es online! oder als Testsuite

Erläuterung

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

Gibt 1 zurück, wenn Freunde, 0, wenn Gegner.

Vim, 22 21 Bytes

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

Eingabe: Eine einzelne Zeile mit den beiden Zeichen.

Ausgabe: leerer Puffer bei Freunden, Puffer WUBRGWGRBUWbei Feinden.

Erläuterung

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

Inspiriert von der Lösung von @Martin Ender .

Nimmt ein Array von zwei Zeichencodes als Eingabe.

×%51<9

Probieren Sie es online! | Test Suite

Rückkehr truefür Freunde, falsefür Feinde.

14-Byte-Lösung:

Nimmt zwei Zeichencodes als Eingabe

nV a /3%3 f ¦1

Probieren Sie es online! | Test Suite

Erläuterung:

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-Byte-Lösung:

"WUBRGW"ê èU

Probieren Sie es online! | Test Suite

Erläuterung:

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

Rückkehr 1für Freunde und 0für Feinde.

9-Byte-Lösung :

Inspiriert von @ Arnauld's Lösung .

*V%24%B%2

Test Suite

Rückkehr 1für Freunde, 0für Feinde.

11-Byte-Lösung:

inspiriert von @Mistah Figgins Lösung .

nV %9%5%3¦0

Test Suite

Brain-Flak , 155, 147 , 135 Bytes

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

Probieren Sie es online!

Dies sind 134 Byte Code plus 1 Byte Strafe für das -aFlag, das die ASCII-Eingabe ermöglicht.

Dies funktioniert, indem der absolute Unterschied zwischen den Eingaben ermittelt und überprüft wird, ob sie 2, 11, 16 oder 19 entsprechen. Wenn dies der Fall ist, ist die Eingabe ein Freund und gibt eine 1 aus. Wenn dies nicht der Fall ist, wird nichts gedruckt. Da nichts in Brain-Flak einem leeren Stapel entspricht, der falsch ist, ist keine Ausgabe ein falscher Wert. ( meta )

Eine Sache, die ich an dieser Antwort besonders mag, ist, dass der "absolute Unterschied" -Snippet (das heißt (([(({}[{}]))<>])){({}())<>}{}{}<>{}) nicht stapelrein ist, aber dennoch in dieser Antwort verwendet werden kann, da es uns egal ist, auf welchem ​​Stapel wir landen, bevor wir codieren die möglichen Unterschiede.

Bei einer späteren Bearbeitung habe ich dies noch stärker ausgenutzt, indem ich die Reste auf dem Stapel missbraucht habe, die nicht den absoluten Unterschied ergeben. Bei der ersten Überarbeitung habe ich beide ausgeschaltet, um es ein wenig vernünftiger zu halten. Wenn Sie dies nicht tun, erhalten Sie zwei Hauptgolfplätze:

1. Offensichtlich wird der Code entfernt, um sie zu platzieren:, {}{}aber was noch wichtiger ist:

2. Es erlaubt uns, die 2, 11, 16, 19Sequenz von zu komprimieren

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

   zu

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

   Glücklicherweise ist kein zusätzlicher Code erforderlich, um diese Reste später zu verarbeiten, sodass sie nur auf dem alternativen Stapel verbleiben.

Da Brain Flak notorisch schwer zu verstehen ist, ist hier eine lesbare / kommentierte Version:

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

Jelly , 14 Bytes

“WUBRG”wЀIAÆP

Rückkehr 1für Feinde und 0für Freunde.

Testsuite bei Online testen !

Wie?

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

Dies ist eine Portierung meiner Gelee-Antwort . Nimmt eine Liste von Codepunkten als Eingabe. Druckt 1 für Freunde, 0 für Feinde.

Probieren Sie es online!

Wie es funktioniert

$        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 mit Mistah Figgins Algorithmus

1 Byte dank Lynn gespeichert

l:m9%5%3%!

Ausgänge 1für feindliche Farben, 0für verbündete Farben.

Probieren Sie es online! (Oder überprüfen Sie alle Testfälle )

Erläuterung

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

Probieren Sie es online!

Ganz einfach: Sortiert die Eingabe und versucht, eines der sortierten Verbündetenpaare damit abzugleichen. Leider glaube ich nicht, dass die String-basierte Natur von Retina es ermöglicht, dass einer der interessanteren Ansätze wettbewerbsfähig ist.

Als kleinen Vorgeschmack auf die nächste Retina-Version plane ich, eine Option hinzuzufügen, die Regex und Zielzeichenfolge vertauscht (sodass die aktuelle Zeichenfolge als Regex verwendet wird und Sie ihr eine zu überprüfende Zeichenfolge geben). In diesem Fall ist diese Option kürzer Lösung wird funktionieren (oder etwas in diese Richtung):

?`WUBRGWGRBUW

Java (OpenJDK 8) , 28 23 Bytes

-5 Bytes dank Fergusq

"WUBRGWGRBUW"::contains

Probieren Sie es online!

Brachylog , 10 Bytes

Eine unkomplizierte Lösung ohne Tricks.

p~s"WUBRGW

Probieren Sie es online!

Erläuterung

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

Gelee , 6 Bytes

ạ:3%3Ḃ

Der Vollständigkeit halber. Nimmt zwei Codepunkte als Argument. Ergibt 0 für Freunde, 1 für Feinde.

Probieren Sie es online!

Hintergrund

Sei n und m der Codepunkt zweier eingegebener Zeichen. Mit | n - m | Wir müssen uns nur mit allen 2-Zeichen-Kombinationen befassen. Die folgende Tabelle zeigt für alle 2 Zeichenkombinationen die entsprechenden absoluten Unterschiede.

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

Wenn wir diese ganzen Zahlen durch 3 teilen , erhalten wir die folgenden Quotienten.

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

1 , 4 und 7 können mit Modulo 3 auf 1 abgebildet werden .

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

Jetzt müssen wir uns nur noch die Parität ansehen.

Wie es funktioniert

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

Eine Cubix-Implementierung der Arnauld-Lösung.

U%O@A*'g%2W

Verwendungszweck

Geben Sie die beiden Zeichen ein und geben Sie sie 0für Freunde und 1Feinde aus. Probieren Sie es hier aus.

Erläuterung

Der Code kann so erweitert werden.

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

Die Zeichen werden in dieser Reihenfolge ausgeführt (ohne Kontrollfluss):

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"

Probieren Sie es online!

AWK, 23 Bytes

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

Anwendungsbeispiel: awk '{$ 0 = "WUBRGWGRBUW" ~ $ 1} 1' <<< UB

Dies wird gedruckt, 1wenn das Paar ein Freund ist, 0ansonsten. Ich wollte etwas Kluges tun, aber alles, woran ich dachte, würde länger dauern.

Gelee , 12 Bytes

“WUBRGW”ŒBẇ@

Ausgänge 1für Verbündete, 0für Feinde.

Probieren Sie es online!

Erläuterung

“WUBRGW”ŒBẇ@   Main link

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

Ruby, 28 Bytes

Outputs true für Freund, false für Feind:

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

Die ungolfed Version ist nicht viel anders:

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

05AB1E , 7 Bytes

Anpassung des Mod-Tricks aus Jonathans Jelly-Antwort

Æ451bsè

Probieren Sie es online! oder als Testsuite

Erläuterung

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

GolfScript , 7 Bytes

~*51%9>

Nimmt zwei Codepunkte als Eingabe.

Probieren Sie es online! (Testsuite, die das Eingabeformat zur Vereinfachung konvertiert.)

Ein GolfScript-Port meiner CJam-Antwort (der technisch gesehen ein CJam-Port des Ergebnisses meines GolfScript-Brute-Forcers ist ... ähhh ...).

Da GolfScript jedoch Modulo mit negativen Eingaben richtig einstellt, gibt es eine unterhaltsame alternative Lösung bei gleicher Byteanzahl, die 4für Gegner verwendet wird, anstatt 1:

~-)9%4&

Probieren Sie es 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;}

Port von @Mistah Figgins 'Befunge-98-Antwort ist die kürzeste in Java 7 von den bisher geposteten Antworten.
Wie für die anderen:

39 Bytes: Port aus der Antwort von @Arnauld auf JavaScript (ES6) .

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

39 Bytes: Port von @MartinEnders CJam-Antwort

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

47 Bytes: Port von @Steadybox 'C-Antwort

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

52 Bytes: Port von @Lynns Python 2-Antwort

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

HINWEIS: Übersprungene Antworten, die Primzahlen / Palindrome und dergleichen verwenden, da diese in Java nicht annähernd kurz sind. ;)
TODO: Ich überlege mir meine eigene Antwort. Obwohl ich bezweifle, dass sie kürzer ist als die meisten.

Probieren Sie alles hier.

EDIT: Ok, ich habe mir etwas ausgedacht, das nicht so schlimm ist:

50 Bytes:

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

Erläuterung:

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

Alle Gegner sind entweder im Bereich 4-6 (inklusive) oder 0.
EDIT2: Hmm .. Ich habe gerade bemerkt, dass es der Antwort von @Steadybox sehr ähnlich ist .. :(

PHP, 31 Bytes

echo!strstr(WBGURWRUGBW,$argn);

Laufen Sie mit echo AB | php -nR '<code>, wo Aund Bsind die beiden Farben.

strtrGibt die Zeichenfolge von der Position zurück, an der sich die Eingabe befindet.
mit WBGURWRUGBWals Heuhaufen gibt dies eine wahrheitsgemäße Zeichenfolge zurück, wenn die Farben Feinde sind; leere Zeichenfolge, wenn nicht.

!Wendet die wahrheitsgemäße Zeichenfolge auf an false, was zu einer leeren Ausgabe führt,
und die leere Zeichenfolge auf an true, was zu einer Ausgabe führt 1.