वैम्पायर कम्पेटिबिलिटी

28

पिशाचों के बारे में एक छोटा ज्ञात तथ्य यह है कि उन्हें पीड़ित के रक्त को पीना चाहिए जिसमें एक संगत दाता रक्त प्रकार है। पिशाचों के लिए संगतता मैट्रिक्स नियमित लाल रक्त कोशिका दाता / प्राप्तकर्ता मैट्रिक्स के समान है । इसे निम्नलिखित अमेरिकी रेड क्रॉस तालिका द्वारा संक्षेपित किया जा सकता है 

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, फ़ंक्शन रिटर्न, आदि) में से एक में जाएगा।

अन्य नियम

  • मानक खामियों पर रोक लगाई जाती है
  • आप जो भी पहले से मौजूद 3 पार्टी लाइब्रेरी की आवश्यकता हो, का उपयोग कर सकते हैं, जब तक कि वे इस उद्देश्य के लिए स्पष्ट रूप से डिज़ाइन नहीं किए गए हैं।

उदाहरण

  • इनपुट के लिए AB-, दो आउटपुट लिस्ट होंगी:{AB+, AB-}, {AB-, A-, B-, O-}
  • इनपुट के लिए AB+, दो आउटपुट सूचियाँ होंगी: {AB+}, {O−, O+, A−, A+, B−, B+, AB−, AB+}या{AB+}, {everyone}

व्यक्तिगत नोट: यदि आप करने में सक्षम हैं तो कृपया रक्त दान करने पर विचार करें। कुछ साल पहले मिले आधान के बिना, मैं आज यहां नहीं हो सकता, इसलिए मैं उन लोगों के प्रति बहुत आभारी हूं जो दान करने में सक्षम हैं!

code-golf  combinatorics  bitwise 
— डिजिटल आघात
स्रोत
@ मार्टिनबटनर वास्तव में मैं दोनों को स्वीकार करूंगा। सबसे अधिक संभावना है कि दूसरा फ़ॉर्म अधिकांश भाषाओं में कम कोड का उत्पादन करेगा, लेकिन शायद कुछ विशेष मामले होंगे जहां पहले फ़ॉर्म का उपयोग कम हो सकता है।
— डिजिटल ट्रामा
3
— डिजिटल ट्रामा
1
— काउंटरक्लेविस
1
@leftaroundabout थैंक्स - ए बिट ऑफ़ फ्राई और लॉरी हमेशा से मेरी पसंदीदा रही है!
— डिजिटल ट्रामा
1
एक picky पिशाच, एह? ड्रैकुला अपने कास्केट में बदल रहा है। इसके अलावा, शीर्षक एक सेवानिवृत्त गोथ-रॉक-बैंड के नाम की तरह लगता है।
— रेने लिडर

जवाबों:

9

क्लिप , 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 -.
— Ypnypn
स्रोत
6

जावा 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उन्हें मुख्य विधि से कॉल करने के लिए प्रत्येक विधि में जोड़ा जाना था।

— Ypnypn
स्रोत
2
मैंने आपके लिए आसानी से चलने वाले प्रोग्राम का लिंक जोड़ा। अन्य इनपुट्स के आउटपुट को देखने के लिए मुख्य विधि में फ़ंक्शन कॉल के अंदर स्ट्रिंग पैरामीटर को संपादित करें।
— mbomb007
5

पायथ, 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).
— orlp
स्रोत
@ user23013 संपादन के लिए धन्यवाद। यह निश्चित रूप से कार्टेशियन होना चाहिए :)
— orlp
4

CJam, 64 बाइट्स

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

यह m*:sहिस्सा मार्टिन के सीजेएम उत्तर से आया है । (मैंने अन्य भागों को अभी तक नहीं पढ़ा है।)

अभी भी कुछ गंभीर समस्याएं होंगी क्योंकि वे दो सूचियों के आदेश के बारे में निश्चित नहीं होंगे। और 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. ";
}/
— jimmy23013
स्रोत
3

जावास्क्रिप्ट, 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"))
}

बाइनरी में रक्त के प्रकार को एन्कोडिंग करने से यह फायदा होता है कि एक और एंटीजन (जैसे केल एंटीजन ) को आसानी से केवल थोड़ा सा जोड़कर कोड में शामिल किया जाता है।

ज्यूरिख में रक्त दान करें, सीएच: ब्लटस्पेंड ज़्यूरिख़

— निकलस मेसरली
स्रोत
आप 2 वर्णों को सहेजने के "O-O+B-B+A-A+AB-AB+".match(/\w+\W/g)बजाय उपयोग कर सकते हैं "O- O+ B- B+ A- A+ AB- AB+".split(" ")।
— ओरिऑल
या आप सीमांकक को एक नंबर बनाकर ठीक उसी तरह से बचा सकते हैं "O-1O+1B-1B+1A-1A+1AB-1AB+".split(1)और =>फ़ंक्शन का उपयोग करके कुछ को भी बचा सकते हैं।
— लाल-एक्स
हां, लेकिन @ ओरोल को नियमित रूप से 1 चरित्र द्वारा नियमित अभिव्यक्ति में छोटा किया जा सकता है:/\w+./g
— मैनेटवर्क
हमेशा (;;) के बजाय समय का उपयोग करें ()। कम से कम समान लंबाई, लेकिन कम हो सकती है। n=2;while(n--)=>for(n=2;n--;)
— edc65
सब सब में, बहुत चालाक। मानक गोल्फ ट्रिक्स का उपयोग करके 147 को छोटा किया जा सकता है:http://jsfiddle.net/j2hep8e8/2/
— edc65
2

सीजेएम, 94 बाइट्स

वाह, यह लंबा है ... जबकि मुझे लगता है कि मैं शायद 80 के नीचे इस दृष्टिकोण को गोल्फ कर सकता हूं, मुझे लगता है कि मैंने पहले मैट्रिक्स की गणना करके और फिर सही पंक्ति और कॉलम को उठाकर बेहतर प्रदर्शन किया होगा। वैसे भी, यहाँ यह है:

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

इसका परीक्षण यहां करें।

जब मैं गोल्फ कर रहा होता हूँ तो एक स्पष्टीकरण जोड़ देता हूँ।

— मार्टिन एंडर
स्रोत
2

ग्रूवी, 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)}]]}

विचार ए, बी और रीसस कारक को एक बिट के रूप में सांकेतिक शब्दों में बदलना है। फिर हम बिट्स को उल्टे करने के लिए प्राप्त करने वाले पक्ष पर सभी एंटीजन प्राप्त कर सकते हैं और यह जांचने के लिए उपयोग कर सकते हैं कि दिए गए पक्ष पर कोई संबंधित एंटीबॉडी नहीं है। यह मौजूदा जावास्क्रिप्ट समाधान के समान ही है।

नमूना निष्पादन

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-]]
[]
— n̴̖̋h̷͉a̷̭̿h̸̡̅ẗ̵̨d̷̰ĥ̷̳
स्रोत
2

प्रोलॉग, 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. यह प्रोलॉग है, इसलिए इंटरैक्टिव वातावरण अनुरोध के अनुसार सब कुछ क्वेरी करने की अनुमति देता है (नीचे उदाहरण देखें)। दी, हमारे पास आउटपुट के रूप में कड़ाई से सूचियां नहीं हैं, लेकिन यह समकक्ष है। हम स्वाभाविक रूप से भी त्रुटि के मामलों को एक परिणाम के रूप में संभालते हैं।

उदाहरण

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)साधन ब्लड ग्रुप एक्स के लोगों के ब्लड ग्रुप वाई के लोगों के लिए रक्त दे सकते हैं ।

समूह के लिए रिसीवर खोजें 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 ....

हम एक अनंत पुनरावर्तन पाश में नहीं जाते हैं (यह प्रारंभिक परीक्षणों में मामला था)।

— कोर निपात
स्रोत
1

पायथन, 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
— Claudiu
स्रोत
1

रूबी, 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;

मूल रूप से, मैं रक्त की जांच के लिए एक कस्टम रेगुलर एक्सप्रेशन का निर्माण करता हूं ताकि आप दूसरे ब्लड ग्रुप को दान कर सकें। मैं फिर रक्त प्रकार के माध्यम से पुनरावृत्ति करता हूं और उसी रेगेक्स को उन पर लागू करता हूं और जांचता हूं कि क्या वे निर्दिष्ट एक को दान कर सकते हैं।

यह शायद और भी नीचे गोल्फ हो सकता है। यह मेरी पहली बार कोड गोल्फ, हेह का प्रयास है।

— Mewy
स्रोत
1

पायथन 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)]
— mbomb007
स्रोत
1

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 पैरामीटर की आवश्यकता होती है ।

— इस्माइल मिगुएल
स्रोत
1

सीजेएम, 80 बाइट्स

यह अभी भी बहुत लंबा है। संभवत: मैं 4 से 5 बाइट्स और अधिक शेव कर सकता हूं।

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

किसी भी अमान्य इनपुट के लिए, या तो एक खाली सरणी प्रिंट करता है, या एक त्रुटि फेंकता है।

इसे यहाँ ऑनलाइन आज़माएं या पूरे परीक्षण सूट को चलाएं

— अनुकूलक
स्रोत
क्या भीख मांगने में एक्सकेसीडी है?
— य्प्निपन
@ यिप्पन भीख माँग रहा है? शुरू में मेरा इरादा नहीं था, लेकिन यह इस तरह से बदल गया। शायद दुनिया हमें कुछ बताने की कोशिश कर रही है ...
— ऑप्टिमाइज़र
क्षमा करें, मेरा मतलब था शुरुआत ।
— यपनीपं
1

एपीएल, 66

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

इसे यहाँ आज़माएँ।

— jimmy23013
स्रोत
हो सकता है कि वह 66 अक्षर का हो, लेकिन निश्चित रूप से 66 बाइट्स नहीं। सवाल यह नहीं कहता कि स्कोर करने के लिए क्या उपयोग किया जाता है।
— orlp
1
@orlp कोड-गोल्फ डिफ़ॉल्ट रूप से बाइट्स में रन किया जाता है ( टैग विकी देखें )। लेकिन यह कहा जाता है कि एक एपीएल कोड पृष्ठ है जहां एक चरित्र एक बाइट है। मुझे नहीं पता कि आजकल कौन सा एपीएल कोड पेज इस्तेमाल किया जाता है।
— jimmy23013
@orlp "बाइट्स", लेकिन "यूटीएफ -8 बाइट्स" नहीं। यहाँ एक कोड पेज है जिसमें ये सभी अक्षर हैं।
— मार्टिन एंडर
1

सी, 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(|)
}
— pawel.boczarski
स्रोत
1

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

यहाँ ungolfed संस्करण है:

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 बाइट बचाने के लिए मैनटवर्क का धन्यवाद ।

— ब्लैक होल
स्रोत
पूर्णांक चाल से विभाजन PHP में भी काम करता है explode(1,'A+1O+1B+1AB+1A-1O-1B-1AB-'):। और जैसा कि हम जरूरी नहीं कि अच्छी कोडिंग की आदतों के साथ रहते हैं, कभी-कभी हम split()फ़ंक्शन की तरह हटाए गए सुविधाओं का उपयोग करते हैं।
— मैनेटवर्क
@manatwork अच्छी तरह से देखा! मैंने अपना उत्तर संपादित कर दिया है, धन्यवाद।
— ब्लैकहोल
0

पर्ल, 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
— nutki
स्रोत
0

पायथ, ५th

आंशिक रूप से ऑर्लप के समाधान के समान है , लेकिन कुछ अलग और पूरी तरह से स्व-डिज़ाइन किया गया है।

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)
— PurkkaKoodari
स्रोत
0

जे, 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-

अमान्य इनपुट पर फ़ंक्शन विफल हो जाता है। बड़ी दशमलव संख्या पूर्ण संगतता मैट्रिक्स की एन्कोडिंग है।

(कई कारणों से बहुत लंबा समाधान।)

इसे यहाँ ऑनलाइन आज़माएँ।

— randomra
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.