Viajar con dispositivos electrónicos siempre es divertido, especialmente cuando necesita un adaptador para cargarlos. Su desafío es hacer que la planificación de un viaje sea un poco más fácil al verificar si un enchufe dado será compatible con un enchufe dado.

Desafío

Dado un tipo de enchufe y un tipo de socket, devuelve un valor que indica si funcionarán juntos o no.

Tabla de compatibilidad

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

^{Las tablas muestran la misma información, solo transpuesta.}

Para referencia .

Entrada

• La entrada se dará como dos letras mayúsculas o dos minúsculas (usted elige).

• Las entradas siempre serán /[A-O]/(o /[a-o]/), no hay necesidad de manejar entradas no válidas.

• Puede aceptar las dos entradas en cualquier orden (especifique cuál).

• La entrada se puede tomar en cualquier formato razonable (cadena, stdin, matriz, ...).

• Si toma ambas entradas en una sola cadena, pueden estar separadas por no más de un carácter y no debe haber nada alrededor de ellas.

• Buenas entradas: "G,K", "EF", "a b",['l', 'o']

• Insumos malas: "K l", "f(O)(I)",[1,5]

Salida

• La salida se puede devolver en cualquier formato razonable .

• De salida debe ser o bien truthy/ falsyo uno de los 2 valores constantes

• Buenas salidas: false/ any positive number, 1/ 2, 'T'/'F'

• Salidas malas: an even number/ an odd number, 1/more than 1

Ejemplos

Usando el formato socket, plug=> true/ false.

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

Las lagunas estándar no están permitidas.

Este es el código de golf, por lo que gana la respuesta con la menor cantidad de bytes en cada idioma.

Retina 0.8.2 , 30 29 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba.

Python 3 , 76 bytes

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

Pruébalo en línea!

Créditos

• De 83 a 76 bytes por (Mejor) Neil

Python 3 , 72 bytes 73 bytes 70 bytes

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

Pruébalo en línea!

Editar: ¡Gracias a Chas Brown por cortar algo de grasa!

C (gcc) (arquitectura x86), 76 60 bytes

¡Muchas gracias a Arnauld por los cambios!

Los argumentos se dan en orden (plug, socket).

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

Pruébalo en línea!

Haskell, 67 bytes

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

Los argumentos para funcionar #son dos caracteres, primero el enchufe, segundo el zócalo.

Pruébalo en línea!

JavaScript (Node.js) , 79 bytes

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

Se invoca en función al curry, f(socket)(plug).

Pruébalo en línea! (incluye casos de prueba, que muestran una matriz de resultados).

Jalea , 31 bytes

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

Un enlace monádico que acepta una lista de caracteres [plug,socket]que produce 1si es compatible o 0no.

Pruébalo en línea! O vea un conjunto de pruebas (que separa las dos clases).

PHP , 81 bytes

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

Para ejecutarlo:

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

Ejemplo:

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

O Pruébelo en línea!

Notas:

• Para guardar algunos bytes, he usado cadenas sin comillas simples / dobles como contenedor de cadenas. Por lo tanto, la error_reporting=0opción se utiliza para no generar advertencias.
• La entrada solo funciona con letras mayúsculas.
• Salidas 1 para compatibilidad y 0 para no compatibilidad.

¿Cómo?

Cada enchufe es compatible con el mismo enchufe que él mismo. Hay cuatro enchufes especiales (A, C, E, F) que también son compatibles con algunos enchufes más. Se definen cuatro variables de cadena con el nombre de los enchufes especiales para contener la lista de sus sockets adicionales compatibles.

Se verifica si el conector de entrada y el conector son iguales o si el conector está en la lista de conectores compatibles para ese conector. La última verificación se realiza con la ayuda de variables variables de PHP .

Javascript ES6, 66 65 64 caracteres

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

Toma mayúsculas en pel enchufe y spara el zócalo, devoluciones Falsy ( 0) o Truthy ( 1, 2, 4, ..., 8192) valor.

Prueba:

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 bytes

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

Pruébalo en línea!

Construye la siguiente matriz y extrae m[S,P]=> 1 si es VERDADERO, de lo contrario 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

Se guardaron 3 bytes al comprimir índices usando intToUtf8y reemplazando esta función con !. Ver Historia para una versión más legible.

¡Ahorré 16 bytes gracias a @Giuseppe!

Pascal (FPC) , 113 bytes

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.

Pruébalo en línea!

Prueba de todos los valores

Siguiendo el DEFHKOtren ...

pos(string1,string2)comprueba la primera aparición de string1in string2y devuelve su posición en él o 0 si no existe.