Uguaglianza Transitiva


16

La sfida

Il tuo programma dovrebbe prendere 3 input:

  • Un numero intero positivo che è il numero di variabili,
  • Un insieme di coppie non ordinate di numeri interi non negativi, in cui ogni coppia rappresenta un'uguaglianza tra variabili e
  • Un numero intero positivo che rappresenta la variabile iniziale,

Dovrebbe restituire un insieme di numeri interi non negativi che rappresentano tutte le variabili che possono essere mostrate come transitoriamente uguali alla variabile iniziale (inclusa la variabile iniziale stessa).

In altre parole, dati input N, Ee S, restituiscono un set Q, tale che:

  • S ∈ Q.
  • Se Z ∈ Qe (Y = Z) ∈ E, allora Y ∈ Q.
  • Se Z ∈ Qe (Z = Y) ∈ E, allora Y ∈ Q.

Questo può anche essere espresso come un problema di :

Dato un grafico non diretto e un vertice nel grafico, elenca i vertici nel suo componente collegato .

specificazioni

  • Puoi scegliere di utilizzare l'indicizzazione basata su 0 o 1.
  • Il primo input conta il numero di variabili presenti, in cui le variabili sono indicate come numeri. In alternativa, non è possibile accettare questo input, nel qual caso si presume che sia uguale all'indice di variabile più alto presente o uno in più di questo, a seconda dello schema di indicizzazione.
  • Puoi presumere che l'input sia ben formato: non ti verranno date variabili al di fuori dell'intervallo specificato dal primo input. Ad esempio, 3, [1 = 2, 2 = 0], 1è un input valido, mentre 4, [1 = 719, 1 = 2, 3 = 2], -3non lo è.
  • Non si può presumere che nessuna variabile abbia uguaglianze ad essa associate. Se viene fornito un terzo input "solo" (non ha uguaglianze), l'output corretto è un set singleton contenente solo quell'input (poiché è uguale a se stesso).
  • Puoi presumere che le uguaglianze non conterranno un'uguaglianza da una variabile a se stessa e che la stessa uguaglianza non verrà data più volte (questo include cose come 1 = 2e 2 = 1).
  • Puoi presumere che tutti gli interi indicati siano all'interno dell'intervallo rappresentabile della tua lingua.
  • Puoi prendere il secondo input in qualsiasi formato ragionevole.

Ecco alcuni formati ragionevoli:

0 = 2
0 = 3
1 = 0

{(0, 2), (0, 3), (1, 0)}

[0, 2, 0, 3, 1, 0]

0 2 0 3 1 0

Graph[{{0, 2}, {0, 3}, {1, 0}}]

[0 = 2, 0 = 3, 1 = 0]
  • È possibile produrre in qualsiasi formato ragionevole (ad es. Set, elenco, ecc.). L'ordine è irrilevante.

punteggio

Questo è , quindi vince il programma valido più breve (in byte).

Casi di test (indicizzati 0)

3, [1 = 2, 2 = 0], 1                      -> {0, 1, 2}
5, [0 = 2, 0 = 3, 1 = 2], 3               -> {0, 1, 2, 3}
6, [0 = 3, 1 = 3, 2 = 4, 5 = 1], 4        -> {2, 4}
6, [0 = 3, 1 = 3, 2 = 4, 5 = 1], 5        -> {0, 1, 3, 5}
5, [0 = 1, 2 = 0, 0 = 3, 4 = 0], 2        -> {0, 1, 2, 3, 4}
6, [0 = 1, 1 = 2, 2 = 3, 3 = 4, 4 = 5], 3 -> {0, 1, 2, 3, 4, 5}
4, [0 = 1, 1 = 2, 2 = 0], 3               -> {3}
5, [0 = 2, 2 = 4], 2                      -> {0, 2, 4}
8, [], 7                                  -> {7}

Casi di test (1 indicizzato)

3, [2 = 3, 3 = 1], 2                      -> {1, 2, 3}
5, [1 = 3, 1 = 4, 2 = 3], 4               -> {1, 2, 3, 4}
6, [1 = 4, 2 = 4, 3 = 5, 6 = 2], 5        -> {3, 5}
6, [1 = 4, 2 = 4, 3 = 5, 6 = 2], 6        -> {1, 2, 4, 6}
5, [1 = 2, 3 = 1, 1 = 4, 5 = 1], 3        -> {1, 2, 3, 4, 5}
6, [1 = 2, 2 = 3, 3 = 4, 4 = 5, 5 = 6], 4 -> {1, 2, 3, 4, 5, 6}
4, [1 = 2, 2 = 3, 3 = 1], 4               -> {4}
5, [1 = 3, 3 = 5], 3                      -> {1, 3, 5}
8, [], 8                                  -> {8}


Possiamo rinunciare a prendere il primo input se lo desideriamo? Penso che non sia necessario ottenere l'output corretto
dylnan

@dylnan "Il primo input conta il numero di variabili presenti, in cui le variabili sono indicate come numeri. In alternativa, non è possibile accettare questo input, nel qual caso si presume che sia uguale all'indice di variabile più alto presente, oppure a uno più di questo, a seconda del tuo schema di indicizzazione. "(punto 2 delle specifiche)
Esolanging Fruit

Mi dispiace a volte dimentico di finire di leggere
dylnan il

L'output può contenere duplicati? (Posso affermare che rappresenta un set ...)
Ton Hospel

Risposte:


7

Brachylog , 22 byte

{tc⊇,?k.&¬(t∋;.xȮ)∧}ᶠt

Provalo online!

Spiegazione

{tc⊇,?k.&¬(t∋;.xȮ)∧}ᶠt  Input is a pair, say [2,[[1,3],[2,4],[5,2]]]
{                   }ᶠ   Find all outputs of this predicate:
 t                        Tail: [[1,3],[2,4],[5,2]]
  c                       Concatenate: [1,3,2,4,5,2]
   ⊇                      Choose a subset: [4,5]
    ,?                    Append the input: [4,5,2,[[1,3],[2,4],[5,2]]]
      k                   Remove the last element: [4,5,2]
       .                  This list is the output.
        &¬(      )∧       Also, the following is not true:
           t∋              There is a pair P in the second part of the input.
             ;.x           If you remove from P those elements that occur in the output,
                Ȯ          the result is a one-element list.
                      t  Take the last one of these outputs, which is the shortest one.



2

Pulito , 85 81 byte

import StdEnv
$l=limit o iterate(\v=removeDup(flatten[v:filter(isAnyMember v)l]))

Provalo online!

Definisce la funzione $ :: [[Int]] -> ([Int] -> [Int])


Interessante. Come limitfunziona?
Esolanging Fruit

@EsolangingFruit prende un elenco, ritenuto infinito, e restituisce il primo elemento che si presenta due volte di seguito.
Οuroso

1
Oh, sembra molto utile!
Esolanging Fruit


1

Operazione linguaggio di scripting Flashpoint , 364 byte

f={t=_this;r=t select 1;i=0;while{i<t select 0}do{call format["V%1=[%1]",i];i=i+1};i=0;while{i<count r}do{call format(["V%1=V%1+V%2;V%2=V%1"]+(r select i));i=i+1};l=call format["V%1",t select 2];g={i=0;c=count l;while{i<c}do{if(i<count l)then{e=l select i;call _this};i=i+1}};{l=l+call format["V%1",e]}call g;"l=l-[e]+[e];if(count l<c)then{c=count l;i=0}"call g;l}

Chiama con:

hint format
[
    "%1\n%2\n%3\n%4\n%5\n%6\n%7\n%8\n%9",
    [3, [[1, 2], [2, 0]], 1] call f,
    [5, [[0, 2], [0, 3], [1, 2]], 3] call f,
    [6, [[0, 3], [1, 3], [2, 4], [5, 1]], 4] call f,
    [6, [[0, 3], [1, 3], [2, 4], [5, 1]], 5] call f,
    [5, [[0, 1], [2, 0], [0, 3], [4, 0]], 2] call f,
    [6, [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5]], 3] call f,
    [4, [[0, 1], [1, 2], [2, 0]], 3] call f,
    [5, [[0, 2], [2, 4]], 2] call f,
    [8, [], 7] call f
]

Produzione:

inserisci qui la descrizione dell'immagine

srotolato:

f =
{
    t = _this;
    r = t select 1;
    i = 0;
    while {i < t select 0} do
    {
        call format["V%1=[%1]", i];
        i = i + 1
    };

    i = 0;
    while {i < count r} do
    {
        call format(["V%1=V%1+V%2;V%2=V%1"] + (r select i));
        i = i + 1
    };

    l = call format["V%1", t select 2];

    g =
    {
        i = 0;
        c = count l;
        while {i < c} do
        {
            if (i < count l) then
            {
                e = l select i;
                call _this
            };
            i = i + 1
        }
    };

    {l = l + call format["V%1", e]} call g;
    "l = l - [e] + [e];

    if (count l<c)then
    {
        c = count l;
        i = 0
    }" call g;

    l
}

1

Python 2 , 53 byte

e,s,n=input()
b={s}
for p in n*e:b|=b&p and p
print b

Provalo online!

Stessa lunghezza della funzione:

lambda e,s,n:reduce(lambda b,p:b|(b&p and p),n*e,{s})

Provalo online!

Questo si basa sulla bella soluzione di Rod che utilizza l'aggiornamento di corto circuito b|=b&p and p. Prendere il numero di variabili come input naiuta ad abbreviare il codice del loop.


1

Gelatina ,  12   11  10 byte

-1 grazie a Erik the Outgolfer (sostituisci l'atomo œ&con f)

⁹fÐfȯFµÐLQ

Un collegamento diadico che accetta E a sinistra (come un elenco di due liste di lunghezza) ea Sdestra (come un numero intero) che restituisce un elenco [de-duplicato].

Provalo online!o vedere una suite di test .

Come?

⁹fÐfȯFµÐLQ - Link: list of lists, E; integer S
      µÐL  - repeat the monadic chain to the left until a fixed point is reached:
  Ðf       -   (for each pair in E) filter keep if:
 f         -     filter discard if in
⁹          -     chain's right argument
           -     (originally [S], thereafter the previous result as monadic)
    ȯ      -   logical OR with implicit right
           -   (force first pass to become S if nothing was kept)
     F     -   flatten to a single list
           -   (S -> [S] / [[1,4],[1,0]]->[1,4,1,0] / etc...)
         Q - de-duplicate

œ&I fvalori di ritorno di ' e ' hanno sempre la stessa proprietà booleana.
Erik the Outgolfer,

1

Perl 5 -n0 , 49 39 byte

Dai il valore iniziale su una riga su STDIN seguita da linee di coppie di numeri equivalenti (oppure dai il valore iniziale ultimo o nel mezzo o fornisci più valori iniziali, tutto funziona)

#!/usr/bin/perl -n0
s/
$1? | $1/
/ while/^(\d+
)/msg;say//g

Provalo online!

Questo può generare un elemento nel set di risultati più volte. Questa variazione di 48 byte genera ogni elemento equivalente una sola volta:

s/
$1? | $1/
/ while/^(\d+
)(?!.*^\1)/msg;say//g

Provalo online!



1

K (ngn / k) , 37 36 35 byte

{&a[z]=a:{y[x]&:|y x;y}[+y,,&2]/!x}

Provalo online!

{ }funzione con argomenti x, y, e zrappresentano N, Ee Srispettivamente

!x è l'elenco 0 1 ... x-1

&2 è l'elenco 0 0

y,,&2aggiungiamo la coppia 0 0a yper evitare il caso speciale di un vuotoy

+y,,&2 stessa cosa trasposta da un elenco di coppie a una coppia di elenchi

{ }[+y,,&2]è una proiezione, cioè una funzione in cui xsarà il valore +y,,&2e ysarà l'argomento trasmesso quando si chiama la proiezione

|y xè yagli indici x, invertito ( |)

@[y;x;&;|y x]modificare yagli indici xprendendo il minimo ( &) dell'elemento esistente e un elemento da|y x

/ continuare a chiamare fino alla convergenza

a: assegnare a

a[z]=zmaschera booleana degli elementi di auguale al z-th

& converti la maschera booleana in un elenco di indici


1

Ottava , 48 45 byte

t=@(A,u)find(((eye(size(A))+A+A')^nnz(A))(u,:));

Accetta input come "matrice di adiacenza", ad esempio utilizza [0 0 0; 0 0 1; 1 0 0]per [2 = 3, 3 = 1], provalo online!

Spiegazione

Innanzitutto costruiamo la matrice di adiacenza completa per il grafico transitivo, usando la somma di eye(size(A))(gli elementi sono riflessivi), A(input) eA' (la relazione è simmetrica).

Calcoliamo la chiusura transitiva calcolando la potenza a nnz(A)cui è sufficiente ( nnz(A)è limite superiore per la lunghezza di un percorso), quindi da lì tutto ciò che resta è ottenere la riga giusta con (u,:)e findtutte le voci diverse da zero.




0

JavaScript (ES6), 87 byte

(a,n)=>a.map(([b,c])=>[...d[b]||[b],...d[c]||[c]].map((e,_,a)=>d[e]=a),d=[])&&d[n]||[n]

La deduplicazione sarebbe possibile utilizzando &&[...new Set(d[n]||[n])]al costo di 14 byte.

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.