Waszym wyzwaniem jest dziś wyprowadzenie danego terminu z wyliczenia wszystkich liczb całkowitych. Sekwencja jest następująca: Jeśli mamy funkcję indeksowaną przez zero, która generuje sekwencję f(n)i ceil(x)jest funkcją pułapu, to f(0) = 0; abs(f(n)) = ceil(n/2); sign(f(n))jest dodatni, gdy ni ceil(n/2)są nieparzyste lub oba nieparzyste.

Aby zrozumieć tę sekwencję, pierwsze kilka terminów jest następujących: 0 1 -1 -2 2 3 -3 -4 4 5 -5 -6 6 7 -7...

Twoim zadaniem jest napisanie programu, który pobierze liczbę całkowitą ni wyświetli nth termin ciągu. Dane wejściowe mogą mieć tylko indeks 0 lub 1.

Przypadki testowe (indeksowane 0):

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

To jest golf golfowy , wygrywa najmniej bajtów!

SOGL V0.12 , 8 6 bajtów

I».»⌡±

Wypróbuj tutaj! lub wypróbuj pierwsze kilka liczb (nieco zmienione, aby działało)
0-indeksowane.

Wyjaśnienie:

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

Lub prościej:

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

Python 2 , 26 24 bajtów

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

Wypróbuj online!

JavaScript (ES6), 18 bajtów

1-indeksowany.

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

Próbny

let f =

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

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

C, 25 bajtów

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

Haskell , 26 bajtów

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

Wypróbuj online!

Inne odpowiedzi Haskella wydają się nadmiernie komplikować… ^^

Pyke , 6 bajtów

heQeV_

Wypróbuj tutaj!

Wykorzystuje podejście dzaima ... Beats Ties Jelly!

Wyjaśnienie

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.

Hex kodowane bajtów równoważne to: 68 65 51 65 56 5F.

Galaretka , 6 bajtów

HµĊN⁸¡

Wypróbuj online!

Wykorzystuje algorytm dzaima.

-1 dzięki Jonathan Allan .

Python 2 , 21 bajtów

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

Wypróbuj online!

Mathematica, 24 bajty

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

-14 bajtów od @Misha Lavrov

Haskell , 25 43 42 bajtów

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

Wypróbuj online! 1-indeksowany.

Edycja: poprzednia wersja miała znaki w niewłaściwej kolejności, dzięki @ Potato44 za wskazanie. Naprawiono dla 18 bajtów ...

Edycja 2: Dzięki BMO za -1 bajt!

Python 3 , 29 bajtów

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

Wypróbuj online!

Pyth , 9 bajtów

_F/hQ2/Q2

Wypróbuj tutaj!

Wykorzystuje podejście dzaima .

Haskell, 36 bajtów

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

Wypróbuj online!

05AB1E , 6 bajtów

;DîsF(

Wypróbuj online!

Wykorzystuje algorytm dzaima.

Partia, 29 bajtów

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

JavaScript (ES6), 18 bajtów

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-indeksowane.

JavaScript, 17 bajtów

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

Ten jest zindeksowany. To całkowicie bitowe oszustwo.

Sześciennie , 23 bajty

(1-indeksowany)

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

Wypróbuj online!

Główną trudnością podczas pisania kodu w Cubically są:

• Jest tylko 1 zmienna możliwa do zapisu, oraz
• Zdobycie stałych jest trudne.

To rozwiązanie oblicza

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

gdzie /oznacza dzielenie całkowite. Potrzebuje tylko 1 zmiennej tymczasowej oraz stałych 1 i 2.

Wyjaśnienie:

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 bajtów

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

Pełny program, który nazywa się jak 5:prgmNAME.

TI-Basic jest tokenizowanym językiem , wszystkie użyte tutaj tokeny mają jeden bajt, z wyjątkiem remainder(dwóch. ‾reprezentuje token regatywny, który jest wpisywany za pomocą (-)klawisza.

Przykłady:

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

Wyjaśnienie:

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

Ta sama formuła co funkcja Y-var:

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

dc , 16 bajtów

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

Jestem pewien, że istnieje sposób na skrócenie 0..1 do -1..1 w DC, ale na razie nie ma pomysłów.

Wypróbuj online!

Java 8, 15 bajtów

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

EDYCJA: Czy Java jest naprawdę najkrótszym językiem nie golfowym ?! o.Ô

Wyjaśnienie:

Wypróbuj tutaj.

Wykorzystam poniższą tabelę jako odniesienie do tego, co się dzieje.

1. ~njest równy -n-1.
2. Ponieważ dzielenie liczb całkowitych w Javie automatycznie tworzy podłogi na dodatnich liczbach całkowitych i pułapach na ujemnych liczbach całkowitych, ~n/2spowoduje to sekwencję0,-1,-1,-2,-2,-3,-3,-4,-4,-5,-5,...
3. n&2spowoduje albo, 0albo 2, w sekwencji0,0,2,2,0,0,2,2,0,0,2,...
4. ~-xjest równe (x-1), więc ~-(n&2)( ((n&2)-1)) powoduje sekwencję-1,-1,1,1,-1,-1,1,1,-1,-1,1,...
5. Pomnożenie dwóch sekwencji ~n/2i ~-(n&2)daje prawidłową sekwencję zadaną w wyzwaniu:0,1,-1,-2,2,3,-3,-4,4,5,-5,...

Tabela przeglądowa:

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 bajtów

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

Wypróbuj online!

Wyjaśnienie

Ten kod składa się z dwóch części. Pierwsza część

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

robi saldo obliczeń. To określaceil(n/2) i czy negować wyjście.

Aby wyjaśnić, jak to działa, najpierw wyjaśnię, jak można to obliczyć ceil(n/2). Można to zrobić za pomocą następującego kodu

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

Odlicza się od n za każdym razem, gdy wykonuje not ( ([{}]())) na liczniku i dodaje licznik do wyniku. Ponieważ licznik wynosi zero, czas zwiększa się tylko co drugi bieg, zaczynając od pierwszego.

Teraz chcę również obliczyć znak naszych wyników. Aby to zrobić, uruchamiamy kolejny licznik. Ten licznik zmienia stan tylko wtedy, gdy pierwszy licznik jest wyłączony. W ten sposób otrzymujemy pożądany wzór. Kładziemy te dwa żetony na stosie, aby ułatwić ich przenoszenie, gdy nadejdzie czas.

Teraz, kiedy zakończymy obliczenia, nasz stos będzie wyglądał następująco

          parity(n)
ceil(n/2) sign

Musimy więc popracować, aby uzyskać zamierzony efekt w drugiej części.

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

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

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

Wypróbuj online!

Proton , 23 bajty

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

Wypróbuj online!

Rozwiązanie Port of Halvard .

Proton , 23 bajty

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

Wypróbuj online!

Rozwiązanie Port of Leaky .

Nieco więcej Protonic, 24 bajtów:

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

QBIC , 27 26 bajtów

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

Wyjaśnienie

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 bajty

Pełen werwy, nawet podczas gry w golfa. Idę na głosowanie na współczucie tutaj ... :-)

Gra w golfa:

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

Nie golfowany:

(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 bajtów

Anonimowa funkcja bezpośredniego okna VBE, która przenosi dane wejściowe z komórki A1i dane wyjściowe do bezpośredniego okna VBE

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

Ograniczony do wersji 32-bitowej, ponieważ A^Bnie jest prawidłowy w wersji 64-bitowej ( A ^Bjest tak blisko, jak to możliwe)

Julia 0.6 , 16 bajtów

To tylko rozwiązanie Java, ale potrzebuję ÷podziału na liczby całkowite.

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

Wypróbuj online!