有关

什么可以分配给什么？

在本次挑战中，您将获得两种类型，A并B确定A是可分配给B，B可分配给A还是都不分配。

类型系统

（我将t用来表示任何类型）

基本类型

基本类型用单个大写字母表示，例如X。它们基本上是类。

• X是分配给Y如果Y是任一相同，或父类X。

交叉点类型

交集类型由表示intersect<X, Y>，并且在之间可以具有任意数量的类型<（例如intersect<X, Y, Z, D, E>）。

• t可以分配给intersect<X1, X2... Xn>if t可以分配给all X。
• intersect<X1, X2... Xn>是分配给t如有X可分配给t。

联合类型

联合类型由表示，union<X, Y>并且之间可以有任意多种类型<（例如union<X, Y, Z, D, E>）。

• t可分配给union<X1, X2... Xn>if t，可分配给any X。
• union<X1, X2... Xn>t如果所有X都可分配给，则可分配给t。

输入值

您将收到以下输入：

• 类层次结构。您可以为类层次结构选择输入方法。您可以输入树的表示形式，或者输入每种类型的树及其父级列表，或者输入任何其他能准确表示类层次结构的形式。
• 两种类型（输入是灵活的，只要符号一致，您就可以随意接收这些类型）。

输出量

您将在三个一致和不同值的输出之一，给他们打电话X，Y和Z。鉴于两种类型A和B输出X，如果A是分配给B输出Y，如果B是分配给A和输出Z，否则（如果A是分配给B和B可分配给A，你可以输出X，Y，这两者或第四值）。

测试用例

格式：

# of types
[type, parents...]
[type, parents...]
Type a
Type b

2
[A,B]
[B]
A
B
--
A is assignable to B


3
[A,B,C]
[B,C]
[C]
intersect<A,C>
A
--
A is assignable to intersect<A,C>


3
[A,B,C]
[B,C]
[C]
union<A,C>
A
--
A is assignable to union<A,C>


3
[A,B,C]
[B,C]
[C]
intersect<B,C>
A
--
A is assignable to intersect<B,C>


3
[A,B,C]
[X,Y,Z]
[T,U,V]
intersect<union<A,T,X>,intersect<A,B>,Y>
intersect<T,C,X>
--
intersect<T,C,X> and intersect<union<A,T,X>,intersect<A,B>,Y> are not assignable to each other    

1
[A]
A
A
--
A is assignable to A


3
[A,B,C]
[X,Y,Z]
[T,U,V]
intersect<A,intersect<A,B>,Y>
intersect<T,C,X>
--
intersect<T,C,X> and intersect<A,intersect<A,B>,Y> are not assignable to each other


2
[A]
[B]
A
B
--
B and A are not assignable to each other

3
[A,B,C]
[X,Y,Z]
[T,U,V]
intersect<union<A,X>,intersect<A,B>,Y>
intersect<T,C,X>
--
intersect<T,C,X> and intersect<union<A,X>,intersect<A,B>,Y> are not assignable to each other

这是可用于测试的未解决的Java解决方案的链接（它以与测试用例相同的方式接受输入）

这是代码高尔夫球，因此每种语言中最少的字节会赢得该语言！

Python 3，177字节

c是每种类型的父母的字典，a并且b是要检查的两个表达式。类型由字符串表示，而相交和并集由带有表达式的列表表示，第一个元素设置0为相交和并1集

返回0它们是否彼此不能分配，1是否a可以分配给b，2是否b可以分配给a以及3是否两者都可以分配给对方

lambda c,a,b:y(a,b,c)+2*y(b,a,c)
y=lambda a,b,c:(b in c[a]or a==b if b[0]in c else[all,any][b[0]](y(a,x,c)for x in b[1:]))if a[0]in c else[any,all][a[0]](y(x,b,c)for x in a[1:])

在线尝试！

JavaScript（ES6），138个字节

(p,a,b,g=(a,b)=>a==b||(p[a]||a.i||a.u||[])[a.u?'every':'some'](t=>g(t,b))||(b.i||b.u||[])[b.i?'every':'some'](t=>g(a,t)))=>g(a,b)||+g(b,a)

p是父级映射，它是一个JavaScript对象，其键是具有父级的类型，其值是父级数组。例如，如果存在两种类型的A和B和B是的父A然后p将{A:['B']}。

交集类型以JavaScript对象表示，a并b作为JavaScript对象，i其键值为一个类型数组，而联合类型的键为u。例如，两种类型的交叉点A和B将是{i:['A','B']}。

返回值是trueif a可以分配给b，1if a不能分配给b而是b分配给a，或者0两者都不可以分配给彼此。

C ++ 17，595个字节

#include<type_traits>
#define p(x)template<class...T>class x;
#define d(a,b)disjunction<s<a,b>...>{};
#define c(a,b)conjunction<s<a,b>...>{};
#define u(x)u<x...>
#define i(x)i<x...>
#define k struct s
#define e ...A
#define t(a,b)template<class a,class b>
using namespace std;p(i)p(u)t(B,D)k:disjunction<is_base_of<B,D>,is_same<B,D>>{};t(a,e)k<a,u(A)>:d(a,A)t(a,e)k<a,i(A)>:c(a,A)t(a,e)k<u(A),a>:c(A,a)t(a,e)k<i(A),a>:d(A,a)t(e,...B)k<i(A),i(B)>:d(A,i(B))t(e,...B)k<u(A),u(B)>:c(A,u(B))t(e,...B)k<i(A),u(B)>:d(A,u(B))t(e,...B)k<u(A),i(B)>:c(A,u(B))t(A,B)int f=s<A,B>::value?-1:s<B,A>::value?1:0;

在线尝试！

一种可变模板f接受作为输入某些类型和路口i<...>或联合u<...>他们的并返回-1，如果A是分配给B 和1如果B是分配给A和0其他。

取消高尔夫：

#include <type_traits>
using namespace std;

template<class...T>class Intersect;
template<class...T>class Union;

template<class A,class B>
struct is_assignable_to:
    disjunction<is_base_of<A,B>,is_same<A,B>>{};

template<class a,class...A>
struct is_assignable_to<a,Union<A...>>:
    disjunction<is_assignable_to<a,A>...>{};

template<class a,class...A>
struct is_assignable_to<a,Intersect<A...>>:
    conjunction<is_assignable_to<a,A>...>{};

template<class a,class...A>
struct is_assignable_to<Union<A...>,a>:
    conjunction<is_assignable_to<A,a>...>{};

template<class a,class...A>
struct is_assignable_to<Intersect<A...>,a>:
    disjunction<is_assignable_to<A,a>...>{};

template<class...A,class...B>
struct is_assignable_to<Intersect<A...>,Intersect<B...>>:
    disjunction<is_assignable_to<A,Intersect<B...>>...>{};

template<class...A,class...B>
struct is_assignable_to<Union<A...>,Union<B...>>:
    conjunction<is_assignable_to<A,Union<B...>>...>{};

template<class...A,class...B>
struct is_assignable_to<Intersect<A...>,Union<B...>>:
    disjunction<is_assignable_to<A,Union<B...>>...>{};

template<class...A,class...B>
struct is_assignable_to<Union<A...>,Intersect<B...>>:
    conjunction<is_assignable_to<A,Intersect<B...>>...>{};

template <class A,class B>
int f = is_assignable_to<A,B>::value?-1:is_assignable_to<B,A>::value?1:0;

用法：

#include <iostream>
int main(){
    struct B{};
    struct C{};
    struct Y{};
    struct Z{};
    struct U{};
    struct V{};
    struct A:B,C{};
    struct X:Y,Z{};
    struct T:U,V{};
    std::cout << f<Intersect<A,Intersect<A,B>,Y>,Union<T,C,X>>; 
}