Voyager avec des appareils électroniques est toujours amusant, surtout lorsque vous avez besoin d'un adaptateur pour les charger. Votre défi est de faciliter un peu la planification d'un voyage en vérifiant si une prise donnée sera compatible avec une prise donnée.

Défi

Étant donné un type de prise et un type de prise, renvoyez une valeur qui indique s'ils fonctionneront ensemble ou non.

Tableau de compatibilité

Socket  Accepted plugs  |  Plug  Accepting Sockets
A       A               |  A     A, B
B       A, B            |  B     B
C       C               |  C     C, D, E, F, H, J, K, L, N, O
D       C, D, E, F      |  D     D
E       C, E, F         |  E     D, E, F, H, K, O
F       C, E, F         |  F     D, E, F, H, K, O
G       G               |  G     G
H       C, E, F, H      |  H     H
I       I               |  I     I
J       C, J            |  J     J
K       C, E, F, K      |  K     K
L       C, L            |  L     L
M       M               |  M     M
N       C, N            |  N     N
O       C, E, F, O      |  O     O

^{Les tableaux présentent les mêmes informations, uniquement transposées.}

Pour référence .

Contribution

• L'entrée sera donnée en deux majuscules ou deux minuscules (à votre choix).

• Les entrées seront toujours /[A-O]/(ou /[a-o]/), il n'est pas nécessaire de gérer les entrées non valides.

• Vous pouvez accepter les deux entrées dans n'importe quel ordre (veuillez préciser lesquelles).

• L'entrée peut être prise dans n'importe quel format raisonnable (chaîne, stdin, tableau, ...).

• Si vous prenez les deux entrées dans une même chaîne, elles ne peuvent pas être séparées par plus d'un caractère et rien ne doit les entourer

• De bonnes entrées: "G,K", "EF", "a b",['l', 'o']

• Entrées: Bad "K l", "f(O)(I)",[1,5]

Production

• La sortie peut être retournée dans n'importe quel format raisonnable .

• La sortie doit être soit truthy/ falsysoit l'une des 2 valeurs constantes

• Bonnes sorties: false/ any positive number, 1/ 2, 'T'/'F'

• Mauvaises sorties: an even number/ an odd number, 1/more than 1

Exemples

En utilisant le format socket, plug=> true/ false.

A, A => true
I, K => false
O, C => true
C, O => false
E, F => true
F, E => true

Les failles standard ne sont pas autorisées.

C'est du code-golf donc la réponse avec le moins d'octets dans chaque langue l'emporte.

Retina 0.8.2 , 30 29 octets

(.)\1|[DEFHKO][CEF]|[JLN]C|BA

Essayez-le en ligne! Le lien inclut des cas de test.

Python 3 , 76 octets

lambda s,p:any([s==p,p in"CEF"and s in"DEFHKO",s=="B"<p,s in"JLN"and"C"==p])

Essayez-le en ligne!

Crédits:

• De 83 à 76 octets par (Better) Neil

Python 3 , 72 octets 73 octets 70 octets

lambda p,s:s in{"A":"AB","C":y+"CJLN","E":y,"F":y}.get(p,p)
y="DEFHKO"

Essayez-le en ligne!

Edit: Merci à Chas Brown pour avoir coupé du gras!

C (gcc) (architecture x86), 76 60 octets

Un grand merci à Arnauld pour les changements!

Les arguments sont donnés dans l'ordre (plug, socket).

c[15]={6,0,56696,0,35184,35184};f(a,b){a=a==b|c[a-65]>>b&1;}

Essayez-le en ligne!

Haskell, 67 octets

p#s=p==s||or[elem s b|a:b<-words"AB CDEFHJKLNO EDFHKO FDEHKO",a==p]

Les arguments pour fonctionner #sont deux caractères, plug first, socket second.

Essayez-le en ligne!

JavaScript (Node.js) , 79 octets

S=>P=>P==S|P<'B'&S<'C'|P=='C'&'JLN'[K='includes'](S)|'CEF'[K](P)&'DEFHKO'[K](S)

Appelé en fonction cari, f(socket)(plug).

Essayez-le en ligne! (comprend des cas de test, montrant une matrice de résultats.)

Gelée , 31 octets

Oḅ⁴_ȷe“j⁼⁽⁾ƇƑƓƘƝƤḄẸỊṂṢỴẒĊḞĿ‘o⁼/

Un lien monadique acceptant une liste de caractères [plug,socket]qui donne 1si compatible ou 0sinon.

Essayez-le en ligne! Ou voir une suite de tests (qui sépare les deux classes).

PHP , 81 octets

<?list(,$s,$p)=$argv;$A=AB;$C=$E=$F=DEFHKO;$C.=JLN;echo+($p==$s||strpos($$p,$s));

Pour l'exécuter:

php -n -d error_reporting=0 <filename> <socket> <plug>

Exemple:

php -n -d error_reporting=0 socket_plug_compatibility.php F E

Ou essayez-le en ligne!

Remarques:

• Pour économiser quelques octets, j'ai utilisé des chaînes sans guillemets simples / doubles comme wrapper de chaîne. Ainsi, l' error_reporting=0option est utilisée pour ne pas générer d'avertissements.
• L'entrée ne fonctionne qu'avec des lettres majuscules.
• Sorties 1 pour la compatibilité et 0 pour la non-compatibilité.

Comment?

Chaque fiche est compatible avec la même prise que la sienne. Il existe quatre fiches spéciales (A, C, E, F) qui sont également compatibles avec quelques prises supplémentaires. Quatre variables de chaîne avec le nom des fiches spéciales sont définies pour contenir la liste de leurs prises supplémentaires compatibles.

Il est vérifié si la prise et la prise d'entrée sont identiques ou si la prise est dans la liste des prises compatibles pour cette prise. Cette dernière vérification est effectuée à l'aide des variables variables de PHP .

Javascript ES6, 66 65 64 caractères

p=>s=>p==s|{A:1,C:14172,E:8788,F:8780}[p]&(1<<parseInt(s,36)-11)

Prend en lettres majuscules ppour bouchon et spour la prise, le rendement falsy ( 0) ou truthy ( 1, 2, 4, ..., 8192) valeur.

Tester:

f=p=>s=>p==s|{B:1,C:14172,E:8788,F:8780}[p]&(1<<parseInt(s,36)-11)

console.log(`A, A => true
I, K => false
O, C => true
C, O => false
E, F => true
F, E => true`
.split`
`.map(x=>x.match(/(.), (.) => (\w+)/))
.every(([m,p,s,res])=>!!f(s)(p)==eval(res)))

R , 132 129 113 octets

function(S,P,`!`=utf8ToInt)"[<-"(diag(15),cbind(rep(!"",!"	"),!"
"),1)[-64+!P,-64+!S]

Essayez-le en ligne!

Construit la matrice suivante et extrait m[S,P]=> 1 si VRAI, sinon 0.

       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12] [,13] [,14] [,15]
 [1,]    1    1    0    0    0    0    0    0    0     0     0     0     0     0     0 
 [2,]    0    1    0    0    0    0    0    0    0     0     0     0     0    0     0
 [3,]    0    0    1    1    1    1    0    1    0     1     1     1     0    1     1
 [4,]    0    0    0    1    0    0    0    0    0     0     0     0     0    0     0
 [5,]    0    0    0    1    1    1    0    1    0     0     1     0     0    0     1
 [6,]    0    0    0    1    1    1    0    1    0     0     1     0     0    0     1
 [7,]    0    0    0    0    0    0    1    0    0     0     0     0     0    0     0
 [8,]    0    0    0    0    0    0    0    1    0     0     0     0     0    0     0
 [9,]    0    0    0    0    0    0    0    0    1     0     0     0     0    0     0
[10,]    0    0    0    0    0    0    0    0    0     1     0     0     0    0     0
[11,]    0    0    0    0    0    0    0    0    0     0     1     0     0    0     0
[12,]    0    0    0    0    0    0    0    0    0     0     0     1     0    0     0
[13,]    0    0    0    0    0    0    0    0    0     0     0     0     1    0     0
[14,]    0    0    0    0    0    0    0    0    0     0     0     0     0    1     0
[15,]    0    0    0    0    0    0    0    0    0     0     0     0     0    0     1

Enregistré 3 octets en compressant les index en utilisant intToUtf8et en remplaçant cette fonction par !. Voir l'historique pour une version plus lisible.

16 octets enregistrés grâce à @Giuseppe!

Pascal (FPC) , 113 octets

var p,s:char;begin read(p,s);write((p=s)or(pos(p,'CEF')>0)and(pos(s,'DEFHKO')>0)or(pos(p+s,'AB CJ CL CN')>0))end.

Essayez-le en ligne!

Test pour toutes les valeurs

Suivre le DEFHKOtrain ...

pos(string1,string2)vérifie la première occurrence de string1in string2et renvoie sa position en elle ou 0 si elle n'existe pas.