Змагання:

Розглянемо функцію, F(N) = 2^N + 1де Nдодатне ціле число менше, ніж 31. Послідовність, визначена цією функцією, є:

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

Вхід буде створено наступним чином:

• Візьміть 5 суміжних цілих чисел із наведеної послідовності.
• Замініть одне з них іншим, додатним цілим числом (яке може бути або не бути частиною вищезазначеної послідовності).
• Необов’язково переупорядкуйте 5 отриманих чисел.

Враховуючи такий список із 5 цілих чисел, знайдіть те, яке було замінено, і тому не є частиною вихідних 5 суміжних цілих чисел.

Приклад:

• Оригінальний подспісок: 5, 9, 17, 33, 65.
• Замінити один: 5, 7, 17, 33, 65.
• Упорядкування 33, 17, 5, 7, 65.

Очікуваний результат буде 7.

5 значень вхідних даних завжди будуть різними, і завжди знайдеться унікальне рішення. (Наприклад, вам не доведеться мати справу з вхідними даними, наприклад, 3, 9, 17, 33, 129там, де вони були 3або 129були замінені.)

Випробування:

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

Желе, 15 байт

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

TryItOnline
Усі тестові випадки також у TryItOnline

Повертає список, що містить один список, що містить непарний.

Як?

⁹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 байти

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

Зовсім новий алгоритм, оскільки, як @ edc65 вказував, попередній був порушений. Пояснення: Спочатку ми розбираємося з легким випадком, шукаючи 2 або число, яке не на одну перевищує потужність 2. Якщо жодного не було знайдено, то є два можливі випадки, залежно від того, додаткове значення було нижче або вище початковий пробіг з п'яти, тому ми перевіряємо, чи належить найменше і друге за величиною до одного і того ж прогону з п'яти, і якщо так звинувачуємо найбільше значення, інакше найменше значення.

Пітон, 84 байти

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)

Усі тестові справи знаходяться на ideone

Для дійсного введення повертається набір, що містить лише непарний вихід.
При неправильному введенні буде досягнуто обмеження рекурсії і буде видана помилка.

Математика, 65 байт

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

Це визначає функцію, fяку слід викликати з 5 аргументів, наприклад

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

В принципі, функцію можна викликати будь-якою (ненульовою) кількістю аргументів, але у вас можуть бути несподівані результати ...

Я думаю, що це вперше, що мені вдалося поставити все рішення нетривіального виклику в ліву частину а =.

Пояснення

Це рішення по-справжньому ставить можливості узгодження шаблонів Mathematica працювати для нас. Основна особливість, яку ми використовуємо, полягає в тому, що Mathematica не може просто визначити прості функції, як, f[x_] := (* some expression in x *)але ми можемо використовувати довільно складні шаблони з лівої сторони, наприклад f[{a_, b_}, x_?OddQ] := ..., додамо визначення, fяке використовується лише тоді, коли воно викликається двоелементним список і непарне ціле число. Зручно, ми можемо вже давати назви елементам довільно далеко внизу лівого виразу (наприклад, в останньому прикладі ми могли б негайно посилатися на два елементи списку як aі b).

Шаблон, який ми використовуємо в цьому виклику, такий f[a___,x_,b___]. Ось a___і b___є послідовності нульових або більше аргументів і xє єдиним аргументом. Оскільки права частина визначення є простою x, то, що ми хочемо, є якась магія, яка гарантує, що xвикористовується для вводу, який ми шукаємо, a___і b___є просто макіяжними символами, які охоплюють елементи, що залишилися.

Це робиться шляхом приєднання умови до візерунка з /;. Права частина /;(все до того =) повинна повернутися, Trueщоб цей шаблон відповідав. Принадність в тому , що модель узгодження Mathematica намагатиметься кожне призначення a, xі bдо входів для нас, тому пошуку правильного елемента робиться для нас. Це по суті декларативне вирішення проблеми.

Що стосується самої умови:

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

Зауважте, що це взагалі не залежить x. Натомість ця умова залежить лише від чотирьох решти елементів. Це ще одна зручна особливість рішення узгодження шаблонів: завдяки шаблонам послідовностей aі bразом містять усі інші входи.

Тому ця умова повинна перевірити, чи залишилися чотири елементи суміжними елементами з нашої послідовності, щонайменше з одним проміжком. Основна ідея для перевірки цього полягає в тому, що ми формуємо наступні чотири елементи з мінімуму (через ) і перевіряємо, чи є чотири елементи підмножиною цього. Єдині входи, де це може спричинити неполадки, - це ті, що містять a , оскільки це також генерує дійсні елементи послідовності, тому нам потрібно обробляти це окремо.xi+1 = 2xi - 12

Остання частина: давайте переглянемо власне вираз, адже тут є ще кумедне синтаксичне цукор.

...a~Min~b...

Це позначення інфікса коротке Min[a,b]. Але пам’ятайте, що це aі bє послідовності, тому це насправді розширюється до чотирьох елементів Min[i1, i2, i3, i4]і дає нам найменший елемент, що залишився на вході.

.../. 2->0

Якщо це призведе до рівня 2, ми замінимо його на 0 (що буде генерувати значення, які не в послідовності). Простір необхідний, тому що в іншому випадку Mathematica розбирає поплавковий літерал .2.

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

Ми застосовуємо неназвану функцію зліва 4 рази до цього значення і збираємо результати у списку.

2#-1&

Це просто помножує його вклад на 2 і зменшує його.

...~SubsetQ~{a,b}

І нарешті, ми перевіряємо, що список, що містить усі елементи з aі bє його підмножиною.

Ракетка 198 байт

(λ(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))

Негольована версія:

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

Тестування:

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

Вихід:

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

05AB1E , 32 30 26 24 20 байт

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

Пояснення

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

Спробуйте в Інтернеті!

R, 97 байт

Це виявилося складніше, ніж я думав. Я впевнений, що це може бути значно гольф, хоча.

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

Необережений і пояснив

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]

match()Функція буде повертати , NAякщо якийсь - або елемент вхідного вектора не в тій послідовності , і , отже , ми можемо просто знайти індекс , де NAіснують на вході і повернути це:x[is.na(m)]

Це стає трохи складніше, якщо введення є частиною послідовності, але неправильно. Оскільки введення сортоване, відстань між кожною парою індексів має бути рівним1 . Тому ми можемо знайти неправильно розміщений елемент, дослідивши 1stрізницю відповідних індексів l=diff(m)та обравши індекс, для якого l>1. Цього було б достатньо, якби не факт, що lмістить 4елементи, а не 5. Це лише проблема, якщо останній елемент у відсортованому вході є членом послідовності, АЛЕ не є частиною підпорядкування (як у фінальному тестовому випадку). Отже, якщо 4thелемент >1отримує 5thзапис у відсортованому вході, шукайте індекс у 4векторі -length:x[ifelse(l[4]>1,5,l>1)]

Haskell, 66 64 байт

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

Приклад використання: g [65,129,257,513,4097]->4097 .

Прокручує всі суміжні підсписи довжиною 5 F(N), зберігає елементи, які відсутні у вхідному списку, xі візерунок відповідає тим, що мають довжину 1 (->[s] ).

Редагувати: @xnor врятував два байти, видаливши верхню межу зовнішньої петлі. Оскільки рішення гарантовано існує, лінь Хаскелла зупиняється на першому знайденому номері.

Perl, 64 59 байт

Включає +2 для -an

Наведіть список вводу на 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

Якщо ви не заперечуєте змінну кількість місця навколо результату, цей 58-байтний варіант працює:

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

Обидві версії циклу вічні, якщо вхід не має рішення.

Це дуже жорстокий код, але я не можу придумати нічого елегантного ...

%aНаскільки я (ab) використовую - це новий фокус perlgolf, наскільки я знаю.

Python 2, 73 байти

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

Ітераціює через безліч d з п'яти послідовних елементів послідовності, поки не знайде той, який містить усі, крім одного з вхідних елементів, а потім надрукує різницю, яка є результатом в однонабірному наборі.

Набори dз п’яти послідовних елементів створюються з нічого, багаторазово додаючи новий елемент i+1і видаляючи будь-який старий елемент, i/32+1що з’являється перед поточним вікном 5. Ось як виглядає його прогрес.

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

На початку від ініціалізації є бродячий 1, але він нешкідливий, оскільки його негайно видаляють. Більш дрібні набори під час створення до 5 елементів також нешкідливі.

PHP, 87 76 75 байт

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

бігати з php -r '<code>' <value1> <value2> <value3> <value4> <value5>

C #, 69 байт

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

Java 7,85 байт

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

Безумовно

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 байт

реалізував ідею Titus з модом 5

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

126 байт раніше

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

Піт, 18 байт

hhlD-LQ.:mh^2dSCd5

Сформуйте послідовність, візьміть підлістики довжиною 5, видаліть кожен підпис із Q, візьміть найкоротший результат, виведіть його єдиний елемент.

Котлін, 55 байт

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