Маловідомий факт про вампірів - це те, що вони повинні пити кров жертви, яка має сумісну групу крові донора. Матриця сумісності для вампірів така сама, як і для матриці донора / реципієнта еритроцитів . Це можна підсумувати за допомогою таблиці Американського Червоного Хреста

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, повернення функції тощо).

Інші правила

• Стандартні лазівки заборонені
• Ви можете використовувати всі наявні сторонні бібліотеки, які вам потрібні, до тих пір, поки вони не будуть спеціально розроблені для цієї мети.

Приклади

• Для введення 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 -.

Ява 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потрібно було додати їх до кожного методу, щоб викликати їх із основного методу.

Піта, 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}

неозорений:

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

Перевірте це тут.

Я додам пояснення, коли закінчу гольф.

Гровий, 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-). Виходячи з цієї властивості і трохи зловживаючи позначеннями, щоб скористатися операторами мінус і плюс, ми можемо визначити безліч випадків. Скажіть, будь ласка, чи вважаєте ви це прийнятним . Якщо ви хочете мати оригінальний синтаксис (постфікс), ось версія, яка не використовується для гольфу:

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

Ми не йдемо в нескінченний цикл рекурсії (це було в попередніх тестах).

Пітон, 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'
';}

Це не легко читати і писати непросто.

Він працює за призначенням, виводячи ті, які ви можете надати, і ті, які ви можете отримати в іншому рядку.

Для цього потрібен параметр 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+'

Спробуйте тут.

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

Завдяки манатурності за економію 4 байт.

Перл, 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~èê,

Спробуйте в Інтернеті!