뱀파이어 호환성


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, 함수 반환 등) 중 하나로 이동합니다.

다른 규칙

  • 표준 허점 은 금지되어 있습니다
  • 이 목적을 위해 명시 적으로 설계되지 않은 한 기존의 타사 라이브러리를 사용할 수 있습니다.

  • input AB-의 경우 두 출력 목록은 다음과 같습니다.{AB+, AB-}, {AB-, A-, B-, O-}
  • input AB+의 경우 두 출력 목록은 다음과 같습니다. {AB+}, {O−, O+, A−, A+, B−, B+, AB−, AB+}또는{AB+}, {everyone}

개인 참고 사항 : 가능하면 헌혈을 고려하십시오. 수년 전에받은 수혈이 없으면 오늘 여기에 없을 수도 있기 때문에 기부 할 수있는 사람들에게 매우 감사합니다!


@ MartinBüttner 사실 둘 다 받아들입니다. 대부분의 언어에서 두 번째 형식은 더 짧은 코드를 생성하지만 첫 번째 형식을 사용하는 것이 더 짧은 특수한 경우가있을 수 있습니다.
Digital Trauma

3
탄젠트 관련-이 훌륭한 답변 worldbuilding.stackexchange.com/a/11203/2094
Digital Trauma


1
@leftaroundabout 감사합니다-A Bit of Fry와 Laurie는 항상 내 마음에 드는 사람이었습니다!
Digital Trauma

1
까다로운 뱀파이어? 드라큘라는 그의 관을 돌리고있다. 또한 제목은 은퇴 한 고트 락 밴드의 이름처럼 들립니다.
Renae Lider

답변:


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

설명

혈액형 xy모든 x항원이 포함되어 있으면 줄 수 있습니다 y. 프로그램은 함수 F를에 x제공 할 수 있는지 여부 yT유형 목록으로 정의합니다.

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

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했다가 main 메소드에서 호출하는 각각의 방법에 추가 할 수 있습니다.


2
쉽게 실행할 수있는 프로그램에 대한 링크를 추가했습니다. main 메소드의 함수 호출 내에서 문자열 매개 변수를 편집하여 다른 입력의 출력을보십시오.
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).

@ user23013 편집 해 주셔서 감사합니다. 확실히 직교해야 했어요 :)
orlp

4

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

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}

언 골프 :

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


"O-O+B-B+A-A+AB-AB+".match(/\w+\W/g)대신 "O- O+ B- B+ A- A+ AB- AB+".split(" ")2자를 저장할 수 있습니다 .
Oriol

또는 구분 기호를 숫자로 지정 "O-1O+1B-1B+1A-1A+1AB-1AB+".split(1)하고 =>함수를 사용하면 일부를 저장 하여 정확히 동일하게 저장할 수 있습니다.
red-X

예, 그러나 @ Oriol 's는 정규 표현식에서 1 문자 씩 더 단축 될 수 있습니다./\w+./g
manatwork

while () 대신 항상 for (;;)를 사용하십시오. 최소한 같은 길이이지만 짧을 수 있습니다. n=2;while(n--)=>for(n=2;n--;)
edc65

대체로 매우 영리합니다. 표준 골프 트릭을 사용하여 147로 단축 할 수 있습니다.http://jsfiddle.net/j2hep8e8/2/
edc65

2

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

아이디어는 A, B 및 붉은 털 인자를 각각 1 비트로 인코딩하는 것입니다. 그런 다음 비트를 뒤집어 수신 측의 모든 항원을 가져 와서주는 측에 해당하는 항체가 없는지 확인하는 데 사용할 수 있습니다. 기존 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-]]
[]

2

프롤로그, 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-에 제공 abab-). 이 속성을 기반으로 마이너스 및 더하기 연산자를 사용하기 위해 표기법을 약간 남용하면 많은 경우를 고려할 수 있습니다. 당신이 그것을 받아 들일 경우 알려주세요 . 원래 (접두어) 구문을 선호하는 경우 다음은 골프 용이 아닌 버전입니다.

    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주기 관계입니다 : 혈액형 X의 사람들이 혈액형 Y의 사람들에게 혈액을 줄 수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

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

언 골프 드 :

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

기본적으로 다른 혈액형에 기증 할 수 있는지 확인하기 위해 입력 한 혈액형에 대한 사용자 정의 정규식을 구성합니다. 그런 다음 혈액 유형을 반복하고 동일한 정규 표현식을 적용하고 지정된 유형에 기부 할 수 있는지 확인합니다.

이것은 아마도 더 많이 골프 다운 될 수 있습니다. 코드 골프를 시도한 것은 이번이 처음이다.


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

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

CJam, 80 바이트

아직 너무 깁니다. 아마도 4 ~ 5 바이트를 더 깎을 수 있습니다.

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

유효하지 않은 입력의 경우 빈 배열을 인쇄하거나 오류를 발생시킵니다.

여기에서 온라인으로 시도 하거나 전체 테스트 스위트를 실행하십시오.


구걸의 XKCD는 의도 된 것입니까?
Ypnypn

@Ypnypn 구걸? 나는 처음에 그것을 의도하지 않았지만 그것은 그렇게 밝혀졌습니다. 아마도 세상이 우리에게 무언가를 말하려고 할 것입니다.
Optimizer

죄송합니다 . 시작을 의미했습니다 .
Ypnypn

1

APL, 66

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

여기에서 시도하십시오.


아마도 66 자이지만 66 바이트는 아닙니다. 이 질문에는 점수를 매기는 데 사용 된 내용이 나와 있지 않습니다.
orlp

1
@orlp code-golf 는 기본적으로 바이트 단위로 점수가 매겨집니다 ( wiki 태그 참조 ). 그러나 한 문자가 1 바이트 인 APL 코드 페이지가 있다고합니다. 그러나 현재 어떤 APL 코드 페이지가 사용되는지 정확히 알지 못합니다.
jimmy23013

@orlp는 "바이트"이지만 "UTF-8 바이트"는 아닙니다. 다음은 이러한 모든 문자가 포함 된 코드 페이지 입니다.
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(|)}

탈 골프는 다음을 보여줍니다.

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

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 바이트 절약을위한 manatwork 덕분 입니다.


정수로 나누는 트릭은 PHP에서도 작동합니다 explode(1,'A+1O+1B+1AB+1A-1O-1B-1AB-'). 그리고 우리는 반드시 좋은 코딩 습관을 따라야 할 필요가 없기 때문에 때때로 split()함수 와 같은 더 이상 사용되지 않는 기능을 사용 합니다.
manatwork

@manatwork 잘 발견되었습니다! 답변을 편집했습니다. 감사합니다.
Blackhole

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

0

피시스, 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)

0

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- 

유효하지 않은 입력에서 기능이 실패합니다. 큰 십진수는 전체 호환성 매트릭스의 인코딩입니다.

여러 가지 이유로 매우 긴 솔루션입니다.

여기에서 온라인으로 사용해보십시오.


당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.