Các thách thức:

Hãy xem xét hàm F(N) = 2^N + 1trong đó Nlà một số nguyên dương nhỏ hơn 31. Trình tự được xác định bởi chức năng này là:

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

Một đầu vào sẽ được tạo ra như sau:

• Lấy 5 số nguyên liền kề từ dãy trên.
• Thay thế một trong số chúng bằng một số nguyên dương khác nhau (có thể hoặc không phải là một phần của chuỗi trên).
• Tùy chọn sắp xếp lại 5 số kết quả.

Đưa ra một danh sách gồm 5 số nguyên như vậy, hãy tìm một số nguyên được hoán đổi và do đó không phải là một phần của 5 số nguyên tiếp giáp ban đầu.

Thí dụ:

• Danh sách con ban đầu : 5, 9, 17, 33, 65.
• Thay thế một : 5, 7, 17, 33, 65.
• Sắp xếp lại : 33, 17, 5, 7, 65.

Sản lượng dự kiến ​​sẽ là 7.

5 giá trị trong đầu vào sẽ luôn khác biệt và sẽ luôn có một giải pháp duy nhất. (Ví dụ: bạn sẽ không phải đối phó với các yếu tố đầu vào như 3, 9, 17, 33, 129nơi 3hoặc 129có thể đã được hoán đổi.)

Các trường hợp thử nghiệm:

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

Thạch, 15 byte

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

TryItOnline
Tất cả các trường hợp thử nghiệm cũng tại TryItOnline

Trả về một danh sách chứa một danh sách chứa một số lẻ.

Làm sao?

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

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

Thuật toán hoàn toàn mới, vì như @ edc65 đã chỉ ra thuật toán trước đó đã bị hỏng. Giải thích: Trước tiên, chúng tôi xử lý trường hợp dễ dàng bằng cách tìm số 2 hoặc số không lớn hơn lũy thừa 2. Nếu không tìm thấy thì có hai trường hợp có thể xảy ra, tùy thuộc vào giá trị bổ sung nằm dưới hoặc trên lần chạy ban đầu là năm, vì vậy chúng tôi kiểm tra xem giá trị nhỏ nhất và lớn thứ hai có thuộc cùng một lần chạy năm hay không và nếu có thì đổ lỗi cho giá trị lớn nhất nếu không là giá trị nhỏ nhất.

Python, 84 byte

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)

Tất cả các trường hợp thử nghiệm là ở ideone

Đối với đầu vào hợp lệ trả về một tập hợp chỉ chứa một lần lẻ.
Đối với đầu vào không hợp lệ, giới hạn đệ quy sẽ đạt được và một lỗi sẽ được đưa ra.

Toán học, 65 byte

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

Điều này xác định một hàm fnên được gọi với 5 đối số, ví dụ

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

Về nguyên tắc, hàm có thể được gọi với bất kỳ số lượng đối số (khác không), nhưng bạn có thể nhận được kết quả không mong muốn ...

Tôi nghĩ rằng đây là lần đầu tiên, tôi quản lý để đưa toàn bộ giải pháp cho một thách thức không hề nhỏ vào phía bên trái của một = .

Giải trình

Giải pháp này thực sự khiến khả năng khớp mẫu của Mathicala hoạt động với chúng tôi. Tính năng cơ bản mà chúng tôi đang sử dụng là Mathicala không thể chỉ định nghĩa các hàm đơn giản như f[x_] := (* some expression in x *)nhưng chúng ta có thể sử dụng các mẫu phức tạp tùy ý ở phía bên trái, ví dụ: f[{a_, b_}, x_?OddQ] := ...sẽ thêm một định nghĩa fchỉ được sử dụng khi được gọi bằng hai phần tử danh sách và một số nguyên lẻ. Để thuận tiện, chúng ta đã có thể đặt tên cho các thành phần tùy ý ở xa biểu thức phía bên trái (ví dụ: trong ví dụ trước, chúng ta có thể tham khảo ngay hai yếu tố danh sách là avà b).

Mô hình chúng tôi đang sử dụng trong thử thách này là f[a___,x_,b___]. Ở đây a___và b___là các chuỗi từ 0 hoặc nhiều đối số và xlà một đối số duy nhất. Vì phía bên phải của định nghĩa chỉ đơn giản x, điều chúng tôi muốn là một phép thuật đảm bảo xđược sử dụng cho đầu vào mà chúng tôi đang tìm kiếm a___và b___chỉ đơn giản là các ký tự đại diện bao gồm các yếu tố còn lại.

Điều này được thực hiện bằng cách gắn một điều kiện vào mẫu với /;. Phía bên phải của /;(mọi thứ cho đến =) cần phải trả lại Truecho mẫu này để khớp. Vẻ đẹp là Mẫu trình khớp Mathematica sẽ cố gắng mỗi nhiệm vụ duy nhất của a, xvà bđến đầu vào đối với chúng tôi, vì vậy việc tìm kiếm các yếu tố chính xác được thực hiện cho chúng ta. Đây thực chất là một giải pháp khai báo cho vấn đề.

Đối với điều kiện chính nó:

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

Lưu ý rằng điều này không phụ thuộc vào xtất cả. Thay vào đó, điều kiện này chỉ phụ thuộc vào bốn yếu tố còn lại. Đây là một tính năng tiện lợi khác của giải pháp khớp mẫu: do các mẫu trình tự avà bcùng chứa tất cả các đầu vào khác.

Vì vậy, điều kiện này cần kiểm tra xem bốn phần tử còn lại có phải là các phần tử liền kề từ chuỗi của chúng ta với nhiều nhất một khoảng cách hay không. Ý tưởng cơ bản để kiểm tra điều này là chúng tôi tạo ra bốn yếu tố tiếp theo từ mức tối thiểu (thông qua ) và kiểm tra xem bốn yếu tố có phải là tập hợp con của điều này không. Các đầu vào duy nhất có thể gây rắc rối là những đầu vào có chứa a , bởi vì điều này cũng tạo ra các thành phần chuỗi hợp lệ, vì vậy chúng ta cần xử lý riêng nó.xi+1 = 2xi - 12

Phần cuối: chúng ta hãy đi qua biểu thức thực tế, bởi vì có một số đường cú pháp hài hước hơn ở đây.

...a~Min~b...

Ký hiệu infix này là viết tắt của Min[a,b]. Nhưng hãy nhớ rằng avà blà các chuỗi, vì vậy điều này thực sự mở rộng ra bốn yếu tố Min[i1, i2, i3, i4]và cung cấp cho chúng ta yếu tố nhỏ nhất còn lại trong đầu vào.

.../. 2->0

Nếu điều này dẫn đến 2, chúng tôi thay thế nó bằng 0 (sẽ tạo ra các giá trị không có trong chuỗi). Không gian là cần thiết bởi vì nếu không Mathicala phân tích cú pháp chữ nổi .2.

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

Chúng tôi áp dụng hàm không tên ở bên trái 4 lần cho giá trị này và thu thập kết quả trong một danh sách.

2#-1&

Điều này chỉ đơn giản là nhân số đầu vào của nó lên 2 và giảm nó.

...~SubsetQ~{a,b}

Và cuối cùng, chúng tôi kiểm tra xem danh sách có chứa tất cả các yếu tố từ avà blà một tập hợp con của điều này.

Vợt 198 byte

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

Phiên bản bị đánh cắp:

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

Kiểm tra:

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

Đầu ra:

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

05AB1E , 32 30 26 24 20 byte

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

Giải trình

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

Hãy thử trực tuyến!

R, 97 byte

Điều này hóa ra khó khăn hơn tôi nghĩ. Tôi chắc chắn rằng điều này có thể được chơi golf đáng kể mặc dù.

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

Ung dung và giải thích

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]

Các match()chức năng sẽ trở lại NAnếu bất kỳ yếu tố của vectơ đầu vào không có trong trình tự và do đó chúng ta chỉ có thể tìm thấy các chỉ số nơi NAtồn tại trong đầu vào và trở về này:x[is.na(m)]

Nó phức tạp hơn một chút nếu đầu vào là một phần của chuỗi nhưng đặt sai vị trí. Vì đầu vào đã được sắp xếp, nên khoảng cách giữa mỗi cặp chỉ số sẽ là 1. Do đó, chúng ta có thể tìm thấy phần tử đặt sai vị trí bằng cách điều tra sự 1stkhác biệt của các chỉ số phù hợp l=diff(m)và chọn chỉ mục cho nó l>1. Điều này sẽ là đủ nếu nó không thực tế lcó chứa 4các yếu tố chứ không phải 5. Đây chỉ là một vấn đề nếu phần tử cuối cùng trong đầu vào được sắp xếp là thành viên của chuỗi NHƯNG không phải là một phần của chuỗi (như trong trường hợp thử nghiệm cuối cùng). Do đó, nếu 4thphần tử >1tìm nạp 5thmục nhập trong đầu vào được sắp xếp khác, hãy tìm chỉ mục trong 4vectơ-chiều dài:x[ifelse(l[4]>1,5,l>1)]

Haskell, 66 64 byte

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

Ví dụ sử dụng: g [65,129,257,513,4097]-> 4097.

Các vòng lặp thông qua tất cả các danh sách con liền kề có độ dài 5 F(N), giữ cho các phần tử không có trong danh sách đầu vào xvà mẫu khớp với các phần tử có độ dài 1 (-> [s]).

Chỉnh sửa: @xnor đã lưu hai byte bằng cách loại bỏ giới hạn trên của vòng lặp bên ngoài. Như một giải pháp được đảm bảo tồn tại, sự lười biếng của Haskell dừng lại ở số đầu tiên được tìm thấy.

Perl, 64 59 byte

Bao gồm +2 cho -an

Đưa ra danh sách đầu vào trên 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

Nếu bạn không quan tâm đến dung lượng thay đổi xung quanh kết quả thì verson 58 byte này hoạt động:

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

Cả hai phiên bản lặp lại mãi mãi nếu đầu vào không có giải pháp.

Đây là mã rất bệnh, nhưng tôi không thể nghĩ ra bất cứ điều gì tao nhã ...

Cách tôi (ab) sử dụng %alà một thủ thuật perlgolf mới theo như tôi biết.

Python 2, 73 byte

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

Lặp lại thông qua các bộ dnăm phần tử chuỗi liên tiếp cho đến khi nó tìm thấy một phần tử chứa tất cả trừ một trong các phần tử đầu vào, sau đó in sự khác biệt, đó là đầu ra trong một tập hợp đơn.

Các bộ dnăm yếu tố liên tiếp được xây dựng từ không có gì bằng cách liên tục thêm một yếu tố mới i+1và xóa bất kỳ yếu tố cũ i/32+1nào xuất hiện trước cửa sổ hiện tại của 5. Đây là tiến trình của nó.

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

Có một đi lạc 1 khi bắt đầu từ khi khởi tạo, nhưng nó vô hại vì nó bị loại bỏ ngay lập tức. Các bộ nhỏ hơn khi nó xây dựng lên đến 5 yếu tố cũng vô hại.

PHP, 87 76 75 byte

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

chạy với php -r '<code>' <value1> <value2> <value3> <value4> <value5>

C #, 69 byte

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

Java 7,85 byte

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

Ung dung

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 byte

thực hiện ý tưởng Titus với mod 5

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

126 byte trước

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

Bình thường, 18 byte

hhlD-LQ.:mh^2dSCd5

Tạo chuỗi, lấy danh sách con có độ dài 5, Xóa từng danh sách con khỏi Q, lấy kết quả ngắn nhất, xuất phần tử duy nhất của nó.

Kotlin, 55 byte

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