ข้อเท็จจริงที่ทราบกันเล็กน้อยเกี่ยวกับแวมไพร์คือพวกเขาต้องดื่มเลือดของเหยื่อที่มีกรุ๊ปเลือดของผู้บริจาค เมทริกซ์เข้ากันได้สำหรับแวมไพร์เป็นเช่นเดียวกับปกติสีแดงเม็ดเลือดบริจาค / ผู้รับเมทริกซ์ สามารถสรุปได้ดังต่อไปนี้ตาราง American Red Cross

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, args บรรทัดคำสั่ง args ฟังก์ชั่น ฯลฯ )

หากมีการป้อนข้อมูลอื่น ๆ โปรแกรม / ฟังก์ชั่นจะต้องส่งคืนเอาต์พุตเปล่าหรือเกิดข้อผิดพลาด ปกติการตรวจสอบอินพุตอย่างเข้มงวดนั้นไม่ดีในการเขียนโค้ดกอล์ฟคำถามเกี่ยวกับแต่ฉันรู้สึกว่าได้รับผลกระทบจากความตายของการกรุ๊ปเลือดผิดที่ฉันควรเพิ่มกฎนี้

เอาท์พุต

เอาต์พุตจะเป็นรายการกรุ๊ปเลือดสองแบบที่มนุษย์อ่านได้ในรูปแบบใดก็ตามที่เหมาะกับภาษาของคุณ ในกรณีพิเศษที่หนึ่งในรายการผลลัพธ์มีทั้งหมด 8 ชนิดรายการนี้อาจถูกแทนที่ด้วยรายการในรายการเดียวที่มีeveryoneประเภทรายการนี้อาจเลือกที่จะแทนที่ด้วยรายการรายการเดียวที่มี

เอาท์พุทปกติจะไปที่หนึ่งในสถานที่ปกติ (STDOUT ฟังก์ชั่นกลับมา ฯลฯ )

กฎอื่น ๆ

• ช่องโหว่มาตรฐานถูกแบน
• คุณอาจใช้ไลบรารีบุคคลที่สามใด ๆ ที่มีอยู่ก่อนที่คุณต้องการตราบใดที่ไลบรารีเหล่านั้นไม่ได้ออกแบบมาอย่างชัดเจนเพื่อจุดประสงค์นี้

ตัวอย่าง

• สำหรับอินพุตAB-ทั้งสองรายการเอาต์พุตจะเป็น:{AB+, AB-}, {AB-, A-, B-, O-}
• สำหรับอินพุต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สามารถให้ได้yถ้าxมีแอนติเจนทั้งหมดรวมอยู่yด้วย โปรแกรมกำหนดฟังก์ชั่นFว่าxจะให้yและTเป็นรายการประเภท

*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จะต้องมีการเพิ่มในแต่ละวิธีเพื่อเรียกใช้จากวิธีหลัก

Pyth, 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ส่วนหนึ่งมาจากมาร์ตินคำตอบ 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}

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

ฟังก์ชั่นการทดสอบ:

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 ) จะถูกรวมเข้าไปในรหัสได้อย่างง่ายดายโดยเพียงแค่เพิ่มอีกบิต

บริจาคโลหิตที่เมืองซูริครัฐ CH: Blutspende Zü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-]]
[]

อารัมภบท, 119 110 ไบต์

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-) จากคุณสมบัตินี้และการใช้เครื่องหมายเล็กน้อยเพื่อใช้ประโยชน์จากเครื่องหมายลบและเครื่องหมายบวกเราสามารถคำนึงถึงกรณีจำนวนมาก กรุณาบอกฉันถ้าคุณพบว่ามันเป็นที่ยอมรับ หากคุณต้องการมีไวยากรณ์ (postfix) ดั้งเดิมต่อไปนี้เป็นเวอร์ชันที่ไม่ใช่กอล์ฟ:

   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 อาจให้เลือดแก่ผู้ที่มีกรุ๊ปเลือด YY

ค้นหาผู้รับสำหรับกลุ่ม 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

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

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;

โดยพื้นฐานแล้วฉันสร้างนิพจน์ปกติแบบกำหนดเองสำหรับกรุ๊ปเลือดที่ป้อนเพื่อตรวจสอบว่าคุณสามารถบริจาคให้กรุ๊ปเลือดอื่นได้หรือไม่ จากนั้นฉันก็ย้ำผ่านกรุ๊ปเลือดและใช้ regex เดียวกันกับพวกเขาและตรวจสอบว่าพวกเขาสามารถบริจาคให้กับที่ระบุไว้

สิ่งนี้อาจจะสามารถเล่นกอล์ฟได้มากยิ่งขึ้น นี่เป็นครั้งแรกที่ฉันพยายามเล่นกอล์ฟโคเฮ้

Python 2, 168 ไบต์

นี่เป็นวิธีการเดียวกับคำตอบของ Blackhole ออกโดยมีข้อผิดพลาดหากไม่พบพารามิเตอร์ในรายการประเภท

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

นี่ไม่ใช่เรื่องง่ายที่จะอ่านและไม่ใช่เรื่องง่ายที่จะเขียน

มันทำงานได้ตามที่ตั้งใจเอาท์พุทสิ่งที่คุณสามารถให้และสิ่งที่คุณสามารถได้รับจากในบรรทัดอื่น

สิ่งนี้ต้องการพารามิเตอร์ URL T=พร้อมกับประเภท

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

Pyth, 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~èê,

ลองออนไลน์!