Misalkan Anda memiliki satu set himpunan bilangan bulat. Mungkin saja beberapa set akan tumpang tindih (mis. Elemen berbagi). Anda bisa menghilangkan tumpang tindih dengan menghapus elemen dari set, tetapi beberapa dari mereka mungkin berakhir kosong; itu akan memalukan. Bisakah kita membuat semua set terpisah tanpa mengosongkannya?

Perhatikan bahwa dalam situasi ini, tidak pernah ada alasan untuk meninggalkan beberapa elemen dalam satu set, sehingga masalah ini selalu dapat diselesaikan dengan mengurangi setiap set menjadi hanya satu elemen. Itulah versi masalah yang kami selesaikan di sini.

Tugas

Tulis program atau fungsi, sebagai berikut:

Input : Daftar set bilangan bulat.

Output : Daftar bilangan bulat, dengan panjang yang sama dengan input, untuk yang:

• Semua bilangan bulat dalam output berbeda; dan
• Setiap integer dalam output adalah elemen dari set input yang sesuai.

Klarifikasi

• Anda dapat mewakili satu set sebagai daftar jika Anda ingin (atau apa pun yang sesuai untuk bahasa Anda), mengabaikan urutan elemen.
• Anda tidak harus menangani kasus di mana tidak ada solusi (yaitu akan selalu ada setidaknya satu solusi).
• Mungkin ada lebih dari satu solusi. Algoritme Anda harus selalu menghasilkan solusi yang valid, tetapi diizinkan untuk tidak deterministik (artinya tidak masalah jika mengambil solusi valid yang berbeda setiap kali berjalan).
• Jumlah bilangan bulat berbeda yang muncul dalam input, n , akan sama dengan jumlah set dalam input, dan untuk kesederhanaan, akan menjadi bilangan bulat dari 1 hingga n inklusif (karena nilai aktualnya tidak masalah). Terserah Anda apakah Anda ingin mengeksploitasi fakta ini atau tidak.

Testcases

[{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]

Kondisi kemenangan

Suatu program membutuhkan kompleksitas waktu yang optimal untuk menang, yaitu jika suatu algoritma dengan kompleksitas waktu yang lebih baik ditemukan, itu mendiskualifikasi semua entri yang lebih lambat. (Anda dapat mengasumsikan bahwa bawaan bahasa Anda berjalan secepat mungkin, misalnya Anda dapat mengasumsikan bahwa bawaan penyortiran berjalan dalam waktu O (n log n). Demikian juga, asumsikan bahwa semua bilangan bulat dengan ukuran yang sebanding dengan n dapat ditambahkan, dikalikan, dll. (dalam waktu yang konstan.)

Karena kompleksitas waktu yang optimal kemungkinan cukup mudah diperoleh dalam sebagian besar bahasa, maka pemenang akan menjadi program terpendek di antara mereka yang memiliki kompleksitas waktu pemenang, diukur dalam byte.

Jelly , 8 byte

Œp⁼Q$ÐfḢ

Cobalah online!

Penjelasan

Œ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

Sangat tidak efisien. Asimptotik ϴ(n^(n+1))menurut Misha Lavrov; Saya pikir itu benar.

Bahasa Wolfram (Mathematica) , 87 byte dan ϴ (n ³ )

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

Cobalah online!

Membangun grafik bipartit yang simpul-simpulnya di satu sisi adalah himpunan (diindeks oleh -1,-2,...,-n) dan simpul-simpulnya di sisi yang lain adalah elemen-elemennya 1,2,...,n, dengan ujung dari -isampai jkapan jterkandung dalam ihimpunan -th. Temukan kecocokan sempurna dalam grafik ini menggunakan bawaan. Kemudian buatlah daftar elemen yang sesuai -1,-2,...,-ndalam urutan itu dalam pencocokan sempurna.

Mathematica FindIndependentEdgeSetadalah hambatan di sini; yang lain membutuhkan O (n ² ) operasi untuk dilakukan. Mathematica mungkin menggunakan algoritma Hungaria , dan jadi saya akan berasumsi bahwa itu berjalan dalam waktu ϴ (n ³ ) , meskipun ada kemungkinan bahwa Mathematica memiliki implementasi yang naif dengan kompleksitas O (n ⁴ ).

Haskell , 48 byte

-1 byte terima kasih kepada nimi.

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

Cobalah online!

Mathematica 39 Bytes

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

Pada masalah kompleksitas, saya pikir ini sangat tergantung pada panjang masing-masing sublist, serta ukuran seberapa terpisah sublists.

Jadi, saya pikir algoritma ini adalah O (n Log n + n ^ 2 Log m) di mana m kira-kira panjang rata-rata setiap sublist.

Sesuatu seperti ini akan memiliki kompleksitas O (a ^ n) di mana a> 1 adalah ukuran dari tumpang tindih dalam sublists:

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

Sulit mengatakan mana yang benar-benar lebih cepat tanpa mengetahui sifat-sifat input yang mungkin.

05AB1E , 13 byte, O (n! * N)

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

Cobalah online! Penjelasan:

ā               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

Sekam , 5 byte

►oLuΠ

Cobalah online!

Penjelasan

Hanya melihat hal tentang kompleksitas: Seperti yang sering terjadi dengan solusi bahasa golf, mereka tidak terlalu efisien - yang ini memiliki kompleksitas 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 byte (ϴ (n ^{n + 1} ))

Karena ini berfungsi persis seperti solusi Jelly, kemungkinan besar memiliki kompleksitas yang sama.

h{I#.nM*F

Coba di sini!

Bagaimana?

h {I # .nM * F | Program lengkap.

       * F | Lipat produk Cartesian.
    .nM | Ratakan masing-masing.
   # | Simpan itu:
 {I Itu berbeda dari penghapusan elemen duplikat.
h | Ambil elemen pertama.

JavaScript (ES6), 74 73 byte

1 byte disimpan, terima kasih kepada @Neil.

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

Berulang secara berulang melalui array mencari solusi.

Tidak Disatukan:

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

Kasus uji:

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 byte

-9 byte berkat caird coinheringaahing

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

Cobalah online!