도전 과제 :

기능을 고려 양의 정수 미만입니다 . 이 기능으로 정의 된 순서는 다음과 같습니다.F(N) = 2^N + 1N31

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)

자바 스크립트 (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의 거듭 제곱보다 크지 않은 숫자를 찾아서 쉬운 경우를 처리합니다. 아무것도 발견되지 않은 경우 추가 값이 우리는 가장 작은 값과 두 번째로 큰 값이 같은 5의 런에 속하는지 확인하고, 가장 큰 값을 비난하면 가장 작은 값을 비난합니다.

파이썬, 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)

모든 테스트 사례는 아이디어가 있습니다

유효한 입력의 경우 홀수 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]

원칙적으로 함수는 0이 아닌 수의 인수로 호출 할 수 있지만 예기치 않은 결과가 발생할 수 있습니다 ...

나는 이것이 처음이라고 생각합니다. 전체 솔루션을 사소한 도전에 왼쪽의 왼쪽에 넣었습니다 =.

설명

이 솔루션은 실제로 Mathematica의 패턴 매칭 기능을 우리에게 제공합니다. 우리가 사용하는 기본 기능은 매스 매 티카는 것처럼 간단한 함수를 정의 할 수 없다는 것입니다 f[x_] := (* some expression in x *)하지만 우리는, 왼쪽에 등을 임의의 복잡한 패턴을 사용할 수 있습니다 f[{a_, b_}, x_?OddQ] := ...에 정의를 추가 할 f두 요소가있는 경우에만이 호출 할 때 사용됩니다 리스트와 홀수 정수. 편리하게, 우리는 이미 요소에 이름을 임의로까지 아래 왼쪽 표현 (예 : 마지막 예를 들어, 우리는 즉시로이 개 목록의 요소를 참조 할 수 줄 수 a과 b).

우리가이 도전에서 사용하는 패턴은 f[a___,x_,b___]입니다. 여기에 a___와 b___있는 시퀀스 0 개 이상의 인수가 및 x단일 인수입니다. 정의의 오른쪽은 단순히이기 때문에 x, 우리가 원하는 것은 어떤 마술 것을 보장이다 x의 입력 우린 검색을 위해 사용되며 a___그리고 b___단순히 와일드 카드 커버 그 나머지 요소입니다.

를 사용하여 패턴에 조건 을 첨부하면 됩니다 /;. 이 패턴이 일치 /;하려면 (의 모든 것) 의 오른쪽 이 =되돌아 True와야합니다. 아름다움은 매스 매 티카의 패턴 매처는 모든 단일 할당을 시도 할 것입니다 a, x그리고 b우리의 입력에, 그래서 올바른 요소에 대한 검색이 우리를 위해 수행된다. 이것은 본질적으로 문제에 대한 선언적 해결책입니다.

조건 자체는 다음과 같습니다.

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

이것은 전혀 의존하지 않습니다 x. 대신이 조건은 나머지 네 가지 요소에만 의존합니다. 이 패턴 정합 용액의 또 다른 편리한 기능이다 시퀀스 패턴으로 인해, a그리고 b서로 다른 입력을 포함한다.

따라서이 조건은 나머지 4 개의 요소가 시퀀스에서 최대 1 개의 갭이있는 연속 요소인지 확인해야합니다. 이를 확인하기위한 기본 아이디어는 최소 (via ) 에서 다음 4 개의 요소를 생성 하고 4 개의 요소가 이것의 하위 집합인지 확인하는 것입니다. 문제를 일으킬 수있는 유일한 입력은을 포함하는 입력입니다. 유효한 시퀀스 요소도 생성하므로 별도로 처리해야합니다.xi+1 = 2xi - 12

마지막 부분 : 여기에 좀 더 재미있는 구문 설탕이 있기 때문에 실제 표현을 봅시다.

...a~Min~b...

이 접두사 표기법은의 약어입니다 Min[a,b]. 그러나 기억 a하고 b이 실제로 네 가지 요소로 확장, 그래서 순서입니다 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포함 하는 사실이 아니라면 충분합니다 . 정렬 된 입력의 마지막 요소가 (최종 테스트 사례에서와 같이) 하위 시퀀스의 일부가 아닌 시퀀스 BUT의 멤버 인 경우에만 문제가됩니다. 따라서 요소 가 정렬 된 입력에서 항목을 가져 오는 경우 -length 벡터 에서 색인을 찾습니다 .454th>15th4x[ifelse(l[4]>1,5,l>1)]

하스켈, 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의 게으름은 처음 발견 된 숫자에서 멈 춥니 다.

펄, 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은 내가 아는 한 새로운 perlgolf 트릭입니다.

파이썬 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입력 요소 중 하나만 포함하고 하나만 포함 된 요소를 찾을 때까지 5 개의 연속 시퀀스 요소 세트 를 반복 한 다음 차이를 인쇄합니다.이 차이는 단일 세트로 출력됩니다.

d5 개의 연속 요소 세트 는 새 요소를 반복적으로 추가하고 5의 현재 창 이전에 나오는 i+1오래된 요소 i/32+1를 삭제 하여 아무 것도 만들어지지 않습니다 . 진행 상황은 다음과 같습니다.

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

자바 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 바이트

모드 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에서 각 서브리스트를 제거하고, 가장 짧은 결과를 취하여 유일한 요소를 출력하십시오.

코 틀린, 55 바이트

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