Eine wenig bekannte Tatsache über Vampire ist, dass sie das Blut eines Opfers mit einer kompatiblen Spenderblutgruppe trinken müssen. Die Kompatibilitätsmatrix für Vampire ist die gleiche wie die normale Spender / Empfänger-Matrix für rote Blutkörperchen . Dies kann durch die folgende Tabelle des Amerikanischen Roten Kreuzes zusammengefasst werden

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-

Herausforderung

Schreiben Sie eine Funktion oder ein Programm, das eine Blutgruppe als Eingabe verwendet und zwei Listen ausgibt:

1. die ungeordnete Liste der Typen, die eine Spende des Eingabetyps erhalten können
2. die ungeordnete Liste der Typen, die dem Eingabetyp eine Spende geben können

Wenn Sie eine Funktion schreiben, stellen Sie bitte auch ein Testprogramm zum Aufrufen dieser Funktion mit einigen Beispielen bereit, damit ich sie problemlos testen kann. In diesem Fall würde das Testprogramm nicht auf Ihre Punktzahl angerechnet.

Eingang

Die Eingabe muss eine Zeichenfolge sein, die genau einen der 8 möglichen roten Blutkörperchentypen darstellt O− O+ A− A+ B− B+ AB− AB+. Die Eingabe kann über die normalen Methoden (STDIN, Befehlszeilenargumente, Funktionsargumente usw.) erfolgen.

Wenn eine andere Eingabe erfolgt, muss das Programm / die Funktion eine leere Ausgabe zurückgeben oder einen Fehler auslösen. Normalerweise ist eine strenge Eingabeüberprüfung bei Code-Golf- Fragen nicht besonders wichtig , aber ich hatte das Gefühl, dass ich diese Regel hinzufügen sollte, wenn die Auswirkungen auf Leben und Tod falsch sind.

Ausgabe

Es werden zwei für Menschen lesbare Listen von Blutgruppen in dem für Ihre Sprache geeigneten Format ausgegeben. In besonderen Fällen, in denen eine der Ausgabelisten alle 8 Typen enthält, kann diese Liste optional durch eine einzelne Artikelliste mit ersetzt werden everyone.

Die normale Ausgabe erfolgt an eine der normalen Stellen (STDOUT, Funktionsrückgabe usw.).

Andere Regeln

• Standardlücken sind verboten
• Sie können vorhandene Bibliotheken von Drittanbietern verwenden, sofern diese nicht ausdrücklich für diesen Zweck entwickelt wurden.

Beispiele

• Für die Eingabe AB-wären die beiden Ausgabelisten:{AB+, AB-}, {AB-, A-, B-, O-}
• Für die Eingabe AB+wären die beiden Ausgabelisten: {AB+}, {O−, O+, A−, A+, B−, B+, AB−, AB+}oder{AB+}, {everyone}

_{Persönliche Notiz: Bitte überlegen Sie, ob Sie Blut spenden können. Ohne die Transfusion, die ich vor ein paar Jahren erhalten habe, könnte ich heute nicht hier sein, deshalb bin ich denen sehr dankbar, die spenden können!}

Clip , 69

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

Eingang: AB-

Ausgabe: {{"AB+", "AB-"}, {"A-", "B-", "AB-", "O-"}}

Erläuterung

Eine Blutgruppe xkann geben, ywenn alle xAntigene in enthalten sind y. Das Programm definiert die Funktion Fals ob xgeben kann y, und Tals die Liste der Typen.

*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;}

Erläuterung

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

Führen Sie es hier aus: http://repl.it/e98/1

Beachten Sie, dass staticzu jeder Methode hinzugefügt werden musste, um sie von der Hauptmethode aufzurufen.

Pyth, 61 59 50

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

Führen Sie es hier aus.

Erläuterung:

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 Bytes

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

Der m*:sTeil stammt aus Martins CJam-Antwort . (Die anderen Teile habe ich noch nicht gelesen.)

Es wird immer noch einige ernsthafte Probleme geben, da sie sich über die Reihenfolge der beiden Listen nicht sicher sind. Und Block ArrayList &möglicherweise in späteren Versionen von CJam implementiert.

Erläuterung

"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}

ungolfed:

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

Testfunktion:

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"))
}

Das Kodieren der Blutgruppe in binärer Form hat den Vorteil, dass ein anderes Antigen (z. B. das Kell-Antigen ) leicht in den Code eingebaut werden kann, indem nur ein weiteres Bit hinzugefügt wird.

Blutspende in Zürich, CH: Blutspende Zürich

CJam, 94 Bytes

Wow, das ist lang ... obwohl ich glaube, dass ich diesen Ansatz unter 80 Golf spielen könnte, hätte ich es vielleicht besser gemacht, wenn ich zuerst die Matrix berechnet und dann einfach die richtige Zeile und Spalte ausgewählt hätte. Wie auch immer, hier ist es:

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

Teste es hier.

Ich werde eine Erklärung hinzufügen, wenn ich mit dem Golfen fertig bin.

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)}]]}

Die Idee ist, A, B und Rhesusfaktor jeweils als ein Bit zu codieren. Wir können dann die Bits invertieren, um alle Antigene auf der Empfängerseite zu erhalten und damit zu überprüfen, ob auf der Geberseite keine entsprechenden Antikörper vorhanden sind. Dies entspricht in etwa der vorhandenen JavaScript-Lösung.

Beispielausführung

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 Bytes

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).

Bemerkungen :

1. Blutgruppen haben die folgenden Eigenschaften: Jedes Mal, wenn Sie eine haben -(z. B. a-), können Sie denselben Personen wie denen, die ein positives Äquivalent zu Ihrer Gruppe haben (z. B. a), sowie deren negatives Gegenstück geben (z. B. agibt ab, also a-gibt) abund ab-). Basierend auf dieser Eigenschaft und wenn wir die Notationen ein wenig missbrauchen , um die Minus- und Plus-Operatoren zu verwenden, können wir viele Fälle berücksichtigen. Bitte sagen Sie mir, wenn Sie es akzeptabel finden . Wenn Sie die ursprüngliche (Postfix-) Syntax bevorzugen, finden Sie hier eine nicht-golfende Version:

   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. Dies ist Prolog, daher kann in der interaktiven Umgebung alles wie gewünscht abgefragt werden (siehe Beispiel unten). Zugegeben, wir haben keine Listen als Ausgabe, aber das ist äquivalent. Als Folge behandeln wir natürlich auch Fehlerfälle.

Beispiel

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.

Dann führen wir aus 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)])

... die ohne richtige Formatierung dieselbe Matrix wie die in der Frage angegebene ist.

Einzelheiten

Das Prädikat g/2ist die Give- Beziehung: g(X,Y)bedeutet, dass Personen der Blutgruppe X Blut an Personen der Blutgruppe Y geben können .

Empfänger für Gruppe suchen a:

[eclipse]: g(a,R).    

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

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

Empfänger finden für orange_juice(sollte fehlschlagen):

[eclipse] g(orange_juice,L).

No (0.00s cpu)

Spender finden für O-:

[eclipse] g(X,-o).

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

Wer kann was geben? :

[eclipse] g(X,Y).

.... 27 answers ....

Wir gehen nicht in eine unendliche Rekursionsschleife (das war bei Vorversuchen der Fall).

Python, 187 Bytes

Anderer Ansatz:

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]

Kann wohl etwas mehr golfen werden.

Prüfung:

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

Ausgabe:

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 Bytes

Einige überflüssige Backslashes in den regulären Ausdrücken wurden korrigiert und so angepasst, dass die Listen nur gedruckt und nicht in Variablen gespeichert und dann gedruckt werden. Manchmal vermisst man die offensichtlichen Dinge beim Golfspielen!

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)}

Ungolfed:

#!/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;

Grundsätzlich konstruiere ich einen benutzerdefinierten regulären Ausdruck für die eingegebene Blutgruppe, um zu überprüfen, ob Sie für eine andere Blutgruppe spenden können. Ich durchlaufe dann die Blutgruppen und wende denselben regulären Ausdruck auf sie an und überprüfe, ob sie für die angegebene Blutgruppe spenden können.

Damit lässt sich wohl noch mehr Golf spielen. Dies ist mein erster Versuch, Codegolf zu spielen, heh.

Python 2, 168 Bytes

Dies ist die gleiche Methode wie Blackholes Antwort. Wird mit einem Fehler beendet, wenn der Parameter nicht in der Typenliste gefunden wird.

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]

Weniger golfen:

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

Führen Sie es hier aus: http://repl.it/eaB

Ich habe auch ein paar andere kleine Änderungen versucht, konnte es aber nicht kürzer machen ...

#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 Bytes):

Ja, das ist ziemlich lang, aber es funktioniert wie erwartet.

Es kann möglich sein, eine Menge zu verkürzen:

!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'
';}

Dies ist nicht leicht zu lesen und zu schreiben.

Es funktioniert wie beabsichtigt und gibt diejenigen aus, die Sie geben und die Sie von einer anderen Leitung empfangen können.

Dies erfordert einen URL-Parameter T=mit dem Typ.

CJam, 80 Bytes

Das ist noch zu lang. Wahrscheinlich kann ich 4 bis 5 Bytes mehr abschneiden.

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

Bei ungültigen Eingaben wird entweder ein leeres Array gedruckt oder ein Fehler ausgegeben.

Probieren Sie es hier online aus oder führen Sie die gesamte Testsuite aus

APL, 66

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

Probieren Sie es hier aus.

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(|)}

Entgolft zeigt es:

/* 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 Bytes

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);}

Hier ist die ungolfed Version:

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);
}

Dank an manatwork für die Einsparung von 4 Bytes.

Perl 107, 112

Das abschließende Codieren der Typnamen in Zahlen ergab den kürzeren Code.

#!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+/

Ältere Version

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

Pyth, 58

Teilweise die gleiche Lösung wie bei orlp , aber etwas anders und vollständig selbst gestaltet.

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

Erläuterung

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 Bytes

   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- 

Die Funktion schlägt bei ungültigen Eingaben fehl. Die große Dezimalzahl ist die Kodierung der vollständigen Kompatibilitätsmatrix.

(Sehr lange Lösung aus mehreren Gründen.)

Probieren Sie es hier online aus.

05AB1E , 29 Bytes

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

Probieren Sie es online!