I due set sono uguali

9

{}è l'insieme vuoto. È possibile utilizzare ()o []se si sceglie.

Non definiremo rigorosamente "set", ma tutti i set soddisfano le seguenti proprietà:

Gli insiemi seguono la solita struttura matematica. Ecco alcuni punti importanti:

  • I set non sono ordinati.
  • Nessun set contiene se stesso.
  • Gli elementi sono in un set o no, questo è booleano. Pertanto gli elementi dell'insieme non possono avere molteplicità (ovvero un elemento non può essere in un insieme più volte).
  • Gli elementi di un insieme sono anche insiemi ed {}è l'unico elemento primitivo.

Compito

Scrivi un programma / funzione che determina se due set sono uguali.

Ingresso

Due set validi tramite stdin o argomento della funzione. Il formato di input è sciolto entro limiti ragionevoli.

Alcuni input validi sono:

{} {{}}
{{},{{}}} {{{{{},{{}}}}}}
{{},{{},{{}}}} {{{},{{}}},{{{{{},{{}}}}}}}

Ingressi non validi:

{{} {}              Brackets will always be balanced.
{{},{}} {}          Set contains the same element twice

Produzione

Un valore veritiero se gli input sono uguali, falsa altrimenti.

Casi test

L'invio deve rispondere correttamente per tutti gli input validi, non solo per i casi di test. Questi possono essere aggiornati in qualsiasi momento.

Truthy:

{} {}
{{},{{}}} {{{}},{}}
{{},{{},{{{}},{}}}} {{{{},{{}}},{}},{}}

Falsy:

{} {{}}
{{},{{},{{{}},{}}}} {{{{}}},{},{{}}}
{{},{{}},{{{}}},{{},{{}}}} {}

punteggio

code-golf

Regole aggiuntive

È stata aggiunta una regola aggiuntiva che vieta del tutto i tipi iterabili non ordinati. Sono troppo comuni e banalizzano troppo questa sfida. Sentiti libero di lasciare le risposte che violano questo posto, per favore fai solo un'indicazione che sono state fatte prima della modifica della regola.

code-golf  decision-problem  balanced-string 
— Liam
fonte
Una lingua con un tipo di set annidabile può solo controllare l'uguaglianza?
— xnor
@xnor Gli built-in dovrebbero essere un gioco equo, sì
— Liam,
1
@Dennis bene, anche se questa è una sfida "a corde bilanciate", non l'ho mai considerata una sfida di analisi. Ma, ora che ci penso, supponendo che tutti gli input siano validi, l'ho trasformata in una sfida di analisi. Quindi penso che tu abbia ragione. Probabilmente abbastanza lingue hanno l'idea di un elenco non ordinato che lo banalizzerebbe.
— Liam,
1
Starò bene con qualsiasi decisione tu prenda. Personalmente, mentre penso che usare i set in qualche modo possa ancora essere creativo senza banalizzare la sfida (come la mia risposta Julia, che converte ricorsivamente un array nidificato in un set nidificato), consentire set nidificati come input rende il tutto un po 'troppo semplice ( ==in Julia, 2 byte; frozenset.__eq__in Python, 16 byte; ecc.).
— Dennis,
8
See the comments for an explanation. Per favore, non farlo. I commenti sono volatili e vanno via molto facilmente, quindi un sutff importante va nel corpo della posta
— gatto

Risposte:

4

Gelatina , 6 byte

߀Ṣ
ÇE

Provalo online! o verifica tutti i casi di test .

Come funziona

ÇE   Main link. Argument: [s, t] (pair of set arrays)

Ç    Apply the helper link to [s, t].
 E   Check if the elements of the resulting pair are equal.


߀Ṣ  Helper link. Argument: u (set array)

߀   Recursively map this link over u.
  Ṣ  Sort the result.
— Dennis
fonte
3

Brachylog , 8 byte

{p:1a.}.

Questo prevede parentesi in Input e Output.

Per esempio: 

?- run_from_atom('{p:1a.}.', [[]:[[]]], [[[]]:[]]).
true .

Spiegazione

{     }.   True if the predicate inside brackets is true with input Input and output Output

 p          Unify an implicit variable with a permutation of Input
  :1a       Apply this same predicate to each element of that implicit variable
     .      True if Output can be unified with the resulting list
— Fatalize
fonte
2

Mathematica, 16 byte

Equal@@Sort//@#&

Una funzione senza nome che prevede un elenco contenente entrambi i set, ad es

Equal@@Sort//@#& @ {{{}, {{}}}, {{{}}, {}}}

Usiamo //@( MapAll) per ordinare i set ad ogni livello e quindi affermiamo che i risultati sono uguali.

— Martin Ender
fonte
2

JavaScript (ES6), 42 byte

f=(a,b,g=a=>0+a.map(g).sort()+1)=>g(a)==g(b)

Accetta input usando []s es f([[],[[]]],[[[]],[]]). Funziona convertendo le matrici in stringhe e quindi ordinandole dall'interno verso l'esterno. 0e 1vengono utilizzati perché sono più brevi di '['e ']', quindi ad esempio g([[[]],[]])è 001,00111quale rappresenta [[],[[]]].

— Neil
fonte
Non usi la ricorsione, quindi puoi renderla anonima
— Bálint,
Perché è 0+lì?
— Bálint,
@ Bálint Perché senza il 0+e +1tutto ciò che otterrei sono le virgole.
— Neil,
@ Bálint Non so perché ho dimenticato di rimuovere il f=, non l'ho incluso nel conteggio dei byte e sono troppo pigro per modificare il post solo per quello.
— Neil,
2

Python 2, 49 byte

f=lambda x:sorted(map(f,x))
lambda a,b:f(a)==f(b)

Ad esempio, chiamando la funzione anonima g:

>>> g( [[],[[]]] , [[[]],[]] )
True
— Lynn
fonte
g([[],[[],[]],[[],[[]]],[[]],[[[]]]], [[[],[]],[[[]],[]],[[]],[[[]]],[]])ritorna False, ma i set sono uguali. Ciò dovrebbe essere risolto mappando prima dell'ordinamento.
— Dennis,
2

Prolog (SWI) , 37 byte

X+Y:-permutation(X,Z),maplist(+,Z,Y).

Provalo online!

Accetta input come elenchi nidificati, ovvero con parentesi quadre anziché parentesi graffe. Inizialmente lo era X+Y:-sort(X,M),sort(Y,N),maplist(+,M,N)., ma poi ho provato a tradurre la risposta Brachylog v1 di Fatalize e si è rivelato più corto di 3 byte.

X+Y :-                    X+Y succeeds when
    permutation(X, Z),    for some permutation Z of X
    maplist(+, Z, Y).     + succeeds for every pair in Z zipped with Y.
                          (where maplist will succeed without the recursive call to + for
                          two empty lists, and fail if the lists have different lengths)

Al contrario, può gestire parentesi graffe, per altri 23 byte:

Prolog (SWI) , 60 byte

{A}*C:-A=..[,|B],sort(B,C).
X+Y:-X=Y;X*M,Y*N,maplist(+,M,N).

Provalo online!

*qui converte un termine (non vuoto, quindi il X=Y;) parentesi graffa sul lato destro in un elenco degli elementi del termine, quindi lo ordina sul lato sinistro.

{A}*C :-            X*C succeeds when X is the brace term containing A
    A =.. [,|B],    where A is a comma-tuple and B is a list of its elements,
    sort(B, C).     and C is B sorted.

Poiché entrambi gli argomenti +sono *già in corso, l'inserimento di a sortin *consente di risparmiare 7 byte rispetto all'uso di permutationin +.

E infine, ecco una versione che gestisce gli elenchi di input possibilmente con elementi duplicati, che è ciò che mi ha ispirato a scrivere una soluzione in Prolog per cominciare:

Prolog (SWI) , 57 byte

X+Y:-X/Y,Y/X.
X/Y:-maplist(-(Y),X).
Y-E:-member(F,Y),E+F.

Provalo online!

X+Y :-                   X+Y succeeds when
    X/Y, Y/X.            X/Y and Y/X succeed.
X/Y :-                   X/Y succeeds when
    maplist(-(Y), X).    for every element E of X, Y-E succeeds
                         (or when X is empty).
Y-E :-                   Y-E succeeds when
    member(F, Y),        there exists some element F of Y
    E+F.                 such that E+F succeeds.

In sostanza, X/Ydichiara che X è un sottoinsieme di Y, dichiarando che per ogni elemento di X, c'è un elemento uguale di Y, quindi X/Y,Y/Xdichiara che X e Y sono insiemi uguali.

— Stringa non correlata
fonte
E ora ho bisogno di dormire
— Unrelated String
2

APL (NARS2000), 4 byte

≡⍦

⍦è l'operatore multiset, che modifica le funzioni per trattare i loro argomenti come set anziché liste
≡è la funzione di equivalenza, che restituisce un valore booleano che indica se gli argomenti sono completamente equivalenti in valore e forma

Per quanto riguarda la regola aggiuntiva: si noti che questa risposta non utilizza alcun tipo di dati impostato non ordinato, ma solo elenchi normali (che possono contenere più elementi identici). Li tratta semplicemente come set.

Il conteggio dei byte è 4 perché NARS2000 utilizza esclusivamente UCS-2.

— Adamo
fonte
1

Julia, 36 35 32 byte

u*v=(sort(u.*v)...)
s%t=s*s==t*t

L'input è un array nidificato o la {}sintassi (obsoleta) o Any[].

Provalo online!

— Dennis
fonte
1

SETL, 1 byte

=

Accetta i set come argomenti sinistro e destro.

Notare che questo NON rispetta la regola aggiunta che proibisce i tipi di dati impostati non ordinati.

— Adamo
fonte
1

Brachylog v2, 3 byte

p↰ᵐ

Provalo online!

Accetta un set attraverso la variabile di input e l'altro set attraverso la variabile di output. Ha successo se i set sono uguali e fallisce se non lo sono.

Come la mia principale risposta Prolog, una traduzione della risposta Brachylog v1 di Fatalize (che penso possa essere giocata fino a p:0a?).

       The input
p      can be re-ordered so that
 ↰     when this predicate is applied again to
  ᵐ    all of its elements,
       it is the output.
— Stringa non correlata
fonte
0

𝔼𝕊𝕄𝕚𝕟, 7 caratteri / 9 byte

ѨƾꞨî,Ꞩí

Try it here (ES6 browsers only).

Spiegazione

         // implicit: î=input1,í=input2
  Ꞩî,Ꞩí // apply the Set method to both inputs
Ѩƾ      // check if the Sets are equal
        // implicit output
— Mama Fun Roll
fonte
0

Haskell, 77 byte

import Data.List
data S=L[S]deriving(Eq,Ord)
f(L x)=L$sort$f<$>x
a!b=f a==f b
— Lynn
fonte
Per interesse, perché hai bisogno di definire il tuo tipo di elenco qui? (Sono ==e <non sono definiti per impostazione predefinita per gli elenchi?)
1
il tipo di dati è ricorsivo: lo definisco Scome un Lelenco di indirizzi S. Haskell non ha un tipo incorporato che può rappresentare elenchi di elenchi di elenchi di ...
— Lynn
0

Perl 6 , 55 byte

my&f=->\a,\b {a==b&&all map {f(|$_)},(a.sort Z,b.sort)}

Accetta input con [].

Provalo online!

— bb94
fonte
Alcune cose: non è necessario lo spazio dopo gli argomenti per il blocco di codice, è spesso più breve usare la $^sintassi invece, e non penso che l' []input funzioni, dal momento che tutti gli altri [[]],[[[]]],[[[[]]]]valutano[]
— Jo King,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.