Magic the Gathering: amis ou ennemis?

67

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 , 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
Martin Ender
la source
33
Prochaine étape: implémentation des règles de base: P
Captain Man
12
@ CaptainMan, je vous inviterai à voter si vous pouvez l'intégrer dans un message de personnage de 30
000 $
@Walfrat 30k? Devrait être possible
Pas que Charles
2
@ IvanKolmychek, issu des alliances les plus inattendues, donne les résultats les plus inattendus.
Aluriak
1
Anecdote: Magic: le rassemblement est terminé :)
Matthew Roh

Réponses:

82

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!

Arnauld
la source
10
Ah, enfin quelque chose d'amusant. :)
Martin Ender
4
Trouvaille fantastique!
Greg Martin
Y at-il des maths intelligents dont je ne suis pas au courant ou avez-vous simplement forcé différents modulos à force brutale jusqu'à ce que vous en obteniez un qui fonctionne?
FourOhFour
@FourOhFour C'était brute forcé. Je pense que c'est la plus petite solution double modulo . Mais un port de cette réponse (qui utilise une comparaison) aurait en réalité un octet de moins.
Arnauld
1
@OddDev J'ai effectivement testé tous les bits, pas seulement le moins important. Par exemple, a*b%290&8fonctionnerait aussi bien (produire 0pour des amis ou 8pour des ennemis).
Arnauld
37

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.
Dennis
la source
Joliment repéré! Pourquoi la valeur absolue est-elle nécessaire? (J'ai essayé en ligne et cela n'a pas donné la bonne réponse; mathématiquement, cela ne devrait pas avoir d'importance.)
Greg Martin
@GregMartin Ce n'est pas nécessaire; différence signée fonctionnerait tout aussi bien. La soustraction est _est la gelée. Avez-vous utilisé autre chose?
Dennis
Ah je vois, j'ai lu à tort comme une valeur absolue, pas une différence absolue.
Greg Martin
21

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

MildlyMilquetoast
la source
Utilisez Jelly pour 9 octets: IA%9%5%3¬Edit Essayez-le en ligne!
Jonathan Allan
@ JonathanAllan Je te vois déjà fait! Agréable.
MildlyMilquetoast
En fait, j'ai transformé votre méthode (en utilisant la différence réelle plutôt que la différence absolue) mod 9 mod 6 et ai utilisé le fait que Jelly indexait les listes de manière modulaire pour la réduire à 7 . Je vous ai accrédité et lié ici.
Jonathan Allan
@JonathanAllan J'ai aussi proposé la méthode mod 9 mod 6, mais Befunge n'a pas de différence réelle ni de valeur absolue, ce n'était donc pas aussi faisable
MildlyMilquetoast Le
18

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

Jonathan Allan
la source
16

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

Yakk
la source
On dirait qu’il ya un total de deux espaces blancs redondants dans templates.
Yytsi
@TuukkaX corrigé, d'oh
Yakk
14

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.

GB
la source
2
Ah bien, je ne cesse d'oublier que des entiers peuvent être indexés. +1
Martin Ender
16 octets: ->x,y{x*y%103%2}Notez que 0et 1sont inversés.
Eric Duminil
1
Et 15 octets avec x*y%51>9comme tout le monde. Je pense qu'il serait injuste pour les votes positifs de le changer si radicalement maintenant.
GB
10

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.

Martin Ender
la source
9

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 */
}
Kritixi Lithos
la source
o_O vitesse de l'éclair
Pavel
Il est possible d'économiser 5 octets en lisant les valeurs d'entrée dans le flux au lieu de prendre des paramètres:, {[(_.._)in"WUBRGWGRBUW"]}mais la fonction doit alors s'appeler comme [a, b] | f.
fergusq
9

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
Emigna
la source
9

C, 33 32 29 24 22 octets

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

Renvoie 1 si amis, 0 si ennemis.

Steadybox
la source
8

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
m-chrzan
la source
2
Vous pouvez faire Cau lieu decw
Kritixi Lithos
8

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

Oliver
la source
8

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
{}
DJMcMayhem
la source
Il y a un push, un pop que vous pouvez supprimer, et vous pouvez appuyer sur 0 si plus efficacement pour atteindre le 129: TIO
Riley
@Riley Cool, merci pour le tuyau! J'aime avoir une version commentée, je vais donc attendre de pouvoir comprendre cette version avant de la mettre à jour.
DJMcMayhem
Ce ne sont que deux changements mineurs. Voici la partie importante. Mes commentaires sont en majuscules, désolé si ça ressemble à je crie.
Riley
7

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
Jonathan Allan
la source
7

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).
Dennis
la source
6

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
Chat d'affaires
la source
N'essayez pas d'être trop intelligent! l:m9%5%3%!est un octet plus court.
Lynn
@ Lynn Oh wow, c'est ça. C'est un peu ennuyeux. Merci
Business Cat
5

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
Martin Ender
la source
4

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
Leo
la source
4

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.
Dennis
la source
4

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
Luke
la source
2

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.

Robert Benson
la source
2

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
Chat d'affaires
la source
2

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(''))
Sculper
la source
2

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
Martin Ender
la source
2

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 ': ..

Kevin Cruijssen
la source
2

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.

Titus
la source