Về mặt khái niệm, thử thách này thực sự đơn giản. Bạn được cung cấp một danh sách các số nguyên không âm . Nếu có thể, hãy tìm một số nguyên không âm , sao cho danh sách bao gồm được sắp xếp. Nếu không có như vậy , đầu ra sẽ là bất cứ thứ gì không thể nhầm với giá trị , ví dụ số âm, không có gì cả, lỗi, v.v.aiNbi = ai XOR NNN

Đây là một ví dụ:

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

Nếu chúng tôi lấy mọi yếu tố trong danh sách này XOR 5, chúng tôi sẽ nhận được

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

được sắp xếp. (Lưu ý rằng danh sách kết quả không có các phần tử duy nhất và không có khoảng trống. Nếu kết quả của thao tác [0, 1, 1, 3]đó vẫn không hợp lệ.) Mặt khác cho danh sách

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

không Ntồn tại

Bạn có thể viết chương trình hoặc hàm, lấy đầu vào qua STDIN (hoặc thay thế gần nhất), đối số dòng lệnh hoặc đối số hàm và xuất kết quả qua tham số STDOUT (hoặc thay thế gần nhất), tham số trả về hàm hoặc tham số hàm (out).

Đầu vào có thể ở bất kỳ danh sách thuận tiện hoặc định dạng chuỗi. Bạn có thể giả sử rằng ít hơn mỗi và danh sách chứa ít nhất một phần tử.ai231

Mã của bạn phải xử lý bất kỳ trường hợp thử nghiệm nào (đặc biệt là bốn trường hợp lớn) trong vài giây.

Mã tiêu chuẩnLuật áp dụng.

Các trường hợp thử nghiệm

Đối với mọi trường hợp kiểm tra không trả về, -1có vô số câu trả lời đúng. Cái được liệt kê ở đây là cái nhỏ nhất. Các giải pháp bổ sung tồn tại bằng cách bổ sung các bit giống nhau trên tất cả các số nguyên trong đầu vào (đáng chú ý là các bit lớn hơn bit có ý nghĩa nhất trong số lượng lớn nhất của danh sách).

[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

Cuối cùng, đây là bốn trường hợp thử nghiệm rất lớn để đảm bảo rằng các bài nộp đủ hiệu quả:

• Trường hợp kiểm tra 1 nên mang lại -1.
• Trường hợp thử nghiệm 2 nên mang lại 0.
• Trường hợp thử nghiệm 3 nên mang lại 1096442624.
• Trường hợp thử nghiệm 4 nên mang lại -1.

Tại sao mọi người sẽ làm điều này?

Một ngày khác, một thao tác XOR có thể "sắp xếp" một mảng, điều này cho phép thực hiện tìm kiếm nhị phân trên mảng trong O (log n) mà không phải sắp xếp trước. Dường như có thể xác địnhN trong thời gian giả, điều này sẽ làm cho điều này trở thành một sự thay thế nhanh hơn cho hầu hết các thuật toán sắp xếp và nó không có các yêu cầu về bộ nhớ của loại cơ số. Tất nhiên, một tìm kiếm tuyến tính thẳng qua mảng chưa sắp xếp sẽ nhanh hơn, nhưng nếu bạn muốn tìm kiếm cùng một mảng nhiều lần, một tính toán trước tuyến tính duy nhất có thể giảm thời gian cần thiết cho mỗi tìm kiếm.

Thật không may, lớp danh sách này hoạt động khá hạn chế (phân phối ngẫu nhiên thống nhất không có khả năng thừa nhận N ).

Một câu hỏi thú vị là liệu có các chức năng phỏng đoán khác dễ kiểm tra hơn và / hoặc có thể áp dụng cho một danh sách rộng hơn không.

Thạch, 25 byte

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

Lần gần đây nhất cam kết hoãn thử thách này, nhưng đoạn mã trên hoạt động với phiên bản này , trước đó là thử thách . Hãy thử trực tuyến!

Để chạy các trường hợp thử nghiệm lớn, tùy thuộc vào vỏ của bạn, có thể cần phải bọc mã ở trên trong một chương trình đọc đầu vào từ STDIN. Hãy thử trực tuyến!

Các trường hợp thử nghiệm

$ 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

Ý tưởng

Điều này sử dụng một cách tiếp cận tương tự như câu trả lời của @ Jakube , nhưng cách thực hiện của tôi hơi khác một chút.

Jelly chưa có sự sắp xếp nào, vì vậy chúng tôi tính toán một ứng cử viên xorting, XOR danh sách đầu vào với nó, tính toán một ứng cử viên xorting của danh sách XORed và kiểm tra xem ứng cử viên mới có bằng không. Nếu có, chúng tôi in ứng cử viên đầu tiên; mặt khác, chúng tôi in -1 .

Ngoài ra, Jelly dường như chưa có cách nào để chuyển thành số nguyên (thậm chí phép chia số nguyên có thể trả về số float), vì vậy tôi đã đưa ra một cách khá sáng tạo để làm tròn danh sách các số xuống tới lũy thừa 2 . Thay vì log-floor-pow, tôi chuyển đổi tất cả các số nguyên thành nhị phân, thay thế tất cả các chữ số nhị phân bằng 1 , chuyển đổi lại thành số nguyên, thêm 1 và chia cho 2 .

Mã

ṡ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

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Mỗi trường hợp thử nghiệm lớn kết thúc sau vài giây.

Giải trình:

Đầu tiên tôi sẽ giải thích phương pháp và lý do tại sao nó hoạt động. Tôi sẽ làm điều này với danh sách ví dụ:[7, 2, 13, 9] .

Hai số đầu tiên đã sai ( 7 > 2). Chúng tôi muốn xor với một số số để thay đổi biểu tượng bất đẳng thức đó ( 7 xor X < 2 xor X). Vì xor hoạt động trên các biểu diễn nhị phân, hãy xem xét chúng.

7 = 1 1 1
2 =   1 0

Khi chúng tôi áp dụng xor với một số số cho mỗi số, giá trị tại một số vị trí sẽ thay đổi. Nếu bạn thay đổi các giá trị ở vị trí đầu tiên ( 2^0), biểu tượng bất bình đẳng sẽ không thay đổi. Điều tương tự cũng xảy ra, khi chúng ta thay đổi các giá trị ở vị trí thứ hai ( 2^1). Cũng là biểu tượng sẽ không thay đổi nếu chúng ta thay đổi giá trị tại thứ tư, thứ năm, ... vị trí ( 2^3, 2^4, ...). Biểu tượng bất bình đẳng chỉ thay đổi hướng, nếu chúng ta thay đổi vị trí thứ ba ( 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

Nếu chúng ta thay đổi nhiều vị trí cùng một lúc, tất nhiên điều tương tự sẽ xảy ra. Nếu bất kỳ vị trí nào chúng ta thay đổi là vị trí thứ ba, thì biểu tượng bất bình đẳng sẽ thay đổi, nếu không thì không.

Các cặp tiếp theo đã được sắp xếp : 2 < 13. Nếu chúng ta nhìn vào biểu diễn nhị phân, chúng ta nhận thấy rằng chúng ta có thể xor bất cứ thứ gì cho nó và biểu tượng bất bình đẳng vẫn đúng, ngoại trừ khi chúng ta thay đổi vị trí thứ tư ( 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

Vì vậy, chúng tôi không muốn thay đổi vị trí thứ tư. Đối với cặp tiếp theo, chúng tôi muốn thay đổi một cái gì đó, kể từ đó 13 > 9. Ở đây chúng tôi một lần nữa phải thay đổi vị trí thứ ba.

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

Bây giờ tóm tắt lại: Để kết thúc trong một danh sách được sắp xếp, một lần nữa chúng ta phải thay đổi vị trí thứ ba và không muốn thay đổi vị trí thứ tư. Tất cả các vị trí khác không quan trọng. Số lượng nhỏ nhất chỉ đơn giản là 4 = 0100. Lựa chọn khác sẽ là 5 = 0101, 6 = 0110, 7 = 0111, 20 = 10100, 21 = 10101, ...

Xoring với 4sẽ dẫn đến danh sách [3, 6, 9, 13], với 6sẽ nhận được [1, 4, 11, 15]và với 21sẽ nhận được [18, 23, 24, 28].

Vì vậy, đối với một danh sách, chúng ta cần tìm các vị trí, điều đó sẽ thay đổi biểu tượng bất bình đẳng nếu nó chỉ sai hướng. Chúng tôi tìm vị trí chỉ đơn giản bằng cách lấy bit đáng kể nhất của xor của cặp. Chúng tôi kết hợp tất cả các vị trí này (với hoặc) để tạo ra một số ứng cử viên. Chúng tôi kiểm tra, nếu chúng tôi vô tình phá hủy các cặp đã được sắp xếp.

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

Hồng ngọc 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}

Chạy trong 42 mili giây trên các trường hợp thử nghiệm lớn.

Ung dung:

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

Lần đầu tiên tôi đã viết phiên bản không có bản quyền, sau đó đánh gôn nó, vì việc tìm ra thuật toán đúng là một thách thức trong chính nó.

Tôi thực sự đã cố gắng viết một cái gì đó như thế này vài năm trước để tạo cấu trúc cây nhị phân tự cân bằng cục bộ bằng cách để mỗi nút xác định lại chức năng so sánh của nó một cách linh hoạt. Lúc đầu, tôi nghĩ rằng tôi chỉ có thể sử dụng xor, nhưng như bạn nói đối với dữ liệu ngẫu nhiên, không có khả năng là một giá trị khả thi.

Julia, 174 144 77 75 71

[EDIT] Cảm ơn Alex A. vì đã ẩn danh & các tốc ký khác nhau.
[EDIT 2] Đã thay thế triển khai của riêng tôi bằng nội dungissorted() .

Chạy trong thời gian tuyến tính và xử lý các tệp lớn mà không có độ trễ đáng chú ý. Hoạt động tốt như là số âm.

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

Một biến thể khác tính toán kết quả gần nhất với một khóa nhất định (ở trên trả về giá trị nhỏ nhất).

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

sử dụng:

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

Ví dụ, từng bước: [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

Chỉnh sửa Đã xóa ngu ngốc, cuối cùng vô dụng VÀ
Edit2 Tìm kiếm bit hàng đầu rút ngắn
Edit3 Wow! Tôi phát hiện ra rằng ES6 (gần như) có dựng sẵn để tìm các bit đầu (Math.clz32 đếm 0 bit đầu)

Điều này dựa trên giải pháp của @Jakube (vui lòng upvote mà). Tôi không bao giờ có thể tự tìm thấy nó.

Ở đây tôi tiến lên một bước, lặp lại danh sách một lần và giữ một mặt nạ bit với các bit phải được lật, và một bước khác với các bit phải được giữ.

Nếu có sự chồng lấp của mặt nạ bit, thì không có giải pháp nào khả thi, giải pháp khác là "bit to flip"

Vì các hoạt động nhị phân trong javascript chỉ hoạt động trên các số nguyên 32 bit đã ký, giá trị trả về là số nguyên 32 bit đã ký có thể âm hoặc 0.

Nếu không có giải pháp, giá trị trả về là '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

Kiểm tra

Các bài kiểm tra dài hơn trên 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)

Chỉnh sửa: Vào thời điểm tôi phải viết câu trả lời, thuật toán đã được đăng độc lập bởi @Jakube; thuật toán của tôi là như nhau nhưng đây không phải là đạo văn! Ngoài ra tôi nhận thấy một câu trả lời JavaScript khác cũng đã được đăng. Xin lỗi nếu tôi giẫm lên ngón chân của bất cứ ai.

Chỉnh sửa: Đã lưu 8 byte nhờ 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);}

Đây gần như là tiêu chuẩn C99 (nó bỏ lỡ một vài intchỉ định và có 1 đối số cho main). Nó cũng dựa vào số 0<<-10 (điều này có vẻ đúng khi được biên dịch với Clang ít nhất - tôi chưa thử nghiệm người khác)

Tôi đã sử dụng phương pháp của Jakube và chuyển nó sang C. Tôi nghĩ rằng nó rất khôn ngoan về kích thước đối với C. Nó cũng cực nhanh (0,061 giây để chạy tất cả các tệp thử nghiệm, bao gồm cả 4 tệp lớn). Nó nhận đầu vào từ STDIN và sẽ in giá trị khớp hoặc -1 thành STDOUT, vì vậy hãy chạy nó với một trong:

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

Phá vỡ:

// 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

Đây là một hàm chấp nhận một mảng số nguyên và trả về một số nguyên. Nó sử dụng phương pháp của Jakube .

Ung dung:

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

Đầu vào được truyền dưới dạng danh sách cho hàm f.

Mã này chỉ ra giá trị của N (được đặt tên là n trong chương trình) một bit tại một thời điểm, bắt đầu bằng bit quan trọng nhất. (vòng lặp "cho tôi")

Đối với mỗi vị trí bit, vòng lặp "for n" trước tiên thử sử dụng 0 cho bit đó của n. Nếu nó không hoạt động, nó sẽ thử sử dụng 1. Nếu cả hai đều không hoạt động, thì không có giải pháp. Lưu ý rằng mệnh đề khác nằm trong vòng lặp "for n", không phải câu lệnh if. Trong Python, một câu lệnh for có thể có một mệnh đề khác, được thực thi sau khi vòng lặp chạy đến khi hoàn thành, nhưng không phải là thực thi nếu chúng ta thoát ra khỏi vòng lặp.

Hàm q kiểm tra các vấn đề với thứ tự danh sách được đưa ra danh sách (a), mặt nạ bit (m) và giá trị được xored với mỗi giá trị trong danh sách (n). Nó trả về 1 nếu có vấn đề với đơn đặt hàng hoặc Không có nếu đơn hàng ổn. Không có giá trị trả về mặc định, do đó đã lưu cho tôi một vài ký tự.

Mã này xử lý một danh sách trống hoặc một danh sách có đúng 1 phần tử, trả về 0. "nếu a:" trong hàm q chỉ có để tránh ngoại lệ IndexError khi danh sách trống. Vì vậy, có thể xóa thêm 5 byte nếu không cần xử lý danh sách trống.

Trên máy tính của tôi, trường hợp thử nghiệm lớn # 3 mất 0,262 giây. # 2 mất về cùng. Tất cả các trường hợp thử nghiệm cùng nhau mất 0,765 giây.

CJam, 37 byte

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

Kiểm tra nó ở đây.

Điều này sử dụng thuật toán tương tự như một số câu trả lời khác. Về cơ bản, đó là cách thực hiện tham chiếu của tôi mà tôi đã sử dụng để tạo các trường hợp thử nghiệm. Tuy nhiên, tôi đã đánh cắp mánh khóe của Jakube chỉ kiểm tra các cặp vi phạm và chỉ đơn giản là thử kết quả với một loại. Điều đó phá vỡ giả hành, nhưng O (n log n) vẫn đủ nhanh cho các trường hợp thử nghiệm. Mã ban đầu của tôi cũng kiểm tra các cặp đã theo thứ tự và xây dựng một danh sách các bit không được chuyển đổi để giữ trật tự tương đối của chúng và kiểm tra xem cuối cùng không có sự trùng lặp giữa hai mặt nạ bit. Thuật toán này ban đầu được đề xuất bởi Ben Jackson .

Con trăn 2, 226 214 byte

Thuật toán đơn giản, xây dựng nó ngày hôm qua, chơi golf ngày hôm nay.

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]

Ung dung:

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;}

Xác định hàm h(int*a,int l)lấy một con trỏ tới một mảng và độ dài của nó. Đây là một chương trình thử nghiệm.

Hơi vô dụng:

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;
}

Toán học, 99 97 ký tự

Cảm ơn Martin Büttner cho lời khuyên.

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

Giải trình:

Chúng tôi sẽ thực hiện nhiều lần thử sửa đổi Nbắt đầu từ số 0 và thực hiện kiểm tra để xác thực ứng viên N.

Bước 1. Chúng tôi nhận được các số này (số nguyên 32 bit) "xor" ed bởi N( = 0now) và chia cho 2^31: ⌊l~BitXor~#/#2⌋. Có ba trường hợp:

• ra lệnh, vd {0, 0, 1, 1, 1, 1, 1, 1};
• có thể được sửa chữa, ví dụ {1, 1, 1, 1, 0, 0, 0, 0};
• khác, ví dụ {0, 0, 1, 0, 0, 1, 1, 1}.

Chúng tôi không làm gì Ncho trường hợp đầu tiên, hoặc chúng tôi thêm 2^31vào Nđể sửa thứ tự cho trường hợp thứ hai : #+#2Boole@!OrderedQ@.... Trong khi đối với trường hợp thứ ba, không thể xorting danh sách những gì chúng ta làm, do đó chúng ta chỉ cần thêm 2^31vào Nđể đơn giản (hoặc bất cứ điều gì!).

Bước 2. Chúng tôi nhận được các số "xor" ed Nvà chia cho 2^30. Lại có ba trường hợp:

• ra lệnh, vd {0, 1, 2, 2, 2, 2, 3, 3};
• có thể được sửa chữa, ví dụ {1, 1 , 0, 0, 3, 2, 2, 2};
• khác, ví dụ {3, 3, 1, 3, 2, 0, 1, 0}.

Chúng tôi không làm gì Ncho trường hợp đầu tiên, hoặc chúng tôi thêm 2^30vào Nđể sửa thứ tự cho trường hợp thứ hai. Mặt khác, chúng tôi nhận ra rằng xorting là không thể, do đó chúng tôi chỉ cần thêm 2^30vào Nđể đơn giản một lần nữa.

Bước 3 ~ 32. Chúng tôi đệ quy có được những con số "xor" ed bởi Nvà chia cho 2^29, 2^28, ..., 2^0. Và làm những điều tương tự:Fold[...,0,2^32/2^Range[32]]

Bước 33. Bây giờ cuối cùng chúng tôi cũng có được một ứng cử viên N. If[OrderedQ[l~BitXor~#],#,-1]&được sử dụng để kiểm tra nếu Nthực sự xorting danh sách. Nếu một số danh sách có thể được xorting bởi một số người N, không khó để chứng minh rằng chúng ta sẽ luôn gặp phải trường hợp đầu tiên hoặc trường hợp thứ hai.

Perl 6 , 79 byte

Nếu không có giới hạn thời gian, mã Perl 6 ngắn nhất có thể là

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

Thay vào đó tôi phải làm một cái gì đó thông minh hơn một chút.
Vì tôi mất một thời gian để quay lại vấn đề này, đã có một câu trả lời mô tả một thuật toán tốt và lý do đằng sau nó.

{$/=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 ｢@_｣
}

Sử dụng:

# 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

Toán học 650 415 194 byte

Thử thách này đã giúp tôi hiểu khá nhiều về Xorđiều mà tôi chưa bao giờ nghĩ tới. Phải mất một thời gian dài để giảm mã, nhưng đáng nỗ lực.

BitXorhoạt động trực tiếp trên cơ sở 10 số. Điều này làm giảm đáng kể mã từ các phiên bản trước.

Logic rất đơn giản. Một hoạt động, không phải với các cặp số (như một số lần gửi đã làm) mà là với bộ số hoàn chỉnh sau khi đượcBitXor bằng "khóa" hiện tại.

Bắt đầu với giải pháp dự kiến, hoặc "khóa" bằng 0, nghĩa là với tất cả các bit đều bằng không. Khi các nsố ban đầu là BitXored với số không, chúng được trả về, không thay đổi. Tương quan thứ tự của các số với phạm vi1, 2, ...n , đại diện cho một danh sách được sắp xếp hoàn hảo. Mối tương quan, với giá trị giữa -1 và 1, phản ánh mức độ các số được sắp xếp.

Sau đó thiết lập bit hi, lấy khóa mới và BitXor khóa với bộ số hiện tại. Nếu mối tương quan giữa chuỗi số mới và danh sách được sắp xếp hoàn hảo là một sự cải tiến, hãy giữ bit được đặt. Nếu không, để lại bit unset.

Tiến hành theo cách này từ hi đến bit thấp. Nếu tương quan tốt nhất là 1, thì chìa khóa là giải pháp. Nếu không, nó là -1.

Chẳng hạn, sẽ có cách làm cho mã hiệu quả hơn một chút, ví dụ, bằng cách làm gián đoạn quá trình ngay khi tìm thấy giải pháp, nhưng điều này sẽ đòi hỏi nhiều mã hóa hơn và cách tiếp cận hiện tại rất nhanh. (Trường hợp thử nghiệm cuối cùng và dài nhất mất 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

Thêm ++ , 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

Hãy thử trực tuyến!

_{Tôi thực sự tự hào rằng Add ++ có thể làm điều này và không phải là giải pháp lâu nhất ở đây}

Khai báo một hàm flấy mỗi phần tử làm đối số riêng (ví dụ $f>4>2>3>1)

Làm thế nào nó hoạt động

Nhốt mọi người lại, đây sẽ là một chuyến đi dài

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┬

Chạy và gỡ lỗi trực tuyến!

Sử dụng giải pháp của @ RainerP. (đã đưa ra phần lật một cách độc lập nhưng sử dụng 32rr phần đó)

Độ phức tạp thời gian tuyến tính.

Sử dụng phiên bản giải nén để giải thích.

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