verbunden

Was ist was zuzuordnen?

In dieser Herausforderung werden Sie zwei Arten gegeben werden, Aund Bund bestimmen , ob Azu zuweisbaren ist B, Bist zuordenbar Aoder keines von beiden.

Das Typsystem

(Ich werde verwenden t, um jeden Typ darzustellen)

Grundtypen

Grundtypen werden durch einen einzelnen Großbuchstaben dargestellt, z X. Sie sind im Grunde Klassen.

• Xist zuweisbar, Ywenn Yentweder die gleiche oder eine übergeordnete Klasse von ist X.

Schnittpunkttypen

Schnittpunkttypen werden durch dargestellt intersect<X, Y>und können eine beliebige Anzahl von Typen zwischen den <'s haben (z intersect<X, Y, Z, D, E>. B. ).

• tist zuweisbar, intersect<X1, X2... Xn>wenn tes allen zuweisbar ist X.
• intersect<X1, X2... Xn>ist zuweisbar, twenn eine Xzuweisbar ist t.

Unionstypen

Unionstypen werden durch union<X, Y>eine beliebige Anzahl von Typen zwischen den <'s (z union<X, Y, Z, D, E>. B. ) dargestellt und können diese haben .

• tist zuweisbar, union<X1, X2... Xn>wenn tes einer zuweisbar ist X.
• union<X1, X2... Xn>ist zuweisbar, twenn alle Xzuweisbar sind t.

Eingang

Sie erhalten als Eingabe:

• Die Klassenhierarchie. Sie können die Eingabemethode für die Klassenhierarchie auswählen. Sie können eine Darstellung eines Baums oder jedes Typs mit einer Liste seiner übergeordneten Elemente oder alles andere eingeben, das die Klassenhierarchie genau darstellt.
• Zwei Typen (Eingabe ist flexibel, solange die Notation konsistent ist, können Sie diese Typen erhalten, wie Sie möchten).

Ausgabe

Sie werden Ausgang einer von drei konsistenten und eindeutigen Werten, rufen sie X, Yund Z. Gegeben seien zwei Arten Aund der BAusgang , Xwenn Azu zuweisbaren ist B, ausgegeben , Ywenn Bist zuordenbar Aund Ausgang Zansonsten (Wenn Aist zuordenbar Bund Bist zuordenbar A, Sie ausgeben X, Y, beide oder ein vierter Wert).

Testfälle

Format:

# 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

Hier ist ein Link zu einer funktionierenden Java-Lösung, die Sie zum Testen verwenden können (die Eingabe erfolgt auf die gleiche Weise wie in den Testfällen).

Dies ist Code-Golf, also gewinnen die wenigsten Bytes in jeder Sprache für diese Sprache!

Python 3 , 177 Bytes

cist ein Wörterbuch der Eltern jedes Typs aund bsind die beiden zu überprüfenden Ausdrücke. Typen werden durch Zeichenfolgen dargestellt, während Schnittpunkte und Vereinigungen durch Listen mit Ausdrücken dargestellt werden, wobei das erste Element 0für Schnittpunkt und 1Vereinigung festgelegt ist

Gibt zurück, 0wenn sie nicht einander zuweisbar sind, 1wenn sie azuweisbar sind b, 2wenn sie bzuweisbar sind aund 3wenn beide einander zuweisbar sind

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

Probieren Sie es online aus!

JavaScript (ES6), 138 Byte

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

pist die übergeordnete Zuordnung, bei der es sich um ein JavaScript-Objekt handelt, dessen Schlüssel die Typen mit übergeordneten Elementen sind und dessen Werte Arrays von übergeordneten Elementen sind. Zum Beispiel, wenn es zwei Typen gibt Aund Bund Bdas Elternteil von Adann pwäre {A:['B']}.

Schnittpunkttypen werden in aund bals JavaScript-Objekt dargestellt, idessen Schlüssel ein Array von Typen ist, während Vereinigungstypen einen Schlüssel von haben u. Zum Beispiel wäre der Schnittpunkt zweier Typen Aund Bwäre {i:['A','B']}.

Der Rückgabewert ist, trueob er azuweisbar ist b, 1ob er anicht zuweisbar ist, baber bzuweisbar aist oder 0ob keiner von beiden einander zuweisbar ist.

C ++ 17, 595 Bytes

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

Probieren Sie es online aus!

Eine Variablenvorlage f, die einige Typen und Schnittpunkte i<...>oder Vereinigungen als Eingabe akzeptiert u<...>und zurückgibt, -1ob sie Azugewiesen werden kann B und 1ob sie Bzugewiesen werden kann Aund auf 0andere Weise.

Ungolfed:

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

Verwendungszweck:

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