relazionato

Cosa è assegnabile a cosa?

In questa sfida vi sarà dato due tipi, Ae Be determinare se Aè assegnabile a B, Bè assegnabile a A, o nessuno dei due.

Il sistema di tipi

(Userò tper rappresentare qualsiasi tipo)

Tipi di base

I tipi di base sono rappresentati da una singola lettera maiuscola, ad esempio X. Sono sostanzialmente delle classi.

• Xè assegnabile a Yif Yè uguale o di una classe padre di X.

Tipi di intersezione

I tipi di intersezione sono rappresentati da intersect<X, Y>e possono avere un numero qualsiasi di tipi tra quelli <(ad es intersect<X, Y, Z, D, E>.).

• tè assegnabile a intersect<X1, X2... Xn>if tè assegnabile a tutti X.
• intersect<X1, X2... Xn>è assegnabile a tse ne Xè assegnabile una t.

Tipi di unione

I tipi di unione sono rappresentati da union<X, Y>e possono avere un numero qualsiasi di tipi tra <i (ad es union<X, Y, Z, D, E>.).

• tè assegnabile a union<X1, X2... Xn>se tè assegnabile a nessuno X.
• union<X1, X2... Xn>è assegnabile a tse tutti Xsono assegnabili a t.

Ingresso

Riceverai come input:

• La gerarchia di classi. È possibile scegliere il metodo di input per la gerarchia di classi. Puoi inserire una rappresentazione di un albero, o ogni tipo con un elenco dei suoi genitori, o qualsiasi altra cosa che rappresenti accuratamente la gerarchia di classi.
• Due tipi (l'input è flessibile, purché la notazione sia coerente, potresti ricevere questi tipi come preferisci).

Produzione

Si sarà in uscita uno dei tre valori costanti ed evidenti, li chiamano X, Ye Z. Dati due tipi Ae B, in uscita X, se Aè assegnabile a B, uscita Yse Bè assegnabile ad Ae l'uscita Zin caso contrario (se Aè assegnabile a Bed Bè assegnabile a A, si può in uscita X, Ysia, o un quarto valore).

Casi test

Formato:

# 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

Ecco un link a una soluzione Java non golf funzionante che puoi utilizzare per i test (accetta input nello stesso modo dei casi di test)

Questo è code-golf, quindi vince meno byte in ogni lingua per quella lingua!

Python 3 , 177 byte

cè un dizionario dei genitori di ciascun tipo ae bsono le due espressioni da verificare. I tipi sono rappresentati da stringhe, mentre le intersezioni e le unioni sono rappresentate da liste con delle espressioni, con il primo elemento impostato su 0per interseca e 1per unione

Restituisce 0se non sono assegnabili tra loro, 1se aè assegnabile a b, 2se bè assegnabile a ae 3se entrambi sono assegnabili l'uno all'altro

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

Provalo online!

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)

pè la mappa padre, che è un oggetto JavaScript le cui chiavi sono i tipi con i genitori e i cui valori sono matrici di padre / i. Ad esempio, se ci sono due tipi Aed Bed Bè il genitore di Aallora psarebbe {A:['B']}.

I tipi di intersezione sono rappresentati in ae bcome un oggetto JavaScript con una chiave il icui valore è un array di tipi, mentre i tipi di unione hanno una chiave di u. Ad esempio, l'intersezione di due tipi Ae Bsarebbe {i:['A','B']}.

Il valore restituito è truese aè assegnabile a b, 1se anon è assegnabile a bma bè assegnabile a a, o 0se nessuno dei due è assegnabile l'uno all'altro.

C ++ 17, 595 byte

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

Provalo online!

Un modello variabile fche accetta come input alcuni tipi e di intersezione i<...>o l'unione u<...>di loro e ritorna -1se Aè assegnabile ad B e 1se Bè assegnabile a Aed 0altrimenti.

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;

Uso:

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