ความท้าทายของคุณในวันนี้คือการส่งออกคำที่กำหนดของลำดับที่ระบุจำนวนเต็มทั้งหมด ลำดับมีดังนี้: ถ้าเรามีฟังก์ชั่น 0 ดัชนีสร้างลำดับf(n)และceil(x)เป็นฟังก์ชั่นเพดานแล้วf(0) = 0; abs(f(n)) = ceil(n/2); sign(f(n))เป็นบวกเมื่อnและceil(n/2)เป็นทั้งคู่หรือทั้งคู่

เพื่อช่วยให้เข้าใจลำดับนี้คำศัพท์สองสามคำแรกมีดังนี้: 0 1 -1 -2 2 3 -3 -4 4 5 -5 -6 6 7 -7...

งานของคุณคือการเขียนโปรแกรมที่ใช้จำนวนเต็มnและส่งออกnคำที่ตามลำดับ อินพุตอาจเป็น 0 หรือ 1-indexed เท่านั้น

กรณีทดสอบ (ดัชนี 0):

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

นี่คือcode-golfไบต์ที่น้อยที่สุดชนะ!

SOGL V0.12 , 8 6 ไบต์

I».»⌡±

ลองที่นี่! หรือลองตัวเลขคู่แรก (เปลี่ยนไปเล็กน้อยเพื่อให้ทำงานได้)
ทำดัชนี 0

คำอธิบาย:

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

หรือง่ายกว่า:

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

Python 2 , 26 24 ไบต์

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

ลองออนไลน์!

JavaScript (ES6), 18 ไบต์

1 การจัดทำดัชนี

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

การสาธิต

let f =

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

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

C, 25 ไบต์

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

Haskell , 26 ไบต์

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

ลองออนไลน์!

คำตอบอื่น ๆ ของ Haskell ดูเหมือนจะเป็นเรื่องที่ซับซ้อนเกินไป… ^^

Pykeขนาด 6 ไบต์

heQeV_

ลองที่นี่!

ใช้วิธีของ dzaima ... Beats Ties Jelly!

คำอธิบาย

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 68 65 51 65 56 5Fเข้ารหัสเทียบเท่าจะเป็น:

เยลลี่ 6 ไบต์

HµĊN⁸¡

ลองออนไลน์!

ใช้อัลกอริทึมของ dzaima

-1 ขอบคุณที่โจนาธานอัลลัน

Python 2 , 21 ไบต์

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

ลองออนไลน์!

Mathematica ขนาด 24 ไบต์

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

-14 ไบต์จาก @Misha Lavrov

Haskell , 25 43 42 ไบต์

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

ลองออนไลน์! 1 การจัดทำดัชนี

แก้ไข:รุ่นก่อนหน้ามีสัญญาณผิดลำดับขอบคุณ @ Potato44 ที่ชี้ให้เห็น แก้ไขเป็น 18 ไบต์ ...

แก้ไข 2:ขอบคุณ BMO สำหรับ -1 ไบต์!

Python 3 , 29 ไบต์

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

ลองออนไลน์!

Pyth , 9 ไบต์

_F/hQ2/Q2

ลองที่นี่!

ใช้วิธีการ dzaima ของ

Haskell, 36 ไบต์

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

ลองออนไลน์!

05AB1E , 6 ไบต์

;DîsF(

ลองออนไลน์!

ใช้อัลกอริทึมของ dzaima

แบตช์ 29 ไบต์

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

JavaScript (ES6), 18 ไบต์

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 การจัดทำดัชนี

Javascript, 17 ไบต์

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

อันนี้เป็นดัชนี 0 มันเป็นการใช้เล่ห์เหลี่ยมระดับบิตอย่างสิ้นเชิง

ตามอำเภอใจ 23 ไบต์

(1 จัดทำดัชนี)

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

ลองออนไลน์!

ปัญหาหลักเมื่อเขียนโค้ดในแบบ Cubically คือ:

• มีตัวแปรเขียนได้เพียง 1 ตัวเท่านั้นและ
• รับค่าคงที่นั้นยาก

ดังนั้นวิธีนี้คำนวณ

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

โดยที่/หมายถึงการหารจำนวนเต็ม ต้องการเพียง 1 ตัวแปรชั่วคราวและค่าคงที่ 1 และ 2

คำอธิบาย:

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 ไบต์

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

5:prgmNAMEโปรแกรมเต็มรูปแบบที่เรียกว่าเหมือน

TI-Basic เป็นlanugageโทเค็นโทเค็นทั้งหมดที่ใช้ที่นี่เป็นหนึ่งไบต์ยกเว้นremainder(ว่าเป็นสอง ‾แสดงถึงโทเค็นการปกครองซึ่งพิมพ์ด้วย(-)คีย์

ตัวอย่าง:

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

คำอธิบาย:

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

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

dc , 16 ไบต์

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

ฉันแน่ใจว่ามีวิธีที่จะทำให้ 0..1 ถึง -1..1 ใน dc ที่สั้นลง แต่ตอนนี้ยังไม่มีแนวคิด

ลองออนไลน์!

Java 8, 15 ไบต์

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

แก้ไข: Java เป็นภาษาที่สั้นที่สุดไม่ใช่ภาษากอล์ฟหรือไม่! o.o

คำอธิบาย:

ลองที่นี่

ฉันจะใช้ตารางด้านล่างเป็นข้อมูลอ้างอิงในสิ่งที่เกิดขึ้น

1. ~n-n-1จะมีค่าเท่ากับ
2. เนื่องจากการแบ่งจำนวนเต็มใน Java จะทำการออร์เดอร์จำนวนเต็มบวกและ ceils กับจำนวนเต็มลบ~n/2จะส่งผลให้ลำดับ0,-1,-1,-2,-2,-3,-3,-4,-4,-5,-5,...
3. n&2จะส่งผลใน0หรือ2ในลำดับ0,0,2,2,0,0,2,2,0,0,2,...
4. ~-xเท่ากับ(x-1)ดังนั้น~-(n&2)( ((n&2)-1)) ผลลัพธ์ในลำดับ-1,-1,1,1,-1,-1,1,1,-1,-1,1,...
5. การคูณสองลำดับ~n/2และการ~-(n&2)ให้เป็นลำดับที่ถูกต้องที่ถามในการท้าทาย0,1,-1,-2,2,3,-3,-4,4,5,-5,...

ตารางภาพรวม:

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 ไบต์

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

ลองออนไลน์!

คำอธิบาย

รหัสนี้มีสองส่วน ส่วนแรก

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

กล้ามเนื้อของการคำนวณ มันเป็นตัวกำหนดceil(n/2)และหรือไม่ที่จะคัดค้านการส่งออก

เพื่ออธิบายวิธีการทำงานฉันจะอธิบายก่อนว่าจะคำนวณceil(n/2)อย่างไร ซึ่งสามารถทำได้ด้วยรหัสต่อไปนี้

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

สิ่งนี้นับถอยหลังจากnในแต่ละครั้งที่ทำเครื่องหมายไม่ ( ([{}]())) บนตัวนับและเพิ่มตัวนับลงในผลลัพธ์ เนื่องจากตัวนับมีค่าเป็นศูนย์ครึ่งหนึ่งของเวลาเราจึงเพิ่มค่าการรันอื่น ๆ ทั้งหมดที่เริ่มต้นด้วยตัวแรก

ตอนนี้ฉันต้องการคำนวณสัญลักษณ์ของผลลัพธ์ของเราด้วย เมื่อต้องการทำสิ่งนี้เราจะเริ่มตัวนับอื่น ตัวนับนี้จะเปลี่ยนสถานะหากตัวนับแรกถูกปิด ด้วยวิธีนี้เราจะได้รูปแบบที่ต้องการ เราวางเคาน์เตอร์ทั้งสองนี้ไว้บนกองซ้อนเพื่อให้ง่ายต่อการเคลื่อนย้ายไปมาเมื่อถึงเวลา

ทีนี้เมื่อเราคำนวณเสร็จแล้วสแต็คของเราจะเป็นแบบนี้

          parity(n)
ceil(n/2) sign

ดังนั้นเราต้องทำงานบางอย่างเพื่อให้ได้ผลลัพธ์ตามที่ตั้งใจส่วนที่สองนี้ทำได้

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

Perl 5 , 32 + 1 ( -p) = 33 ไบต์

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

ลองออนไลน์!

โปรตอน , 23 ไบต์

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

ลองออนไลน์!

พอร์ตของการแก้ปัญหาของ Halvard

โปรตอน , 23 ไบต์

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

ลองออนไลน์!

พอร์ตของการแก้ปัญหารั่วของ

Protonic อีกเล็กน้อย 24 ไบต์:

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

QBIC , 27 26 ไบต์

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

คำอธิบาย

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 ไบต์

Verbose แม้เมื่อเล่นกอล์ฟ ฉันจะลงคะแนนให้กับความเห็นอกเห็นใจที่นี่ ... :-)

แข็งแรงเล่นกอล์ฟ:

(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- บิต₃₉ 37 ไบต์

ฟังก์ชันหน้าต่าง VBE แบบไม่ระบุชื่อทันทีที่รับอินพุตจากเซลล์A1และเอาต์พุตไปยังหน้าต่างทันที VBE

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

จำกัด ไว้ที่ 32- บิตตามที่A^Bไม่ถูกต้องใน 64- บิต ( A ^Bใกล้ที่สุดเท่าที่จะทำได้)

Julia 0.6 , 16 ไบต์

มันเป็นแค่โซลูชัน java ยกเว้นฉันต้องการ÷หารจำนวนเต็ม

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

ลองออนไลน์!