Bugünkü zorluğunuz, tüm tamsayıları numaralandıran bir dizi terim üretmektir. Dizi aşağıdaki gibidir: Diziyi oluşturan 0 dizinli bir işleve sahipsek f(n)ve ceil(x)tavan işlevi ise f(0) = 0; abs(f(n)) = ceil(n/2); sign(f(n))ne zaman nve ceil(n/2)hatta her ikisi de garip olduğu zaman pozitifdir.

Bu diziyi anlamaya yardımcı olmak için ilk birkaç terim şöyledir: 0 1 -1 -2 2 3 -3 -4 4 5 -5 -6 6 7 -7...

Göreviniz bir tamsayı alan nve ndizinin üçüncü terimini çıkaran bir program yazmaktır . Giriş yalnızca 0 veya 1 indeksli olabilir.

Test durumları (0 indeksli):

0  =>  0
1  =>  1
2  => -1
3  => -2
4  =>  2
5  =>  3

Bu kod golf , en az bayt kazanıyor!

SOGL V0.12 , 8 6 bayt

I».»⌡±

Burada dene! ya da ilk çift sayılarını deneyin (biraz çalışması için değiştirildi)
.

Açıklama:

I       increment the input
 »      floor divide by 2
  .     push the original input
   »    floor divide by 2
    ⌡   that many times
     ±    negate

Veya daha basit:

(input + 1) // 2 negated input // 2 times
        I     »     ±      .     »    ⌡

Python 2 , 26 24 bayt

lambda x:-~x/2/(1-(x&2))

Çevrimiçi deneyin!

JavaScript (ES6), 18 bayt

1 endeksli.

n=>n/(++n&2||-2)|0

gösteri

let f =

n=>n/(++n&2||-2)|0

for(n = 1; n < 20; n++) {
  console.log(n + ' --> ' + f(n))
}

C, 25 bayt

f(n){return~n/2*~-(n&2);}

Haskell , 26 bayt

f x=div(x+1)2*(-1)^div x 2

Çevrimiçi deneyin!

Diğer Haskell cevapları işleri karmaşıklaştırıyor gibi görünüyor… ^^

Pyke , 6 bayt

heQeV_

Burada dene!

Dzaima'nın yaklaşımını kullanır ... Beats Ties Jelly!

açıklama

h      - Increment the input, which is implicit at the beginning.
 e     - Floor halve.
  Q    - Push the input.
   e   - Floor halve.
    V_ - Apply repeatedly (V), ^ times, using negation (_).
       - Output implicitly.

Eşdeğer heks-kodlanmış bayt olur: 68 65 51 65 56 5F.

Jöle , 6 bayt

HµĊN⁸¡

Çevrimiçi deneyin!

Dzaima'nın algoritmasını kullanır.

-1 Jonathan Allan'a teşekkürler .

Python 2 , 21 bayt

lambda x:-x/2*~-(x&2)

Çevrimiçi deneyin!

Mathematica, 24 bayt

(s=⌈#/2⌉)(-1)^(#+s)&  

-14 bytes @Misha Lavrov

Haskell , 25 43 42 bayt

((do a<-[0..];[[-a,a],[a,-a]]!!mod a 2)!!)

Çevrimiçi deneyin!1 endeksli.

Düzenle: Önceki sürümde işaretler yanlış sıralanmıştı, işaret için @ Potato44. 18 byte için düzeltildi ...

Düzenleme 2: -1 bayt için BMO'ya teşekkürler!

Python 3 , 29 bayt

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

Çevrimiçi deneyin!

Pyth , 9 bayt

_F/hQ2/Q2

Burada dene!

Dzaima'nın yaklaşımını kullanır .

Haskell, 36 bayt

g x=x: -x:g(-x-signum x)
((0:g 1)!!)

Çevrimiçi deneyin!

05AB1E , 6 bayt

;DîsF(

Çevrimiçi deneyin!

Dzaima'nın algoritmasını kullanır.

Toplu iş, 29 bayt

@cmd/cset/a"%1/2^(%1<<30>>30)

JavaScript (ES6), 18 bayt

f=
n=>n/2^(n<<30>>30)

<input type=number min=0 value=0 oninput=o.textContent=f(this.value)><pre id=o>0

0 endeksli.

Javascript, 17 bayt

n=>~n/2*~-(n&2)^0

f=
n=>~n/2*~-(n&2)^0

<input type=number min=0 value=0 oninput=o.textContent=f(this.value)><pre id=o>0

Bu, 0 endeksli. Tamamen bitsel kandırmacadır.

Kübik olarak , 23 bayt

(1 endeksli)

FDF'$:7+8/0_0*0-8*7/0%6

Çevrimiçi deneyin!

Cubically kod yazarken ana zorluk şunlardır:

• Yalnızca 1 yazma özel değişkeni var ve
• Sabit almak zor.

Yani, bu çözüm hesapla

((((n+1)/2)%2)*2-1)*n/2

burada /bölme tam sayı O anlamına gelir. Bu sadece 1 geçici değişkene ve 1 ve 2 sabitlerine ihtiyaç duyar.

Açıklama:

FDF'$:7+8/0_0*0-8*7/0%6
FDF'                      Set face value of face 0 to 2, and value of memory index 8 (cube is unsolved) to 1 (true = unsolved)
    $                     Read input
     :7                                 input
       +8                                + 1
         /0                        (        ) /2
           _0                     (             ) %2
             *0                  (                  ) *2
               -8                                        -1
                 *7             (                          ) *n
                   /0                                          /2
                     %6   Print

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

‾int(‾Ans/2)(1-2remainder(int(Ans/2),2

Gibi denilen tam bir program 5:prgmNAME.

TI-Basic, tokenize bir dildir , burada kullanılan tüm jetonlar remainder(, iki tanesi hariç, bir bayttır . tuşu ‾ile yazılan regülatörü belirtir (-).

Örnekler:

0:prgmNAME
 => 0
1:prgmNAME
 => 1
2:prgmNAME
 => -1
#etc

Açıklama:

‾int(‾Ans/2)(1-2remainder(int(Ans/2),2
‾int(‾Ans/2)                           # -int(-X) is ciel(X), so ciel(Ans/2)
                          int(Ans/2)   # int(X) is floor(X), so floor(Ans/2)
                remainder(int(Ans/2),2 # 1 if floor(Ans/2) is odd else 0
            (1-2remainder(int(Ans/2),2 # -1 if floor(Ans/2) is odd, else 1
_int(_Ans/2)(1-2remainder(int(Ans/2),2 # -ciel(Ans/2) if floor(Ans/2) is odd, else ciel(Ans/2)

Y-var işlevi ile aynı formül:

Y1= ‾int(‾X/2)(1-2remainder(int(X/2),2

dc , 16 bayt

1+d2~+2%2*1-r2/*

DC'de 0,1 ile -1,1 arasında bir değer elde etmenin bir yolu olduğuna eminim, ancak şimdilik fikir yok.

Çevrimiçi deneyin!

Java 8, 15 bayt

n->~n/2*~-(n&2)

EDIT: Java gerçekten golf oynamayan dillerden en kısa mı ?! o.o

Açıklama:

Burada dene.

Neler olduğunu referans olarak aşağıdaki tabloyu kullanacağım.

1. ~neşittir -n-1.
2. Java’da tamsayı bölme otomatik olarak pozitif tamsayılara ve negatif tamsayılara tavanlara dayandığından ~n/2, sekansla sonuçlanacaktır.0,-1,-1,-2,-2,-3,-3,-4,-4,-5,-5,...
3. n&2sırayla ya 0da 2, ya sonuçlanacak0,0,2,2,0,0,2,2,0,0,2,...
4. ~-xeşittir (x-1), yani ~-(n&2)( ((n&2)-1)) diziyle sonuçlanır-1,-1,1,1,-1,-1,1,1,-1,-1,1,...
5. İki dizinin ~n/2ve verinin çoğaltılması, ~-(n&2)zorlukta sorulan doğru dizilimdir:0,1,-1,-2,2,3,-3,-4,4,5,-5,...

Genel bakış tablosu:

n       ~n      ~n/2    n&2     ~-(n&2)     ~n/2*~-(n&2)
0       -1      0       0       -1          0
1       -2      -1      0       -1          1
2       -3      -1      2       1           -1
3       -4      -2      2       1           -2
4       -5      -2      0       -1          2
5       -6      -3      0       -1          3
6       -7      -3      2       1           -3
7       -8      -4      2       1           -4
8       -9      -4      0       -1          4
9       -10     -5      0       -1          5
10      -11     -5      2       1           -5

Brain-Flak , 86 74 72 70 bayt

{({}[()]<({}<>([({})]{(<{}([{}]())>)}{}())<>)>)}{}<>{}{<>([{}])(<>)}<>

Çevrimiçi deneyin!

açıklama

Bu kodun iki bölümü var. İlk bölüm

({}[()]<({}<>([({})]{(<{}([{}]())>)}{}())<>)>)}{}

hesaplama Brawn yapar. ceil(n/2)Çıktıyı olumsuzlayıp olumsuzlaştırmayacağını belirler .

Nasıl çalıştığını açıklamak için önce nasıl hesaplanacağını açıklayacağım ceil(n/2). Bu, aşağıdaki kodla yapılabilir

{({}[()]<({}([{}]()))>)}{}

Bu, her gerçekleştirdiğinde n'den geriye doğru sayar (([{}]()) , bir sayaçta ) ve sayacı bir sonuca ekler. Sayaç, zamanın yarısı sıfır olduğu için, ilk çalıştırmadan başlayarak diğer tüm koşuları artırıyoruz.

Şimdi sonuçlarımızın işaretini de hesaplamak istiyorum. Bunu yapmak için başka bir sayaç başlatırız. Bu sayaç yalnızca ilk sayaç kapalı olduğunda durumu değiştirir. Bu şekilde istenen modeli elde ederiz. Bu iki sayacı, zamanı geldiğinde hareket ettirmeyi kolaylaştırmak için kapalı yığına koyarız.

Şimdi bir kez bu hesaplamayı tamamladığımızda yığımız böyle gözüküyor

          parity(n)
ceil(n/2) sign

Bu nedenle, amaçlanan sonucu elde etmek için biraz çalışmamız gerekiyor, bu ikinci bölüm bunu yapıyor.

<>{}{<>([{}])(<>)}<>

Perl 5 , 32 + 1 ( -p) = 33 bayt

$_='-'x(($_+++($b=0|$_/2))%2).$b

Çevrimiçi deneyin!

Proton , 23 bayt

n=>-~n//2//(-1)**(n//2)

Çevrimiçi deneyin!

Halvard'ın çözümünün limanı .

Proton , 23 bayt

n=>-~n//2*(-1)**(n%4>1)

Çevrimiçi deneyin!

Leaky'nin çözümünün limanı .

Biraz daha Protonik, 24 bayt:

n=>-~n//2*(**)(-1,n%4>1)

QBIC , 27 26 bayt

g=(:+1)'\2`~(a-g)%2|?-g\?g

açıklama

g=          set worker var 'g' to
(:+1)           our index (plus one for the ceil() bit)
'\2`            integer divided by 2 (the int div needs a code literal: '..`
~(a-g)%2    IF index - temp result is odd (index 2 minus result 1 = 1)
|?-g        THEN PRINT g negated
\?g         ELSE PRINT g

Clojure 122 bayt

Verbose, golf oynarken bile. Buradaki sempati oyu için gidiyorum ... :-)

golfed:

(defn d[n](let[x(int(Math/ceil(/ n 2)))y(cond(or(and(even? n)(even? x))(and(odd? n)(odd? x)))(Math/abs x):else(- 0 x))]y))

Ungolfed:

(defn dizzy-integer [n]
  (let [x   (int (Math/ceil (/ n 2)))
        y   (cond
                (or (and (even? n) (even? x))
                    (and (odd? n)  (odd? x))) (Math/abs x)
                :else (- 0 x)) ]
    y))

Excel VBA 32 Bit, ₃₉ 37 Bayt

Hücreden girdi alan A1ve VBE acil durum penceresine çıkan anonim VBE acil pencere işlevi

?[Sign((-1)^Int(A1/2))*Int((A1+1)/2)]

A^B64-Bit'te geçerli olmadığı için 32-Bit ile sınırlıdır ( A ^Belde edilebilecek en yakın)

Julia 0.6 , 16 bayt

÷Tamsayı bölme ihtiyacım dışında sadece java çözümü .

n->~n÷2*~-(n&2)

Çevrimiçi deneyin!