チャレンジ：

がより小さい正の整数F(N) = 2^N + 1である関数を考えます。この関数で定義されるシーケンスは次のとおりです。N31

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つの連続した整数を取得します。
• それらの1つを別の正の整数に置き換えます（上記のシーケンスの一部である場合とそうでない場合があります）。
• オプションで、結果の5つの数値を並べ替えます。

このような5つの整数のリストが与えられた場合、スワップインされたため、元の5つの連続した整数の一部ではないものを見つけます。

例：

• 元のサブリスト：5, 9, 17, 33, 65。
• 1つを置き換えます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でも

奇数のリストを含む1つのリストを含むリストを返します。

どうやって？

⁹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の累乗よりも1だけ大きい数を探します。何も見つからなかった場合、2つの可能なケースがあります。元の5回の実行であるため、最小値と2番目に大きい値が同じ5回の実行に属しているかどうかをチェックし、そうである場合は最大値を非表示にします。

Python、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にあります

有効な入力の場合、奇数1出力のみを含むセットを返します。
無効な入力の場合、再帰制限に達し、エラーがスローされます。

Mathematica、65バイト

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

これは、f5つの引数で呼び出されるべき関数を定義します。例えば

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

原則として、関数は任意の（ゼロ以外の）引数で呼び出すことができますが、予期しない結果が得られる可能性があります...

私はこれが初めてだと思う、私は解決策全体を非自明な課題に何とかしての左側に置くことができた=。

説明

このソリューションは、Mathematicaのパターンマッチング機能を本当に役立てます。私たちが使用している基本的な機能は、Mathematicaが単純な関数を定義できるだけでなくf[x_] := (* some expression in x *)、左側に任意の複雑なパターンを使用できることです。たとえば、2要素で呼び出されたときにのみ使用されるf[{a_, b_}, x_?OddQ] := ...定義を追加しますfリストと奇数の整数。便利なことに、左側の式のはるか下の要素に名前を付けることができます（たとえば、最後の例では、2つのリスト要素をaand としてすぐに参照でき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。代わりに、この条件は残りの4つの要素のみに依存します。これは、パターンマッチング液の別の便利な機能である：配列パターンに起因する、aとb一緒にほかのすべての入力を含みます。

したがって、この条件では、残りの4つの要素が、最大で1つのギャップを持つシーケンスからの連続した要素であるかどうかを確認する必要があります。これをチェックするための基本的な考え方は、次の4つの要素を最小値（を介して）から生成し、4つの要素がこのサブセットであるかどうかをチェックすることです。それが問題を引き起こす可能性がある唯一の入力は、を含む入力です。これは有効なシーケンス要素も生成するため、それを個別に処理する必要があるからです。xi+1 = 2xi - 12

最後の部分：実際の表現を見ていきましょう。ここにはもっと面白い構文糖があります。

...a~Min~b...

この中置記法はの略ですMin[a,b]。ただし、aand bはシーケンスであるため、これは実際には4つの要素に展開さMin[i1, i2, i3, i4]れ、入力の残りの最小要素を提供します。

.../. 2->0

これが2になった場合、0に置き換えます（シーケンスにない値を生成します）。そうでないとMathematicaがfloatリテラルを解析するため、スペースが必要.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含むという事実がなければ十分です。これは、ソートされた入力の最後の要素がシーケンスのメンバーである場合にのみ問題になりますが、サブシーケンスの一部ではありません（最終テストケースの場合のように）。その結果、要素がソートされた入力のエントリをフェッチする場合は、-lengthベクトルのインデックスを探します。454th>15th4x[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は、外側のループの上限を削除して2バイトを節約しました。ソリューションの存在が保証されているため、Haskellの怠は最初に見つかった数で停止します。

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）useする方法は新しい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入力要素の1つを除くすべてを含む要素が見つかるまで、5つの連続したシーケンス要素のセットを反復処理し、シングルトンセットの出力である差を出力します。

d5つの連続した要素のセットは、新しい要素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バイト

mod 5でTitusのアイデアを実装しました

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

Pyth、18バイト

hhlD-LQ.:mh^2dSCd5

シーケンスを形成し、長さ5のサブリストを取得し、Qから各サブリストを削除し、最短の結果を取得し、その唯一の要素を出力します。

Kotlin、55バイト

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