Dans le jeu de cartes Magic: the Gathering, il y a cinq couleurs différentes, qui représentent des affiliations lâches de cartes, Blanc ( W), Bleu ( U), Noir ( B), Rouge ( R) et Vert ( G). Ceux-ci sont souvent disposés dans un pentagone comme suit:

  W
G   U
 R B

Tant dans l'histoire de MtG que dans de nombreux mécanismes de cartes, les couleurs adjacentes de ce pentagone sont généralement considérées comme des alliés, et les couleurs non adjacentes (en quelque sorte opposées) sont considérées comme des ennemis.

Dans ce défi, vous recevrez deux couleurs et devrez déterminer leur relation.

Le défi

On vous donne deux caractères distincts de l'ensemble BGRUW. Vous pouvez les prendre comme une chaîne de deux caractères, une chaîne avec un séparateur entre les caractères, deux valeurs de caractères distinctes, deux chaînes singleton, deux entiers représentant leurs points de code ou un type de liste ou de jeu contenant deux caractères / chaînes / entiers.

Votre sortie doit être l’une des deux valeurs distinctes et cohérentes de votre choix, l’une qui indique que les deux couleurs sont des alliés et l’autre qui indique qu’elles sont des ennemis. L'une de ces deux valeurs peut ne produire aucune sortie.

Vous pouvez écrire un programme ou une fonction et utiliser l’une quelconque de nos méthodes standard de réception d’entrée et de sortie.

Vous pouvez utiliser n'importe quel langage de programmation , mais notez que ces failles sont interdites par défaut.

C'est du code-golf , donc la réponse valide la plus courte - mesurée en octets - est gagnante.

Cas de test

Il n'y a que 20 entrées possibles, je vais donc toutes les énumérer.

Copains:

WU   UB   BR   RG   GW   UW   BU   RB   GR   WG

Ennemis:

WB   UR   BG   RW   GU   BW   RU   GB   WR   UG

JavaScript (ES6),  26 23 17 15  14 octets

Accepte deux codes ASCII dans la syntaxe de curry (a)(b). Retours 4pour amis ou 0pour ennemis.

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

Essayez-le en ligne!

Comment?

NB: seul le quotient entier de la division par 0,6 est présenté ci-dessous.

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

Approche précédente, 15 octets

Accepte deux codes ASCII dans la syntaxe de curry (a)(b). Retours 0pour amis ou 1pour ennemis.

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

Essayez-le en ligne!

Comment?

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

Approche initiale, 23 octets

Prend la saisie sous forme de chaîne de 2 caractères. Retours truepour amis ou falsepour ennemis.

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

Essayez-le en ligne!

Gelée , 6 octets

ạg105Ị

Prend deux points de code comme argument. Donne 1 pour les amis, 0 pour les ennemis.

Essayez-le en ligne!

Contexte

Soit n et m les points de code de deux caractères saisis. En prenant | n - m | , nous devons nous préoccuper uniquement des deux combinaisons de caractères. Le tableau suivant montre toutes les 2 combinaisons de caractères avec les différences absolues correspondantes.

WU  2
UB 19
BR 16
RG 11
GW 16

WB 21
UR  3
BG  5
RW  5
GU 14

Tous les ennemi combinaisons sont divisibles par 3 , 5 ou 7 , mais aucun des amis combinaisons ce, alors amis sont exactement ceux qui sont co-premier avec 3 x 5 x 7 = 105 .

Comment ça fonctionne

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

"WUBRGWGRBUW".count

Essayez-le en ligne!

Une fonction anonyme: revient 1pour les amis et 0pour les ennemis.

Befunge-98, 13 12 octets

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

Essayez-le en ligne!

Imprimés 0pour les amis et 1pour les ennemis

Ceci utilise la différence entre les valeurs ASCII des lettres.

Si nous prenons le (((ASCII difference % 9) % 5) % 3), les valeurs pour les ennemis seront 0. Ensuite, nous ne pas la valeur et l’imprimons.

Merci à @Martin pour le golf

Gelée , 8 7 octets

Les greffons de la fabuleuse réponse Befunge de Mistah Figgins !

Iị390B¤

Essayez-le en ligne!

Comment?

Comme Mistah Figgins l'a noté, la décision peut être prise en prenant la différence absolue entre les valeurs ASCII mod 9 mod 5 mod 3 - 0 sont alors des amis et les 1 et 2 sont des ennemis.

Si nous prenons plutôt la différence (en clair) mod 9, nous constatons que les amis sont 1, 2, 7 et 8 tandis que les ennemis sont 3, 4, 5 et 6.

Le code prend la différence avec Iet indices dans la longueur 9 liste [1,1,0,0,0,0,1,1,0], qui est 390 en binaire, 390B. L'indexation est à la fois modulaire (si bien que l'indexation exécute le mod 9 gratuitement) et à base 1 (d'où le 1 à l'extrême gauche).

Métaprogrammation de modèles C ++, 85 octets

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

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

S'agissant d'un langage de métaprogrammation, une construction compilant ou non est une sortie possible.

Une instance de f<'W','B'>compile si et seulement si 'W'et 'B'sont des ennemis.

Math basé sur la réponse Befunge .

Exemple en direct .

Comme la métaprogrammation des modèles C ++ est l’une des pires langues du golf, toute personne qui est pire que cela devrait avoir honte. ;)

Ruby, 22 19 octets

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

Entrée: code ASCII des 2 caractères. Sortie: 1 pour les alliés, 0 pour les ennemis.

Comment ça fonctionne:

Obtenez la différence entre les 2 nombres modulo 9, utilisez un masque de bits (390 est le binaire 110000110) et obtenez un seul bit en utilisant l' []opérateur.

CJam , 8 octets

{*51%9>}

Un bloc sans nom qui attend deux codes de caractère au-dessus de la pile et les remplace par 0(amis) ou 1(ennemis).

Essayez-le en ligne!

Explication

Eh bien, nous avons vu beaucoup de solutions arithmétiques amusantes à présent, alors je suppose que ce n'est pas grave si je présente la mienne maintenant. Le plus proche de ce que j'ai vu jusqu'à présent est la solution C de Steadybox . Celui-ci a été trouvé avec l'aide d'un brute forcer de GolfScript que j'ai écrit il y a quelque temps pour Anarchy Golf.

Voici ce que celui-ci fait aux différentes entrées (en ignorant l'ordre, car la multiplication initiale est commutative):

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

Nous pouvons voir comment prendre le produit des entrées modulo 51 sépare bien les entrées en résultats grands et petits, et nous pouvons utiliser n'importe laquelle des valeurs intermédiaires pour distinguer les deux cas.

Röda , 30 22 21 octets

Octets sauvegardés grâce à @fergusq en utilisant _pour prendre en entrée les valeurs du flux

{[_ in"WUBRGWGRBUW"]}

Essayez-le en ligne!

La fonction est lancée comme push "WU" | faprès l'attribution d'un nom à la fonction

Explication

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

05AB1E , 10 octets

Renvoie 0 pour un ami et 1 pour un ennemi.

‘Û‹BWR‘ûIå

Essayez-le en ligne! ou en tant que suite de tests

Explication

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

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

Renvoie 1 si amis, 0 si ennemis.

Vim, 22 21 octets

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

Entrée: une seule ligne contenant les deux caractères.

Sortie: tampon vide si amis, tampon contenant WUBRGWGRBUWsi ennemis.

Explication

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 octets

Inspiré par la solution de @Martin Ender .

Prend un tableau de deux codes de caractères en entrée.

×%51<9

Essayez-le en ligne! | Suite de tests

Retour truepour les amis, falsepour les ennemis.

Solution de 14 octets:

Prend deux codes de caractères en entrée

nV a /3%3 f ¦1

Essayez-le en ligne! | Suite de tests

Explication:

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

Solution de 12 octets:

"WUBRGW"ê èU

Essayez-le en ligne! | Suite de tests

Explication:

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

Retours 1pour les amis et 0pour les ennemis.

Solution de 9 octets :

Inspiré par la solution de @ Arnauld .

*V%24%B%2

Suite de tests

Retour 1pour les amis, 0pour les ennemis.

Solution de 11 octets:

inspiré par la solution de @Mistah Figgins .

nV %9%5%3¦0

Suite de tests

Brain-Flak , 155, 147 , 135 octets

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

Essayez-le en ligne!

Cela correspond à 134 octets de code plus une pénalité d'un octet pour le -adrapeau qui active l'entrée ASCII.

Cela fonctionne en trouvant la différence absolue entre les entrées et en vérifiant si elles sont égales à 2, 11, 16 ou 19. Si c'est le cas, l'entrée est un ami et elle affiche un 1. Si ce n'est pas le cas, elle n'imprime rien. Puisque rien dans brain-flak ne correspond à une pile vide, ce qui est faux, aucune sortie n'est une valeur de faux. ( méta )

Une chose que j’aime particulièrement dans cette réponse, c’est que le fragment "Différence absolue" (c’est-à-dire (([(({}[{}]))<>])){({}())<>}{}{}<>{}) n’est pas pur à la pile, mais il peut toujours être utilisé dans cette réponse car nous ne nous soucions pas de la pile sur laquelle nous nous retrouvons avant l’encodage. les différences possibles.

Lors d'une édition ultérieure, j'en ai encore plus profité en abusant des restes de la pile qui ne finissaient pas avec la différence absolue. Lors de la première révision, je les ai enlevés tous les deux pour le garder un peu plus sain d'esprit. Ne pas faire cela donne deux golfs majeurs:

1. Évidemment, cela supprime le code pour les faire apparaître:, {}{}mais plus important encore:

2. Cela nous permet de compresser la 2, 11, 16, 19séquence de

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

   à

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

   Heureusement, il n'y a pas de code supplémentaire nécessaire pour gérer ces restes plus tard, ils sont donc simplement laissés sur la pile alternative.

Comme il est notoirement difficile de comprendre le brain-flak, voici une version lisible / commentée:

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

Gelée , 14 octets

“WUBRG”wЀIAÆP

Retour 1pour les ennemis et 0pour les amis.

Suite de test sur Essayez-le en ligne!

Comment?

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

$Æ105¿Ö

Ceci est un port de ma réponse de gelée . Prend une liste de points de code en entrée. Imprime 1 pour les amis, 0 pour les ennemis.

Essayez-le en ligne!

Comment ça fonctionne

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

Golfé 4 octets en utilisant l'algorithme de Mistah Figgins

Sauvé 1 octet grâce à Lynn

l:m9%5%3%!

Sorties 1pour les couleurs ennemies, 0pour les couleurs alliées.

Essayez-le en ligne! (Ou vérifier tous les cas de test )

Explication

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 octets

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

Essayez-le en ligne!

Assez simple: trie l'entrée et essaie de lui faire correspondre n'importe quelle paire d'alliés triée. Malheureusement, je ne pense pas que la nature basée sur les cordes de Retina permette à l'une des approches les plus intéressantes d'être compétitives.

En guise d’aperçu de la prochaine version de Retina, j’ai l’intention d’ajouter une option permettant d’échanger les expressions rationnelles et les chaînes cibles (la chaîne actuelle sera utilisée comme expression rationnelle et vous lui attribuez une chaîne à vérifier), auquel cas cette la solution fonctionnera (ou quelque chose du genre):

?`WUBRGWGRBUW

Java (OpenJDK 8) , 28 23 octets

-5 octets grâce à fergusq

"WUBRGWGRBUW"::contains

Essayez-le en ligne!

Brachylog , 10 octets

Une solution simple, sans astuces.

p~s"WUBRGW

Essayez-le en ligne!

Explication

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

Gelée , 6 octets

ạ:3%3Ḃ

Pour être complet. Prend deux points de code comme argument. Donne 0 pour les amis, 1 pour les ennemis.

Essayez-le en ligne!

Contexte

Soit n et m les points de code de deux caractères saisis. En prenant | n - m | , nous devons nous préoccuper uniquement des deux combinaisons de caractères. Le tableau suivant montre toutes les 2 combinaisons de caractères avec les différences absolues correspondantes.

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

Si nous divisons ces entiers par 3 , nous obtenons les quotients suivants.

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

1 , 4 et 7 peuvent être mappés à 1 en prenant les résultats modulo 3 .

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

Maintenant, il suffit de regarder la parité.

Comment ça fonctionne

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

Une implémentation de Cubix de la solution d'Arnauld.

U%O@A*'g%2W

Usage

Entrez les deux caractères, et les résultats sont 0destinés aux amis et 1aux ennemis. Essayez-le ici.

Explication

Le code peut être développé comme ceci.

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

Les caractères sont exécutés dans cet ordre (à l'exclusion du flux de contrôle):

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 octets

lambda a:a in"GWUBRGRBUWG"

Essayez-le en ligne!

AWK, 23 octets

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

Exemple d'utilisation: awk '{$ 0 = "WUBRGWGRBUW" ~ $ 1} 1' <<< UB

Cela imprime 1si la paire est un ami, 0sinon. Je voulais faire quelque chose d'intelligent, mais tout ce à quoi je pensais serait plus long.

Gelée , 12 octets

“WUBRGW”ŒBẇ@

Sorties 1pour les alliés, 0pour les ennemis.

Essayez-le en ligne!

Explication

“WUBRGW”ŒBẇ@   Main link

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

Ruby, 28 octets

Sorties true pour un ami, false pour un ennemi:

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

La version non-lisée n'est pas très différente:

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

05AB1E , 7 octets

Adaptation du mod-trick de Jonathan's Jelly answer

Æ451bsè

Essayez-le en ligne! ou en tant que suite de tests

Explication

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

GolfScript , 7 octets

~*51%9>

Prend deux points de code en entrée.

Essayez-le en ligne! (Suite de test qui convertit le format d'entrée pour plus de commodité.)

Un portage GolfScript de ma réponse CJam (qui, techniquement, est un portage CJam du résultat de ma brute forcée GolfScript ... euhhh ...).

Cependant, étant donné que GolfScript fonctionne correctement avec modulo avec des entrées négatives, il existe une solution alternative amusante avec le même nombre d'octets qui utilise 4pour les ennemis au lieu de 1:

~-)9%4&

Essayez-le en ligne!

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 octets

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

La réponse du port de @Mistah Figgins Befunge-98 est la plus courte de Java 7 parmi les réponses affichées jusqu'à présent.
Pour les autres:

39 octets: Port de la réponse JavaScript (ES6) de @Arnauld .

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

39 octets: Port de @MartinEnder réponse CJAM s »

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

47 octets: Port de la réponse C de @Steadybox '

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

52 octets: Port de la réponse Python 2 de @Lynn

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

REMARQUE: les réponses ignorées utilisant des nombres premiers / palindromes et similaires, car celles-ci sont loin d'être courtes en Java. ;)
TODO: Venir avec ma propre réponse .. Bien que je doute que ce soit plus court que la plupart d'entre eux.

Essayez tous ici.

EDIT: Ok, je suis venu avec quelque chose qui n'est pas si mal:

50 octets:

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

Explication:

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

Tous les ennemis sont dans la plage 4-6 (inclus) ou 0.
EDIT2: Hmm .. Je viens de remarquer que cela ressemble beaucoup à la réponse de @Steadybox ': ..

PHP, 31 octets

echo!strstr(WBGURWRUGBW,$argn);

Courir avec echo AB | php -nR '<code>, où Aet Bsont les deux couleurs.

strtrrenvoie la chaîne de la position où l'entrée est trouvée;
avec WBGURWRUGBWcomme botte de foin, cela retourne une chaîne de vérité si les couleurs sont des ennemis; chaîne vide sinon.

!fait passer la chaîne de vérité à false, ce qui donne une sortie vide
et la chaîne vide à true, ce qui donne une sortie 1.