关于吸血鬼的鲜为人知的事实是，他们必须喝具有兼容的供血者血型的受害者的血液。吸血鬼的相容性矩阵与常规红细胞供体/受体矩阵相同。可以通过以下美国红十字会表格进行总结

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-

挑战

编写一个将血液类型作为输入并输出两个列表的函数或程序：

1. 可能会收到输入类型的捐赠的类型的无序列表
2. 可能会捐赠输入类型的无序类型列表

如果您编写了一个函数，那么还请提供一个测试程序来调用该函数并提供一些示例，以便我可以轻松地对其进行测试。在这种情况下，测试程序将不会计入您的分数。

输入项

输入的字符串必须恰好代表8种可能的红细胞类型之一O− O+ A− A+ B− B+ AB− AB+。输入可以通过常规方法（STDIN，命令行参数，函数参数等）给出。

如果给出任何其他输入，则程序/函数必须返回空输出或引发错误。通常，严格的输入检查在代码高尔夫球问题中并不好，但是我认为鉴于弄错血型对生命的影响，我应该添加此规则。

输出量

输出将是两个人类可读的血液类型列表，其格式适合您的语言。在输出列表之一包含所有8种类型的特殊情况下，可以选择将该列表替换为包含的单个项目列表everyone。

正常输出将转到正常位置之一（STDOUT，函数返回等）。

其他规定

• 禁止标准漏洞
• 您可以使用所需的任何现有第三方库，只要它们不是为此目的而明确设计的。

例子

• 对于input AB-，两个输出列表将是：{AB+, AB-}, {AB-, A-, B-, O-}
• 对于input AB+，两个输出列表将是：{AB+}, {O−, O+, A−, A+, B−, B+, AB−, AB+}或{AB+}, {everyone}

_{个人说明：如果可以的话，请考虑献血。如果没有几年前的输血，今天我可能不在这里，所以我对那些能够捐款的人感到非常感谢！}

剪辑，69

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

输入： AB-

输出： {{"AB+", "AB-"}, {"A-", "B-", "AB-", "O-"}}

说明

如果所有的抗原都包含在血液中，x就会产生血型。程序将函数定义为是否可以赋予，并定义为类型列表。yxyFxyT

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

说明

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

在这里运行：http : //repl.it/e98/1

请注意，static必须将其添加到每个方法中才能从main方法中调用它们。

佩斯61 59 50

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

在这里运行。

说明：

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个字节

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

该m*:s部分来自Martin的CJam答案。（我还没有阅读其他部分。）

仍然会有一些严重的问题，因为他们永远无法确定两个列表的顺序。并且Block ArrayList &可能在更高版本的CJam中实现。

说明

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

松散：

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

测试功能：

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

将血液类型编码为二进制具有以下优点：只需添加另一位，即可轻松地将另一种抗原（例如Kell抗原）并入代码中。

在瑞士苏黎世捐赠血液：BlutspendeZürich

CJam，94个字节

哇，这很长……虽然我认为我可能会在80以下打高尔夫球，但我想我可能会做得更好，首先计算矩阵，然后简单地选择正确的行和列。无论如何，这里是：

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

在这里测试。

打完高尔夫球后，我会加一个解释。

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

想法是将A，B和恒流因数分别编码为一位。然后，我们可以反转这些位，以在接收侧获得所有抗原，并使用它来检查在提供侧没有相应的抗体。这与现有的JavaScript解决方案大致相同。

样本执行

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，119110字节

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

备注：

1. 血液类型具有以下属性：每次有 -（例如a-），你可以给同样的人作为一个谁拥有你的小组正当量（例如a），以及它们的负对手（如a给予ab，所以a-给予ab和ab-）。基于此属性，并略微使用符号来使用减号和加号运算符，我们可以考虑很多情况。请告诉我您是否认为可以接受。如果您更喜欢使用原始（后缀）语法，请使用以下版本：

   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. 这是Prolog，因此交互式环境允许按要求查询所有内容（请参见下面的示例）。当然，我们没有严格意义上的列表作为输出，但这是等效的。因此，我们自然也可以处理错误情况。

例

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.

然后，我们执行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)])

...，如果没有正确设置格式，则与问题中给出的矩阵相同。

细节

谓词g/2是给定关系：g(X,Y)意味着X型血的人可以给Y型血的人献血。

查找组的接收者a：

[eclipse]: g(a,R).    

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

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

查找收件人orange_juice（应该失败）：

[eclipse] g(orange_juice,L).

No (0.00s cpu)

查找以下捐助者O-：

[eclipse] g(X,-o).

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

谁能给什么？：

[eclipse] g(X,Y).

.... 27 answers ....

我们不会进入无限递归循环（在初步测试中就是这种情况）。

Python，187个字节

不同的方法：

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]

可以打更多的高尔夫球。

测试：

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

输出：

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

红宝石，237 232 223 221 210 207字节

修复了正则表达式中的一些多余的反斜杠，并使其使其仅打印出列表，而不是将其存储到变量然后打印出来。有时，您在打高尔夫球时会错过一些显而易见的事情！

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

取消高尔夫：

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

基本上，我会为输入的血型构造一个自定义正则表达式，以检查您是否可以捐献给另一种血型。然后，我遍历血型并将相同的正则表达式应用于它们，并检查它们是否可以捐献给指定的一种。

这可能会打得更多。这是我第一次尝试打高尔夫球，呵呵。

Python 2，168字节

这与黑洞的答案相同。如果在类型列表中找不到参数，则退出并返回错误。

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]

少打高尔夫球：

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

在此处运行：http : //repl.it/eaB

我还尝试了一些其他的细微更改，但无法再缩短了...

#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字节）：

是的，这很长，但是可以正常使用。

可能会缩短很多时间：

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

这不容易阅读，也不容易编写。

它按预期工作，在另一行上输出您可以提供的内容和可以从中接收的内容。

这需要T=具有类型的URL参数。

CJam，80个字节

这仍然太长。大概我可以再减少4到5个字节。

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

对于任何无效的输入，要么输出一个空数组，要么抛出一个错误。

在此处在线尝试或运行整个测试套件

APL，66

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

在这里尝试。

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

去高尔夫显示：

/* 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字节

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

这是非高尔夫版本：

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

感谢manatwork节省了4个字节。

Perl中，107 112

最后用数字对类型名称进行编码，从而得到较短的代码。

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

旧版

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

佩思，58

与orlp的解决方案部分相同，但是有些不同并且完全是自行设计的。

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

说明

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字节

   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- 

输入无效时功能失败。大十进制数字是完整兼容性矩阵的编码。

（出于多种原因，很长的解决方案。）

在这里在线尝试。

05AB1E，29个字节

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

在线尝试！