ความท้าทาย:

พิจารณาฟังก์ชั่น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 ถ้าไม่พบไม่พบมีกรณีที่เป็นไปได้สองกรณีขึ้นอยู่กับว่าค่าพิเศษต่ำกว่าหรือสูงกว่า ค่าเริ่มต้นเดิมคือห้าดังนั้นเราจะตรวจสอบว่าค่าที่เล็กที่สุดและใหญ่เป็นอันดับสองนั้นเป็นของการรันที่เท่ากันทั้งห้าหรือไม่

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

สำหรับการป้อนข้อมูลที่ถูกต้องส่งกลับชุดที่มีเพียงคี่หนึ่งออก
สำหรับการป้อนข้อมูลที่ไม่ถูกต้องจะมีการ จำกัด การเรียกซ้ำและข้อผิดพลาดจะถูกโยน

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

Ungolfed และอธิบาย

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 บันทึกสองไบต์โดยการลบขอบบนของลูปด้านนอก ในฐานะที่เป็นโซลูชั่นที่รับประกันว่าจะมีอยู่ความเกียจคร้านของ 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 byte verson นี้ใช้งานได้:

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

ทั้งสองเวอร์ชันวนซ้ำตลอดไปหากอินพุตไม่มีวิธีแก้ไข

นี่เป็นรหัสที่แย่มาก แต่ฉันไม่สามารถคิดอะไรที่สง่างาม ...

วิธีที่ฉันใช้ (ab) %aเป็นเคล็ดลับ 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];}

Ungolfed

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

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