血型遗传

复制def possible_blood_types(parent_a: str, parent_b: str) -> list:
    """根据父母血型推断子女可能血型。"""
    # 血型基因型映射：A型=AA/AO, B型=BB/BO, O型=OO, AB型=AB
    genotypes = {
        'A': ['AA', 'AO'],
        'B': ['BB', 'BO'],
        'O': ['OO'],
        'AB': ['AB']
    }
    
    if parent_a not in genotypes or parent_b not in genotypes:
        raise ValueError("血型必须为 A, B, O, AB 之一")
    
    possible = set()
    for g1 in genotypes[parent_a]:
        for g2 in genotypes[parent_b]:
            # 每个亲本贡献一个等位基因
            for allele1 in g1:
                for allele2 in g2:
                    child = ''.join(sorted(allele1 + allele2))
                    # 基因型转血型
                    if child == 'AA' or child == 'AO':
                        possible.add('A')
                    elif child == 'BB' or child == 'BO':
                        possible.add('B')
                    elif child == 'AB':
                        possible.add('AB')
                    else:  # OO
                        possible.add('O')
    return sorted(possible)

# 示例
print(possible_blood_types('A', 'B'))   # ['A', 'AB', 'B', 'O']
print(possible_blood_types('O', 'AB'))  # ['A', 'B']

复制package main

import (
	"fmt"
	"sort"
)

// 血型基因型映射
var genotypes = map[string][]string{
	"A":  {"AA", "AO"},
	"B":  {"BB", "BO"},
	"O":  {"OO"},
	"AB": {"AB"},
}

func possibleBloodTypes(parentA, parentB string) []string {
	ga, okA := genotypes[parentA]
	gb, okB := genotypes[parentB]
	if !okA || !okB {
		panic("血型必须为 A, B, O, AB 之一")
	}

	set := make(map[string]bool)
	for _, g1 := range ga {
		for _, g2 := range gb {
			for _, a1 := range g1 {
				for _, a2 := range g2 {
					child := string([]rune{a1, a2})
					// 排序确保一致
					if child[0] > child[1] {
						child = string([]rune{child[1], child[0]})
					}
					switch child {
					case "AA", "AO":
						set["A"] = true
					case "BB", "BO":
						set["B"] = true
					case "AB":
						set["AB"] = true
					default: // OO
						set["O"] = true
					}
				}
			}
		}
	}

	result := make([]string, 0, len(set))
	for k := range set {
		result = append(result, k)
	}
	sort.Strings(result)
	return result
}

func main() {
	fmt.Println(possibleBloodTypes("A", "B"))  // [A AB B O]
	fmt.Println(possibleBloodTypes("O", "AB")) // [A B]
}

复制/**
 * 根据父母血型推断子女可能血型
 * @param {string} parentA - 父/母血型 (A/B/O/AB)
 * @param {string} parentB - 另一亲本血型
 * @returns {string[]} 可能的血型列表（排序后）
 */
function possibleBloodTypes(parentA, parentB) {
    const genotypes = {
        'A': ['AA', 'AO'],
        'B': ['BB', 'BO'],
        'O': ['OO'],
        'AB': ['AB']
    };

    if (!genotypes[parentA] || !genotypes[parentB]) {
        throw new Error('血型必须为 A, B, O, AB 之一');
    }

    const possible = new Set();
    for (const g1 of genotypes[parentA]) {
        for (const g2 of genotypes[parentB]) {
            for (const a1 of g1) {
                for (const a2 of g2) {
                    const child = [a1, a2].sort().join('');
                    if (child === 'AA' || child === 'AO') possible.add('A');
                    else if (child === 'BB' || child === 'BO') possible.add('B');
                    else if (child === 'AB') possible.add('AB');
                    else possible.add('O'); // OO
                }
            }
        }
    }
    return [...possible].sort();
}

// 示例
console.log(possibleBloodTypes('A', 'B'));   // ['A', 'AB', 'B', 'O']
console.log(possibleBloodTypes('O', 'AB'));  // ['A', 'B']