개념적으로이 과제는 정말 간단합니다. 음이 아닌 정수 목록이 제공 됩니다. 가능한 경우, 음수가 아닌 정수를 찾아 구성된 목록 이 정렬되도록하십시오. 그러한 것이 존재 하지 않으면 , 출력은 유효한 , 예를 들어 음수, 아무것도 아님 , 오류 등 으로 착각 할 수없는 것이어야합니다 .aiNbi = ai XOR NNN

예를 들면 다음과 같습니다.

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

이리스트의 모든 요소를 ​​취 XOR 5하면

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

정렬되어 있습니다. (결과 목록이 고유 한 요소를 가질 필요는없고 간격을 포함하지 않아도됩니다. 이러한 작업의 결과 [0, 1, 1, 3]가 여전히 유효한 경우) 목록의 경우

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

그런 N존재는 없습니다 .

STDIN (또는 가장 가까운 대안), 명령 행 인수 또는 함수 인수를 통해 입력을 받고 STDOUT (또는 가장 가까운 대안), 함수 리턴 값 또는 함수 (out) 매개 변수를 통해 결과를 출력하는 프로그램 또는 함수를 작성할 수 있습니다.

입력은 편리한 목록 또는 문자열 형식 일 수 있습니다. 가 각각 보다 작고 목록에 하나 이상의 요소 가 있다고 가정 할 수 있습니다 .ai231

코드는 몇 초 안에 모든 테스트 사례 (특히 4 개의 큰 사례)를 처리해야합니다.

표준 코드 골프 규칙이 적용됩니다.

테스트 사례

반환되지 않는 모든 테스트 사례에 -1대해 무한한 정답이 있습니다. 여기에 나열된 것은 가장 작은 것입니다. 입력의 모든 정수에서 동일한 비트 (특히 목록의 가장 큰 수에서 가장 중요한 비트보다 큰 비트)를 추가로 설정하면 추가 솔루션이 존재합니다.

[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

마지막으로, 제출이 충분히 효율적임을 보장하기위한 4 가지 매우 큰 테스트 사례가 있습니다.

• 테스트 사례 1 은을 산출해야합니다 -1.
• 테스트 사례 2 가 산출해야합니다 0.
• 테스트 사례 3 은을 산출해야합니다 1096442624.
• 테스트 사례 4 는을 산출해야합니다 -1.

왜 이런 짓을했을까요?

XOR 연산이 배열을 "정렬"할 수있는 날이 저에게 일어났습니다. 따라서 배열을 먼저 정렬하지 않고도 O (log n) 의 배열에서 이진 검색을 수행 할 수 있습니다 . N의사 선형 시간 으로 결정하는 것이 가능 해져 대부분의 정렬 알고리즘에 대한 빠른 대안이 될 수 있으며 기수 정렬의 메모리 요구 사항이 없습니다. 물론 정렬되지 않은 배열을 통한 직선 선형 검색은 더 빠르지 만 동일한 배열을 여러 번 검색하려는 경우 단일 선형 사전 계산으로 각 검색에 필요한 시간이 크게 단축 될 수 있습니다.

불행히도,이 작업의 목록 클래스는 다소 제한적입니다 (균일하게 무작위 분포는을 인정하지 않을 것입니다 N).

흥미로운 질문은 확인하기 쉽고 더 넓은 종류의 목록에 적용 할 수있는 다른 bijective 기능이 있는지 여부입니다.

젤리, 25 바이트

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

최신 커밋은이 과제를 게시하지 않지만 위의 코드는 이 개정판 과 함께 작동하여 이전 버전 보다 우선 합니다. 온라인으로 사용해보십시오!

쉘에 따라 큰 테스트 케이스를 실행하려면 위 코드를 STDIN에서 입력을 읽는 프로그램으로 랩핑해야합니다. 온라인으로 사용해보십시오!

테스트 사례

$ 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

생각

이것은 @Jakube의 답변 과 동일한 접근 방식을 사용 하지만 구현 방식이 약간 다릅니다.

젤리는 아직 정렬이 없으므로 xorting 후보를 계산하고 입력 목록을 XOR로 입력하고 XORed 목록의 xorting 후보를 계산하고 새 후보가 0인지 확인합니다. 그렇다면 첫 번째 후보를 인쇄합니다. 그렇지 않으면 -1 을 인쇄 합니다.

또한 Jelly는 정수로 캐스팅 할 수있는 방법이 없지만 (정수 나누기조차도 float를 반환 할 수 있음) 숫자 목록을 2 의 다음 거듭 제곱으로 반올림하는 다소 창의적인 방법을 생각해 내야했습니다 . 오히려 로그 바닥 펑보다, 나는 모든 이진수를 교체 진 모든 정수로 변환 1 , 정수로 다시 변환, 추가 1 로하고, 격차를 2 .

암호

ṡ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 바이트

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

온라인으로 사용해보십시오 : 데모 또는 테스트 스위트

각각의 큰 테스트 사례는 몇 초 안에 완료됩니다.

설명:

먼저 방법과 그 이유를 설명하겠습니다. 예제 목록으로이 작업을 수행합니다 [7, 2, 13, 9].

처음 두 숫자는 이미 잘못되었습니다 ( 7 > 2). 부등호 기호 ( 7 xor X < 2 xor X) 를 변경하기 위해 숫자로 조정하려고 합니다. xor는 이진 표현으로 작동하므로 살펴보십시오.

7 = 1 1 1
2 =   1 0

각 숫자에 숫자가있는 xor를 적용하면 일부 위치의 값이 변경됩니다. 첫 번째 위치 ( 2^0) 에서 값을 변경하면 불평등 기호가 변경되지 않습니다. 두 번째 위치 ( 2^1) 에서 값을 변경할 때도 마찬가지 입니다. 우리 다섯째, 넷째로 값을 변경하는 경우에는 기호가 변경되지 ... 위치 ( 2^3, 2^4, ...). 불평등 기호는 세 번째 위치 ( 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

한 번에 여러 위치를 변경하면 물론 동일한 일이 발생합니다. 우리가 변경하는 위치 중 하나가 세 번째이면 불평등 기호가 바뀌는 것보다 그렇지 않습니다.

다음 쌍은 이미 정렬되어 있습니다 : 2 < 13. 이진 표현을 살펴보면 우리는 아무 것도 고칠 수 있으며 네 번째 위치 ( 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

따라서 우리는 네 번째 위치를 바꾸고 싶지 않습니다. 다음 쌍의 경우, 이후에 무언가를 변경하고 싶습니다 13 > 9. 여기에서 다시 세 번째 위치를 변경해야합니다.

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

이제 정리 : 정렬 된 목록으로 돌아가려면 다시 세 번째 위치를 변경해야하며 네 번째 위치를 변경하고 싶지 않습니다. 다른 모든 위치는 중요하지 않습니다. 가장 작은 숫자는 간단 4 = 0100합니다. 다른 선택이 될 것이다 5 = 0101, 6 = 0110, 7 = 0111, 20 = 10100, 21 = 10101, ...

Xoring을 사용 4하면 목록이 표시 [3, 6, 9, 13]되고 with 6는 get [1, 4, 11, 15]이되고 with 21는 get이 [18, 23, 24, 28]됩니다.

따라서 목록의 경우 부등호 기호가 잘못된 방향을 가리키는 경우 위치를 찾아야합니다. 우리는 단순히 쌍의 xor의 가장 중요한 비트를 취함으로써 위치를 찾습니다. 우리는이 모든 직책 (또는 or)을 결합하여 후보자 번호를 얻습니다. 우리는 우연히 이미 정렬 된 쌍을 파괴하지 않은 경우 확인합니다.

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

루비 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}

큰 테스트 사례에서 42 밀리 초로 실행됩니다.

언 골프 드 :

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

한 번은 ungolfed 버전을 먼저 작성한 다음 골프를 쳤습니다. 올바른 알고리즘을 찾는 것이 그 자체로 어려운 일이었습니다.

실제로 몇 년 전에 각 노드가 비교 함수를 동적으로 재정의함으로써 로컬 자체 균형을 유지하는 이진 트리 구조를 만들기 위해 이와 같은 것을 작성하려고했습니다. 처음에는 xor를 사용할 수 있다고 생각했지만 임의의 데이터에 대해 말하면 실행 가능한 값이 없을 것입니다.

줄리아 174 144 77 75 71

[편집] 익명 및 다양한 속기의 Alex A.에게 감사합니다.
[편집 2] 내 구현을 내장으로 대체했습니다 issorted().

선형 시간으로 실행되며 눈에 띄게 지연없이 큰 파일을 처리합니다. 음수에도 적용됩니다.

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

주어진 키에 가장 가까운 결과를 계산하는 또 다른 변형 (위의 값이 가장 작음).

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

용법:

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

예를 들어, 단계별 : [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.

자바 스크립트 (ES6) 85 97 114 117

편집 제거 바보, 쓸모없는 마지막 AND
Edit2 톱 비트 검색 단축
Edit3 와우! ES6 (거의) 에 최상위 비트를 찾기 위한 내장 기능이 있음 을 발견했습니다 (Math.clz32는 상위 0 비트를 계산합니다)

이것은 @Jakube의 솔루션을 기반으로합니다 (pls upvote that). 나는 혼자서 그것을 찾을 수 없었습니다.

여기서는 한 단계 앞으로 가서 목록을 한 번 반복하고 뒤집어 야 할 비트로 비트 마스크를 유지하고 유지 해야하는 비트로 비트 마스크를 유지합니다.

비트 마스크가 겹치는 경우 솔루션을 사용할 수 없습니다. 그렇지 않은 경우 솔루션은 "비트 전환"입니다.

자바 스크립트의 이진 연산은 부호있는 32 비트 정수에서만 작동하므로 반환 값은 부호있는 32 비트 정수이며 음수이거나 0 일 수 있습니다.

솔루션이 없으면 리턴 값은 '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

테스트

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 바이트

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)

편집 : 대답을 쓰는 데 시간이 걸렸을 때 알고리즘이 이미 독립적으로 @Jakube에 의해 게시되었습니다. 내 알고리즘은 동일하지만 이것은 표절 정직하지 않았습니다! 또한 다른 JavaScript 답변도 게시되었습니다. 내가 발가락을 밟고 있다면 죄송합니다.

편집 : edc65 덕분에 8 바이트가 절약되었습니다.

C, 144 바이트

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

이 C99 (이 몇 그리워 거의 표준 int지정자를하고 1 인자가 있습니다 main). 또한 0<<-10 에 의존합니다 (적어도 Clang으로 컴파일 할 때 사실 인 것 같습니다-다른 사람은 테스트하지 않았습니다)

나는 Jakube의 방법을 취해 그것을 C로 포팅했다. 나는 그것이 C에 대해 놀랍게도 크기별로 훌륭하다고 생각한다. 그것은 또한 매우 빠르다. STDIN에서 입력을 받고 일치하는 값 또는 -1을 STDOUT으로 인쇄하므로 다음 중 하나를 사용하여 실행하십시오.

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

고장:

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

줄리아, 124 바이트

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

정수 배열을 받아들이고 정수를 반환하는 함수입니다. Jakube의 접근 방식을 사용합니다 .

언 골프 드 :

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

파이썬 2, 204 바이트

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

입력은 기능 f에 목록으로 전달됩니다.

이 코드는 가장 중요한 비트부터 시작하여 한 번에 한 비트 씩 N (프로그램에서 n이라는 이름) 값을 계산합니다. ( "i"루프)

각 비트 위치에 대해 "for n"루프는 먼저 n의 해당 비트에 0을 사용하려고 시도합니다. 그래도 작동하지 않으면 1을 사용해보십시오.이 둘 중 어느 것도 작동하지 않으면 해결책이 없습니다. else 절은 if 문이 아니라 "for n"루프에 있습니다. 파이썬에서 for 문은 else 절을 ​​가질 수 있습니다. else 절은 루프가 완료된 후에 실행되지만 루프를 벗어나면 실행 되지 않습니다 .

q 함수는 목록 (a), 비트 마스크 (m) 및 목록 (n)의 각 값과 xor 될 값이 주어진 목록 순서의 문제점을 점검합니다. 주문에 문제가 있으면 1을 반환하고 주문에 문제가 없으면 None을 반환합니다. 기본 반환 값은 None이므로 여러 문자를 저장했습니다.

이 코드는 빈 목록 또는 1 개의 요소가있는 목록을 올바르게 처리하여 0을 반환합니다. 함수 q의 "if a :"는 목록이 비어있을 때 IndexError 예외를 피하기위한 것입니다. 따라서 빈 목록을 처리 할 필요가없는 경우 5 바이트를 더 제거 할 수 있습니다.

내 컴퓨터에서 큰 테스트 사례 # 3은 0.262 초가 걸렸습니다. # 2도 마찬가지였다. 모든 테스트 사례는 0.765 초가 걸렸습니다.

CJam, 37 바이트

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

여기에서 테스트하십시오.

이것은 다른 답변들과 같은 알고리즘을 사용합니다. 본질적으로 테스트 사례를 만드는 데 사용한 참조 구현입니다. 그러나 나는 Jakube의 문제 쌍을 확인하고 단순히 결과를 시도하는 트릭을 훔쳤습니다. 그것은 의사 선형성을 깨뜨리지 만 O (n log n) 는 여전히 테스트 사례에 충분히 빠릅니다. 내 원래 코드는 이미 순서대로 쌍을 확인하고 상대 순서를 유지하기 위해 토글해서는 안되는 비트 목록을 작성했으며 두 비트 마스크 사이에 겹침이 없는지 마지막에 확인했습니다. 이 알고리즘은 원래 Ben Jackson에 의해 제안되었습니다 .

파이썬 2, 226214 바이트

어제 구축 된 간단한 알고리즘이 오늘 골프를 쳤다.

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]

언 골프 드 :

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 바이트

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

h(int*a,int l)배열과 길이에 대한 포인터를 취하는 함수 를 정의합니다 . 다음 은 테스트 프로그램입니다.

약간 골퍼되지 않음 :

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 자

조언을 해준 Martin Büttner에게 감사합니다.

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

설명:

우리는 N0에서 시작 하여 수정을 여러 번 시도 하고 후보를 검증하는 테스트를 수행합니다 N.

1 단계. 이 숫자 (32 비트 정수)를 "xor" N( = 0지금)로 나누고 2^31: 로 나눕니다 ⌊l~BitXor~#/#2⌋. 세 가지 경우가 있습니다.

• 예를 들어 {0, 0, 1, 1, 1, 1, 1, 1};
• 예를 들어 {1, 1, 1, 1, 0, 0, 0, 0};
• 그렇지 않으면 예를 들어 {0, 0, 1, 0, 0, 1, 1, 1}.

N첫 번째 경우에는 아무 것도하지 않거나 두 번째 경우의 순서를 수정하기 위해 추가 2^31합니다 N: #+#2Boole@!OrderedQ@.... 세 번째 경우에는 우리가하는 일을 목록으로 분류하는 것이 불가능하므로 단순성 (또는 무엇이든)을 추가 2^31하기 만하면 N됩니다.

단계 2. 우리는이 숫자들을 "xor" N로 나누고 나눈다 2^30. 다시 세 가지 경우가 있습니다.

• 예를 들어 {0, 1, 2, 2, 2, 2, 3, 3};
• 예를 들어 {1, 1 , 0, 0, 3, 2, 2, 2};
• 그렇지 않으면 예를 들어 {3, 3, 1, 3, 2, 0, 1, 0}.

N첫 번째 경우에는 아무 것도하지 않거나 두 번째 경우의 순서를 수정하기 위해 추가 2^30합니다 N. 그렇지 않으면, 우리는 따라서 우리가 추가 xorting이 불가능하다는 것을 깨닫게 2^30로 N다시 단순화를 위해.

3 단계 ~ 32 우리는 반복적으로이 숫자는 "XOR"에 의해 에드 얻을 N과 나눈 2^29, 2^28, ..., 2^0. 그리고 비슷한 일을하십시오 :Fold[...,0,2^32/2^Range[32]]

단계 33. 이제 우리는 후보자를 얻는다 N. 실제로 목록을 정렬 If[OrderedQ[l~BitXor~#],#,-1]&하는지 확인하는 데 사용됩니다 N. 목록이 일부 N에 의해 조정될 수있는 경우, 항상 첫 번째 또는 두 번째 경우가 발생한다는 것을 증명하는 것은 어렵지 않습니다.

펄 6 , 79 바이트

시간 제한이 없다면 가장 짧은 Perl 6 코드는 아마도

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

대신 좀 더 영리한 것을해야합니다.
나는 이것으로 되돌아 오는 데 시간이 걸렸으므로 이미 좋은 알고리즘과 그 이유를 설명 하는 대답 이있었습니다.

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

용법:

# 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

매쓰 650 415 194 바이트

이 도전은 내가 Xor생각하지 못한 것에 대해 상당히 이해하는 데 도움이되었습니다 . 코드를 작성하는 데 오랜 시간이 걸렸지 만 그만한 가치가있었습니다.

BitXor기본 10 숫자에 직접 작동합니다. 이것은 이전 버전의 코드를 크게 줄였습니다.

논리는 간단합니다. 하나는 숫자 쌍 (일부 제출과 마찬가지로)이 아니라 BitXor현재 "키" 로 ed 된 후 완전한 숫자 세트로 작동합니다 .

임시 솔루션 또는 0의 "키"로 시작합니다. 즉, 모든 비트가 0입니다. 원래 n숫자가 BitXor0으로 바뀌면 변경되지 않은 채 반환됩니다. 1, 2, ...n완벽하게 정렬 된 목록을 나타내는 범위와 숫자의 순서를 연관시킵니다 . -1과 1 사이의 값을 갖는 상관 관계는 숫자의 정렬 순서를 나타냅니다.

그런 다음 hi 비트를 설정하고 새 BitXor키와 현재 숫자 세트가있는 키를 얻습니다. 새 숫자 시퀀스와 완벽하게 정렬 된 목록 간의 상관 관계가 개선 된 경우 비트 세트를 유지하십시오. 그렇지 않은 경우 비트를 설정하지 않은 상태로 두십시오.

이 방법으로 하이에서 로우 비트로 진행하십시오. 최상의 상관 관계가 1이면 솔루션이 핵심입니다. 그렇지 않으면 -1입니다.

솔루션이 발견되는 즉시 프로세스를 중단하여 코드를 좀 더 효율적으로 만드는 방법이 있지만 더 많은 코딩이 필요하고 현재의 접근 방식은 매우 빠릅니다. (최종 및 가장 긴 테스트 케이스는 20msec가 소요됩니다.)

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

++ 추가 , 125 119 바이트를

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

온라인으로 사용해보십시오!

_{실제로 Add ++ 가이 작업을 수행 할 수 있으며 여기에서 가장 긴 해결책은 아니라는 것이 정말 자랑 스럽습니다.}

함수 선언 f개별 인자로 각 요소를 얻어 (예를 $f>4>2>3>1)

작동 원리

사람들을 버클, 그것은 긴 거리가 될거야

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 바이트

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

온라인으로 실행하고 디버그하십시오!

@RainerP.의 솔루션을 사용합니다 (뒤집기 비트 부분은 독립적으로 나타 났지만 그 32rr부분을 사용함 )

선형 시간 복잡성.

압축이 풀린 버전을 사용하여 설명합니다.

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