Secara konseptual, tantangan ini sangat sederhana. Anda diberi daftar bilangan bulat non-negatif . Jika memungkinkan, cari bilangan bulat non-negatif , sehingga daftar yang terdiri dari diurutkan. Jika tidak ada, output harus berupa apa pun yang tidak dapat disalahartikan sebagai valid , misalnya angka negatif, tidak ada sama sekali, kesalahan, dll.aiNbi = ai XOR NNN

Berikut ini sebuah contoh:

[4, 7, 6, 1, 0, 3]

Jika kita mengambil setiap elemen dalam daftar ini XOR 5, kita dapatkan

[1, 2, 3, 4, 5, 6]

yang disortir. (Perhatikan bahwa bukan merupakan persyaratan bagi daftar yang dihasilkan untuk memiliki elemen unik dan tidak mengandung celah. Jika hasil dari operasi semacam itu [0, 1, 1, 3]masih akan valid.) Di sisi lain untuk daftar

[4, 7, 1, 6, 0, 3]

tidak Nada yang seperti itu.

Anda dapat menulis sebuah program atau fungsi, mengambil input melalui STDIN (atau alternatif terdekat), argumen baris perintah atau argumen fungsi dan mengeluarkan hasilnya melalui STDOUT (atau alternatif terdekat), nilai pengembalian fungsi atau parameter function (out).

Input mungkin dalam format string atau daftar yang mudah digunakan. Anda dapat mengasumsikan bahwa jumlahnya kurang dari masing-masing dan bahwa daftar tersebut mengandung setidaknya satu elemen.ai231

Kode Anda harus menangani salah satu kasus uji (terutama empat yang besar) dalam hitungan beberapa detik.

Aturan standar kode-golf berlaku.

Uji Kasus

Untuk setiap test case yang tidak kembali -1ada jumlah jawaban yang benar tak terbatas Yang tercantum di sini adalah yang terkecil. Solusi tambahan ada dengan tambahan menetapkan bit yang sama di semua bilangan bulat dalam input (terutama yang lebih besar dari bit paling signifikan dalam jumlah terbesar dari daftar).

[4 7 6 1 0 3] => 5
[4 7 1 6 0 3] => -1
[0 1 3 4 6 7] => 0
[4 2 3 1] => 6
[2 3 0 0 7 7 4 5 11 11] => 2
[2 3 0 0 7 7 5 4 11 11] => -1
[1086101479 748947367 1767817317 656404978 1818793883 1143500039] => -1
[180522983 1885393660 751646477 367706848 331742205 724919510 850844696 2121330641 869882699 1831158987 542636180 1117249765 823387844 731663826 1762069894 240170102 1020696223 1212052937 2041219958 712044033 195249879 1871889904 1787674355 1849980586 1308879787 1743053674 1496763661 607071669 1987302942 178202560 1666170841 1035995406 75303032 1755269469 200581873 500680130 561748675 1749521426 1828237297 835004548 934883150 38711700 1978960635 209243689 1355970350 546308601 590319412 959613996 1956169400 140411967 112601925 88760619 1977727497 672943813 909069787 318174568 385280382 370710480 809689639 557034312 865578556 217468424 346250334 388513751 717158057 941441272 437016122 196344643 379529969 821549457 97008503 872313181 2105942402 603939495 143590999 1580192283 177939344 853074291 1288703007 1605552664 162070930 1325694479 850975127 681702163 1432762307 1994488829 780869518 4379756 602743458 1963508385 2115219284 1219523498 559301490 4191682 1918142271 169309431 346461371 1619467789 1521741606 1881525154] => -1
[37580156 64423492 87193676 91914964 93632157 96332899 154427982 176139560 184435039 228963836 230164674 279802291 301492375 309127664 345705721 370150824 380319820 403997410 410504675 416543032 418193132 424733526 428149607 435596038 477224208 515649925 519407995 525469350 614538124 624884850 642649261 653488151 679260270 685637235 690613185 739141066 825795124 832026691 832633584 833213619 852655299 913744258 917674993 921902522 925691996 931307936 954676047 972992595 997654606 1020009811 1027484648 1052748108 1071580605 1108881241 1113730139 1122392118 1154042251 1170901568 1180031842 1180186856 1206428383 1214066097 1242934611 1243983997 1244736049 1262979035 1312007069 1312030297 1356274316 1368442960 1377432523 1415342434 1471294243 1529353536 1537868913 1566069818 1610578189 1612277199 1613646498 1639183592 1668015280 1764022840 1784234921 1786654280 1835593744 1849372222 1875931624 1877593764 1899940939 2007896363 2023046907 2030492562 2032619034 2085680072 2085750388 2110824853 2123924948 2131327206 2134927760 2136423634] => 0
[1922985547 1934203179 1883318806 1910889055 1983590560 1965316186 2059139291 2075108931 2067514794 2117429526 2140519185 1659645051 1676816799 1611982084 1736461223 1810643297 1753583499 1767991311 1819386745 1355466982 1349603237 1360540003 1453750157 1461849199 1439893078 1432297529 1431882086 1427078318 1487887679 1484011617 1476718655 1509845392 1496496626 1583530675 1579588643 1609495371 1559139172 1554135669 1549766410 1566844751 1562161307 1561938937 1123551908 1086169529 1093103602 1202377124 1193780708 1148229310 1144649241 1257633250 1247607861 1241535002 1262624219 1288523504 1299222235 840314050 909401445 926048886 886867060 873099939 979662326 963003815 1012918112 1034467235 1026553732 568519178 650996158 647728822 616596108 617472393 614787483 604041145 633043809 678181561 698401105 776651230 325294125 271242551 291800692 389634988 346041163 344959554 345547011 342290228 354762650 442183586 467158857 412090528 532898841 534371187 32464799 21286066 109721665 127458375 192166356 146495963 142507512 167676030 236532616 262832772] => 1927544832
[1922985547 1934203179 1883318806 1910889055 1983590560 1965316186 2059139291 2075108931 2067514794 2117429526 2140519185 1659645051 1676816799 1611982084 1736461223 1810643297 1753583499 1767991311 1819386745 1355466982 1349603237 1360540003 1453750157 1461849199 1439893078 1432297529 1431882086 1427078318 1487887679 1484011617 1476718655 1509845392 1496496626 1583530675 1579588643 1609495371 1559139172 1554135669 1549766410 1566844751 1562161307 1561938937 1123551908 1086169529 1093103602 1202377124 1193780708 1148229310 1144649241 1257633250 1241535002 1247607861 1262624219 1288523504 1299222235 840314050 909401445 926048886 886867060 873099939 979662326 963003815 1012918112 1034467235 1026553732 568519178 650996158 647728822 616596108 617472393 614787483 604041145 633043809 678181561 698401105 776651230 325294125 271242551 291800692 389634988 346041163 344959554 345547011 342290228 354762650 442183586 467158857 412090528 532898841 534371187 32464799 21286066 109721665 127458375 192166356 146495963 142507512 167676030 236532616 262832772] => -1

Akhirnya, berikut adalah empat kasus uji yang sangat besar untuk memastikan bahwa pengiriman cukup efisien:

• Uji Kasus 1 harus menghasilkan -1.
• Uji Kasus 2 harus menghasilkan 0.
• Uji Kasus 3 harus menghasilkan 1096442624.
• Test Case 4 harus menghasilkan -1.

Mengapa ada orang yang melakukan hal ini?

Terpikir oleh saya suatu hari bahwa operasi XOR dapat "mengurutkan" sebuah array, yang memungkinkan untuk melakukan pencarian biner pada array di O (log n) tanpa harus mengurutkannya terlebih dahulu. Tampaknya mungkin untuk menentukan Ndalam waktu pseudolinear, yang akan menjadikan ini alternatif yang lebih cepat untuk sebagian besar algoritma pengurutan, dan tidak memiliki persyaratan memori jenis radix. Tentu saja, pencarian linear lurus melalui array yang tidak disortir akan lebih cepat, tetapi jika Anda ingin mencari array yang sama berkali-kali, satu pra-komputasi linear dapat menurunkan waktu yang dibutuhkan untuk setiap pencarian secara signifikan.

Sayangnya, kelas daftar ini berfungsi agak terbatas (distribusi acak seragam tidak mungkin mengakui N).

Pertanyaan yang menarik adalah apakah ada fungsi bijective lain yang lebih mudah untuk diperiksa dan / atau berlaku untuk kelas daftar yang lebih luas.

Jelly, 25 byte

ṡ2Zµ^/Bo1Ḅ‘×>/|/H
Ç-¹^Ç¥?

Yang terbaru melakukan postdate tantangan ini, tetapi kode di atas bekerja dengan revisi ini , yang mendahului itu. Cobalah online!

Untuk menjalankan case uji besar, tergantung pada shell Anda, mungkin perlu untuk membungkus kode di atas dalam program yang membaca input dari STDIN. Cobalah online!

Uji kasus

$ xxd -c 13 -g 1 xort-prog.jelly 
0000000: ae 32 5a 8c 5e 2f 42 6f 31 a4 b6 94 3e  .2Z.^/Bo1...>
000000d: 2f 7c 2f 48 0a 92 2d 8e 5e 92 84 3f     /|/H..-.^..?
$ ./jelly f xort-prog.jelly '[4, 7, 6, 1, 0, 3]'; echo
5
$ ./jelly f xort-prog.jelly '[4, 7, 1, 6, 0, 3]'; echo
-1
$ ./jelly f xort-prog.jelly '[0, 1, 3, 4, 6, 7]'; echo
0
$ ./jelly f xort-prog.jelly '[4, 2, 3, 1]'; echo
6
$ ./jelly f xort-prog.jelly '[2, 3, 0, 0, 7, 7, 4, 5, 11, 11]'; echo
2
$ ./jelly f xort-prog.jelly '[2, 3, 0, 0, 7, 7, 5, 4, 11, 11]'; echo
-1
$
$ wget -q http://pastebin.com/raw/{P96PNi79,zCNLMsx9,GFLBXn5b,6F1Yn3gG}
$ xxd -c 14 -g 1 xort-func.jelly 
0000000: ae 32 5a 8c 5e 2f 42 6f 31 a4 b6 94 3e 2f  .2Z.^/Bo1...>/
000000e: 7c 2f 48 0a 92 2d 8e 5e 92 84 3f 0a a0 92  |/H..-.^..?...
$ tr \  , < P96PNi79 | time -f '\n%es' ./jelly f xort-func.jelly
-1
3.69s
$ tr \  , < zCNLMsx9 | time -f '\n%es' ./jelly f xort-func.jelly
0
2.78s
$ tr \  , < GFLBXn5b | time -f '\n%es' ./jelly f xort-func.jelly
1096442624
2.73s
$ tr \  , < 6F1Yn3gG | time -f '\n%es' ./jelly f xort-func.jelly
-1
2.70s

Ide

Ini menggunakan pendekatan yang sama dengan jawaban @ Jakube , tetapi implementasi saya agak berbeda.

Jelly belum menyortir, jadi kami menghitung kandidat xorting, XOR daftar input dengan itu, menghitung kandidat xorting dari daftar XOR, dan memeriksa apakah kandidat baru adalah nol. Jika ya, kami mencetak kandidat pertama; jika tidak, kami mencetak -1 .

Selain itu, Jelly tampaknya belum memiliki cara waras untuk melakukan integer (bahkan divisi integer dapat mengembalikan float), jadi saya harus menemukan cara yang agak kreatif untuk membulatkan daftar angka ke angka 2 berikutnya . Daripada log-floor-pow, saya mengkonversi semua integer ke biner, ganti semua digit biner dengan 1 , konversikan kembali ke integer, tambahkan 1 , dan bagi dengan 2 .

Kode

ṡ2Zµ^/Bo1Ḅ‘×>/|/H  Helper link. Argument: M (list of integers)

ṡ2                 Yield all overlapping slices of length 2 (pairs) of M.
  Z                Zip to group first and second coordinates.
   µ               Begin a new, monadic chain.
    ^/             XOR the corresponding coordinates.
      B            Convert all results to binary.
       o1          OR (logical) all binary digits with 1.
         Ḅ         Convert back to integer.
          ‘        Increment all integers.
           ×>/     Multiply each rounded (a ^ b) by (a > b).
                   This replaces (a ^ b) with 0 unless a > b.
              |/   OR all results.
                H  Halve the result.

Ç-¹^Ç¥?            Main link. Input: L (list of integers)

Ç                  Call the helper link on L. Result: C (integer)
     ¥             Create a dyadic chain:
   ^                 XOR the elements of L with C.
    Ç                Call the helper link on the result.
      ?            If the result in non-zero:
 -                   Yield -1.
  ¹                Else, yield C.

Pyth, 40 36 31 30 byte

Ju.|G^2slHxMf>FT.:Q2Z|tSIxRJQJ

Cobalah online: Demonstrasi atau Test Suite

Masing-masing kotak uji besar selesai dalam beberapa detik.

Penjelasan:

Pertama saya akan menjelaskan metode dan mengapa ini berhasil. Saya akan melakukan ini dengan daftar contoh: [7, 2, 13, 9].

Dua angka pertama sudah salah ( 7 > 2). Kami ingin xor dengan beberapa nomor untuk mengubah simbol ketimpangan ( 7 xor X < 2 xor X). Karena xor beroperasi pada representasi biner, mari kita melihatnya.

7 = 1 1 1
2 =   1 0

Ketika kami menerapkan xor dengan beberapa nomor untuk setiap nomor, nilai di beberapa posisi akan berubah. Jika Anda mengubah nilai di posisi pertama ( 2^0), simbol ketimpangan tidak berubah. Hal yang sama terjadi, ketika kita mengubah nilai di posisi kedua ( 2^1). Juga simbol tidak akan berubah jika kita mengubah nilai-nilai di keempat, kelima, ... posisi ( 2^3, 2^4, ...). Simbol ketidaksetaraan hanya mengubah arah, jika kita mengubah posisi ketiga ( 2^2).

7 xor 2^0 = 1 1 0   7 xor 2^1 = 1 0 1   7 xor 2^2 =   1 1   7 xor 2^3 = 1 1 1 1
2 xor 2^0 =   1 1   2 xor 2^1 =     0   2 xor 2^2 = 1 1 0   2 xor 2^3 = 1 0 1 0
     6 > 3               5 > 0               3 < 6               15 > 10

Jika kita mengubah banyak posisi sekaligus, tentu saja hal yang sama terjadi. Jika salah satu posisi yang kita ubah adalah posisi ketiga, maka simbol ketidaksetaraan akan berubah, sebaliknya tidak.

Pasangan berikutnya sudah diurutkan: 2 < 13. Jika kita melihat representasi biner, kita perhatikan, bahwa kita dapat xor apa saja untuk itu dan simbol ketimpangan masih benar, kecuali ketika kita mengubah posisi keempat ( 2^3).

 2 =     1 0    2 xor 2^3 = 1 0 1 0
13 = 1 1 0 1   13 xor 2^3 =   1 0 1
   2 < 13            10 > 5

Jadi kami tidak ingin mengubah posisi keempat. Untuk pasangan berikutnya, kami ingin mengubah sesuatu 13 > 9. Di sini kita kembali harus mengubah posisi ketiga.

13 = 1 1 0 1   13 xor 2^2 = 1 0 0 1
 9 = 1 0 0 1    9 xor 2^2 = 1 1 0 1
   13 > 9            9 < 13

Sekarang rekap: Untuk berakhir di daftar yang disortir, kita lagi-lagi harus mengubah posisi ketiga dan tidak ingin mengubah posisi keempat. Semua posisi lain tidak masalah. Jumlah terkecil adalah sederhana 4 = 0100. Pilihan lain akan 5 = 0101, 6 = 0110, 7 = 0111, 20 = 10100, 21 = 10101, ...

Xoring dengan 4akan menghasilkan daftar [3, 6, 9, 13], dengan 6akan mendapatkan [1, 4, 11, 15], dan dengan 21akan mendapatkan [18, 23, 24, 28].

Jadi untuk daftar, kita perlu menemukan posisi, yang akan mengubah simbol ketidaksetaraan jika menunjuk ke arah yang salah. Kami menemukan posisi hanya dengan mengambil bit paling signifikan dari pasangan. Kami menggabungkan semua posisi ini (dengan atau) untuk menghasilkan nomor kandidat. Kami periksa, jika kami tidak secara tidak sengaja menghancurkan pasangan yang sudah diurutkan.

Ju.|G^2slHxMf>FT.:Q2Z   implicit: Q = input list
                .:Q2    all substrings of length 2
            f>FT        filter for pairs that are in descending order
          xM            apply xor to each such pair
 u                  Z   reduce this list, start value G = 0
                           iteration value is H
     ^2slH                 2 to the power of floor(logarithm base 2 of H)
                           this gives a mask representing the most significant bit
  .|G                      update G with the bitwise or of G and ^
J                       store the result in J


|tSIxRJQJ   
    xRJQ      xor each element of the input list with J
  SI          check if the list is sorted
 t            subtract 1
|       J     this number or (if equal to zero) J
              implicit print

Ruby 2, 119

->a,*o{a.each_cons(2){|x,y|x==y||o[i=(x^y).bit_length-1]==1-(o[i]=x[i])&&(return-1)};(o.map(&:to_i).reverse*'').to_i 2}

Berjalan dalam 42 milidetik pada kasus uji besar.

Tidak Disatukan:

def first_differing_bit(a,b)
  (a^b).bit_length - 1
end

def xort(ary)
  required_bits = []
  ary.each_cons(2) do |a,b|
    i = first_differing_bit(a,b)
    if i > -1
      bit = a[i]
      if required_bits[i] && required_bits[i] != bit
        return -1
      else
        required_bits[i] = bit
      end
    end
  end
  required_bits.map(&:to_i).reverse.join.to_i(2)
end

Untuk pertama kalinya saya menulis versi yang ungolfed, lalu memainkannya, karena mencari tahu algoritma yang tepat adalah tantangan tersendiri.

Saya sebenarnya mencoba menulis sesuatu seperti ini beberapa tahun yang lalu untuk membuat struktur pohon biner yang secara lokal akan menyeimbangkan diri dengan membiarkan setiap node mendefinisikan kembali fungsi pembandingannya secara dinamis. Pada awalnya saya pikir saya hanya bisa menggunakan xor, tetapi seperti yang Anda katakan untuk data acak tidak mungkin ada nilai yang layak.

Julia, 174 144 77 75 71

[EDIT] Terima kasih kepada Alex A. untuk penganoniman & berbagai singkatan.
[EDIT 2] Mengganti implementasi saya sendiri dengan builtin issorted().

Berjalan dalam waktu linier dan menangani file besar tanpa penundaan yang nyata. Berfungsi dengan baik untuk angka negatif.

l->(r=0;s=issorted;for d=63:-1:0 s((l$r).>>d)||(r$=2^d)end;s(l$r)?r:[])

Varian lain yang menghitung hasil paling dekat dengan kunci yang diberikan (yang di atas mengembalikan yang terkecil).

(l,r)->(s=issorted;for d=63:-1:0 s((l$r).>>d)||(r$=2^d)end;s(l$r)?r:[])

pemakaian:

julia> xort = l->(r=0;s=issorted;for d=63:-1:0 s((l$r).>>d)||(r$=2^d)end;s(l$r)?r:[])
(anonymous function)

julia> xort([4 7 6 1 0 3])
5

Contoh, langkah demi langkah: [4 7 6 1 0 3] => 5

Start with:
     4  0b0100
     7  0b0111
     6  0b0110
     1  0b0001
     0  0b0000
     3  0b0011
result  0b0000

If the first n bits are sorted, do nothing.
        0b0
        0b0
        0b0
        0b0
        0b0
        0b0
result  0b0000
          ^
If the first n bits are not sorted, flip the nth bit.
        0b01            0b00
        0b01            0b00
        0b01            0b00
        0b00      =>    0b01
        0b00            0b01
        0b00            0b01
result  0b0000          0b0100
           ^               ^
        0b000
        0b001
        0b001
        0b010
        0b010
        0b011
result  0b0100
            ^
        0b0000          0b0001  1
        0b0011          0b0010  2
        0b0010          0b0011  3
        0b0101    =>    0b0100  4
        0b0100          0b0101  5
        0b0111          0b0110  6
result  0b0100          0b0101  5
             ^               ^
If the bit flip does not sort the truncated integers, xorting is
impossible. We continue anyway and check for success in the end.

JavaScript (ES6) 85 97 114 117

Edit Dihapus bodoh, tidak berguna lalu DAN
Edit2 Pencarian bit pendek dipersingkat
Edit3 Wow! Saya menemukan bahwa ES6 (hampir) memiliki builtin untuk menemukan bit atas (Math.clz32 menghitung 0 bit atas)

Ini didasarkan pada solusi @Jakube (mohon maaf atas hal itu). Saya tidak akan pernah bisa menemukannya sendiri.

Di sini saya melangkah maju, mengulang daftar sekali dan menjaga bit mask dengan bit yang harus dibalik, dan satu lagi dengan bit yang harus disimpan.

Jika ada tumpang tindih masker bit, maka tidak ada solusi yang mungkin, jika tidak solusinya adalah "bit to flip"

Karena operasi biner dalam javascript hanya berfungsi pada bilangan bulat 32 bit yang ditandatangani, nilai kembalinya adalah bilangan bulat 32 bit yang ditandatangani yang bisa negatif atau 0.

Jika tidak ada solusi, nilai baliknya adalah 'X'

l=>l.map(v=>(t=v^p&&1<<(31-Math.clz32(v^p)),v>p?k|=t:c|=t,p=v),p=l[c=k=0])&&c&k?"X":c

Uji

Semakin lama tes pada jsfiddle

X=l=>l.map(v=>(t=v^p&&1<<(31-Math.clz32(v^p)),v>p?k|=t:c|=t,p=v),p=l[c=k=0])&&c&k?"X":c

console.log=x=>O.textContent+=x+'\n'
;[
[[4,7,6,1,0,3], 5],
[[4,7,1,6,0,3], 'X'],
[[0,1,3,4,6,7], 0],
[[4,2,3,1], 6], 
[[2,3,0,0,7,7,4,5,11,11], 2],
[[2,3,0,0,7,7,5,4,11,11], 'X'],
[[1086101479,748947367,1767817317,656404978,1818793883,1143500039],'X'],
[[180522983,1885393660,751646477,367706848,331742205,724919510,850844696,2121330641,869882699,1831158987,542636180,1117249765,823387844,731663826,1762069894,240170102,1020696223,1212052937,2041219958,712044033,195249879,1871889904,1787674355,1849980586,1308879787,1743053674,1496763661,607071669,1987302942,178202560,1666170841,1035995406,75303032,1755269469,200581873,500680130,561748675,1749521426,1828237297,835004548,934883150,38711700,1978960635,209243689,1355970350,546308601,590319412,959613996,1956169400,140411967,112601925,88760619,1977727497,672943813,909069787,318174568,385280382,370710480,809689639,557034312,865578556,217468424,346250334,388513751,717158057,941441272,437016122,196344643,379529969,821549457,97008503,872313181,2105942402,603939495,143590999,1580192283,177939344,853074291,1288703007,1605552664,162070930,1325694479,850975127,681702163,1432762307,1994488829,780869518,4379756,602743458,1963508385,2115219284,1219523498,559301490,4191682,1918142271,169309431,346461371,1619467789,1521741606,1881525154],'X'],
[[37580156,64423492,87193676,91914964,93632157,96332899,154427982,176139560,184435039,228963836,230164674,279802291,301492375,309127664,345705721,370150824,380319820,403997410,410504675,416543032,418193132,424733526,428149607,435596038,477224208,515649925,519407995,525469350,614538124,624884850,642649261,653488151,679260270,685637235,690613185,739141066,825795124,832026691,832633584,833213619,852655299,913744258,917674993,921902522,925691996,931307936,954676047,972992595,997654606,1020009811,1027484648,1052748108,1071580605,1108881241,1113730139,1122392118,1154042251,1170901568,1180031842,1180186856,1206428383,1214066097,1242934611,1243983997,1244736049,1262979035,1312007069,1312030297,1356274316,1368442960,1377432523,1415342434,1471294243,1529353536,1537868913,1566069818,1610578189,1612277199,1613646498,1639183592,1668015280,1764022840,1784234921,1786654280,1835593744,1849372222,1875931624,1877593764,1899940939,2007896363,2023046907,2030492562,2032619034,2085680072,2085750388,2110824853,2123924948,2131327206,2134927760,2136423634],0],
[[1922985547,1934203179,1883318806,1910889055,1983590560,1965316186,2059139291,2075108931,2067514794,2117429526,2140519185,1659645051,1676816799,1611982084,1736461223,1810643297,1753583499,1767991311,1819386745,1355466982,1349603237,1360540003,1453750157,1461849199,1439893078,1432297529,1431882086,1427078318,1487887679,1484011617,1476718655,1509845392,1496496626,1583530675,1579588643,1609495371,1559139172,1554135669,1549766410,1566844751,1562161307,1561938937,1123551908,1086169529,1093103602,1202377124,1193780708,1148229310,1144649241,1257633250,1247607861,1241535002,1262624219,1288523504,1299222235,840314050,909401445,926048886,886867060,873099939,979662326,963003815,1012918112,1034467235,1026553732,568519178,650996158,647728822,616596108,617472393,614787483,604041145,633043809,678181561,698401105,776651230,325294125,271242551,291800692,389634988,346041163,344959554,345547011,342290228,354762650,442183586,467158857,412090528,532898841,534371187,32464799,21286066,109721665,127458375,192166356,146495963,142507512,167676030,236532616,262832772],1927544832],
[[1922985547,1934203179,1883318806,1910889055,1983590560,1965316186,2059139291,2075108931,2067514794,2117429526,2140519185,1659645051,1676816799,1611982084,1736461223,1810643297,1753583499,1767991311,1819386745,1355466982,1349603237,1360540003,1453750157,1461849199,1439893078,1432297529,1431882086,1427078318,1487887679,1484011617,1476718655,1509845392,1496496626,1583530675,1579588643,1609495371,1559139172,1554135669,1549766410,1566844751,1562161307,1561938937,1123551908,1086169529,1093103602,1202377124,1193780708,1148229310,1144649241,1257633250,1241535002,1247607861,1262624219,1288523504,1299222235,840314050,909401445,926048886,886867060,873099939,979662326,963003815,1012918112,1034467235,1026553732,568519178,650996158,647728822,616596108,617472393,614787483,604041145,633043809,678181561,698401105,776651230,325294125,271242551,291800692,389634988,346041163,344959554,345547011,342290228,354762650,442183586,467158857,412090528,532898841,534371187,32464799,21286066,109721665,127458375,192166356,146495963,142507512,167676030,236532616,262832772],'X']
].forEach(t=>{
  var i=t[0],k=t[1],r=X(i)
  console.log((k==r?'OK ':'Error (expected '+k+') ')+r+' for input '+i)
})

<pre id=O></pre>

ES6, 84 byte

a=>(i=e=0,a.reduce((x,y)=>(z=1<<31-Math.clz32(x^y),x>y?i|=z:y>x?e|=z:z,y)),i&e?-1:i)

Sunting: Pada saat saya menulis jawaban, algoritma sudah diposkan secara independen oleh @Jakube; algoritme saya sama tetapi ini tidak jujur ​​plagiarisme! Juga saya perhatikan jawaban JavaScript lain sejak itu telah diposting juga. Maaf jika saya menginjak kaki siapa pun.

Sunting: Disimpan 8 byte berkat edc65.

C, 144 byte

#include <strings.h>
#include <stdio.h>
m[2],l,i;main(v){while(scanf("%d",&v)==1)m[l<v]|=(i++&&v^l)<<~-fls(v^l),l=v;printf("%d",*m&m[1]?-1:*m);}

Ini hampir standar C99 (ia kehilangan beberapa intspecifier dan memiliki 1 argumen untuk main). Ini juga bergantung pada 0<<-10 (yang tampaknya benar ketika dikompilasi dengan Dentang setidaknya - saya belum menguji yang lain)

Saya telah mengambil metode Jakube dan porting ke C. Saya pikir itu tidak mengherankan baik ukuran untuk C. Ini juga sangat cepat (0,061 untuk menjalankan semua file tes, termasuk 4 besar). Dibutuhkan input dari STDIN dan akan mencetak nilai yang cocok atau -1 ke STDOUT, jadi jalankan dengan salah satu dari:

echo "4 7 6 1 0 0 3" | ./xort
./xort < file.txt

Kerusakan:

// Globals initialise to 0
m[2],                                    // Stores our bit masks
                                         // (m[0]=CHANGE, m[1]=MUST NOT CHANGE)
l,                                       // Last value
i;                                       // Current iteration
main(v){
    while(scanf("%d",&v)==1)             // Read each value in turn
        m[l<v]|=                         // If they are sorted, we mark a bit as
                                         // MUST NOT CHANGE (m[1]), otherwise we
                                         // mark as CHANGE (m[0])
                (i++&&v^l)               // If this is the first iteration,
                                         // or the value is unchanged, mark nothing
                          <<~-fls(v^l),  // Mark the highest bit which has changed
                                         // = (1<<(fls(v^l)-1)
        l=v;                             // Update last value
    printf("%d",
                *m&m[1]                  // Check if result is valid (if any bits
                                         // are both MUST NOT CHANGE and CHANGE,
                                         // it is not valid)
                       ?-1               // Print -1 on failure
                          :*m);          // Print value on success
}

Julia, 124 byte

f(x,g=0)=issorted(([g|=2^Int(log2(h)÷1)for h=map(k->k[1]$k[2],filter(j->j[1]>=j[2],[x[i-1:i]for i=2:endof(x)]))];g)$x)?g:-1

Ini adalah fungsi yang menerima array integer dan mengembalikan integer. Itu menggunakan pendekatan Jakube .

Tidak Disatukan:

function f{T<:Integer}(x::Array{T,1}, g::T=0)
    # Get all pairs of elements in the input array
    pairs = [x[i-1:i] for i = 2:endof(x)]

    # Filter to pairs in descending order
    desc = filter(j -> j[1] ≥ j[2], pairs)

    # Map XOR over these pairs
    xord = map(k -> k[1] $ k[2], desc)

    # For each element of this array, update the
    # parameter g (which defaults to 0) as the
    # bitwise OR of itself and 2^floor(log2(element))
    for h in xord
        g |= 2^Int(log2(h) ÷ 1)
    end

    # If the array constructed as g XOR the input is
    # sorted, we've found our answer! Otherwise -1.
    return issorted(g $ x) ? g : -1
end

Python 2, 204 byte

def f(a):
 m=n=0
 for i in range(32):
  b=2**(31-i);m|=b
  for n in[n,n|b]:
   if not q(a,m,n):break
  else:return-1
 return n
def q(a,m,n):
 if a:p=a[0]&m^n
 for t in a:
  t=t&m^n
  if t<p:return 1
  p=t

Input dilewatkan sebagai daftar untuk berfungsi f.

Kode ini menggambarkan nilai N (dinamai n dalam program) satu bit pada satu waktu, dimulai dengan bit yang paling signifikan. (loop "untuk saya")

Untuk setiap posisi bit, loop "for n" pertama kali mencoba menggunakan 0 untuk bit n tersebut. Jika itu tidak berhasil, ia mencoba menggunakan 1. Jika tidak satu pun dari ini bekerja, maka tidak ada solusi. Perhatikan bahwa klausa lain ada di loop "for n", bukan pernyataan if. Dalam Python, pernyataan for dapat memiliki klausa lain, yang dieksekusi setelah loop berjalan sampai selesai, tetapi tidak dieksekusi jika kita keluar dari loop.

Fungsi q memeriksa masalah dengan urutan daftar yang diberikan daftar (a), bit mask (m), dan nilai yang akan di-xored dengan masing-masing nilai dalam daftar (n). Mengembalikan 1 jika ada masalah dengan pemesanan, atau Tidak ada jika pesanan ok. Tidak ada nilai pengembalian default, sehingga menyelamatkan saya beberapa karakter.

Kode ini menangani daftar kosong atau daftar dengan 1 elemen dengan benar, menghasilkan 0. Fungsi "jika a:" ada hanya untuk menghindari pengecualian IndexError ketika daftar kosong. Jadi 5 byte lagi dapat dihapus jika penanganan daftar kosong tidak diperlukan.

Di komputer saya, test case besar # 3 butuh 0,262 detik. # 2 mengambil hal yang sama. Semua kasus uji bersama-sama mengambil 0,765 detik.

CJam, 37 byte

q~_2ew{:>},{:^2mLi2\#}%0+:|_@f^_$=\W?

Uji di sini.

Ini menggunakan algoritma yang sama dengan beberapa jawaban lainnya. Ini pada dasarnya implementasi referensi saya yang saya gunakan untuk membuat test case. Namun, saya mencuri trik Jakube hanya memeriksa pasangan yang menyinggung dan hanya mencoba hasilnya dengan semacam. Itu merusak pseudolinearitas, tetapi O (n log n) masih cukup cepat untuk kasus uji. Kode asli saya juga memeriksa pasangan yang sudah berurutan, dan menyusun daftar bit yang tidak boleh di-toggle untuk menjaga urutan relatifnya, dan memeriksa pada akhirnya bahwa tidak ada tumpang tindih antara kedua topeng bit. Algoritma ini awalnya disarankan oleh Ben Jackson .

Python 2, 226 214 byte

Algoritma simpleish, dibangun kemarin, golf hari ini.

o=input()
s=sorted
p=s(set(o),key=o.index)
n=q=0
while 1:
 a=1
 while 1-q and p[0]<p[1]:p=p[1:];q=len(p)==1
 if q:break
 while not p[0]^a<p[1]^a:a*=2
 n+=a;p=[i^a for i in p]
t=[a^n for a in o]
print[-1,n][s(t)==t]

Tidak Disatukan:

def xor(a,b): return a^b

def rm_dupes(seq):
    seen = set()
    seen_add = seen.add
    return [x for x in seq if not (x in seen or seen_add(x))]

def rm_sorted(seq):
    while seq[0] < seq[1]:
        seq = seq[1:]
        if len(seq) == 1: return seq
    return seq

inp = input()
oi = inp

inp = rm_dupes(inp)
n=0
old_inp=0
while old_inp != inp:
    old_inp = inp
    inp = rm_sorted(inp)
    if len(inp)==1:break
    highest_set0 = len(bin(inp[0]))-3 # bin returns in form 0bxxx
    highest_set1 = len(bin(inp[1]))-3 # bin returns in form 0bxxx
    if highest_set1 == 0:
        try:
            t0 = max(int(bin(inp[0])[3:], 2), 1)
        except ValueError: toggle_amount = 1
        else: toggle_amount = t0^inp[0]
    else:
        fallen = False
        for i in xrange(max(highest_set0,highest_set1)+1):
            toggle_amount = 2**i
            if inp[0]^toggle_amount < inp[1]^toggle_amount:
                fallen = True
                break
        assert(fallen)
    n+=toggle_amount
    inp = [i^toggle_amount for i in inp]

out=map(xor, oi, [n]*len(oi))
if sorted(out)==out :print n
else:print -1

C, 312 byte

#define R return
t,i,*b;f(int*a,int l,int k){int s=a[0]>>k&1,j=-1,i=1;if(k<0)R 0;for(;i<l;++i){t=a[i]>>k&1;if(s!=t)if(j<0)j=i,s=t;else R 1;}if(j<0)R f(a,l,k-1);else{if(s+b[k]==2)R 1;b[k]=s+1;R f(a,j,--k)||f(a+j,l-j,k);}}h(int*a,int l){int c[32]={0};b=c;if(f(a,l,30))R -1;t=0;for(i=0;i<32;++i)t|=(b[i]&1)<<i;R t;}

Menentukan fungsi yang h(int*a,int l)membawa pointer ke array dan panjangnya. Berikut ini adalah program uji raksasa.

Sedikit tidak berbulu:

int t, i, *b;

int f(int * a, int l, int k) {
    int s = a[0] >> k & 1;
    int j = -1;
    int i = 1;
    if (k < 0) return 0;
    for (; i < l; ++i) {
        t = a[i] >> k & 1;
        if (s != t) {
            if (j < 0) {
                j = i;
                s = t;
            } else return 1;
        }
    }
    if (j < 0) {
        return f(a, l, k - 1);
    } else {
        if (s + b[k] == 2) return 1;
        b[k] = s + 1;
        return f(a, j, --k) || f(a + j, l - j, k);
    }
}

int h(int * a, int l) {
    int c[32] = {0};
    b = c;
    if (f(a, l, 30)) return -1;
    t = 0;
    for (i = 0; i < 32; ++i) {
        t |= (b[i] & 1) << i;
    }
    return t;
}

Mathematica, 99 97 Karakter

Terima kasih kepada Martin Büttner untuk sarannya.

x@l_:=If[OrderedQ[l~BitXor~#],#,-1]&@Fold[#+#2Boole@!OrderedQ@⌊l~BitXor~#/#2⌋&,0,2^32/2^Range@32]

Penjelasan:

Kami akan melakukan beberapa percobaan untuk memodifikasi Nmulai dari nol, dan melakukan tes untuk memvalidasi kandidat N.

Langkah 1. Kami mendapatkan angka-angka ini (32-bit bilangan bulat) "xor" ed oleh N( = 0sekarang) dan dibagi dengan 2^31: ⌊l~BitXor~#/#2⌋. Ada tiga kasus:

• dipesan, misalnya {0, 0, 1, 1, 1, 1, 1, 1};
• dapat diperbaiki, misalnya {1, 1, 1, 1, 0, 0, 0, 0};
• lain, mis {0, 0, 1, 0, 0, 1, 1, 1}.

Kami melakukan apa-apa untuk Nuntuk kasus pertama, atau kita tambahkan 2^31untuk Nmemperbaiki agar kasus kedua: #+#2Boole@!OrderedQ@.... Sedangkan untuk kasus ketiga, adalah mustahil untuk xorting daftar apa yang pernah kita lakukan, sehingga kita hanya menambahkan 2^31untuk Nuntuk kesederhanaan (atau apa pun!).

Langkah 2. Kami mendapatkan angka-angka ini "xor" ed oleh Ndan dibagi dengan 2^30. Ada lagi tiga kasus:

• dipesan, misalnya {0, 1, 2, 2, 2, 2, 3, 3};
• dapat diperbaiki, misalnya {1, 1 , 0, 0, 3, 2, 2, 2};
• lain, mis {3, 3, 1, 3, 2, 0, 1, 0}.

Kami melakukan apa-apa untuk Nuntuk kasus pertama, atau kita tambahkan 2^30untuk Nmemperbaiki agar kasus kedua. Jika tidak, kita menyadari bahwa xorting tidak mungkin, sehingga kita hanya menambahkan 2^30untuk Nuntuk kesederhanaan lagi.

Langkah 3 ~ 32. Kami rekursif mendapatkan angka-angka ini "xor" ed oleh Ndan dibagi dengan 2^29, 2^28, ..., 2^0. Dan lakukan hal serupa:Fold[...,0,2^32/2^Range[32]]

Langkah 33. Sekarang kita akhirnya mendapatkan kandidat N. If[OrderedQ[l~BitXor~#],#,-1]&digunakan untuk memeriksa apakah itu Nmemang xorting daftar. Jika daftar dapat di-xorting oleh sebagian orang N, tidak sulit untuk membuktikan bahwa kita akan selalu menemukan kasus pertama atau kedua.

Perl 6 , 79 byte

Jika tidak ada batas waktu kode Perl 6 terpendek mungkin akan

{first {[<=] $_ X+^@_},^2*.max} # 31 bytes

Sebaliknya saya harus melakukan sesuatu yang sedikit lebih pintar.
Karena saya perlu beberapa saat untuk kembali ke ini, sudah ada jawaban yang menggambarkan algoritma yang baik, dan alasan di baliknya.

{$/=0;for @_.rotor(2=>-1) ->(\a,\b){b>=a or$/+|=2**msb a+^b};$/if [<=] $/X+^@_} # 79

{
  # cheat by using a special variable
  # so there is no need to declare it
  $/=0;

  # takes the elements two at a time, backing up one
  for @_.rotor(2=>-1)
    # since that is a non-flat list, desugar each element into 2
    # terms
    ->(\a,\b){
      # if they are not sorted
      b>=a or
      # take the most significant bit of xoring the two values
      # and numeric or ｢+|｣ it into ｢$/｣
      $/+|=2**msb a+^b
    };


  # returns ｢$/｣ if the list is Xorted
  # otherwise returns Empty
  $/if [<=] $/X+^@_

  # ｢ $/ X[+^] @_ ｣
  # does numeric xor ｢+^｣ between ｢$/｣
  # and each element of the original list ｢@_｣
}

Pemakaian:

# give it a lexical name for ease of use
my &code = {...}

say code [8,4,3,2,1];     # 15

say code [4,7,6,1,0,3]; # 5
say code [4,7,1,6,0,3]; # ()
say code [0,1,3,4,6,7]; # 0
say code [4,2,3,1];     # 6
say code [2,3,0,0,7,7,4,5,11,11]; # 2
say code [2,3,0,0,7,7,5,4,11,11]; # ()
say code [1086101479,748947367,1767817317,656404978,1818793883,1143500039]; # ()

# the example files
for 'testfiles'.IO.dir.sort».comb(/«\d+»/) {
  printf "%10s in %5.2f secs\n", code( @$_ ).gist, now - ENTER now;
}
#         () in  9.99 secs
#          0 in 11.70 secs
# 1096442624 in 13.54 secs
#         () in 11.44 secs

Mathematica 650 415 194 byte

Tantangan ini membantu saya memahami sedikit tentang hal Xoryang belum pernah saya pikirkan. Butuh waktu lama untuk memotong kode, tetapi sepadan dengan usaha.

BitXorbekerja langsung pada basis 10 angka. Ini sangat mengurangi kode dari versi sebelumnya.

Logikanya sederhana. Satu berfungsi, tidak dengan pasangan angka (seperti yang dilakukan beberapa pengiriman) tetapi dengan set angka lengkap setelah BitXordiedit dengan "kunci" saat ini.

Mulai dengan solusi tentatif, atau "kunci" dari nol, yaitu semua bit adalah nol. Ketika nangka asli BitXordiedit dengan nol, mereka dikembalikan, tidak berubah. Korelasikan pengurutan angka dengan kisaran 1, 2, ...n, yang mewakili daftar yang dipesan dengan sempurna. Korelasi, dengan nilai antara -1 dan 1, mencerminkan seberapa baik angka yang dipesan.

Kemudian atur bit hi, dapatkan kunci baru, dan BitXorkunci dengan set angka saat ini. Jika korelasi antara urutan angka baru dan daftar yang diurutkan dengan sempurna adalah peningkatan, pertahankan bit yang ditetapkan. Jika tidak, biarkan bitnya tidak disetel.

Lanjutkan dengan cara ini dari hi ke bit rendah. Jika korelasi terbaik adalah 1, maka kuncinya adalah solusinya. Jika tidak, itu -1.

Akan ada cara untuk membuat kode sedikit lebih efisien, misalnya, dengan mengganggu proses segera setelah solusi ditemukan, tetapi ini akan membutuhkan lebih banyak pengkodean dan pendekatan saat ini sangat cepat seperti itu. (Kasus uji terakhir dan terpanjang membutuhkan waktu 20 msec.)

c@i_:=Correlation[Ordering@i,Range[Length[i]]]//N;
t@{i_,k_,b_,w_}:=(v= c@BitXor[i,m=k+2^(b-1)];{i,If[v>w,m,k],b-1,v~Max~w})
g@i_:= (If[#4==1,#2,-1] &@@Nest[t,{i,0,b=1+Floor@Log[2,Max@i],x=c@i},b])

g[{4, 7, 6, 1, 0, 3}]

5

g[{4, 7, 1, 6, 0, 3}]

-1

g2@{0, 1, 3, 4, 6, 7}

0

g@{1922985547, 1934203179, 1883318806, 1910889055, 1983590560, 1965316186,2059139291, 2075108931, 2067514794, 2117429526, 2140519185, 1659645051, 1676816799, 1611982084, 1736461223, 1810643297, 1753583499, 1767991311, 1819386745, 1355466982, 1349603237, 1360540003, 1453750157, 1461849199, 1439893078, 1432297529, 1431882086, 1427078318, 1487887679, 1484011617, 1476718655, 1509845392, 1496496626, 1583530675, 1579588643, 1609495371, 1559139172, 1554135669, 1549766410, 1566844751, 1562161307,1561938937, 1123551908, 1086169529, 1093103602, 1202377124, 1193780708, 1148229310, 1144649241, 1257633250, 1247607861, 1241535002, 1262624219, 1288523504, 1299222235,840314050, 909401445, 926048886, 886867060, 873099939, 979662326,963003815, 1012918112, 1034467235, 1026553732, 568519178, 650996158,647728822, 616596108, 617472393, 614787483, 604041145, 633043809, 678181561, 698401105, 776651230, 325294125, 271242551, 291800692, 389634988, 346041163, 344959554, 345547011, 342290228, 354762650, 442183586, 467158857, 412090528, 532898841, 534371187, 32464799, 21286066, 109721665, 127458375, 192166356, 146495963, 142507512, 167676030, 236532616, 262832772}

1927544832

Tambahkan ++ , 125 119 byte

D,g,@@,BxBBBDbU1€oB]BJ2$Bb1+
D,j,@,bUBSVcGbU£{g}B]BkAbUBSVcGbU£>B]BKBcB*¦Bo2/i
L!,B#a=
D,f,?!,{j}Vad{j}BF€Bx1]G$0=-1$Qp

Cobalah online!

_{Saya sebenarnya sangat bangga bahwa Add ++ dapat melakukan ini, dan bukan solusi terpanjang di sini}

Mendeklarasikan fungsi fyang mengambil setiap elemen sebagai argumen terpisah (mis. $f>4>2>3>1)

Bagaimana itu bekerja

Mengikat orang-orang, itu akan menjadi perjalanan panjang

D,g,@@,		; Declare a function 'g'
		; Example arguments: 		[4 7]
	Bx	; Xor;			STACK = [3]
	BB	; To binary;		STACK = [11]
	BD	; Digits;		STACK = [[1 1]]
	bU	; Unpack;		STACK = [1 1]
	1€o	; Replace 0s with 1s;	STACK = [1 1]
	B]	; Wrap;			STACK = [[1 1]]
	BJ	; Concatenate;		STACK = ['11']
	2$Bb	; From binary;		STACK = [3]
	1+	; Increment;		STACK = [4]
		;			Return   4

D,j,@,		; Declare a function 'j'
		; Example argument:		[[4 7 6 1 0 3]]
	bU	; Unpack;		STACK = [4 7 6 1 0 3]
	BS	; Overlapping pairs;	STACK = [4 7 6 1 0 3 [[4 7] [4 6] [6 1] [1 0] [0 3]]]
	VcG	; Keep first element;	STACK = [[[4 7] [4 6] [6 1] [1 0] [0 3]]]
	bU	; Unpack;		STACK = [[4 7] [4 6] [6 1] [1 0] [0 3]]
	£{g}	; Apply 'g' over each;	STACK = [4 2 8 2 4]
	B]	; Wrap;			STACK = [[4 2 8 2 4]]
	Bk	; Global save;		STACK = []		; GLOBAL = [4 2 8 2 4]
	A	; Push arguments;	STACK = [[4 7 6 1 0 3]]
	bU	; Unpack;		STACK = [4 7 6 1 0 3]
	BSVcGbU	; Overlapping pairs;	STACK = [[4 7] [4 6] [6 1] [1 0] [0 3]]
	£>	; Greater than each;	STACK = [0 1 1 1 0]
	B]	; Wrap;			STACK = [[0 1 1 1 0]]
	BK	; Global get;		STACK = [[0 1 1 1 0] [4 2 8 2 4]]
	BcB*	; Products;		STACK = [[0 2 8 2 0]]
	¦Bo	; Reduce by logical OR;	STACK = [10]
	2/i	; Halve;		STACK = [5]
		;			Return   5

L!,		; Declare 'lambda 1'
		; Example argument:		[[1 2 3 4 5]]
	B#	; Sort;			STACK = [[1 2 3 4 5]]
	a=	; Equal to argument;	STACK = [1]
		; 			Return   1

D,f,?!,		; Declare a function 'f'
		; Example arguments:		[[4 7 6 1 0 3]]
	{j}	; Call 'j';		STACK = [5]
	V	; Save;			STACK = []		; REGISTER = 5
	ad	; Push arguments twice;	STACK = [[4 7 6 1 0 3] [4 7 6 1 0 3]]
	{j}	; Call 'j';		STACK = [[4 7 6 1 0 3] 5]
	BF	; Flatten;		STACK = [4 7 6 1 0 3 5]
	€Bx	; Xor each with 5;	STACK = [1 2 3 4 5 6]
	1]	; Call 'lambda 1';	STACK = [1]
	G$	; Retrieve REGISTER;	STACK = [5 1]
	0=	; If equal to 0:
	-1$Q	;   Return -1
	p	; Else, pop condition;	STACK = [5]
		;			Return   5

Stax , 29 byte

¬√▬ⁿ{j╔■α√ï(íP♫_z(.▀ng▒JU↨@b┬

Jalankan dan debug online!

Menggunakan solusi RainerP. (Muncul dengan bagian bit membalik secara mandiri tetapi menggunakan 32rrbagian itu)

Kompleksitas waktu linier.

Gunakan versi yang belum dibongkar untuk menjelaskan.

32rr{|2Y;{y/m:^!c{,{y|^m~}Mm,:^ud:b
32rr                                   Range [32,31..0]
    {                      m           Map each number `k` in the range with
     |2Y                                   `2^k`
        ;{y/m                              Map each number `l` in the input to `floor(l/2^k)`
             :^!                           The mapped array is not non-decreasing
                                           This is the binary digit `l` is mapped to
                c{       }M                If that's true, do
                  ,{y|^m~                  Flip the corresponding bit of every element in the input
                            ,:^        The final array is sorted
                               ud      Take inverse and discard, if the final array is not sorted this results in zero-division error
                                 :b    Convert mapped binary to integer