Nel gioco di carte Magic: the Gathering ci sono cinque colori diversi, che rappresentano affiliazioni libere di carte, White ( W), Blue ( U), Black ( B), Red ( R) e Green ( G). Questi sono spesso disposti in un pentagono come segue:

  W
G   U
 R B

Sia nella tradizione di MtG che in molte meccaniche di carte, i colori adiacenti in questo pentagono sono generalmente considerati alleati e i colori non adiacenti (una specie di opposto) sono considerati nemici.

In questa sfida, ti verranno dati due colori e dovresti determinare la loro relazione.

La sfida

Ti vengono dati due personaggi distinti dal set BGRUW. Puoi prenderli come una stringa di due caratteri, una stringa con un delimitatore tra i caratteri, due valori di caratteri separati, due stringhe singleton, due numeri interi che rappresentano i loro punti di codice o un tipo di elenco o set contenente due caratteri / stringhe / numeri interi.

Il tuo output dovrebbe essere uno dei due valori distinti e coerenti di tua scelta, uno che indica che i due colori sono alleati e uno che indica che sono nemici. Uno di questi due valori potrebbe non essere affatto output.

È possibile scrivere un programma o una funzione e utilizzare uno dei nostri metodi standard per ricevere input e fornire output.

È possibile utilizzare qualsiasi linguaggio di programmazione , ma si noti che queste scappatoie sono vietate per impostazione predefinita.

Questo è code-golf , quindi la risposta valida più breve - misurata in byte - vince.

Casi test

Ci sono solo 20 possibili input, quindi li elencherò tutti.

Amici:

WU   UB   BR   RG   GW   UW   BU   RB   GR   WG

nemici:

WB   UR   BG   RW   GU   BW   RU   GB   WR   UG

JavaScript (ES6),  26 23 17 15  14 byte

Accetta input come due codici ASCII nella sintassi del curry (a)(b). Ritorna 4per amici o 0per nemici.

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

Provalo online!

Come?

NB: sotto è mostrato solo il quoziente intero della divisione per 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

Approccio precedente, 15 byte

Accetta input come due codici ASCII nella sintassi del curry (a)(b). Ritorna 0per amici o 1per nemici.

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

Provalo online!

Come?

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

Approccio iniziale, 23 byte

Accetta l'input come stringa di 2 caratteri. Ritorna trueper amici o falseper nemici.

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

Provalo online!

Gelatina , 6 byte

ạg105Ị

Accetta due punti di codice come argomento. Produce 1 per gli amici, 0 per i nemici.

Provalo online!

sfondo

Sia n e m i punti di codice di due caratteri di input. Prendendo | n - m | , dobbiamo preoccuparci solo di tutte e 2 le combinazioni di personaggi. La tabella seguente mostra tutte le 2 combinazioni di caratteri le corrispondenti differenze assolute.

WU  2
UB 19
BR 16
RG 11
GW 16

WB 21
UR  3
BG  5
RW  5
GU 14

Tutti nemico combinazioni sono divisibili per 3 , 5 o 7 , ma nessuno degli amici combinazioni questo, così gli amici sono esattamente quelli che sono co-prime con 3 × 5 × 7 = 105 .

Come funziona

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

"WUBRGWGRBUW".count

Provalo online!

Una funzione anonima: ritorna 1per gli amici e 0per i nemici.

Befunge-98, 13 12 byte

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

Provalo online!

Stampe 0per amici e 1nemici

Questo utilizza la differenza tra i valori ASCII delle lettere.

Se prendiamo il (((ASCII difference % 9) % 5) % 3), i valori per i nemici saranno 0. Quindi, non il valore e lo stampiamo.

Grazie a @Martin per il golf

Gelatina , 8 7 byte

A due passi dalla favolosa risposta di Befunge di Mistah Figgins !

Iị390B¤

Provalo online!

Come?

Come ha osservato Mistah Figgins, la decisione può essere presa prendendo la differenza assoluta tra i valori ASCII mod 9 mod 5 mod 3 - 0s sono quindi amici e 1s e 2s sono nemici.

Se invece prendiamo la (semplice) differenza mod 9 scopriamo che gli amici sono 1s, 2s, 7s e 8s mentre i nemici sono 3s, 4s, 5s e 6s.

Il codice ha la differenza Ie poi indici nell'elenco lunghezza 9 [1,1,0,0,0,0,1,1,0], che è 390 in binario, 390B. L'indicizzazione è sia modulare (in modo efficace che l'indicizzazione esegue gratuitamente la mod 9) sia basata su 1 (da qui l'1 a sinistra).

Metaprogrammazione di modelli C ++, 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>{};

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

Poiché si tratta di un linguaggio di metaprogrammazione, un costrutto che compila o meno è un possibile risultato.

Un'istanza di f<'W','B'>compilazione se e solo se 'W'e 'B'sono nemici.

La matematica si basa sulla risposta di Befunge .

Esempio dal vivo .

Poiché la metaprogrammazione del modello C ++ è uno dei peggiori linguaggi del golf, chiunque sia peggio di questo dovrebbe provare vergogna. ;)

Rubino, 22 19 byte

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

Input: codice ASCII dei 2 caratteri. Uscita: 1 per gli alleati, 0 per i nemici.

Come funziona:

Ottieni la differenza tra i 2 numeri modulo 9, usa una maschera di bit (390 è binario 110000110) e ottieni un singolo bit usando l' []operatore.

CJam , 8 byte

{*51%9>}

Un blocco senza nome che prevede due codici di carattere in cima alla pila e li sostituisce con 0(amici) o1 (nemici).

Provalo online!

Spiegazione

Bene, ora abbiamo visto molte soluzioni aritmetiche divertenti, quindi immagino che vada bene se ne presento una mia adesso. Il più vicino a questo che ho visto finora è la soluzione C di Steadybox . Questo è stato trovato con l'aiuto di un forcer bruto GolfScript che ho scritto qualche tempo fa per l'anarchia del golf.

Ecco cosa fa questo ai vari input (ignorando l'ordine, perché la moltiplicazione iniziale è commutativa):

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

Possiamo vedere come prendere il prodotto degli input modulo 51 separa piacevolmente gli input in risultati grandi e piccoli e possiamo usare uno qualsiasi dei valori intermedi per distinguere tra i due casi.

Röda , 30 22 21 byte

Byte salvati grazie a @fergusq usando _per prendere i valori sullo stream come input

{[_ in"WUBRGWGRBUW"]}

Provalo online!

La funzione viene eseguita come push "WU" | fdopo aver assegnato un nome alla funzione

Spiegazione

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

05AB1E , 10 byte

Restituisce 0 per amico e 1 per nemico.

‘Û‹BWR‘ûIå

Provalo online! o come suite di test

Spiegazione

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

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

Restituisce 1 se amici, 0 se nemici.

Vim, 22 21 byte

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

Input: una singola riga contenente i due caratteri.

Output: buffer vuoto se amici, buffer contenente WUBRGWGRBUWse nemici.

Spiegazione

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 byte

Ispirato da @Martin Ender's soluzione di .

Accetta un array di due codici char come input.

×%51<9

Provalo online! |Test Suite

ritorna true per gli amici, falseper i nemici.

Soluzione a 14 byte:

Accetta due codici char come input

nV a /3%3 f ¦1

Provalo online! |Test Suite

Spiegazione:

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

Soluzione a 12 byte:

"WUBRGW"ê èU

Provalo online! | Test Suite

Spiegazione:

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

Ritorni 1per amici e0 per nemici.

Soluzione a 9 byte :

Ispirato dalla soluzione di @ Arnauld .

*V%24%B%2

Test Suite

Ritorni 1per amici,0per i nemici.

Soluzione a 11 byte:

ispirato alla soluzione di @Mistah Figgins .

nV %9%5%3¦0

Test Suite

Brain-Flak , 155, 147 , 135 byte

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

Provalo online!

Sono 134 byte di codice più una penalità di byte per il -aflag che abilita l'ingresso ASCII.

Funziona trovando la differenza assoluta tra gli input e verificando che siano uguali a 2, 11, 16 o 19. In caso affermativo, l'input è un amico e stampa un 1. In caso contrario, non stampa nulla. Dal momento che nulla nell'ingombro del cervello corrisponde a una pila vuota, che è falsa, nessuna produzione è un valore falsa. ( meta )

Una cosa che mi piace particolarmente di questa risposta è che lo snippet di "differenza assoluta" (ovvero (([(({}[{}]))<>])){({}())<>}{}{}<>{} ) non è pulito stack, ma può ancora essere usato in questa risposta poiché non ci interessa quale stack finiamo prima della codifica le possibili differenze.

In una modifica successiva, ne ho approfittato ancora di più abusando degli avanzi sullo stack che non finiscono con la differenza assoluta su di esso. Durante la prima revisione, ho rimosso entrambi per mantenerlo leggermente più sano. Non farlo dà due importanti campi da golf:

1. Ovviamente, rimuove il codice per farli apparire:, {}{}ma soprattutto:

2. Ci permette di comprimere la 2, 11, 16, 19sequenza da

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

   per

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

   Fortunatamente, non è necessario un codice aggiuntivo per gestire questi avanzi in seguito, quindi vengono lasciati nello stack alternativo.

Poiché notoriamente difficile è comprensibile, ecco una versione leggibile / commentata:

#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 byte

“WUBRG”wЀIAÆP

Ritorni 1per nemici e 0per amici.

Test suite su Provalo online!

Come?

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

$Æ105¿Ö

Questa è una porta della mia risposta Jelly . Prende un elenco di punti di codice come input. Stampa 1 per gli amici, 0 per i nemici.

Provalo online!

Come funziona

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

Giocato a golf 4 byte usando l'algoritmo di Mistah Figgins

Salvato 1 byte grazie a Lynn

l:m9%5%3%!

Uscite 1per i colori nemici, 0per i colori alleati.

Provalo online! (O verifica tutti i casi di test )

Spiegazione

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 byte

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

Provalo online!

Abbastanza diretto: ordina l'input e cerca di far corrispondere una qualsiasi coppia di alleati ordinata contro di essa. Sfortunatamente, non penso che la natura basata su stringhe di Retina consenta che uno degli approcci più interessanti sia competitivo.

Come anteprima per la prossima versione di Retina, sto pianificando di aggiungere un'opzione che scambia regex e stringa di destinazione (quindi la stringa corrente verrà utilizzata come regex e le darai una stringa da controllare), nel qual caso questa più breve la soluzione funzionerà (o qualcosa del genere):

?`WUBRGWGRBUW

Java (OpenJDK 8) , 28 23 byte

-5 byte grazie a fergusq

"WUBRGWGRBUW"::contains

Provalo online!

Brachylog , 10 byte

Una soluzione semplice, senza trucchi.

p~s"WUBRGW

Provalo online!

Spiegazione

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

Gelatina , 6 byte

ạ:3%3Ḃ

Per completezza. Accetta due punti di codice come argomento. Produce 0 per gli amici, 1 per i nemici.

Provalo online!

sfondo

Sia n e m i punti di codice di due caratteri di input. Prendendo | n - m | , dobbiamo preoccuparci solo di tutte e 2 le combinazioni di personaggi. La tabella seguente mostra tutte le 2 combinazioni di caratteri le corrispondenti differenze assolute.

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

Se dividiamo questi numeri interi per 3 , otteniamo i seguenti quozienti.

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

1 , 4 e 7 possono essere mappati su 1 prendendo i risultati modulo 3 .

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

Ora non ci resta che guardare la parità.

Come funziona

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

Un'implementazione Cubix della soluzione di Arnauld.

U%O@A*'g%2W

uso

Inserisci i due personaggi e viene prodotto 0per gli amici e 1per i nemici. Provalo qui.

Spiegazione

Il codice può essere espanso in questo modo.

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

I caratteri vengono eseguiti in questo ordine (escluso il flusso di controllo):

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 byte

lambda a:a in"GWUBRGRBUWG"

Provalo online!

AWK, 23 byte

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

Esempio di utilizzo: awk '{$ 0 = "WUBRGWGRBUW" ~ $ 1} 1' <<< UB

Questo stampa 1se la coppia è un amico, 0altrimenti. Volevo fare qualcosa di intelligente, ma tutto ciò a cui pensavo sarebbe stato più lungo.

Gelatina , 12 byte

“WUBRGW”ŒBẇ@

Uscite 1per alleati, 0per nemici.

Provalo online!

Spiegazione

“WUBRGW”ŒBẇ@   Main link

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

Rubino, 28 byte

Output vero per amico, falso per nemico:

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

La versione non golfata non è molto diversa:

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

05AB1E , 7 byte

Adattamento del mod-trick dalla risposta Jelly di Jonathan

Æ451bsè

Provalo online! o come suite di test

Spiegazione

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

GolfScript , 7 byte

~*51%9>

Accetta due punti di codice come input.

Provalo online! (Test suite che converte il formato di input per comodità.)

Una porta GolfScript di mia risposta CJam (che tecnicamente, è una porta CJam del risultato del mio forzante brutale GolfScript ... uhhh ...).

Tuttavia, poiché GolfScript ottiene il modulo con input negativi corretti, esiste una divertente soluzione alternativa con lo stesso numero di byte che utilizza 4per i nemici anziché 1:

~-)9%4&

Provalo 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 byte

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

La porta dalla risposta Befunge-98 di @Mistah Figgins è la più breve in Java 7 dalle risposte postate finora.
Per quanto riguarda gli altri:

39 byte: porta dalla risposta JavaScript (ES6) di @Arnauld .

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

39 byte: porto da @MartinEnder CJam risposta s'

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

47 byte: porta dalla risposta C di @Steadybox

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

52 byte: porta dalla risposta Python 2 di @Lynn

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

NOTA: Risposte saltate che usano numeri primi / palindromi e simili, perché in Java non sono affatto brevi. ;)
TODO: Sto arrivando con la mia risposta .. Anche se dubito che sia più breve della maggior parte di questi.

Prova tutto qui.

EDIT: Ok, ho inventato qualcosa che non è poi così male:

50 byte:

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

Spiegazione:

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

Tutti i nemici sono compresi nell'intervallo 4-6 (incluso) o 0.
EDIT2: Hmm .. Ho appena notato che è molto simile alla risposta di @Steadybox .. :(

PHP, 31 byte

echo!strstr(WBGURWRUGBW,$argn);

Corri con echo AB | php -nR '<code>, dove Ae Bsono i due colori.

strtrrestituisce la stringa dalla posizione in cui si trova l'input;
con WBGURWRUGBWcome pagliaio restituisce una stringa veritiera se i colori sono nemici; stringa vuota in caso contrario.

!trasforma la stringa di verità in false, generando output vuoto
e la stringa vuota in true, generando output 1.