El reto:

Considere la función F(N) = 2^N + 1donde Nes un entero positivo menor que 31. La secuencia definida por esta función es:

3, 5, 9, 17, 33, 65, 129, 257, 513, 1025, 2049, 4097, 8193, 16385, 32769, 65537, 131073, 262145, 524289, 1048577, 2097153, 4194305, 8388609, 16777217, 33554433, 67108865, 134217729, 268435457, 536870913, 1073741825

Se generará una entrada de la siguiente manera:

• Toma 5 enteros contiguos de la secuencia anterior.
• Reemplace uno de ellos con un número entero positivo diferente (que puede o no ser parte de la secuencia anterior).
• Opcionalmente reordenar los 5 números resultantes.

Dada tal lista de 5 enteros, encuentre el que se intercambió y, por lo tanto, no forma parte de los 5 enteros contiguos originales.

Ejemplo:

• Sublista original: 5, 9, 17, 33, 65.
• Reemplazar uno: 5, 7, 17, 33, 65.
• Reordenar: 33, 17, 5, 7, 65.

El resultado esperado sería 7.

Los 5 valores en la entrada siempre serán distintos y siempre habrá una solución única. (Por ejemplo, no tendrá que lidiar con entradas como 3, 9, 17, 33, 129dónde 3o 129si se hubieran intercambiado).

Casos de prueba:

5,9,17,33,829
o/p: 829

9,5,17,829,33
o/p: 829

33, 17, 5, 7, 65
o/p: 7

5,9,177,33,65
o/p: 177

65,129,259,513,1025
o/p: 259

129,259,513,1025,65
o/p: 259

63,129,257,513,1025
o/p: 63

65,129,257,513,4097
o/p: 4097

5, 9, 2, 17, 33
o/p: 2

536870913, 67108865, 1073741825, 1, 268435457
o/p: 1

Jalea, 15 bytes

⁹R2*‘ṡ5ḟ@€µEÐfQ

TryItOnline
Todos los casos de prueba también en TryItOnline

Devuelve una lista que contiene una lista que contiene la impar.

¿Cómo?

⁹R2*‘ṡ5ḟ@€µEÐfQ - Main link, a (list)
⁹               - literal 256 (saving a byte over literal 30)
 R              - range, [1,2,3,...]
  2*            - 2 ** x, [2,4,8,...]
    ‘           - increment, [3,5,9,...]
     ṡ5         - all contiguous slices of length 5
       ḟ@€      - filter with reversed arguments for each
          µ     - monadic chain separation
            Ðf  - filter on condition:
           E    - all equal (those previously filtered lists with only one value)
              Q - unique (there can be two, but both will have the same odd-one-out)

JavaScript (ES6), 62 bytes

a=>a.find(n=>--n&--n|!n)||a.sort((a,b)=>a-b)[a[0]*16>a[3]?4:0]

Algoritmo completamente nuevo, ya que, como señaló @ edc65, el anterior estaba roto. Explicación: Primero tratamos el caso fácil buscando un 2 o un número que no sea uno mayor que una potencia de 2. Si no se encontró ninguno, hay dos casos posibles, dependiendo de si el valor adicional estaba por debajo o por encima del ejecución original de cinco, por lo que verificamos si el valor más pequeño y el segundo más grande pertenecen a la misma ejecución de cinco y, de ser así, culpar al valor más grande de lo contrario al valor más pequeño.

Python, 84 bytes

def f(a,i=0):s=set(a)-{2**j+1for j in range(i,i+5)};return len(s)<2and s or f(a,i+1)

Todos los casos de prueba están en ideone

Para una entrada válida, devuelve un conjunto que contiene solo la salida impar.
Para una entrada no válida, se alcanzará el límite de recursión y se generará un error.

Mathematica, 65 bytes

f[a___,x_,b___]/;NestList[2#-1&,a~Min~b/. 2->0,4]~SubsetQ~{a,b}=x

Esto define una función fque debería llamarse con 5 argumentos, p. Ej.

f[5, 9, 17, 33, 829]

En principio, la función se puede invocar con cualquier número (distinto de cero) de argumentos, pero puede obtener resultados inesperados ...

Creo que esta es la primera vez, que logré poner toda la solución a un desafío no trivial en el lado izquierdo de a =.

Explicación

Esta solución realmente pone las capacidades de coincidencia de patrones de Mathematica a trabajar para nosotros. La característica básica que estamos usando es que Mathematica no solo puede definir funciones simples como, f[x_] := (* some expression in x *)sino que podemos usar patrones arbitrariamente complejos en el lado izquierdo, por ejemplo f[{a_, b_}, x_?OddQ] := ..., agregaría una definición a la fque solo se usa cuando se llama con un elemento de dos elementos. lista y un entero impar. Convenientemente, ya podemos dar nombres a elementos arbitrariamente en la parte inferior de la expresión del lado izquierdo (por ejemplo, en el último ejemplo, podríamos referirnos inmediatamente a los dos elementos de la lista como ay b).

El patrón que estamos usando en este desafío es f[a___,x_,b___]. Aquí a___y b___son secuencias de cero o más argumentos y xes un argumento único. Dado que el lado derecho de la definición es simplemente x, lo que queremos es algo de magia que garantice que xse use para la entrada que estamos buscando a___y que b___sean simplemente comodines que cubran los elementos restantes.

Esto se realiza adjuntando una condición al patrón con /;. El lado derecho de /;(todo hasta el =) debe regresar Truepara que este patrón coincida. La belleza es que comparador de patrón de Mathematica tratará cada asignación de a, xy ba las entradas para nosotros, por lo que la búsqueda del elemento correcto está hecho por nosotros. Esto es esencialmente una solución declarativa al problema.

En cuanto a la condición en sí:

NestList[2#-1&,a~Min~b/. 2->0,4]~SubsetQ~{a,b}

Tenga en cuenta que esto no depende xen absoluto. En cambio, esta condición depende solo de los cuatro elementos restantes. Esta es otra característica conveniente de la solución de coincidencia de patrones: debido a los patrones de secuencia, ay bjuntos contienen todas las demás entradas.

Por lo tanto, esta condición debe verificar si los cuatro elementos restantes son elementos contiguos de nuestra secuencia con un espacio como máximo. La idea básica para verificar esto es que generamos los siguientes cuatro elementos desde el mínimo (vía ) y verificamos si los cuatro elementos son un subconjunto de esto. Las únicas entradas donde eso puede causar problemas son aquellas que contienen un , porque esto también genera elementos de secuencia válidos, por lo que debemos manejarlo por separado.xi+1 = 2xi - 12

Última parte: veamos la expresión real, porque hay algo más de azúcar sintáctica divertida aquí.

...a~Min~b...

Esta notación infija es la abreviatura de Min[a,b]. Pero recuerde que ay bson secuencias, por lo que esto realmente se expande a los cuatro elementos Min[i1, i2, i3, i4]y nos da el elemento restante más pequeño en la entrada.

.../. 2->0

Si esto resulta en un 2, lo reemplazamos con un 0 (que generará valores que no están en la secuencia). El espacio es necesario porque, de lo contrario, Mathematica analiza el literal flotante .2.

NestList[...&,...,4]

Aplicamos la función sin nombre de la izquierda 4 veces a este valor y recopilamos los resultados en una lista.

2#-1&

Esto simplemente multiplica su entrada por 2 y la disminuye.

...~SubsetQ~{a,b}

Y finalmente, verificamos que la lista que contiene todos los elementos de ay bes un subconjunto de esto.

Raqueta 198 bytes

(λ(m)(let((l(for/list((i(range 1 31)))(+ 1(expt 2 i))))(r 1)(n(length m)))(for((i(-(length l)n)))(let
((o(for/list((j m)#:unless(member j(take(drop l i)n)))j)))(when(eq?(length o)1)(set! r o))))r))

Versión sin golf:

(define f
  (λ(m)
    (let ((l (for/list ((i (range 1 31))) 
               (+ 1 (expt 2 i))))
          (res 1)
          (n (length m)))
      (for ((i (- (length l) n)))
        (let ((o (for/list ((j m) 
                             #:unless (member j 
                                             (take (drop l i) n))) 
                    j)))
          (when (eq? (length o) 1)
            (set! res o))))
      res)))

Pruebas:

(f '(5 9 17 33 829))
(f '(9 5 17 829 33))
(f '(5 9 177 33 65))
(f '(65 129 259 513 1025))
(f '(129 259 513 1025 65))
(f '(63 129 257 513 1025))
(f '(65 129 257 513 4097))

Salida:

'(829)
'(829)
'(177)
'(259)
'(259)
'(63)
'(4097)

05AB1E , 32 30 26 24 20 bytes

30Lo>Œ5ùv¹yvyK}Dgi`q

Explicación

30Lo>    # list containing the sequence [3 .. 1073741825]
Œ5ù      # all sequence sublists of length 5
v        # for each such list
 ¹yvyK}  # remove it's elements from input
 Dgi     # if the remaining list has length 1
    `q   # end the program and print the final list flattened

Pruébalo en línea!

R, 97 bytes

Esto resultó ser más difícil de lo que pensaba. Sin embargo, estoy seguro de que esto se puede jugar mucho.

m=match(x<-sort(scan()),2^(1:31)+1);l=diff(m);ifelse(NA%in%m,x[is.na(m)],x[ifelse(l[4]>1,5,l>1)])

Desengañado y explicado

x<-sort(scan())                  # read input from stdin and sort, store as vector
m=match(x, 2^(1:31)+1)           # generate a vector of indices for which input matches the sequence
l=diff(m)                        # vector of the difference of indices (will only contain 4 elements)
ifelse(NA%in%m,                  # if m contains NA do:
       x[is.na(m)],              # return x where no match has been found, else:
       x[ifelse(l[4]>1,5,l>1)])  # return x by index where diff>1 unless it's the last object, then return x[5]

La match()función volverá NAsi algún elemento del vector de entrada no está en la secuencia y, en consecuencia, podemos encontrar el índice donde NAexiste en la entrada y devolver esto:x[is.na(m)]

Se vuelve un poco más complicado si la entrada es parte de la secuencia pero está fuera de lugar. Debido a que la entrada ha sido ordenada, la distancia entre cada par de índices debería ser 1. Por lo tanto, podemos encontrar el elemento fuera de lugar investigando la 1stdiferencia de los índices coincidentes l=diff(m)y seleccionando el índice para el cual l>1. Esto sería suficiente si no fuera por el hecho de que lcontiene 4elementos en lugar de 5. Esto es solo un problema si el último elemento en la entrada ordenada es un miembro de la secuencia PERO no es parte de la subsecuencia (como en el caso de prueba final). En consecuencia, si el 4thelemento >1busca la 5thentrada en la entrada ordenada, busque el índice en el 4vector -length:x[ifelse(l[4]>1,5,l>1)]

Haskell, 66 64 bytes

g x=[s|n<-[1..],[s]<-[filter(`notElem`[2^m+1|m<-[n..n+4]])x]]!!0

Ejemplo de uso: g [65,129,257,513,4097]-> 4097.

Recorre todas las sublistas contiguas de longitud 5 de F(N), mantiene los elementos que no están en la lista de entrada xy el patrón coincide con los de longitud 1 (-> [s]).

Editar: @xnor guardó dos bytes al eliminar el límite superior del bucle externo. Como se garantiza que existe una solución, la pereza de Haskell se detiene en el primer número encontrado.

Perl, 64 59 bytes

Incluye +2 para -an

Dar lista de entrada en STDIN:

perl -M5.010 oddout.pl <<< "5 9 2 17 33"

oddout.pl:

#!/usr/bin/perl -an
@a=grep$_,@a{@F,map{2**$_+++1}($.++)x5}=@F while$#a;say@a

Si no le importa la cantidad variable de espacio alrededor del resultado, este 58 byte verson funciona:

#!/usr/bin/perl -ap
$_=join$",@a{@F,map{2**$_+++1}($.++)x5}=@F while/\b +\b/

Ambas versiones se repiten para siempre si la entrada no tiene solución.

Este es un código muy enfermo, pero no puedo pensar en nada elegante ...

La forma en que uso (ab) %aes un nuevo truco de Perlgolf, que yo sepa.

Python 2, 73 bytes

s=set(input());i,=d={1}
while~-len(s-d):i*=2;d=d-{i/32+1}|{i+1}
print s-d

Itera a través de conjuntos dde cinco elementos de secuencia consecutivos hasta que encuentra uno que contiene todos los elementos de entrada menos uno, y luego imprime la diferencia, que es la salida en un conjunto de singleton.

Los conjuntos dde cinco elementos consecutivos se crean a partir de la nada al agregar repetidamente un nuevo elemento i+1y eliminar cualquier elemento anterior i/32+1que aparezca antes de la ventana actual de 5. Así es como se ve su progreso.

{1}
{3}
{3, 5}
{3, 5, 9}
{3, 5, 9, 17}
{3, 5, 9, 17, 33}
{5, 9, 17, 33, 65}
{9, 17, 33, 65, 129}
{17, 33, 65, 129, 257}
{33, 65, 129, 257, 513}

Hay un 1 perdido al comienzo de la inicialización, pero es inofensivo porque se elimina de inmediato. Los conjuntos más pequeños, ya que acumula hasta 5 elementos, también son inofensivos.

PHP, 87 76 75 bytes

for(;count($b=array_diff($argv,$a?:[]))-2;)$a[$n%5]=1<<++$n|1;echo end($b);

corre con php -r '<code>' <value1> <value2> <value3> <value4> <value5>

C #, 69 bytes

int M(int[]a)=>a.Except(new int[30].Select((_,i)=>(1<<i+1)+1)).Sum();

Java 7,85 bytes

int f(int[]a,int l){int i=1;for(;i<l;)if(a[i++-1]*2-1!=a[i])return a[i];return a[0];}

Sin golf

int f(int[]a,int l){
    int i=1;
    for(;i<l;)
    if(a[i++-1]*2-1!=a[i])
    return a[i];
   return a[0];

}

PHP, 76 bytes

implementado la idea de Titus con el mod 5

<?for(;count($x=array_diff($_GET[a],$r))-1;$r[++$i%5]=2**$i+1);echo end($x);

126 bytes antes

<?for(;$x=array_diff($_GET[a],array_map(function($z){return 2**$z+1;},range(++$i,$i+4)));)if(count($x)<2){echo end($x);break;}

Pyth, 18 bytes

hhlD-LQ.:mh^2dSCd5

Forme la secuencia, tome sublistas de longitud 5, elimine cada sublista de Q, tome el resultado más corto, genere su único elemento.

Kotlin, 55 bytes

fun f(a:IntArray)=a.find{it-1 !in(1..30).map{1 shl it}}