Concettualmente, questa sfida è davvero semplice. Ti viene fornito un elenco di numeri interi non negativi . Se possibile, trova un numero intero non negativo , in modo tale che l'elenco costituito da sia ordinato. Se tale non esiste, l'output dovrebbe essere qualcosa che non può essere scambiato per un valido , ad esempio un numero negativo, niente affatto, un errore ecc.aiNbi = ai XOR NNN

Ecco un esempio:

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

Se prendiamo tutti gli elementi in questo elenco XOR 5, otteniamo

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

che è ordinato. (Si noti che non è necessario che l'elenco risultante abbia elementi univoci e non contenga spazi vuoti. Se il risultato di tale operazione fosse [0, 1, 1, 3]quello sarebbe ancora valido.) D'altra parte per l'elenco

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

non Nesiste tale .

È possibile scrivere un programma o una funzione, prendendo l'input tramite STDIN (o l'alternativa più vicina), l'argomento della riga di comando o l'argomento della funzione e producendo il risultato tramite STDOUT (o l'alternativa più vicina), il valore di ritorno della funzione o il parametro della funzione (out).

L'input può essere in qualsiasi elenco o formato stringa conveniente. Si può presumere che siano inferiori a ciascuno e che l'elenco contenga almeno un elemento.ai231

Il tuo codice deve gestire uno qualsiasi dei casi di test (specialmente i quattro più grandi) in pochi secondi.

Si applicano le regole standard del code-golf .

Casi test

Per ogni caso di test che non ritorna -1c'è un numero infinito di risposte corrette. Quello elencato qui è il più piccolo. Esistono soluzioni aggiuntive impostando in aggiunta bit uguali su tutti i numeri interi nell'input (in particolare quelli che sono più grandi del bit più significativo nel numero più grande dell'elenco).

[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

Infine, ecco quattro casi di test molto grandi per garantire che le comunicazioni siano sufficientemente efficienti:

• Il caso di test 1 dovrebbe cedere -1.
• Test Case 2 dovrebbe cedere 0.
• Il caso di test 3 dovrebbe cedere 1096442624.
• Il caso di test 4 dovrebbe cedere -1.

Perché qualcuno dovrebbe farlo?

L'altro giorno mi è venuto in mente che un'operazione XOR può "ordinare" un array, il che rende possibile eseguire una ricerca binaria sull'array in O (log n) senza prima doverlo ordinare. Sembra essere possibile determinare Nin tempo pseudolinear, che renderebbe questa un'alternativa più veloce alla maggior parte degli algoritmi di ordinamento e non ha i requisiti di memoria dell'ordinamento radix. Naturalmente, una ricerca lineare diritta attraverso l'array non ordinato sarà più veloce, ma se si desidera cercare lo stesso array più volte, un singolo pre-calcolo lineare può ridurre significativamente il tempo richiesto per ogni ricerca.

Sfortunatamente, la classe di elenchi su cui funziona è piuttosto limitata (è improbabile che distribuzioni uniformemente casuali ammettano un N).

Una domanda interessante è se ci sono altre funzioni biiettive che sono più facili da controllare e / o applicabili per una più ampia classe di elenchi.

Gelatina, 25 byte

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

L'ultima commette dopo questa data, ma il codice sopra funziona con questa revisione , che la precede. Provalo online!

Per eseguire casi di test di grandi dimensioni, a seconda della shell, potrebbe essere necessario racchiudere il codice sopra in un programma che legge l'input da STDIN. Provalo online!

Casi test

$ 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

Idea

Questo utilizza lo stesso approccio della risposta di @ Jakube , ma la mia implementazione è leggermente diversa.

Jelly non ha ancora alcun ordinamento, quindi calcoliamo un candidato xorting, XOR la ​​lista di input con esso, calcoliamo un candidato xorting della lista XORed e controlliamo se il nuovo candidato è zero. Se lo è, stampiamo il primo candidato; altrimenti, stampiamo -1 .

Inoltre, Jelly sembra non avere ancora un modo sano di lanciare un numero intero (anche la divisione di numeri interi può restituire i float), quindi ho dovuto trovare un modo piuttosto creativo di arrotondare un elenco di numeri al prossimo potere di 2 . Invece di log-floor-pow, converto tutti i numeri interi in binario, sostituisco tutte le cifre binarie con 1 , riconvertisco in numero intero, aggiungo 1 e divido per 2 .

Codice

ṡ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

Provalo online: Dimostrazione o Test Suite

Ognuno dei grandi casi di test termina in un paio di secondi.

Spiegazione:

Prima spiegherò il metodo e perché funziona. Farò questo con l'elenco esempio: [7, 2, 13, 9].

I primi due numeri sono già sbagliati ( 7 > 2). Vogliamo xor con qualche numero per cambiare quel simbolo di disuguaglianza ( 7 xor X < 2 xor X). Poiché xor opera sulle rappresentazioni binarie, guardiamole.

7 = 1 1 1
2 =   1 0

Quando applichiamo xor con un numero a ciascun numero, il valore in alcune posizioni cambierà. Se si cambiano i valori nella prima posizione ( 2^0), il simbolo di disuguaglianza non cambia. La stessa cosa accade quando cambiamo i valori nella seconda posizione ( 2^1). Anche il simbolo non cambia se cambiamo i valori al quarto, quinto, ... posizioni ( 2^3, 2^4, ...). Il simbolo di disuguaglianza cambia direzione solo se cambiamo la terza posizione ( 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

Se cambiamo più posizioni contemporaneamente, ovviamente succede la stessa cosa. Se una delle posizioni che cambiamo è la terza, allora il simbolo della disuguaglianza cambia, altrimenti no.

La coppia successiva è già ordinato: 2 < 13. Se osserviamo la rappresentazione binaria, notiamo che possiamo xorare qualsiasi cosa e il simbolo di disuguaglianza è ancora corretto, tranne quando cambiamo la quarta posizione ( 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

Quindi non vogliamo cambiare la quarta posizione. Per la prossima coppia vogliamo cambiare qualcosa, da allora 13 > 9. Qui dobbiamo di nuovo cambiare la terza posizione.

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

Ricapitolando ora: per finire in un elenco ordinato, dobbiamo di nuovo cambiare la terza posizione e non vogliamo cambiare la quarta posizione. Tutte le altre posizioni non contano. Il numero più piccolo è semplicemente 4 = 0100. Altre scelte sarebbero 5 = 0101, 6 = 0110, 7 = 0111, 20 = 10100, 21 = 10101, ...

Xoring con 4verrà visualizzato nell'elenco [3, 6, 9, 13], con 6get [1, 4, 11, 15]e con 21get [18, 23, 24, 28].

Quindi per un elenco, dobbiamo trovare le posizioni, che cambieranno il simbolo della disuguaglianza se punta nella direzione sbagliata. Troviamo la posizione semplicemente prendendo il bit più significativo dello xor della coppia. Combiniamo tutte queste posizioni (con o) per ottenere un numero candidato. Verifichiamo se non abbiamo distrutto accidentalmente le coppie già ordinate.

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


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

Ruby 2, 119

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

Funziona in 42 millisecondi sui casi di test di grandi dimensioni.

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

Per una volta ho scritto prima la versione non golfata, poi l'ho giocata a golf, poiché capire l'algoritmo giusto era una sfida in sé.

In realtà ho provato a scrivere qualcosa del genere qualche anno fa per creare una struttura ad albero binaria che si bilanciasse localmente lasciando che ciascun nodo ridefinisse la sua funzione di confronto in modo dinamico. All'inizio pensavo di poter usare solo xor, ma come dici tu per i dati casuali è improbabile che ci sia un valore praticabile.

Julia, 174 144 77 75 71

[MODIFICA] Grazie ad Alex A. per l'anonimato e varie scorciatoie.
[EDIT 2] Sostituito la mia implementazione dall'integrato issorted().

Funziona in tempo lineare e gestisce i file di grandi dimensioni senza notevoli ritardi. Funziona altrettanto bene per i numeri negativi.

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

Un'altra variante che calcola il risultato più vicino a una determinata chiave (quanto sopra restituisce il più piccolo).

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

utilizzo:

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

Esempio, passo dopo passo: [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

Modifica Rimosso stupido, ultimo inutile E
Modifica2 Ricerca bit superiore abbreviata
Modifica3 Caspita! Ho scoperto che ES6 (quasi) ha un builtin per trovare il bit superiore (Math.clz32 conta i primi 0 bit)

Questo si basa sulla soluzione di @Jakube (per favore, votalo). Non avrei mai potuto trovarlo da solo.

Qui faccio un passo avanti, ripetendo una volta l'elenco e mantenendo una maschera di bit con i bit che devono essere girati, e un altro con i bit che devono essere mantenuti.

Se c'è una sovrapposizione delle maschere di bit, allora nessuna soluzione è possibile, altrimenti la soluzione è "bit da capovolgere"

Poiché le operazioni binarie in javascript funzionano solo su numeri interi a 32 bit con segno, il valore restituito è un numero intero a 32 bit con segno che può essere negativo o 0.

Se non esiste alcuna soluzione, il valore restituito è '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

Test

I test più lunghi su 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)

Modifica: quando mi ci è voluto scrivere la risposta, l'algoritmo era già stato pubblicato in modo indipendente da @Jakube; il mio algoritmo è lo stesso ma questo non è stato un plagio onesto! Inoltre ho notato che è stata postata anche un'altra risposta JavaScript. Scusami se sto calpestando qualcuno.

Modifica: salvato 8 byte grazie a 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);}

Questo è quasi standard C99 (manca alcuni intspecificatori e ha 1 argomento per main). Si basa anche 0<<-1sull'essere 0 (che sembra essere vero se compilato almeno con Clang - non ho testato altri)

Ho preso il metodo di Jakube e l'ho portato su C. Penso che funzioni sorprendentemente bene in termini di dimensioni per C. È anche superveloce (0,061 secondi per eseguire tutti i file di test, incluso il massiccio 4). Prende l'input da STDIN e stamperà il valore corrispondente o -1 su STDOUT, quindi eseguilo con uno di:

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

Abbattersi:

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

Questa è una funzione che accetta un array intero e restituisce un intero. Usa l'approccio di Jakube .

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

L'input viene passato come elenco per funzionare f.

Questo codice determina il valore di N (chiamato n nel programma) un bit alla volta, a partire dal bit più significativo. (il ciclo "per i")

Per ogni posizione di bit, il ciclo "for n" tenta innanzitutto di utilizzare 0 per quel bit di n. Se il problema persiste, prova a utilizzare 1. Se nessuno dei due funziona, non esiste una soluzione. Si noti che la clausola else si trova sul ciclo "for n", non sull'istruzione if. In Python, un'istruzione for può avere una clausola else, che viene eseguita dopo il completamento del ciclo, ma non viene eseguita se si esce dal ciclo.

La funzione q verifica la presenza di problemi con l'ordine di elenco dato l'elenco (a), una maschera di bit (m) e il valore da eseguire su x con ogni valore nell'elenco (n). Restituisce 1 se si verifica un problema con l'ordinamento o Nessuno se l'ordine è corretto. Nessuno è il valore di ritorno predefinito, quindi mi ha salvato diversi caratteri.

Questo codice gestisce correttamente un elenco vuoto o un elenco con 1 elemento, restituendo 0. L'opzione "if a:" nella funzione q è presente solo per evitare un'eccezione IndexError quando l'elenco è vuoto. Quindi potrebbero essere rimossi altri 5 byte se non è richiesta la gestione di elenchi vuoti.

Sul mio computer, il caso di test n. 3 di grandi dimensioni ha richiesto 0,262 secondi. # 2 ha preso lo stesso. Tutti i casi di test insieme hanno impiegato 0,765 secondi.

CJam, 37 byte

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

Provalo qui.

Questo utilizza lo stesso algoritmo di molte altre risposte. È essenzialmente la mia implementazione di riferimento che ho usato per creare i casi di test. Tuttavia, ho rubato il trucco di Jakube di controllare solo le coppie offensive e semplicemente provare il risultato con una specie. Ciò rompe la pseudolinearità, ma O (n log n) è ancora abbastanza veloce per i casi di test. Il mio codice originale ha anche verificato le coppie che sono già in ordine e ha creato un elenco di bit che non devono essere attivati ​​per mantenere il loro ordine relativo e ha verificato alla fine che non vi siano sovrapposizioni tra le maschere a due bit. Questo algoritmo è stato originariamente suggerito da Ben Jackson .

Python 2, 226 214 byte

Algoritmo semplice, costruito ieri, oggi giocato a golf.

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

Definisce una funzione che h(int*a,int l)porta un puntatore a un array e alla sua lunghezza. Ecco un programma di prova colosso.

Leggermente non golfato:

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 personaggi

Grazie a Martin Büttner per i consigli.

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

Spiegazione:

Faremo più tentativi di modifica a Npartire da zero e faremo un test per convalidare il candidato N.

Fase 1. Noi ottenere questi numeri (interi a 32 bit) "xor" ED da N( = 0ormai) e diviso per 2^31: ⌊l~BitXor~#/#2⌋. Esistono tre casi:

• ordinato, ad es {0, 0, 1, 1, 1, 1, 1, 1}.
• può essere corretto, ad es {1, 1, 1, 1, 0, 0, 0, 0}.
• altro, ad es {0, 0, 1, 0, 0, 1, 1, 1}.

Noi non facciamo nulla per Nper il primo caso, o aggiungiamo 2^31a Ncorreggere l'ordine per il secondo caso: #+#2Boole@!OrderedQ@.... Mentre per il terzo caso, è impossibile xorting lista che cosa mai che facciamo, quindi basta aggiungere 2^31a Nper semplicità (o niente!).

Passaggio 2. Otteniamo questi numeri "xo" editati Ne divisi per 2^30. Ci sono ancora tre casi:

• ordinato, ad es {0, 1, 2, 2, 2, 2, 3, 3}.
• può essere corretto, ad es {1, 1 , 0, 0, 3, 2, 2, 2}.
• altro, ad es {3, 3, 1, 3, 2, 0, 1, 0}.

Noi non facciamo nulla per Nper il primo caso, o aggiungiamo 2^30a Ncorreggere l'ordine per il secondo caso. In caso contrario, ci rendiamo conto che xorting è impossibile, quindi basta aggiungere 2^30a Nper semplicità di nuovo.

Fase 3 ~ 32. Abbiamo ricorsivamente ottenere questi numeri "xor" ed da Ne diviso per 2^29, 2^28, ..., 2^0. E fai cose simili:Fold[...,0,2^32/2^Range[32]]

Passo 33. Ora finalmente abbiamo un candidato N. If[OrderedQ[l~BitXor~#],#,-1]&viene utilizzato per verificare se tale Nxorting l'elenco. Se l'elenco può essere xorting da alcuni N, non è difficile provare che incontreremo sempre il primo o il secondo caso.

Perl 6 , 79 byte

Se non ci fosse un limite di tempo, il codice Perl 6 più corto sarebbe probabilmente

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

Invece devo fare qualcosa di un po 'più intelligente.
Da quando ho impiegato un po 'di tempo per tornare a questo, c'era già una risposta che descrive un buon algoritmo e il ragionamento alla base.

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

Uso:

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

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

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

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

Mathematica 650 415 194 byte

Questa sfida mi ha aiutato a capire un po 'di Xorciò a cui non avevo mai pensato. Ci è voluto molto tempo per sminuire il codice, ma ne è valsa la pena.

BitXorfunziona direttamente sui numeri di base 10. Ciò ha notevolmente ridotto il codice rispetto alle versioni precedenti.

La logica è semplice Uno funziona, non con coppie di numeri (come hanno fatto alcuni invii) ma piuttosto con l'insieme completo di numeri dopo essere stato modificato BitXorcon l'attuale "chiave".

Inizia con una soluzione provvisoria, o "chiave" di zero, ovvero con tutti i bit zero. Quando i nnumeri originali vengono modificati BitXorcon zero, vengono restituiti, inalterati. Correlare l'ordinamento dei numeri con l'intervallo 1, 2, ...n, che rappresentano un elenco perfettamente ordinato. La correlazione, con un valore compreso tra -1 e 1, riflette quanto bene sono ordinati i numeri.

Quindi impostare il bit hi, ottenere la nuova chiave e BitXorla chiave con il set di numeri corrente. Se la correlazione tra la nuova sequenza di numeri e l'elenco perfettamente ordinato è un miglioramento, mantenere il bit impostato. In caso contrario, lasciare il bit non impostato.

Procedere in questo modo dall'alto al basso. Se la migliore correlazione è 1, la chiave è la soluzione. In caso contrario, è -1.

Ci sarebbero modi per rendere il codice un po 'più efficiente, ad esempio, interrompendo il processo non appena viene trovata una soluzione, ma ciò richiederebbe più codifica e l'approccio attuale è molto veloce così com'è. (Il caso di test finale e più lungo richiede 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

Aggiungi ++ , 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

Provalo online!

_{Sono davvero orgoglioso che Add ++ sia in grado di farlo, e non è la soluzione più lunga qui}

Dichiara una funzione fche accetta ogni elemento come argomento separato (ad es. $f>4>2>3>1)

Come funziona

Allacciate gente, sarà un lungo viaggio

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┬

Esegui ed esegui il debug online!

Utilizza la soluzione di @ RainerP. (È stata inventata la parte del bit lanciante in modo indipendente ma utilizza la 32rrparte)

Complessità temporale lineare.

Usa la versione decompressa per spiegare.

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