Kavramsal olarak, bu zorluk gerçekten basittir. Size negatif olmayan tam sayıların bir listesi verilir . Mümkünse, negatif olan bir tamsayı bulun , böylece oluşan liste sıralanır. Eğer böyle bir şey mevcut değilse, çıktı geçerli bir şeyle karıştırılamayacak bir şey olmalıdır , örneğin negatif bir sayı, hiçbir şey, bir hata vb.aiNbi = ai XOR NNN

İşte bir örnek:

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

Bu listedeki her elementi XOR 5alırsak,

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

sıralanır. (Elde edilen listenin benzersiz öğelere sahip olması ve boşluk içermemesi gerekmediğine dikkat edin. Böyle bir işlemin sonucu [0, 1, 1, 3]hala geçerliyse.) Öte yandan, liste için

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

böyle bir şey Nyok.

STDIN (veya en yakın alternatif), komut satırı argümanı veya işlev argümanı yoluyla giriş alarak ve sonucu STDOUT (veya en yakın alternatif), fonksiyon dönüş değeri veya function (out) parametresi ile çıktı alarak bir program veya işlev yazabilirsiniz.

Giriş herhangi bir uygun listede veya dize biçiminde olabilir. Her birinin altında olduğundan ve listenin en az bir öğe içerdiğini varsayabilirsiniz .ai231

Kodunuz birkaç saniye içinde test durumlarından herhangi birini (özellikle dört büyük olanları) işlemelidir.

Standart kod-golf kuralları geçerlidir.

Test Kılıfları

Dönmeyen her test durumu -1için sınırsız sayıda doğru cevap vardır. Burada listelenen en küçüğüdür. Ek olarak, girdideki tüm tam sayılara aynı olan bitleri (özellikle listenin en büyük sayısındaki en önemli bitten daha büyük olanlar) ayarlayarak ek çözümler vardır.

[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

Son olarak, başvuruların yeterince verimli olmasını sağlamak için dört çok büyük test durumları:

• Test senaryosu 1 vermelidir -1.
• Test Durumu 2 verilmelidir 0.
• Test Durumu 3 verilmelidir 1096442624.
• Test Durumu 4'ün vermesi gerekir -1.

Birisi bunu neden yapar ki?

Geçen gün, bir XOR işleminin bir diziyi "sıralayabilmesi" gerçekleşti, bu da dizide bir ikili arama yapmayı ilk önce sıralamak zorunda kalmadan O (log n) olarak değiştirdi. Bunu N, çoğu sıralama algoritmasına daha hızlı bir alternatif haline getiren psödolinear zamanda belirlemek mümkün gibi görünmektedir ve radix türünün bellek gereksinimlerine sahip değildir. Tabii ki, sıralanmamış dizi üzerinden yapılan düz bir doğrusal arama daha hızlı olacaktır, ancak aynı diziyi birçok kez aramak istiyorsanız, tek bir doğrusal ön hesaplama, her arama için gereken süreyi önemli ölçüde azaltabilir.

Ne yazık ki, bunun üzerinde çalıştığı listelerin sınıfı oldukça sınırlıdır (eşit olarak rastgele dağılımların kabul etmesi muhtemel değildir N).

İlginç bir soru, daha geniş bir liste sınıfı için kontrol edilmesi kolay ve / veya uygulanabilir başka bijektif işlevlerin olup olmadığıdır.

Jöle, 25 bayt

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

En son kararlar bu zorluğun tarihini gösteriyor, ancak yukarıdaki kod bu revizyonla başlıyor ve bu da onu öneriyor. Çevrimiçi deneyin!

Büyük test durumlarını çalıştırmak için, kabuğunuza bağlı olarak, yukarıdaki kodu STDIN'den giriş okuyan bir programa sarmanız gerekebilir. Çevrimiçi deneyin!

Test durumları

$ 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

Fikir

Bu @ Jakube'un cevabıyla aynı yaklaşımı kullanır , ancak benim uygulamam biraz farklı.

Jelly henüz bir sıralama yapmıyor, bu yüzden bir xorting adayı hesaplıyoruz, XOR onunla giriş listesini, XORed listesinin bir xorting adayını hesaplıyoruz ve yeni adayın sıfır olup olmadığını kontrol ediyoruz. Öyleyse, ilk adayı basarız; Aksi takdirde -1 basarız .

Ayrıca, Jelly henüz tamsayıya atmak için aklı başında bir yol yok gibi gözüküyor (tamsayı bölümü bile yüzdeleri geri getirebilir), bu yüzden bir sonraki 2 gücüne kadar sayılar listesini yuvarlamak için daha yaratıcı bir yol bulmalıydım . Log-floor-pow yerine, tüm tamsayıları ikiliye dönüştürürüm, tüm ikili basamakları 1 ile değiştiririm , tamsayıya dönüştürürüm, 1 ekler ve 2'ye bölerim .

kod

ṡ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 bayt

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

Çevrimiçi deneyin: Gösteri veya Test Paketi

Büyük test vakalarının her biri birkaç saniye içinde bitiyor.

Açıklama:

İlk önce yöntemi ve neden çalıştığını açıklayacağım. Ben örnek liste ile yapacağım: [7, 2, 13, 9].

İlk iki sayı zaten yanlıştır ( 7 > 2). Bu eşitsizlik sembolünü ( 7 xor X < 2 xor X) değiştirmek için bir sayıyla xor yapmak istiyoruz . Xor ikili gösterimler üzerinde çalıştığı için, onlara bakalım.

7 = 1 1 1
2 =   1 0

Her sayıya bir sayı ile xor uygulayacağımız zaman, bazı pozisyonlardaki değer değişecektir. Değerleri ilk pozisyonda ( 2^0) değiştirirseniz eşitsizlik sembolü değişmez. İkinci şeydeki değerleri değiştirdiğimizde de aynı şey olur ( 2^1). Beşinci, dördüncü de değerleri değiştirmek Ayrıca sembol, değişmeyecek ... pozisyonları ( 2^3, 2^4, ...). Eşitsizlik sembolü yalnızca üçüncü pozisyonu değiştirdiğimizde yön değiştirir ( 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

Aynı anda birden fazla konumu değiştirirsek, elbette aynı şey olur. Eğer değiştirdiğimiz pozisyonlardan herhangi biri üçüncü ise, eşitsizlik sembolü değişir, aksi halde olmaz.

Bir sonraki çifti zaten sıralanır: 2 < 13. İkili gösterime bakarsak, ona göre herhangi bir şeyi yayabileceğimizi ve eşitsizlik sembolünün hala dördüncü konumu ( 2^3) değiştirdiğimiz zamanların doğru olduğunu fark ederiz .

 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

Dördüncü pozisyonu değiştirmek istemiyoruz. Bir sonraki çift için, bir şeyleri değiştirmek istiyoruz, o zamandan beri 13 > 9. Burada yine üçüncü pozisyonu değiştirmeliyiz.

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

Şimdi özetle: Sıralı bir listeye son vermek için, üçüncü pozisyonu tekrar değiştirmek zorundayız ve dördüncü pozisyonu değiştirmek istemiyoruz. Diğer tüm pozisyonlar önemli değil. En küçük sayı basit 4 = 0100. Diğer seçenekler olacaktır 5 = 0101, 6 = 0110, 7 = 0111, 20 = 10100, 21 = 10101, ...

Xoring ile birlikte 4liste [3, 6, 9, 13]halinde 6alacak , ile alacak [1, 4, 11, 15]ve ile 21alacak [18, 23, 24, 28].

Dolayısıyla bir liste için, yanlış yöne işaret ederse eşitsizlik sembolünü değiştirecek olan pozisyonları bulmamız gerekir. Pozisyonu basitçe çiftin xor değerinin en önemli kısmını alarak buluruz. Aday sayısına ulaşmak için tüm bu pozisyonları (veya ile) birleştiriyoruz. Zaten sıralanan çiftleri kazara imha etmemişsek kontrol ederiz.

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

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

Büyük test durumlarında 42 milisaniyede çalışır.

Ungolfed:

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

İlk defa ungolfed versiyonunu yazdım, sonra golf oynadım, çünkü doğru algoritmayı bulmak başlı başına bir zorluktu.

Aslında birkaç yıl önce böyle bir şey yazmaya çalıştım, her düğümün karşılaştırma işlevini dinamik olarak yeniden tanımlamasını sağlayarak yerel olarak kendi kendini dengeleyecek bir ikili ağaç yapısı oluşturmak için. İlk başta sadece xor kullanabileceğimi düşündüm, fakat rastgele veriler için dediğiniz gibi, makul bir değer olması mümkün değil.

Julia, 174 144 77 75 71

[EDIT] Alex A.'ya anonimleştirme ve çeşitli kısa notlar için teşekkür ederiz.
[EDIT 2] Yaptığım uygulama tarafından yerleşik olarak değiştirildi issorted().

Doğrusal zamanda çalışır ve büyük dosyaları fark edilir bir gecikme olmadan yönetir. Negatif sayılar için de işe yarar.

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

Belirli bir anahtara en yakın sonucu hesaplayan başka bir değişken (yukarıdaki en küçük değeri döndürür).

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

kullanımı:

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

Örnek, adım adım: [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

Düzenle Kaldırıldı aptal, yararsız son VE
Edit2 En bit arama kısaltılmış
Edit3 Vay! ES6'nın (neredeyse) en iyi ucu bulmak için yerleşik bir özelliği olduğunu keşfettim (Math.clz32 en iyi 0 biti sayar)

Bu @Jakube çözümüne dayanmaktadır (pls bu kadar oy). Bunu asla kendi başıma bulamazdım.

Burada bir adım ileri gidiyorum, listeyi bir kez tekrar ediyorum ve çevrilmesi gereken bitlerle bit maskesini tuttum, diğeri tutulması gereken bitlerle.

Bit maskelerinin bir üst üste gelmesi durumunda, o zaman çözüm mümkün değildir, yoksa çözüm "çevrilecek bit" olur.

Javascript’teki ikili işlemler yalnızca işaretli 32 bit tam sayılarda çalıştığından, dönüş değeri negatif veya 0 olabilen işaretli bir 32 bit tam sayıdır.

Çözüm yoksa iade değeri 'X' olur

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

Ölçek

Jsfiddle'da daha uzun testler

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 bayt

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)

Düzenleme: Cevabını yazmam zaman aldı ve algoritma bağımsız olarak @Jakube tarafından gönderildi; algoritmam aynı, ama bu intihal dürüst değildi! Ayrıca o zamandan beri başka bir JavaScript cevabının gönderildiğini fark ettim. Üzgünüm, birinin ayak parmağına basıyorsam.

Düzenleme: edc65 sayesinde 8 bayt kaydedildi.

C, 144 bayt

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

Bu neredeyse standart C99'dur (birkaç intbelirleyiciyi kaçırır ve bunun için 1 argümanı vardır main). Ayrıca 0<<-1, 0 olmasına da güveniyor (en azından Clang ile derlendiğinde doğru görünüyor - başkalarını test etmedim)

Jakube'in yöntemini kullandım ve C'ye taşıdım. C için şaşırtıcı derecede iyi olduğunu düşünüyorum. Ayrıca süper hızlı (büyük 4 dahil tüm test dosyalarını çalıştırmak için 0.061). STDIN'den girdi alır ve eşleşen değeri veya -1'i STDOUT'a basar, bu nedenle aşağıdakilerden birini çalıştırın:

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

Yıkmak:

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

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

Bu bir tamsayı dizisini kabul eden ve bir tamsayı döndüren bir işlevdir. Jakube'un yaklaşımını kullanır .

Ungolfed:

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 bayt

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

Girdi, f işlevi için bir liste olarak iletilir.

Bu kod, N'nin (programda n olarak adlandırılan) değerini, en anlamlı bit ile başlayarak, bir seferde bir bit olarak hesaplar. ("i" için döngü)

Her bir bit pozisyonu için, "for n" döngüsü ilk önce n'nin o biti için 0 kullanmaya çalışır. Bu işe yaramazsa, 1 kullanarak çalışır. Bu ikisi de işe yaramazsa, o zaman bir çözüm yoktur. Else deyiminin if ifadesinde değil "for n" döngüsünde olduğunu unutmayın. Python'da, deyimi için bir döngü tamamlanması için çalıştıktan sonra yürütülür, ancak bir başka şartı, olabilir değil biz döngünün patlak eğer idam.

Q işlevi, verilen liste sırasındaki sorunları (a), bir bit maskesini (m) ve listedeki (n) her bir değerle xorelenecek olan değeri kontrol eder. Siparişle ilgili bir sorun varsa 1, sipariş tamamsa Yok değerini döndürür. Hiçbiri varsayılan dönüş değeri değildir, bu yüzden bana birkaç karakter kazandırdı.

Bu kod, boş bir liste veya 1 elemanlı bir listeyi doğru şekilde ele alarak 0 döndürür. Q fonksiyonundaki "if a:" sadece liste boş olduğunda bir IndexError istisnasını önlemek için vardır. Bu nedenle, boş listelerin ele alınması gerekmiyorsa 5 bayt daha kaldırılabilir.

Bilgisayarımdaki büyük sınama durumu # 3 0.262 saniye sürdü. # 2 de aynı şeyi aldı. Tüm test vakaları birlikte 0.765 saniye sürdü.

CJam, 37 bayt

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

Burada test et.

Bu, diğer cevapların birçoğuyla aynı algoritmayı kullanır. Esasen test senaryolarını oluşturmak için kullandığım referans uygulamam. Bununla birlikte, Jakube’nin sadece rahatsız olan çiftleri kontrol etme ve sadece bir çeşit sonuç almaya çalışarak aldıkları numarayı çaldım. Bu psödolineariteyi kırar, ancak O (n log n) test durumları için hala yeterince hızlıdır. Orijinal kodum, zaten sıralı olan çiftleri de kontrol etti ve göreceli sıralarını korumak için açılmaması gereken bir bit listesi oluşturdu ve sonunda iki bit maskeleri arasında çakışma olmadığını kontrol etti. Bu algoritma başlangıçta Ben Jackson tarafından önerildi .

Python 2,226 214 bayt

Simpleish algoritması, dün inşa etti, bugün golf oynadı.

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]

Ungolfed:

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 bayt

#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)İşaretçiyi bir diziye ve uzunluğa götüren işlevi tanımlar . İşte behemoth bir test programı.

Biraz ungolfed:

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 Karakterler

Tavsiyeler için Martin Büttner'e teşekkürler.

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

Açıklama:

NSıfırdan başlayarak değiştirmek için birden fazla deneme yapacağız ve adayı doğrulamak için bir test yapacağız N.

Adım 1. Biz bu sayıları (32-bit tamsayı) "xor" tarafından ed olsun N( = 0şimdi) ve bölü 2^31: ⌊l~BitXor~#/#2⌋. Üç vaka var:

• sipariş, örneğin {0, 0, 1, 1, 1, 1, 1, 1};
• düzeltilebilir, örneğin {1, 1, 1, 1, 0, 0, 0, 0};
• Başka, örneğin {0, 0, 1, 0, 0, 1, 1, 1}.

Biz bir şey yapmak Nilk durum için, ya da biz eklemek 2^31için Nikinci durumda emrini düzeltmek için: #+#2Boole@!OrderedQ@.... Üçüncü vaka için, her zamankinden biz ne listesini xorting olanaksız olsa da, böylece biz sadece eklemek 2^31için Nbasitlik için (ya da bir şey!).

Adım 2. Biz bu numaralar "xor" ed olsun Nve bölü 2^30. Yine üç vaka var:

• sipariş, örneğin {0, 1, 2, 2, 2, 2, 3, 3};
• düzeltilebilir, örneğin {1, 1 , 0, 0, 3, 2, 2, 2};
• Başka, örneğin {3, 3, 1, 3, 2, 0, 1, 0}.

Biz bir şey yapmak Nilk durum için, ya da biz eklemek 2^30için Nikinci durumda emrini düzeltmek için. Aksi takdirde, bu yolda ekleyin xorting imkansız olduğunu fark 2^30etmek Nyine basitlik için.

Adım 3 ~ 32. Biz yinelemeli bu sayılar "xor" tarafından ed olsun Nve bölü 2^29, 2^28, ..., 2^0. Ve benzer şeyler yapın:Fold[...,0,2^32/2^Range[32]]

Adım 33. Şimdi nihayet bir aday bulduk N. If[OrderedQ[l~BitXor~#],#,-1]&böyle bir Nlisteyi gerçekten xorting ile kontrol etmek için kullanılır . Liste bir kısmı tarafından xorting yapabiliyorsa N, her zaman birinci veya ikinci vakayla karşı karşıya kalacağımızı kanıtlamak zor değildir.

Perl 6 , 79 bayt

Eğer bir zaman sınırı olmasaydı, en kısa Perl 6 kodu muhtemelen

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

Bunun yerine biraz daha zekice bir şey yapmalıyım.
Buna geri dönmem biraz zaman aldığım için, zaten iyi bir algoritma ve bunun nedenini açıklayan bir cevap vardı.

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

Kullanımı:

# 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 bayt

Bu zorluk Xor, hiç düşünmediğim kadarıyla ilgili biraz anlamama yardımcı oldu . Kodu kırmak çok uzun sürdü, ama bu çabaya değerdi.

BitXordoğrudan 10 numara üzerinde çalışır. Bu, önceki sürümlerden gelen kodu büyük ölçüde azalttı.

Mantık basittir. Biri, sayı çiftleri ile değil (bazı gönderilerin yaptığı gibi) değil BitXor, geçerli "anahtar" ile girildikten sonra sayıların tamamı ile çalışır.

Geçici çözüm veya sıfırın "anahtarı" ile başlayın, yani tüm bitler sıfırdır. Orijinal nsayılar BitXorsıfıra getirildiğinde, bunlar değiştirilmeden döndürülür. Sayıların sıralamasını, 1, 2, ...nmükemmel bir sıralanan listeyi temsil eden aralıkla ilişkilendirin . -1 ile 1 arasındaki bir değere sahip olan korelasyon, sayıların ne kadar iyi sıralandığını yansıtır.

Ardından hi bit'i ayarlayın, yeni anahtarı ve BitXorgeçerli sayı kümesini içeren anahtarı alın. Yeni sayı dizisi ile mükemmel sıralı liste arasındaki korelasyon bir iyileştirme ise, bit ayarını tutun. Eğer değilse, ucu ayarsız bırakın.

Bu şekilde hi'den düşük bit'e kadar devam edin. En iyi korelasyon 1 ise, anahtar çözümdür. Eğer değilse, -1'dir.

Örneğin, bir çözüm bulunur bulunmadığında işlemi keserek kodu biraz daha verimli hale getirmenin yolları olabilir, ancak bu daha fazla kodlama gerektirir ve mevcut yaklaşım olduğu gibi çok hızlı olur. (Son ve en uzun test durumu 20 msn sürer.)

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 bayt ekleyin

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

Çevrimiçi deneyin!

_{Aslında Add ++ 'ın bunu yapabildiği için gerçekten gurur duyuyorum ve buradaki en uzun çözüm değil.}

fHer öğeyi ayrı bir argüman olarak alan bir işlev bildirir (örn. $f>4>2>3>1)

Nasıl çalışır

Millet, tokmak uzun bir yolculuk olacak

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 bayt

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

Çevrimiçi çalıştırın ve hata ayıklayın!

@ RainerP.'nin çözümünü kullanır (ters çevirme parçasını bağımsız olarak bulur, ancak 32rrparçayı kullanır )

Doğrusal zaman karmaşıklığı.

Açıklamak için paketlenmemiş sürümü kullanır.

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