Một sự thật ít được biết đến về ma cà rồng là họ phải uống máu nạn nhân có nhóm máu người hiến tương thích. Ma trận tương thích cho ma cà rồng giống như ma trận người cho / người nhận hồng cầu thông thường . Điều này có thể được tóm tắt bằng bảng Chữ thập đỏ Mỹ sau đây

Type    You Can Give Blood To    You Can Receive Blood From
A+      A+, AB+                  A+, A-, O+, O-
O+      O+, A+, B+,AB+           O+, O-
B+      B+, AB+                  B+, B-, O+, O-
AB+     AB+                      everyone
A-      A+, A-, AB+, AB-         A-, O-
O-      everyone                 O-
B-      B+, B-, AB+, AB-         B-  O-
AB-     AB+, AB-                 AB-, A-, B-, O-

Thử thách

Viết hàm hoặc chương trình lấy nhóm máu làm đầu vào và xuất ra hai danh sách:

1. danh sách các loại có thể nhận được sự đóng góp của loại đầu vào
2. danh sách các loại không được sắp xếp có thể đóng góp cho loại đầu vào

Nếu bạn viết một hàm, thì vui lòng cung cấp một chương trình kiểm tra để gọi hàm đó với một vài ví dụ, để tôi có thể dễ dàng kiểm tra nó. Trong trường hợp này, chương trình kiểm tra sẽ không được tính vào điểm số của bạn.

Đầu vào

Đầu vào phải là một chuỗi đại diện chính xác cho một trong 8 loại tế bào hồng cầu có thể O− O+ A− A+ B− B+ AB− AB+. Đầu vào có thể được cung cấp thông qua các phương thức bình thường (STDIN, đối số dòng lệnh, đối số hàm, v.v.).

Nếu bất kỳ đầu vào nào khác được đưa ra thì chương trình / hàm phải trả lại đầu ra trống hoặc đưa ra lỗi. Thông thường kiểm tra đầu vào nghiêm ngặt không phải là tuyệt vời trong các câu hỏi về golf-code , nhưng tôi cảm thấy có liên quan đến sự sống chết khi nhận sai nhóm máu mà tôi nên thêm quy tắc này.

Đầu ra

Đầu ra sẽ là hai danh sách các nhóm máu có thể đọc được ở bất kỳ định dạng nào phù hợp với ngôn ngữ của bạn. Trong các trường hợp đặc biệt khi một trong các danh sách đầu ra chứa tất cả 8 loại, danh sách này có thể tùy chọn được thay thế bằng một danh sách mục duy nhất có chứa everyone.

Đầu ra bình thường sẽ đi đến một trong những nơi bình thường (STDOUT, trả về hàm, v.v.).

Các quy tắc khác

• Sơ hở tiêu chuẩn bị cấm
• Bạn có thể sử dụng bất kỳ thư viện bên thứ 3 nào hiện có mà bạn cần, miễn là chúng không được thiết kế rõ ràng cho mục đích này.

Ví dụ

• Đối với đầu vào AB-, hai danh sách đầu ra sẽ là:{AB+, AB-}, {AB-, A-, B-, O-}
• Đối với đầu vào AB+, hai danh sách đầu ra sẽ là: {AB+}, {O−, O+, A−, A+, B−, B+, AB−, AB+}hoặc{AB+}, {everyone}

_{Lưu ý cá nhân: Vui lòng xem xét hiến máu nếu bạn có thể. Nếu không được truyền máu cách đây vài năm, tôi có thể không ở đây hôm nay, vì vậy tôi cảm thấy rất biết ơn những người có thể quyên góp!}

Clip , 69

*cTx\{fFx`Tf[tFtx}T`[Fx[y!VVx"O-"Vy"O-"}[TC"A+ B+ AB+ O+ A- B- AB- O-

Đầu vào: AB-

Đầu ra: {{"AB+", "AB-"}, {"A-", "B-", "AB-", "O-"}}

Giải trình

Một nhóm máu xcó thể cung cấp cho ynếu tất cả các xkháng nguyên được bao gồm trong y. Chương trình định nghĩa hàm Flà có xthể cung cấp cho yvà Tnhư là danh sách các loại.

*cTx                 .- If T contains x (the input)         -.
    \                .- Print                               -.
     {             ` .- a list of                           -.
      fFx`T          .- filter each t in T with F(x,t)      -.
           f[tFtx}T  .- filter each t in T with F(t,x)      -.

[Fx[y              } .- F is a function of x and y          -.
     !V              .- all letters of ... are included in ...   -.
       Vx"O-"        .- x, with O and - removed             -.
             Vy"O-"  .- y, with O and - removed             -. 

[TC"A+ B+ AB+ O+ A- B- AB- O-   .- T is the list of types -.

Java 8, 373

import java.util.*;void f(String s){List<String>l=new ArrayList(Arrays.asList("A+,B+,AB+,O+,A-,B-,AB-,O-".split(","))),m=new ArrayList(l);int i=l.contains(s)?1:0/0;l.removeIf(x->g(s,x)<1);m.removeIf(x->g(x,s)<1);System.out.print(l+","+m);}int g(String s,String t){for(char c:s.replaceAll("O|-","").toCharArray())if(!t.replaceAll("O|-","").contains(""+c))return 0;return 1;}

Giải trình

void f(String s) {
    List<String> l = new ArrayList(Arrays.asList("A+,B+,AB+,O+,A-,B-,AB-,O-".split(","))),
                 m = new ArrayList(l);
    int i = l.contains(s) ? 1 : 0 / 0;
    l.removeIf(x -> g(s, x) < 1);
    m.removeIf(x -> g(x, s) < 1);
    System.out.print(l + "," + m);
}

int g(String s, String t) {
    for (char c : s.replaceAll("O|-", "").toCharArray()) {
        if (!t.replaceAll("O|-", "").contains("" + c)) {
            return 0;
        }
    }
    return 1;
}

Chạy nó ở đây: http://repl.it/e98/1

Lưu ý rằng staticphải được thêm vào mỗi phương thức để gọi chúng từ phương thức chính.

Bình thường, 61 59 50

L-{b"O-"M!-yGyHJmsd*c"A O B AB"d"+-"I}zJfgzTJfgYzJ

Chạy nó ở đây.

Giải trình:

L-{b"O-"                         Create function y(b) that makes a set from b's 
                                 characters minus O and -.
M!-yGyH                          Create function g(G,H) that checks if y(G) is 
                                 a subset of y(H).
J                                Assign to J...
 msd                             The concatenation of every element in...
    *c"A O B AB"d"+-"            The Cartesian product of A O B AB and + -.
I}zJ                             If input in J then...
    fgzTJ                        Print all elements e in J if g(input, e).
    fgYzJ                        Print all elements e in J if g(e, input).

CJam, 64 byte

"AB"_a+'O+"+-"m*:s:TT{}+Tqa#=a+T4=f&_)f{\-!}\)f-:!]{T]z::*La-p}/

Phần m*:sđến từ câu trả lời CJam của Martin . (Tôi chưa đọc các phần khác.)

Vẫn còn một số vấn đề nghiêm trọng bởi vì họ sẽ không bao giờ chắc chắn về thứ tự của hai danh sách. Và Block ArrayList &có thể được thực hiện trong các phiên bản sau của CJam.

Giải trình

"AB"_a+'O+         " Generate ['A 'B \"AB\" 'O]. ";
"+-"m*:s:T         " Generate the list of blood types and store in T. ";
T{}+
    Tqa#           " Find the input in T. ";
=                  " Find the blood type by the index.
                     If not found, return a block to cause an error. ";
a+                 " Append the verified input to T. ";
T4=                " AB+. ";
f&                 " Intersect each blood type with AB+. ";
_)f{\-!}           " Check emptiness of input - each item. ";
\)f-:!             " Check emptiness of each item - input. ";
]{                 " For both lists: ";
    T]z::*         " Replace items in T where there is a 0 with empty strings. ";
    La-            " Remove empty strings. ";
    p              " Print. ";
}/

Javascript, 167

p=function(t){o="";if((x=(l="O- O+ B- B+ A- A+ AB- AB+".split(" ")).indexOf(t))<0)return;n=2;while(n--){y=8;while(y--)if([y,x][n]-(y&x)==0)o+=" "+l[y];o+=";"}return o}

vô dụng:

function p(btype){
    output = "";
    btypeList = "O- O+ B- B+ A- A+ AB- AB+".split(" ");

    btypeInt = btypeList.indexOf(btype);
    // thus we have the scheme
    // btypeInt = 0b(has A antigen)(has B antigen)(has rhesus antigen)

    if(btypeInt < 0) // i.e. broken blood type string
        return;

    for(receiving = 7; receiving >= 0; receiving--)
        if(giving - (receiving & btypeInt) == 0)
            // i.e. the receiving person has at least all the antigens of our donor
            output += " " + btypeList[receiving];

    output += ";";

    for(giving = 7; giving >= 0; giving--)
        if(btypeInt - (receiving & btypeInt) == 0)
            // i.e. the giving person has no antigens that our patient doesn't have
            output += " " + btypeList[receiving];

    return output;
}

chức năng kiểm tra:

function tester(){
    btypeList = "O- O+ B- B+ A- A+ AB- AB+".split(" ");
    for(i=0; i<8; i++){
        console.log("Patient is " + btypeList[i])
        console.log(p(btypeList[i]))
    }
    console.log("Erroneous blood type => returns void:")
    console.log(p("asdf"))
}

Mã hóa nhóm máu trong nhị phân có lợi thế là một kháng nguyên khác (ví dụ như kháng nguyên Kell ) dễ dàng được kết hợp vào mã bằng cách chỉ cần thêm một bit khác.

Hiến máu tại Zurich, CH: Blutspende Zürich

CJam, 94 byte

Wow, điều này thật dài ... trong khi tôi nghĩ rằng tôi có thể chơi golf theo cách tiếp cận dưới 80 này, tôi nghĩ rằng tôi có thể đã làm tốt hơn bằng cách tính toán ma trận đầu tiên và sau đó chỉ cần chọn ra hàng và cột chính xác. Dù sao, đây là:

'O'A'B"AB"]:A"+-"m*:sq_a@&!!*_)'++_&\"AB"&A{1$\-!},\;\m*::+p)'-+_&\"AB"&A1>{1$-!},'O+\;\m*::+p

Kiểm tra nó ở đây.

Tôi sẽ thêm một lời giải thích khi tôi chơi golf.

Groovy, 115

x={i=(l=('O-O+B-B+A-A+AB-AB+'=~/\w+./)[0..7]).indexOf(it);f=(0..7).&findAll;i<0?[]:[l[f{!(~it&i)}],l[f{!(it&~i)}]]}

Ý tưởng là mã hóa hệ số A, B và rhesus thành từng bit một. Sau đó chúng ta có thể đảo ngược các bit để có được tất cả các kháng nguyên ở phía nhận và sử dụng nó để kiểm tra xem không có kháng thể tương ứng ở phía cho. Điều này ít nhiều giống với giải pháp JavaScript hiện có.

Thi công mẫu

groovy> println x("AB+") 
groovy> println x("AB-") 
groovy> println x("A+") 
groovy> println x("A-") 
groovy> println x("B+") 
groovy> println x("B-") 
groovy> println x("O+") 
groovy> println x("O-") 
groovy> println x("X") 

[[AB+], [O-, O+, B-, B+, A-, A+, AB-, AB+]]
[[AB-, AB+], [O-, B-, A-, AB-]]
[[A+, AB+], [O-, O+, A-, A+]]
[[A-, A+, AB-, AB+], [O-, A-]]
[[B+, AB+], [O-, O+, B-, B+]]
[[B-, B+, AB-, AB+], [O-, B-]]
[[O+, B+, A+, AB+], [O-, O+]]
[[O-, O+, B-, B+, A-, A+, AB-, AB+], [O-]]
[]

Prolog, 119 110 byte

u(A,B):-member(A:B,[a:ab,b:ab,o:a,o:b,o:ab]);A=B,member(A,[a,ab,b,o]).
g(X,Y):-(X= -A;X=A),(Y= -B;Y=B),u(A,B).

Nhận xét :

1. Nhóm máu có các thuộc tính sau: mỗi lần bạn có một -(ví dụ a-), bạn có thể cung cấp cho mọi người giống như một trong những người có tương đương tích cực của nhóm của bạn (ví dụ a), cũng như các đối tác tiêu cực của họ (ví dụ aban cho ab, vì vậy a-cho đến abvà ab-). Dựa trên đặc tính này và lạm dụng các ký hiệu một chút để sử dụng các toán tử trừ và cộng, chúng ta có thể tính đến rất nhiều trường hợp. Xin vui lòng cho tôi biết nếu bạn thấy nó chấp nhận được . Nếu bạn thích có cú pháp gốc (postfix), đây là phiên bản không chơi gôn:

   blood(X):-member(R,['a+','o+','b+','ab+','a-','b-','ab-']).
   give('o-',R):-blood(R).
   give(X,X):-blood(X).
   give('a+','ab+').
   give('b+','ab+').
   give('o+','a+').
   give('o+','b+').
   give('o+','ab+').
   give('a-','a+').
   give('a-','ab+').
   give('a-','ab-').
   give('b-','b+').
   give('b-','ab+').
   give('b-','ab-').
   give('ab-','ab+').
   

2. Đây là Prolog, vì vậy môi trường tương tác cho phép truy vấn mọi thứ theo yêu cầu (xem ví dụ bên dưới). Cấp, chúng tôi không có danh sách nghiêm ngặt như một đầu ra, nhưng điều này là tương đương. Chúng tôi cũng tự nhiên xử lý các trường hợp lỗi là hậu quả.

Thí dụ

donors(X,L) :- findall(Y,g(Y,X),L).
receivers(X,L) :- findall(Y,g(X,Y),L).

test :-
    member(X,[a,o,b,ab,-a,-o,-b,-ab]),
    donors(X,D),
    receivers(X,R),
    writeln(X:give_to(R):receive_from(D)),
    fail.
test.

Sau đó, chúng tôi thực hiện test:

a : give_to([ab, a]) : receive_from([o, a])
o : give_to([a, b, ab, o]) : receive_from([o])
b : give_to([ab, b]) : receive_from([o, b])
ab : give_to([ab]) : receive_from([a, b, o, ab])
-(a) : give_to([+(ab), +(a), -(ab), -(a)]) : receive_from([-(o), -(a)])
-(o) : give_to([+(a), +(b), +(ab), +(o), -(a), -(b), -(ab), -(o)]) : receive_from([-(o)])
-(b) : give_to([+(ab), +(b), -(ab), -(b)]) : receive_from([-(o), -(b)])
-(ab) : give_to([+(ab), -(ab)]) : receive_from([-(a), -(b), -(o), -(ab)])

... Mà, không có định dạng đúng, là ma trận giống như ma trận được đưa ra trong câu hỏi.

Chi tiết

Các vị g/2là Cung cấp cho mối quan hệ: g(X,Y)phương tiện người nhóm máu X có thể hiến máu cho người dân của nhóm máu Y .

Tìm người nhận cho nhóm a:

[eclipse]: g(a,R).    

R = ab
Yes (0.00s cpu, solution 1, maybe more) ? ;

R = a
Yes (0.00s cpu, solution 2)

Tìm người nhận cho orange_juice(nên thất bại):

[eclipse] g(orange_juice,L).

No (0.00s cpu)

Tìm nhà tài trợ cho O-:

[eclipse] g(X,-o).

X = -(o)
Yes (0.00s cpu)

Ai có thể cho cái gì? :

[eclipse] g(X,Y).

.... 27 answers ....

Chúng tôi không đi vào một vòng đệ quy vô hạn (đó là trường hợp trong các thử nghiệm sơ bộ).

Python, 187 byte

Phương pháp khác nhau:

def D(a,b):X=lambda c:c in a and 1-(c in b);return(X('A')+X('B')+X('+'))<1
T="O- O+ A- A+ B- B+ AB- AB+".split()
X=lambda t:(0,([u for u in T if D(t,u)],[u for u in T if D(u,t)]))[t in T]

Có lẽ có thể được chơi golf nhiều hơn một chút.

Kiểm tra:

for t in T + ["zz"]:
    print t, X(t)

Đầu ra:

O- (['O-', 'O+', 'A-', 'A+', 'B-', 'B+', 'AB-', 'AB+'], ['O-'])
O+ (['O+', 'A+', 'B+', 'AB+'], ['O-', 'O+'])
A- (['A-', 'A+', 'AB-', 'AB+'], ['O-', 'A-'])
A+ (['A+', 'AB+'], ['O-', 'O+', 'A-', 'A+'])
B- (['B-', 'B+', 'AB-', 'AB+'], ['O-', 'B-'])
B+ (['B+', 'AB+'], ['O-', 'O+', 'B-', 'B+'])
AB- (['AB-', 'AB+'], ['O-', 'A-', 'B-', 'AB-'])
AB+ (['AB+'], ['O-', 'O+', 'A-', 'A+', 'B-', 'B+', 'AB-', 'AB+'])
zz 0

Ruby, 237 232 223 221 210 207 byte

Đã sửa một số dấu gạch chéo ngược bên ngoài trong các biểu thức thông thường và làm cho nó chỉ in ra các danh sách trái ngược với việc lưu trữ chúng vào các biến và sau đó in chúng. Đôi khi bạn bỏ lỡ những điều rõ ràng khi cố gắng chơi golf!

o=->b{Regexp.new b.gsub(?O,?.).gsub(?+,'.?\\\+').gsub'-','.?(\W)'};b=gets.chop;t=["A+","B+","AB+","O+","A-","B-","AB-","O-"];exit if !t.include? b;p t.reject{|x|!x.match o.(b)};p t.reject{|x|!b.match o.(x)}

Ung dung:

#!/usr/bin/ruby
b=gets.chomp;
types = ["A+","A-","B+","B-","AB+","AB-","O+","O-"];
exit if !types.include?(b);
regex1 = Regexp.new b.gsub("O",".").gsub('+','.?\\\+').gsub('-','.?(\\\+|\\\-)')
donate = types.reject {|x|!x.match(regex1)};
p donate;
receive = types.reject {|x| regex2 = Regexp.new x.gsub("O",".").gsub('+','.?\\\+').gsub('-','.?(\\\+|\\\-)'); !b.match(regex2)};
p receive;

Về cơ bản, tôi xây dựng một biểu thức chính quy tùy chỉnh cho nhóm máu được nhập để kiểm tra xem bạn có thể hiến cho nhóm máu khác hay không. Sau đó tôi lặp lại qua các nhóm máu và áp dụng cùng một biểu thức chính cho họ và kiểm tra xem họ có thể quyên góp cho nhóm được chỉ định hay không.

Điều này có thể có thể được đánh golf xuống nhiều hơn. Đây là lần đầu tiên tôi thử chơi golf code, heh.

Python 2, 168 byte

Đây là phương pháp tương tự như câu trả lời của Blackhole. Thoát với một lỗi nếu không tìm thấy tham số trong danh sách các loại.

def f(t):l='A+ O+ B+ AB+ A- O- B- AB-'.split();c=[9,15,12,8,153,255,204,136];i=l.index(t);print[s for s in l if c[i]&1<<l.index(s)],[s for s in l if c[l.index(s)]&1<<i]

Ít chơi gôn hơn:

def f(t):
    l = 'A+ O+ B+ AB+ A- O- B- AB-'.split()
    c = [9, 15, 12, 8, 153, 255, 204, 136]
    i = l.index(t)
    x = [s for s in l if c[i] & 1 << l.index(s)]
    y = [s for s in l if c[l.index(s)] & 1 << i]
    print x, y

Chạy nó ở đây: http://repl.it/eaB

Tôi cũng đã thử một vài thay đổi nhỏ khác, nhưng không thể rút ngắn được nữa ...

#172 bytes
def f(t):l='A+ O+ B+ AB+ A- O- B- AB-'.split();c=[9,15,12,8,153,255,204,136];a=lambda x:l.index(x);i=a(t);print[s for s in l if c[i]&1<<a(s)],[s for s in l if c[a(s)]&1<<i]

#171 bytes
def f(t):l='A+ O+ B+ AB+ A- O- B- AB-'.split();c=[9,15,12,8,153,255,204,136];a=lambda x:l.index(x);print[s for s in l if c[a(t)]&1<<a(s)],[s for s in l if c[a(s)]&1<<a(t)]

PHP (287 byte):

Vâng, điều này là khá dài, nhưng nó hoạt động như mong đợi.

Có thể rút ngắn rất nhiều:

!preg_match('@^(AB?|B|O)[+-]$@',$t=$_GET[T])&&die("$t invalid");$S=array_flip($D=split(0,'O+0A+0B+0AB+0O-0A-0B-0AB-'));$L=[[1230,40],[13,1504],[23,2604],[3,$r=12345670],[$r,4],[1537,54],[2637,64],[37,7564]];for($j=0;$j<2;){foreach(str_split($L[$S[$t]][$j++])as$v)echo$D[$v].' ';echo'
';}

Điều này không dễ đọc và không dễ viết.

Nó hoạt động như dự định, xuất ra những cái bạn có thể cho và những cái bạn có thể nhận được từ dòng khác.

Điều này đòi hỏi một tham số URL T=với loại.

CJam, 80 byte

Điều này vẫn còn quá dài. Có lẽ tôi có thể cạo thêm 4 đến 5 byte nữa.

U1023_XKC30D]2/La+"AB"a"OAB"1/+:Mr):P;a#=_P"+-":G&+!!{AfbMff=G1/Pf|]z{~m*:s}%}*`

Đối với bất kỳ đầu vào không hợp lệ, in một mảng trống hoặc ném lỗi.

Dùng thử trực tuyến tại đây hoặc chạy toàn bộ bộ thử nghiệm

APL, 66

(↓⊃∧/(↓t∘.∊v)(≥,[.5]≤)¨t∊⊃v⌷⍨v⍳⊂⍞)/¨⊂v←,'+-'∘.,⍨('O'∘,,⊂)2↑t←'AB+'

Hãy thử nó ở đây.

C, 224

#define d(x)for(i=0;i<8;i++)if((i x j)==j)printf("%s%s%s%c ",i&2?"A":"",i&4?"B":"",i&6?"":"0","-+"[i&1]);puts("");
main(i,j){char d[4],*c=&d;scanf("%s",c);j=(c[2]?c++,2:0)+(c[1]-'+'?0:1)+(*c>='A'?2:0)+(*c>'A'?2:0);d(&)d(|)}

De-golfed nó cho thấy:

/* j = 1*(has+) + 2*(hasA) + 4*(hasB) */
#define d(x) for(i=0;i<8;i++) \
                 if((i x j)==j) \
                      printf("%s%s%s%c ",i&2?"A":"",i&4?"B":"",i&6?"":"0","-+"[i&1]); \
             puts("");

main(i,j)
{
    char d[4], *c=&d;
    scanf("%s",c);

    j= (c[2]? (c++,2):0)            /* ABx */
            + (c[1]-'+'?0:1)
            + (c[0]>='A'?2:0)
            + (c[0]>'A'?2:0);

    // print possible receipients, and then donators
    d(&)
    d(|)
}

PHP - 215 212 206 byte

function($t){$c=[9,15,12,8,153,255,204,136];if(($a=array_search($t,$l=split(1,'A+1O+1B+1AB+1A-1O-1B-1AB-')))===!1)die;foreach($l as$k=>$v){if($c[$a]&1<<$k)$x[]=$v;if($c[$k]&1<<$a)$y[]=$v;}var_dump($x,$y);}

Đây là phiên bản chưa được chỉnh sửa:

function ($type)
{
    $typesList = ['A+', 'O+', 'B+', 'AB+', 'A-', 'O-', 'B-', 'AB-'];
    $donationCompatibilityList = [
        0b00001001,
        0b00001111,
        0b00001100,
        0b00001000,
        0b10011001,
        0b11111111,
        0b11001100,
        0b10001000,
    ];

    $idType = array_search($type, $typesList);
    if ($idType === false) {
        die;
    }

    $canGiveToList = [];
    $canReceiveFromList = [];
    foreach ($typesList as $currentIdType => $currentType)
    {
        if ($donationCompatibilityList[$idType] & 1 << $currentIdType ) {
            $canGiveToList[] = $currentType;
        }

        if ($donationCompatibilityList[$currentIdType ] & 1 << $idType) {
            $canReceiveFromList[] = $currentType;
        }
    }

    var_dump($canGiveToList, $canReceiveFromList);
}

Nhờ manatwork để tiết kiệm 4 byte.

Perl, 107 112

Cuối cùng mã hóa tên loại theo số đã cho mã ngắn hơn.

#!perl -p
$x=y/AB+/421/r%9;@a=grep{~$x&$_%9||push@b,$_;!($x&~($_%9))}map{("$_-",$_.1)}0,2,4,42;$_="@a
@b";y/421/AB+/

Phiên bản cũ hơn

#!perl -p
$x=y/AB+/421/r%9;@a=grep!($x&~$_),0..7;@b=grep!(~$x&$_),0..7;$_="@a
@b";s/\d/(map{("$_+","$_-")}0,A,B,AB)[$&]/eg

Bình thường, 58

Một phần giống như giải pháp của orlp , nhưng hơi khác biệt và hoàn toàn tự thiết kế.

M&n+eGeH"+-"!f!}T+H\OPGJsm,+d\++d\-c"O A B AB"dfgzYJfgZzJJ

Giải trình

M                          create a function g(G,H) that returns
  n+eGeH"+-"                 G[-1] + H[-1] is not "+-"
 &                          and
            !f!}T+H\OPG      chars of G[:-1] not in H + "O" is falsy (empty)
J                          J =
 s                          merge
  m                          map
   ,+d\++d\-                  lambda d: (d + "+", d + "-")
            c"O A B AB"d      over ["O", "A", "B", "AB"]
fgzYJ                      print all J's items x where g(input, x)
fgZzJ                      print all J's items x where g(x, input)

J, 120 byte

   f=.3 :';"1(2 8$,(s-:"*<y,'' '')#8 2 8$#:213472854600871062656691437010712264449x)#s=.<;.2''A+ B+ AB+ O+ A- B- AB- O- '''

   f 'A+'
A+ AB+      
A+ O+ A- O- 

   f 'AB-'
AB+ AB-      
A- B- AB- O- 

Các chức năng thất bại trên đầu vào không hợp lệ. Số thập phân lớn là mã hóa của ma trận tương thích đầy đủ.

(Giải pháp rất dài vì nhiều lý do.)

Hãy thử trực tuyến tại đây.

05AB1E , 29 byte

„ABD`'O)„+-âJÐIkVāY&èê,āY~èê,

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