Meydan okuma:

Fonksiyonunu düşünün pozitif bir tamsayı az olduğunu . Bu işlev tarafından tanımlanan sıra: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

Bir girdi aşağıdaki gibi oluşturulacaktır:

• Yukarıdaki diziden 5 bitişik tam sayı alın .
• Bunlardan birini farklı, pozitif bir tamsayı ile değiştirin (yukarıdaki dizinin bir parçası olabilir veya olmayabilir).
• İsteğe bağlı olarak ortaya çıkan 5 sayıyı yeniden sıralayın.

Böyle bir 5 tamsayı listesi verildiğinde, değiştirileni bulun ve bu nedenle orijinal 5 bitişik tamsayıların bir parçası değildir.

Örnek:

• Orjinal alt liste: 5, 9, 17, 33, 65.
• Birini değiştirin: 5, 7, 17, 33, 65.
• Yeniden sıralama: 33, 17, 5, 7, 65.

Beklenen çıktı olurdu 7.

Girişteki 5 değer her zaman farklı olacak ve her zaman benzersiz bir çözüm olacaktır. (Örneğin, 3, 9, 17, 33, 129ikisinin de nereye 3veya 129ne şekilde değiştirilebileceği gibi girdilerle uğraşmanıza gerek kalmaz .)

Test Durumları:

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

Jöle, 15 bayt

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

TryItOnline
Tüm test örnekleri TryItOnline'da da

Garip olanı içeren bir liste içeren bir liste döndürür.

Nasıl?

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

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

Tamamen yeni bir algoritma, @ edc65'in işaret ettiği gibi bir öncekinin kırılmış olması. Açıklama: Öncelikle kolay durumla 2 veya 2'den daha büyük olmayan bir sayı arayarak ilgileniriz. Hiçbiri bulunamazsa, ekstra değerin değerin altında veya üstünde olmasına bağlı olarak iki olası durum vardır. beşinci orijinal çalışma, bu yüzden en küçük ve ikinci en büyük değerin beş ile aynı olup olmadığını kontrol ediyoruz ve eğer öyleyse en büyük değeri aksi takdirde en küçük değeri suçluyoruz.

Python, 84 bayt

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üm test senaryoları ideone'de

Geçerli giriş için yalnızca tek bir çıkışı içeren bir küme döndürür.
Geçersiz giriş için özyineleme sınırına ulaşılır ve bir hata atılır.

Mathematica, 65 bayt

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

Bu, f5 bağımsız değişkenle çağrılması gereken bir işlevi tanımlar , örn.

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

Prensip olarak, işlev herhangi bir (sıfır olmayan) argümanla çağrılabilir, ancak beklenmedik sonuçlar alabilirsiniz ...

Sanırım bu ilk defa, tüm çözümü önemsiz olmayan bir soruna a'nın sol tarafına koymayı başardım =.

açıklama

Bu çözüm, Mathematica'nın kalıp eşleme yeteneklerini bizim için işe yaratıyor. Kullandığımız temel özellik, Mathematica'nın sadece basit fonksiyonları tanımlayamaması, f[x_] := (* some expression in x *)ancak sol tarafta keyfi olarak karmaşık desenler kullanabilmemizdir, örneğin sadece iki elemanlı çağrıldığında kullanılan f[{a_, b_}, x_?OddQ] := ...bir tanım ekleyeceğiz flistesi ve tek bir tamsayı. Elverişli, zaten elemanlarına isimleri keyfi çok aşağı sol taraftaki ifade (örn Son örnekte, derhal iki liste elemanları yönlendirebilecek verebilir ave b).

Bu meydan okumada kullandığımız kalıp f[a___,x_,b___]. Burada a___ve b___olan sekanslar, sıfır ya da daha fazla bağımsız değişken ve xtek bir argümandır. Tanımın sağ tarafı basit olduğundan x, istediğimiz şey, aradığımız xgirdi için kullanılmasını sağlayan a___ve b___sadece kalan elemanları kapsayan joker karakterler olmasını sağlayan bir sihirdir .

Bu, desene bir koşul ekleyerek yapılır /;. Bu kalıbın eşleşmesi için /;(her şeye kadar =) sağ tarafının dönmesi gerekir True. Güzellik Mathematica adlı desen eşleştirme aracı her bir atama çalışacağız olmasıdır a, xve bbizim için girişlerine, bu yüzden doğru eleman arayışı bizim için yapılır. Bu aslında soruna açıklayıcı bir çözümdür.

Durumun kendisi için:

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

Bunun hiç de bağlı olmadığına dikkat edin x. Bunun yerine, bu koşul yalnızca geri kalan dört öğeye bağlıdır. Bu, desen eşleştirme çözümünün bir başka kullanışlı özelliğidir: dizi desenleri nedeniyle ave bbirlikte diğer tüm girişleri içerir.

Bu nedenle, bu koşulun geri kalan dört elementin sekansımızdan en fazla bir boşluk ile bitişik elemanlar olup olmadığını kontrol etmesi gerekir. Bunu kontrol etmek için temel fikir, sonraki dört öğeyi minimumdan (yoluyla ) oluşturmamız ve dört öğenin bunun bir alt kümesi olup olmadığını kontrol etmemizdir. Soruna neden olabilecek tek girdi, a içeren girişlerdir , çünkü bu aynı zamanda geçerli dizi öğeleri üretir, bu yüzden bunu ayrı olarak ele almamız gerekir.xi+1 = 2xi - 12

Son bölüm: asıl ifadeyi inceleyelim, çünkü burada daha komik sözdizimsel şeker var.

...a~Min~b...

Bu infix gösterimi kısadır Min[a,b]. Ama unutmayın ave bdiziler, bu aslında dört öğeye genişler Min[i1, i2, i3, i4]ve bize girdide kalan en küçük öğeyi verir.

.../. 2->0

Bu 2 ile sonuçlanırsa, bunu 0 ile değiştiririz (bu, dizide olmayan değerler oluşturur). Alan gereklidir, çünkü aksi takdirde Mathematica şamandıra hazır bilgisini ayrıştırır .2.

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

Adsız işlevi solda 4 kez bu değere uygularız ve sonuçları bir listede toplarız.

2#-1&

Bu, girdisini 2 ile çarpar ve azaltır.

...~SubsetQ~{a,b}

Ve son olarak, liste tüm unsurları içeren kontrol ave bbu bir alt kümesidir.

Raket 198 bayt

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

Ungolfed sürümü:

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

Test yapmak:

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

Çıktı:

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

05AB1E , 32 30 26 24 20 bayt

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

açıklama

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

Çevrimiçi deneyin!

R, 97 bayt

Bu düşündüğümden daha zor oldu. Eminim bu önemli ölçüde golf olabilir.

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

Açık ve açık

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()Fonksiyon dönecektir NAgiriş vektörü herhangi elemanı sırayla değil ve sonuç olarak biz sadece endeksi bulabilirse NAgirdi bulunur ve bu dönüş:x[is.na(m)]

Giriş dizinin bir parçasıysa ancak yanlış yerleştirilmişse biraz daha karmaşık hale gelir. Girdi sıralandığından, her bir endeks çifti arasındaki mesafe olmalıdır 1. Bu nedenle 1st, eşleşen endekslerin farkını araştırarak yanlış yerleştirilmiş öğeyi bulabilir ve l=diff(m)bunun için dizini seçebiliriz l>1. Bu l, 4unsurları içeren unsurlardan ziyade olmasaydı yeterli olurdu 5. Bu yalnızca, sıralanan girişteki son öğe dizinin bir parçasıysa, ancak alt dizinin bir parçası değilse (son test durumunda olduğu gibi) bir sorundur. Sonuç olarak, eğer 4theleman >1getirme 5thiçinde dizin için sıralı giriş başka görünüm girişi 4uzunlukta vektör:x[ifelse(l[4]>1,5,l>1)]

Haskell, 66 64 bayt

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

Kullanım örneği: g [65,129,257,513,4097]-> 4097.

Uzunluğunun 5 bitişik tüm alt listelerinde dolaşır F(N), giriş listesinde bulunmayan öğeleri xve kalıbı uzunluk 1 (-> [s]) ile eşleşir .

Düzenleme: @xnor dış döngünün üst sınırını kaldırarak iki bayt kaydetti. Bir çözümün varolduğu garanti edildiğinden, Haskell'in tembellik ilk bulunan numarada durur.

Perl, 64 59 bayt

İçin +2 içerir -an

STDIN'de giriş listesi verin:

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

Sonuç etrafında değişken miktarda alan sakıncası yoksa bu 58 bayt verson çalışır:

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

Girişin çözümü yoksa her iki sürüm de sonsuza kadar döngü yapar.

Bu çok hasta bir kod, ama zarif bir şey düşünemiyorum ...

Benim (ab) kullanım %aşekli bildiğim kadarıyla yeni bir perlgolf hilesi.

Python 2, 73 bayt

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

dGirdi öğelerinden biri hariç tümünü içeren birini bulana kadar art arda beş dizi öğesi kümesiyle yinelenir ve sonra tek bir kümedeki çıktı olan farkı yazdırır.

Birbirini takip deden beş elemandan oluşan setler , tekrar tekrar yeni bir eleman ekleyerek i+1ve i/32+15'in geçerli penceresinden önce gelen herhangi bir eski elemanı silerek oluşturulur .

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

Başlatmada başlangıçta bir başıboş 1 var, ama zararsız çünkü hemen kaldırıldı. 5 elemente kadar daha küçük setler de zararsızdır.

PHP, 87 76 75 bayt

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

ile koş php -r '<code>' <value1> <value2> <value3> <value4> <value5>

C #, 69 bayt

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

Java 7,85 bayt

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 Bayt

mod 5 ile Titus fikri uygulandı

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

126 Bayt öncesi

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

hhlD-LQ.:mh^2dSCd5

Diziyi oluşturun, uzunluk 5'in alt listelerini alın, Her alt listeyi Q'dan kaldırın, en kısa sonucu alın, tek öğesini çıktılayın.

Kotlin, 55 bayt

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