整数のセットがあるとします。セットの一部が重複する（つまり、要素を共有する）可能性があります。セットから要素を削除することで重複を取り除くことができますが、それらの一部は空になる可能性があります。それは残念だろう。それらを空にすることなく、すべてのセットをばらばらにすることはできますか？

この状況では、セットに複数の要素を残す理由がないため、この問題は、各セットを1つの要素に減らすことで常に解決できます。これが、私たちがここで解決している問題のバージョンです。

タスク

次のようにプログラムまたは関数を記述します。

入力：整数のセットのリスト。

出力：入力と同じ長さの整数のリスト。

• 出力のすべての整数は区別されます。そして
• 出力の各整数は、対応する入力のセットの要素です。

明確化

• 要素の順序に関係なく、必要に応じて（または言語に適したものであれば）セットをリストとして表すことができます。
• ソリューションが存在しない場合（つまり、常に少なくとも1つのソリューションが存在する場合）を処理する必要はありません。
• 複数の解決策がある場合があります。アルゴリズムは常に有効なソリューションを生成する必要がありますが、非決定的であることが許可されています（つまり、実行するたびに異なる有効なソリューションを選択することは問題ありません）。
• 入力に現れる個別の整数の数nは、入力のセットの数に等しく、簡単にするために、1からnまでの整数になります（実際の値は関係ないため）。この事実を利用するかどうかはあなた次第です。

テストケース

[{1,2},{1,3},{1,4},{3,4}] -> [2,3,1,4] or [2,1,4,3]
[{1,3},{1,2,4},{2,3},{3},{2,3,4,5}] -> [1,4,2,3,5]
[{1,3,4},{2,3,5},{1,2},{4,5},{4,5}] -> [1,3,2,4,5] or [3,2,1,4,5] or [1,3,2,5,4] or [3,2,1,5,4]

勝利条件

プログラムは勝つために最適な時間の複雑さを必要とします。つまり、より時間の複雑さのあるアルゴリズムが見つかった場合、それはすべての遅いエントリを失格にします。（言語のビルトインは可能な限り高速であると想定できます。たとえば、ソートビルトインは時間O（n log n）で実行すると想定できます。同様に、nに匹敵するサイズのすべての整数を加算、乗算できると想定します。一定の時間で。）

最適な時間の複雑さはほとんどの言語でかなり簡単に取得できる可能性が高いため、勝者の時間の複雑さは、バイト数で測定すると、勝者が最も短いプログラムになります。

ゼリー、8バイト

Œp⁼Q$ÐfḢ

オンラインでお試しください！

説明

Œp⁼Q$ÐfḢ  Main Link
Œp        Cartesian Product of the elements; all possible lists
     Ðf   Filter; keep elements that are
  ⁼Q$     Equal to themselves uniquified
      Ḣ   Take the first one

非常に非効率的です。ϴ(n^(n+1))ミシャ・ラブロフによると漸近。そうだと思います。

Wolfram言語（Mathematica）、87バイトおよびϴ（n ³）

-Range[n=Length@#]/.Rule@@@FindIndependentEdgeSet[Join@@Table[-i->j,{i,n},{j,#[[i]]}]]&

オンラインでお試しください！

片側の頂点がセット（で索引付け-1,-2,...,-n）であり、反対側の頂点が要素1,2,...,nである2部グラフを作成します。エッジは-i〜が-番目のセットに含まれるj場合に使用されます。組み込みを使用して、このグラフで完全な一致を見つけます。次に、に完全に一致する順に対応する要素をリストします。ji-1,-2,...,-n

Mathematica FindIndependentEdgeSetはここでのボトルネックです。それ以外はすべてO（n ²）操作を実行します。Mathematicaはおそらくハンガリーのアルゴリズムを使用しているので、ϴ（n ³）で実行すると仮定します時間が、MathematicaはO（n ⁴）の複雑さを持つ素朴な実装を持っている可能性があります。

Haskell、48バイト

nimiのおかげで-1バイト。

import Data.List
head.filter((==)<*>nub).mapM id

オンラインでお試しください！

Mathematica 39バイト

Last@Union[DeleteDuplicates/@Tuples@#]&

複雑さの問題については、各サブリストの長さや、サブリストがどれほどばらばらであるかという尺度に大きく依存すると思います。

したがって、このアルゴリズムはO（n Log n + n ^ 2 Log m）であると思います。ここで、mはおおよそ各サブリストの平均の長さです。

このようなものは複雑さO（a ^ n）を持ちます。ここで、a> 1はサブリストの重複の測定です。

(For[x={1,1},!DuplicateFreeQ@x,x=RandomChoice/@#];x)&

考えられる入力のプロパティを知らなくても、どちらが本当に速いかは言いがたいです。

05AB1E、13バイト、O（n！* n）

āœʒ‚øε`QO}P}н

オンラインでお試しください！説明：

ā               Make a range 1..n
 œ              Generate all permutations
  ʒ        }    Filter
   ‚ø           Zip with input
     ε   }      Loop over sets
      `QO       Check each element for membership
          P     All sets must match
            н   Take the first result

ハスク、5バイト

►oLuΠ

オンラインでお試しください！

説明

複雑さの問題を見ただけです。ゴルフ言語のソリューションの場合はそうであることが多いため、あまり効率的ではありません。これは複雑さO（n・nⁿ）です。

►(Lu)Π  -- input as a list of lists, for example: [[1,2],[1,3],[1,4],[3,4]]
     Π  -- cartesian product: [[1,1,1,3],...,[2,3,4,4]]
►(  )   -- maximum by the following function (eg. on [1,1,1,3]):
   u    --   deduplicate: [1,3]
  L     --   length: 2

Pyth、9バイト（ϴ（n ^{n + 1}））

これはJellyソリューションとまったく同じように機能するため、おそらく同じ複雑さです。

h{I#.nM*F

ここでお試しください！

どうやって？

h {I＃.nM * F | 完全なプログラム。

       * F | デカルト積を折る。
    .nM | それぞれを平らにします。
   ＃| それらを保管してください：
 {I重複要素の削除に対して不変です。
h | 最初の要素を取ります。

JavaScript（ES6）、74 73バイト

@Neilのおかげで、1バイトが節約されました。

f=([a,...A],s=[],S)=>a?a.map(c=>s.includes(c)||(S=S||f(A,[...s,c])))&&S:s

配列を再帰的に反復してソリューションを探します。

未ゴルフ：

f=(
   [a, ...A],                        //a is the first array, A is the rest
   s = [],                           //s is the current trial solution
   S                                 //S holds the solution (if one exists) at this branch
  )=>
     a ? a.map(                      //if we're not done, iterate through a
           c => s.includes(c) ||     //  if this element already exists, short-circuit
                (S = S ||            //  else if S has a solution, keep it
                 f(A, [...s, c])     //  else look for a solution down this branch
                )
         ) && S                      //return S

テストケース：

f=([a,...A],s=[],S)=>a?a.map(c=>s.includes(c)||(S=S||f(A,[...s,c])))&&S:s

console.log(f([[1,2],[1,3],[1,4],[3,4]])) // [2,3,1,4] or [2,1,4,3]
console.log(f([[1,3],[1,2,4],[2,3],[3],[2,3,4,5]])) // [1,4,2,3,5]
console.log(f([[1,3,4],[2,3,5],[1,2],[4,5],[4,5]])) // [1,3,2,4,5] or [3,2,1,4,5] or [1,3,2,5,4] or [3,2,1,5,4],4]

python3、93の 84バイト

-9バイト（caird coinheringaahingのおかげ）

lambda I:next(filter(lambda x:len(x)==len({*x}),product(*I)))
from itertools import*

オンラインでお試しください！