Du lịch với thiết bị điện tử luôn thú vị, đặc biệt là khi bạn cần một bộ chuyển đổi để sạc chúng. Thách thức của bạn là làm cho việc lên kế hoạch cho chuyến đi dễ dàng hơn một chút bằng cách kiểm tra xem một phích cắm nhất định có tương thích với một ổ cắm nhất định không.

Thử thách

Đưa ra một loại phích cắm và loại ổ cắm, trả về một giá trị cho biết liệu chúng có hoạt động cùng nhau hay không.

Bảng tương thích

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

^{Các bảng hiển thị cùng một thông tin, chỉ chuyển đổi.}

Để tham khảo .

Đầu vào

• Đầu vào sẽ được cung cấp dưới dạng hai chữ hoa hoặc hai chữ cái viết thường (bạn chọn).

• Đầu vào sẽ luôn là /[A-O]/(hoặc /[a-o]/), không cần xử lý đầu vào không hợp lệ.

• Bạn có thể chấp nhận hai đầu vào theo bất kỳ thứ tự nào (vui lòng ghi rõ).

• Đầu vào có thể được thực hiện trong bất kỳ định dạng hợp lý (chuỗi, stdin, mảng, ...).

• Nếu bạn lấy cả hai đầu vào trong một chuỗi, chúng có thể được phân tách bằng không quá một ký tự và không có gì xung quanh chúng

• Đầu vào tốt: "G,K", "EF", "a b",['l', 'o']

• Đầu vào xấu: "K l", "f(O)(I)",[1,5]

Đầu ra

• Đầu ra có thể được trả lại trong bất kỳ định dạng hợp lý .

• Đầu ra phải là truthy/ falsyhoặc một trong 2 giá trị không đổi

• Đầu ra tốt: false/ any positive number, 1/ 2, 'T'/'F'

• Đầu ra xấu: an even number/ an odd number, 1/more than 1

Ví dụ

Sử dụng định dạng socket, plug=> true/ false.

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

Sơ hở tiêu chuẩn là không được phép.

Đây là môn đánh gôn, vì vậy câu trả lời có ít byte nhất trong mỗi ngôn ngữ sẽ thắng.

Võng mạc 0.8.2 , 30 29 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm.

Con trăn 3 , 76 byte

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

Hãy thử trực tuyến!

Tín dụng:

• Từ 83 đến 76 byte bởi (Tốt hơn) Neil

Python 3 , 72 Byte 73 byte 70 byte

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

Hãy thử trực tuyến!

Chỉnh sửa: Cảm ơn Chas Brown vì đã cắt giảm một số chất béo!

C (gcc) (kiến trúc x86), 76 60 byte

Rất cám ơn Arnauld vì những thay đổi!

Các đối số được đưa ra theo thứ tự (phích cắm, ổ cắm).

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

Hãy thử trực tuyến!

Haskell, 67 byte

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

Đối số cho chức năng #là hai ký tự, cắm đầu tiên, ổ cắm thứ hai.

Hãy thử trực tuyến!

JavaScript (Node.js) , 79 byte

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

Được gọi là một hàm curried , f(socket)(plug).

Hãy thử trực tuyến! (bao gồm các testcase, hiển thị một ma trận kết quả.)

Thạch , 31 byte

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

Một liên kết đơn âm chấp nhận một danh sách các ký tự [plug,socket]mang lại 1nếu tương thích hoặc 0nếu không.

Hãy thử trực tuyến! Hoặc xem một bộ thử nghiệm (phân tách hai lớp).

PHP , 81 byte

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

Để chạy nó:

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

Thí dụ:

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

Hoặc dùng thử trực tuyến!

Ghi chú:

• Để lưu một số byte, tôi đã sử dụng các chuỗi mà không có trích dẫn đơn / đôi làm trình bao bọc chuỗi. Do đó, error_reporting=0tùy chọn được sử dụng để không đưa ra cảnh báo.
• Đầu vào chỉ hoạt động với chữ in hoa.
• Đầu ra 1 cho khả năng tương thích và 0 cho không tương thích.

Làm sao?

Mỗi phích cắm đều tương thích với cùng một ổ cắm. Có bốn phích cắm đặc biệt (A, C, E, F) tương thích với một vài ổ cắm nữa. Bốn biến chuỗi với tên của các phích cắm đặc biệt được xác định để giữ danh sách các ổ cắm tương thích bổ sung của chúng.

Nó được kiểm tra nếu phích cắm đầu vào và ổ cắm giống nhau hay nếu ổ cắm nằm trong danh sách các ổ cắm tương thích cho phích cắm đó. Việc kiểm tra sau được thực hiện với sự trợ giúp của các biến biến của PHP .

Javascript ES6, 66 65 64 ký tự

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

Mất chữ in hoa vào pcho các plug và scho ổ cắm, lợi nhuận falsy ( 0) hoặc truthy ( 1, 2, 4, ..., 8192) giá trị.

Kiểm tra:

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 byte

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

Hãy thử trực tuyến!

Xây dựng ma trận sau và trích xuất m[S,P]=> 1 nếu TRUE, khác 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

Đã lưu 3 byte bằng cách nén các chỉ mục bằng cách sử dụng intToUtf8và thay thế chức năng này bằng !. Xem Lịch sử để biết thêm phiên bản dễ đọc.

Đã lưu 16 byte nhờ @Giuseppe!

Pascal (FPC) , 113 byte

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.

Hãy thử trực tuyến!

Kiểm tra tất cả các giá trị

Theo DEFHKOtàu ...

pos(string1,string2)kiểm tra sự xuất hiện đầu tiên của string1in string2và trả về vị trí của nó trong đó hoặc 0 nếu nó không tồn tại.