Vampir-Kompatibilität

28

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 Fragen nicht besonders , 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!

Digitales Trauma
quelle
@ MartinBüttner Eigentlich werde ich beides akzeptieren. Höchstwahrscheinlich liefert das 2. Formular in den meisten Sprachen einen kürzeren Code, aber möglicherweise gibt es einen Sonderfall, in dem die Verwendung des ersten Formulars kürzer sein könnte.
Digital Trauma
3
Tangential verbunden - diese brillante Antwort worldbuilding.stackexchange.com/a/11203/2094
Digital Trauma
1
Diese Tatsache ist nicht so wenig bekannt .
drehte sich nicht mehr gegen den Uhrzeigersinn am
1
@leftaroundabout Danke - Ein bisschen Fry und Laurie war schon immer ein Favorit von mir!
Digital Trauma
1
Ein wählerischer Vampir, was? Dracula dreht sich in seinem Sarg um. Der Titel klingt auch wie der Name einer pensionierten Gothic-Rock-Band.
Renae Lider

Antworten:

9

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 -.
Ypnypn
quelle
6

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.

Ypnypn
quelle
2
Ich habe einen Link zu einem einfach zu bedienenden Programm hinzugefügt. Bearbeiten Sie den string-Parameter innerhalb des Funktionsaufrufs in der main-Methode, um die Ausgaben der anderen Eingänge anzuzeigen.
mbomb007
5

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).
orlp
quelle
@ user23013 Danke für die Bearbeitung. Es hätte definitiv kartesisch sein sollen :)
orlp
4

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. ";
}/
jimmy23013
quelle
3

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

Niklaus Messerli
quelle
Sie können "O-O+B-B+A-A+AB-AB+".match(/\w+\W/g)anstelle von "O- O+ B- B+ A- A+ AB- AB+".split(" ")2 Zeichen speichern.
Oriol,
Oder Sie können genau das Gleiche speichern, indem Sie das Trennzeichen zu einer Zahl machen "O-1O+1B-1B+1A-1A+1AB-1AB+".split(1)und mit der =>Funktion auch eine Zahl speichern.
Red-X
Ja, aber @ Oriol's kann im regulären Ausdruck um 1 Zeichen weiter gekürzt werden:/\w+./g
manatwork
Verwenden Sie immer für (;;) anstelle von while (). Mindestens gleich lang, kann aber kürzer sein. n=2;while(n--)=>for(n=2;n--;)
edc65
Alles in allem sehr schlau. Kann mit Standardgolf-Tricks auf 147 verkürzt werden:http://jsfiddle.net/j2hep8e8/2/
edc65
2

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.

Martin Ender
quelle
2

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-]]
[]
n̴̖̋h̴̖̋ã̷͉h̷̭̿d̷̰̀ĥ̷̳
quelle
2

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

Core-Dump
quelle
1

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
Claudiu
quelle
1

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.

Mewy
quelle
1

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)]
mbomb007
quelle
1

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.

Ismael Miguel
quelle
1

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

Optimierer
quelle
Ist die XKCD im Betteln gedacht?
Ypnypn
@Ypnypn betteln? Das hatte ich anfangs nicht vor, aber es stellte sich so heraus. Vielleicht versucht die Welt, uns etwas zu sagen ...
Optimierer
Entschuldigung, ich wollte anfangen .
Ypnypn
1

APL, 66

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

Probieren Sie es hier aus.

jimmy23013
quelle
Vielleicht sind das 66 Zeichen, aber definitiv nicht 66 Bytes. Die Frage sagt jedoch nichts darüber aus, was für ein Tor verwendet wird.
Orlp
1
@orlp Code-Golf wird standardmäßig in Bytes gewertet (siehe das Tag-Wiki ). Es wird jedoch gesagt, dass es eine APL-Codepage gibt, bei der ein Zeichen ein Byte ist. Ich weiß jedoch nicht genau, welche APL-Codepage heutzutage verwendet wird.
Jimmy23013
@orlp "Bytes", aber nicht "UTF-8 Bytes". Hier ist eine Codepage, die alle diese Zeichen enthält.
Martin Ender
1

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(|)
}
pawel.boczarski
quelle
1

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.

Schwarzes Loch
quelle
Die Spaltung von Integer - Trick funktioniert in PHP zu: explode(1,'A+1O+1B+1AB+1A-1O-1B-1AB-'). Und da wir nicht unbedingt mit guten Codierungsgewohnheiten Schritt halten müssen, verwenden wir manchmal veraltete Features wie die split()Funktion.
Manatwork
@manatwork Gut gesehen! Ich habe meine Antwort bearbeitet, danke.
Blackhole
0

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
nutki
quelle
0

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)
PurkkaKoodari
quelle
0

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.

randomra
quelle