Verilen N, bu sonsuz dizinin Nth terimini çıkarır:

-1 2 -2 1 -3 4 -4 3 -5 6 -6 5 -7 8 -8 7 -9 10 -10 9 -11 12 -12 11 ... etc.

N istediğiniz gibi 0 dizinli veya 1 dizinli olabilir.

Girişler daha sonra 0 endeksli Örneğin, 0, 1, 2, 3, 4, ilgili çıkışları üretmelidir -1, 2, -2, 1, -3.

Girişler daha sonra 1 endeksli ise 1, 2, 3, 4, 5, ilgili çıkışları üretmelidir -1, 2, -2, 1, -3.

Açık olmak gerekirse, bu dizi iki kez tekrarlanan pozitif tamsayıların sırasını alarak üretilir.

1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 ...

ve her bir tek sayının çiftinin hemen üzerindeki çift sayıları çevreleyecek şekilde yeniden düzenleme

1 2 2 1 3 4 4 3 5 6 6 5 7 8 8 7 9 10 10 9 11 12 12 11 ...

ve son olarak, ilk terimden başlayarak diğer her terimi olumsuzlamak

-1 2 -2 1 -3 4 -4 3 -5 6 -6 5 -7 8 -8 7 -9 10 -10 9 -11 12 -12 11 ...

Bayt cinsinden en kısa kod kazanır.

Python 2 , 23 bayt

lambda n:~n/2+n%2*(n|2)

Tek girişler kabaca n/2, hatta kabaca olanlar da verir -n/2. Ben de başladım -n/2+n%2*nve oradan ince ayar yaptım .

Çevrimiçi deneyin!

Mathematica, 29 bayt

((#~GCD~4/. 4->-2)+#)/2(-1)^#&

1 indeksli giriş alarak saf fonksiyon. Alternatif işaretler dışında, (-1)^#sekans girişe iki kez yakındır; farklar döngüsel olarak 1, 2, 1, -2'dir. It en güzel #~GCD~4büyük ortak girişinin bölen ve 41'dir, 2, 1, 4 döngüsel; bu yüzden sadece manuel olarak değiştirip 4->-2bir gün diyoruz. Bu yaklaşımı seviyorum çünkü birçok karakterli Mathematica komutlarının çoğundan kaçınıyor.

Pip , 24 22 bayt

v**a*YaBA2|1+:--a//4*2

Girdi, 1 indeksli, komut satırı argümanı olarak. Çevrimiçi deneyin ya da 1-20 doğrulayın .

açıklama

Dizinin, biri sıfır dizinli, diğeri tek dizinli diğer üç diziyi birleştirerek elde edilebileceğini gözlemleyin:

• 0 0 0 0 2 2 2 2 4 4 4 4= a//4*2(0-indexed) ile başlayın ;
• Ekle 1 2 2 1 1 2 2 1 1 2 2 1= aBA2|1, BAbitsel AND ve |mantıksal OR (1-indexed);
• Toplamı -1 1 -1 1 -1 1 -1 1 -1 1 -1 1= (-1)**a(1 indeksli) ile çarpın .

a1-indexed ile başlarsak , önce 1-indexed kısımları hesaplayabiliriz (soldan sağa ifadeyi okuyabiliriz) ve sonra a0-endeksli kısmı için azaltabiliriz . Yerleşik değişkeni kullanarak v=-1, biz olsun

v**a*((aBA2|1)+--a//4*2)

İki baytı daha tıraş etmek için, bazı öncelik önceliği manipülasyon numaralarını kullanmalıyız. İçindeki parantezleri ( birçok dile eşdeğerde) +ile değiştirerek ortadan kaldırabiliriz . Herhangi bir hesaplama ve atama işleci çok düşük önceliğe sahiptir, yani eşdeğerdir . Pip, değişken olmayan bir şeye atama konusunda ancak bir uyarı etkinleştirildiyse bir uyarı verir.+:+=aBA2|1+:--a//4*2(aBA2|1)+:(--a//4*2)

Daha düşük önceliğe olan tek şey :IS Y, yank operatörü * Bu onun Operand değerini atar. yDeğişken ve değişmeden içinden geçirir; bu yüzden değeri yanking ziyade parenthesizing tarafından sıra dış parantez ortadan kaldırabilir: YaBA2|1+:--a//4*2.

_{* Rint Pve Output Yank ile aynı önceliğe sahiptir , ancak burada yararlı değildir.}

Jöle , 8 7 bayt

H^Ḃ~N⁸¡

Bu, Python cevabımdaki algoritmayı kullanır ve bu @GB tarafından önemli ölçüde geliştirilmiştir .

Çevrimiçi deneyin!

Nasıl çalışır

H^Ḃ~N⁸¡  Main link. Argument: n

H        Halve; yield n/2. This returns a float, but ^ will cast it to int.
  Ḃ      Bit; yield n%2.
 ^       Apply bitwise XOR to both results.
   ~     Take the bitwise NOT.
    N⁸¡  Negate the result n times.

Java 8, 19 bayt

n->~(n/2)+n%2*(n|2)

Java 7, 47 37 bayt

int c(int n){return~(n/2)+n%2*(n|2);}

İlk kez Java (8) aslında rekabet eder ve diğer bazı cevaplardan daha kısadır. Yine de Jelly ve diğerleri gibi gerçek golf dillerini yenemezsiniz (duhuh .. ne sürpriz .. ...>; P)

@Xnor ın Python 2 yanıtından 0 dizinlenmiş
Bağlantı Noktası . @GB sayesinde -10 bayt

Burada dene.

Jöle , 15 12 11 bayt

Ḷ^1‘ż@N€Fị@

Çevrimiçi deneyin!

Nasıl çalışır

Ḷ^1‘ż@N€Fị@  Main link. Argument: n

Ḷ            Unlength; yield [0, 1, 2, 3, ..., n-1].
 ^1          Bitwise XOR 1; yield [1, 0, 3, 2, ..., n-1^1].
   ‘         Increment; yield [2, 1, 4, 3, ..., (n-1^1)+1].
      N€     Negate each; yield [-1, -2, -3, -4, ..., -n].
    ż@       Zip with swapped arguments; 
             yield [[-1, 2], [-2, 1], [-3, 4], [-4, 3], ..., [-n, (n-1^1)+1]].
        F    Flatten, yield [-1, 2, -2, 1, -3, 4, -4, 3, ..., -n, (n-1^1)+1].
         ị@  At-index with swapped arguments; select the item at index n.

RProgN 2 , 31 25 22 bayt

nx=x2÷1x4%{+$-1x^*}#-?

Açıklaması

nx=                         # Convert the input to a number, set x to it.
   x2÷                      # Floor divide x by 2.
      1                     # Place a 1 on the stack.
       x4%{       }#-?      # If x%4 is 0, subtract 1 from x//2, otherwise...
           +                # Add the 1 and the x together.
            $-1             # Push -1
               x^           # To the power of x.
                 *          # Multiply x//2+1 by -1^x. (Invert if odd, do nothing if even)

Çevrimiçi deneyin!

Ruby, 26 23 18 bayt

->n{~n/2+n%2*n|=2}

0 tabanlı

-3 byte, Greg Martin , Dennis ve belki başka birinden -1 ^ n fikrini çaldı, sonra x5'den n | 2 fikrini çaldı -5 bayt .

Yığılmış , 30 28 bayt

:2%([:2/\4%2=tmo+][1+2/_])\#

Çevrimiçi deneyin! Meta konsensüs başına izin verilen bir işlevi döndürür . . Yığının tepesinden girdi alır.

RProgN 2 cevabı ile aynı yaklaşımı kullanarak .

Alternatif olarak, 46 bayt. Çevrimiçi deneyin! :

{!()1[::1+,:rev,\srev\,\2+]n*@.n 1-#n 2%tmo*_}

Bu seriyi oluşturur ve ardından üyeyi uygun şekilde seçer ve reddeder.

Python 2 ,  44  33 27 bayt

lambda n:(-1)**n*~(n/2^n%2)

6 byte kapalı golf için @GB!

Çevrimiçi deneyin!

05AB1E, 8 bayt

2‰`^±¹F(

Çevrimiçi deneyin

açıklama

2‰          divmod by 2
  `         flatten list
   ^        XOR
    ±       NOT
     ¹F(    Push 1st argument, loop N times, negate

Jöle , 9 8 bayt

|2×Ḃ+H~$

Çevrimiçi deneyin!

-1 Dennis'e teşekkürler . Duh dönüşümleri yüzer.

@ Xnor'ın Python 2 yaklaşımını kullanır.

EDIT : > _>

CJam , 16 bayt

{_(_1&)^2/)W@#*}

1 tabanlı giriş.

Çevrimiçi deneyin!

açıklama

Burada, her girdi için -'den yığındaki değerlere sahip kodun bir dökümü 1bulunmaktadır 4. İlk birkaç komut sadece en az iki önemli bitini etkiler, n-1bundan sonra 4, bu şey yarıya bağlı olarak sadece 2 ile artan sonuçlarla döngüsel olarak tekrar eder.

Cmd             Stack: [1]       [2]       [3]       [4]
_    Duplicate.        [1 1]     [2 2]     [3 3]     [4 4]
(    Decrement.        [1 0]     [2 1]     [3 2]     [4 3]
_    Duplicate.        [1 0 0]   [2 1 1]   [3 2 2]   [4 3 3]
1&   AND 1.            [1 0 0]   [2 1 1]   [3 2 0]   [4 3 1]
)    Increment.        [1 0 1]   [2 1 2]   [3 2 1]   [4 3 2]
^    XOR.              [1 1]     [2 3]     [3 3]     [4 1]
2/   Halve.            [1 0]     [2 1]     [3 1]     [4 0]
)    Increment.        [1 1]     [2 2]     [3 2]     [4 1]
W    Push -1.          [1 1 -1]  [2 2 -1]  [3 2 -1]  [4 1 -1]
@    Rotate.           [1 -1 1]  [2 -1 2]  [2 -1 3]  [1 -1 4]
#    -1^n.             [1 -1]    [2 1]     [2 -1]    [1 1]
*    Multiply.         [-1]      [2]       [-2]      [1]

Perl 6 ,  55 27 24  22 bayt

{(-1,2,-2,1,{|($^a,$^b,$^c,$^d Z+ -2,2,-2,2)}...*)[$_]}

(Haskell zipWithcevabından ilham aldı )
Deneyin

{+^($_ div 2)+$_%2*($_+|2)}

(Birkaç cevaptan ilham aldı)
Deneyin

{+^($_+>1)+$_%2*($_+|2)}

Dene

{+^$_+>1+$_%2*($_+|2)}

Dene

Expanded:

{  # bare block lambda with implicit parameter ｢$_｣

    +^          # numeric binary invert the following
      $_ +> 1   # numeric bit shift right by one
  +
      $_ % 2    # the input modulo 2
    *
      ($_ +| 2) # numeric binary inclusive or 2
}

(Hepsi 0 tabanlıdır)

Haskell , 37 36 bayt

(([1,3..]>>= \x->[-x,x+1,-x-1,x])!!)

Çevrimiçi deneyin! Bu, bir sayıyı nargüman olarak alan ve ndizinin th elemanını 0 indeksli döndüren isimsiz bir fonksiyondur .

Haskell, 56 bayt

f n=concat(iterate(zipWith(+)[-2,2,-2,2])[-1,2,-2,1])!!n

0 endeksli

Perl 5 47 + 1 (bayrak için) = 48 Bayt

print(((sin$_%4>.5)+1+2*int$_/4)*($_%4&1?1:-1))

Eski Gönderim 82 Bayt

@f=(sub{-$_[0]},sub{$_[0]+1},sub{-$_[0]-1},sub{$_[0]});print$f[$_%4](1+2*int$_/4)

Öyle koş:

perl -n <name of file storing script>  <<<  n

JavaScript (ES7), 28 bayt

n=>(n+2>>2)*2*(-1)**n-!(n&2)

1 endeksli. Henüz başka bir cevaba bakmadım, bu yüzden bunun en iyi algoritma olup olmadığını bilmiyorum, ama sanmıyorum.

JavaScript, 28 22 bayt

6 byte kapalı golf için teşekkürler @ETHproductions

x=>x%2?~x>>1:x%4+x/2-1

Çevrimiçi deneyin!

dc , 98 bayt

?sa0sb1sq[lq1+dsqla!<i3Q]sf[lb1-lfx]su[lblfx]sx[lb1+dsblfx]sj[lqdd4%d0=u1=j2%1=xljxlfx]dsix_1la^*p

Tanrım, buradaki en uzun cevap bu, çünkü aşağıdaki özyinelemeli formüle dayanarak sekansın her bir elemanının mutlak değerini birer birer üretme yoluna girdim:

sonra (-1)^n * a_ndoğrudan, n'elementini hesaplamak yerine çıktı . Her neyse, bu 1-belirlenmiş.

Çevrimiçi deneyin!

R, 38 bayt

function(n)floor(n/2+1-2*!n%%4)*(-1)^n

açıklama

floor(n/2+1)                ->  1 2  2 3  3 4  4 5...
floor(n/2+1-2*!n%%4)        ->  1 2  2 1  3 4  4 3... (subtract 2 where n%%4 == 0)
floor(n/2+1-2*!n%%4)*(-1)^n -> -1 2 -2 1 -3 4 -4 3... (multiply odd n by -1)

TI-Basic (TI-84 Plus CE), 31 bayt

.5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4)))i^(2Ans

TI-Basic belirtilmiş bir dildir ve burada kullanılan her belirteç remainder(iki olan dışında bir bayttır .

Bu 1 indeksli sürümünü kullanır.

Açıklama:

Her dört sayıyı tekrarlayan bir desen var. 1 indeksli versiyonda: - (x + 1) / 2, (x + 1) / 2, - (x + 1) / 2, (x-1) / 2, x giriş değeri için. Bu, parçalı olarak tanımlanmış bir işlev olarak gösterilebilir.

f (x) = - (x + 1) / 2, eğer x ≡ 1 mod 4; (x + 1) / 2, eğer x 2 mod 4; - (x + 1) / 2, x ≡ 3 mod 4 ise; (x-1) / 2 eğer x ≡ 0 mod 4

"X ≡ 1 mod 4" ve "x ≡ 3 mod 4" bölümleri aynı olduğundan, onları "x ≡ 1 mod 2" olarak birleştirebiliriz.

Şimdi parça parça fonksiyonu:

f (x) = - (x + 1) / 2, eğer x ≡ 1 mod 2; (x + 2) / 2, eğer x 2 mod 4; (x-2) / 2 eğer x ≡ 0 mod 4

Burası onu gerçek komutlara bölmeye başladım. Değer, endeksler için pozitif, tekler için negatif olduğundan, (-1) ^ x değerini kullanabiliriz. Ancak, TI-Basic'te i^(2X(5 bayt) (-1)^Ans(6 bayttan) kısadır . İşlem sırası nedeniyle parantez gerektiğine dikkat edin.

Artık tek girişleri engelleme yöntemini kullanmayacağımıza göre, modlara geçiyoruz (olumsuzlamayı daha sonra ekleyerek). Varsayılan olarak bir garip girdi durumu yaptım, bu yüzden başlıyoruz .5(Ans+1).

Hatta çift girişli durumu düzeltmek için, parantez içindeki sayıya bir tane ekleyin, ancak yalnızca x mod 0 mod 2 olduğunda. Bu, .5(Ans+1+remainder(Ans+1,2))veya olarak gösterilebilir .5(Ans+1+not(remainder(Ans,2))), ancak aynı byte sayısına sahiptir, bu yüzden hangisi olduğu önemli değildir.

Birden fazla 4 girişli durumu düzeltmek için, parantez içindeki sayıdan 3 sayıyı çıkarmamız gerekir, ancak 4 tane daha katları eşit olduğundan, bir önceki adımdan bir tane daha ekleyeceğiz .5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4))).

Şimdi, tam programı elde etmek için işaret belirleme kısmının sonuna gelin.

Befunge 93, 25 bayt

Sıfır endeksli

&4/2*1+&4%3%!!+&2%2*1-*.@

Çevrimiçi Deneyin!

Sayı tarafından verilir ((2(n / 4) + 1) + !!((n % 4) % 3)) * (2(n % 2) - 1)

QBIC , 53 bayt

b=1:{[b,b+3|~b=a|_x(-(b%2)*2+1)*(q+(b%4>1)*-1)]]q=q+2

Açıklama:

b=1     Set b to a starting value of 1
        QBIC would usually use the pre-initialised variable q, but that is already in use
:       Get an input number from the cmd-line, our term to find
{       Start an infinite loop
[b,b+3| FOR-loop: this runs in groups of 4, incrementing its own bounds between runs
~b=a|   If we've reached the term requested
_x      QUIT the program and print:

(-(b%2)*2+1)   The b%2 gives a 1 or a 0, times 2 (2,0), negged (-2,0) and plus one (-1,1)
*              That gives us the sign of our term. Now the value:
(q+(b%4>1)*-1) This is q + 1 if the inner loop counter MOD 4 (1,2,3,0...) is 2 or 3.
]       Close the IF that checks the term
]       Close the FOR-loop
q=q+2   And raise q by 2 for the next iteration of the DO-loop.

Bilge , 19 bayt

::>!:><^^~![!-!-~]|

Çevrimiçi Deneyin!

Bu sadece @Dennis'in bir limanıdır 'Jelly'in Wise'a cevabı .

Q, 52 bayt

{(1 rotate(,/){x,(-)x}each 1_((_)x%4)+til 3)x mod 4}

0 dizinli çözüm.

1. Blok numarasını yani. dizi içindeki [-x x + 1 - (x + 1) x] bloğu indeksi içerir.
2. Tüm sıra içindeki değerin dizinini temel alarak blok içindeki değerin dizinini alır.
3. Bloğu oluşturur.
4. 2. adımda elde edilen indeks üzerinden endeksler.