# 奇妙な偶数、正の負

36

Nが与えられた場合、この無限シーケンスのN番目の項を出力します。

``````-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は、必要に応じて0インデックスまたは1インデックスの場合があります。

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

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

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

バイト単位の最短コードが優先されます。

devRicher

@devRicherいいえ、絶対値はあります`1,1,2,2,3,3,4,4,...`が、ここにあり`1,2,2,1,3,4,4,3,...`ます。
マーティンエンダー

6
あなただけの最初のいくつかの用語よりも、もう少し具体的な何かをこのシーケンスのためか、少なくとも閉じた形を提供することができます
0 "

n番目の項の方程式は負の値に評価されることはありません...何か問題があります。

1
@ 0 '閉じた形式ではありませんが、直感的に見ている方法で追加しました。課題の一部は、パターンとは何か、それを数学とコードに変換する方法を理解することです。
カルビンの趣味

32

# Python 2、23バイト

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

オンラインでお試しください！

1

MildlyMilquetoast

17

# Mathematica、29バイト

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

1インデックス付きの入力を受け取る純粋な関数。交互の符号`(-1)^#`を除き、シーケンスの2倍は入力に近く、差は周期的に1、2、1、-2です。`#~GCD~4`入力の最大公約数、および`4`が周期的に1、2、1、4であることは素晴らしいことです。そのため`4->-2`、1日1回手動で交換して呼び出します。多くの文字を含むMathematicaコマンドのほとんどを回避するため、このアプローチが気に入っています。

9

# ピップ、24 22バイト

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

コマンドライン引数として1インデックス付きの入力を受け取ります。オンラインで試すか、検証1-20

### 説明

シーケンスは、他の3つのシーケンスを結合することで取得できることに注意してください。1つはインデックスがゼロで、もう1つはインデックスが1です。

• で始まる`0 0 0 0 2 2 2 2 4 4 4 4`=`a//4*2`（0インデックス）。
• `1 2 2 1 1 2 2 1 1 2 2 1`=を追加します`aBA2|1`。ここ`BA`で、ビット単位のANDは、`|`は論理OR（1インデックス）です。
• 合計に`-1 1 -1 1 -1 1 -1 1 -1 1 -1 1`= `(-1)**a`（1-indexed）を掛けます。

`a`1インデックス付きで開始する場合、最初に1インデックス付き部分を計算し（式を左から右に読み取り）、次に`a`0インデックス付き部分のデクリメントを行うことができます。組み込み変数を使用すると`v=-1`、我々が得ます

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

さらに2バイトを削るには、いくつかの優先順位操作のトリックを使用する必要があります。私たちは、交換することにより、内側の括弧を排除することができます`+``+:`（と同等`+=`の言語の多くで）。計算と割り当ての演算子は優先順位が非常に低いため、次`aBA2|1+:--a//4*2`と同等です。`(aBA2|1)+:(--a//4*2)`です。Pipは、変数ではないものへの代入に関する警告を出力しますが、警告が有効になっている場合のみです。

ヤンク演算子よりも優先順位が低いの`:``Y`、yank演算子だけです。*オペランドの値を`y`変数に割り当て、変更せずに渡します。そのため、値を括弧で囲むのではなく、ヤンクすることで外側の括弧も削除できます`YaBA2|1+:--a//4*2`

* rint `P``O`utputはankと同じ優先順位を持っていますが、`Y`ここでは役に立ちません。

9

# ゼリー、8 7バイト

``````H^Ḃ~N⁸¡
``````

これは、Pythonの回答からのアルゴリズムを使用します。これは@GBによって大幅に改善されました

オンラインでお試しください！

### 使い方

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

これは、Jellyの投稿で見た最も標準的なASCII文字だと思います。私を悩ます（数えない`¡`）2つのキャラクターしか見えません
エソランジングフルーツ

デニス

9

# Java 8、19バイト

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

# Java 7、47 37バイト

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

@XnorのPython 2
からの0インデックス付きポート。@GBの おかげで-10バイト

ここで試してみてください。

2
（n / 2）を括弧で囲むと、3項チェックは必要ありません。
GB

1
@GBああ、それが問題でした。ありがとう。今はちょっとバカな感じ..>。>
ケビン・クルーッセン

ああ、Javaの関数定義だけが許可されていますか？
ランチャー

@Cruncher質問で特に明記されていない限り、デフォルトは完全なプログラムまたは機能です。そのため、はい、Javaのメソッド、またはJava 8のラムダを投稿するだけです（上記の回答にJava 8の同等物を追加しました）。
ケビンCruijssen

1
@EricDuminil チャレンジで特に明記されていない限り、デフォルトはprogramまたはfunctionです。
ケビンCruijssen

8

# ゼリー、15 12 11バイト

``````Ḷ^1‘ż@N€Fị@
``````

オンラインでお試しください！

### 使い方

``````Ḷ^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.
``````

10時頃にゼリーの回答があることを知っていました
ランチャー

このコメントを投稿した直後に私はそれを見ましたlol。私は本当にこれらの日のうちの1つをゼリーを学ぶ必要があります...このSEの質問の歴史を見れば面白いです。以前はすべてGolfScriptでしたが、CJamが引き継ぎ、現在はJellyです。
ランチャー

6

# RProgN 2、31の25 22バイト

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

## 説明した

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

オンラインでお試しください！

R. Kap

6

# ルビー、26 23 18バイト

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

0ベース

グレッグ・マーティンデニス、そしておそらく誰かから-1 ^ nアイデアを盗む-3バイト、次にxnorからn | 2アイデアを盗む-5バイト。

5

# 積み上げ、30 28バイト

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

オンラインでお試しください！メタコンセンサスごとに許可されている関数を返します。スタックの最上部から入力を取得します。

Using the same approach as the RProgN 2 answer.

Alternatively, 46 bytes. Try it online!:

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

This one generates the range then selects and negates the member as appropriate.

5

# Python 2,  44 33 27 bytes

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

Thanks to @GB for golfing off 6 bytes!

Try it online!

4

# 05AB1E, 8 bytes

``````2‰`^±¹F(
``````

Try it online

Explanation

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

Wow, I love it, but `¹F(` seems expensive for "if odd, negate".
Magic Octopus Urn

@carusocomputing It does, but that's the shortest I know of. Dennis's similar answer in Jelly also has 3 bytes for that part. It's still shorter than duplicate, push parity, if, negate.
mbomb007

I tried for 15 minutes to beat it, only thing that came close was another 3 byte solution of to the power of `n`, to the power of `1/n`.
Magic Octopus Urn

3

## CJam, 16 bytes

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

1-based input.

Try it online!

### Explanation

Here is a breakdown of the code with the values on the stack for each input from `1` to `4`. The first few commands only affect the two least significant bits of `n-1` so after `4`, this stuff just repeats cyclically, with the results incremented by 2, due to the halving.

``````Cmd             Stack:                      
_    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

# Perl 6,  55 27 24  22 bytes

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

(Inspired by the Haskell `zipWith` answer)
Try it

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

(Inspired by several answers)
Try it

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

Try it

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

Try it

## 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
}``````

(All are 0 based)

Nice submission!
CraigR8806

2

# Haskell, 37 36 bytes

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

Try it online! This is an anonymous function which takes one number `n` as argument and returns 0-indexed the `n`th element of the sequence.

1

# Haskell, 56 bytes

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

0-indexed

1

# Perl 5 47 + 1 (for flag) = 48 Bytes

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

### Old Submission 82 Bytes

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

Run like so:

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

You can save one byte by using `print +((` and removing the final `)`. And two more by using `say` and `-E`. And also one more by doing `(\$_%4&1||-1)` instead of the ternary.
simbabque

1

# JavaScript (ES7), 28 bytes

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

1-indexed. I haven't looked at any other answers yet so I don't know if this is the best algorithm, but I suspect not.

1

# JavaScript, 28 22 bytes

Thanks @ETHproductions for golfing off 6 bytes

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

Try it online!

Hmm... would `f=x=>x%2?~x>>1:x/2+x%4-1` work?
ETHproductions

For some reason I had left the f= in front of the anonymous function :P
fəˈnɛtɪk

1

# dc, 98 bytes

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

Gosh, this is the longest answer here, mainly because I went the path of generating the absolute value of each element of the sequence one by one based on the following recursive formula: then outputting `(-1)^n * a_n`, rather than directly computing the `n`'th element. Anyways, this is `1`-indexed.

Try it online!

1

# R, 38 bytes

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

Explanation

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

1

# TI-Basic (TI-84 Plus CE), 31 bytes

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

TI-Basic is a tokenized language and each token used here is one byte, except `remainder(`, which is two.

This uses the 1-indexed version.

Explanation:

There is a pattern that repeats every four numbers. In the 1-indexed version, it is: -(x+1)/2, (x+1)/2, -(x+1)/2, (x-1)/2 for the input value x. This can be represented as a piecewise-defined function.

f(x) = -(x+1)/2 if x ≡ 1 mod 4; (x+1)/2 if x ≡ 2 mod 4; -(x+1)/2 if x ≡ 3 mod 4; (x-1)/2 if x ≡ 0 mod 4

Because the "x ≡ 1 mod 4" and "x ≡ 3 mod 4" parts are the same, we can combine them into "x ≡ 1 mod 2".

Now are piecewise function is:

f(x) = -(x+1)/2 if x ≡ 1 mod 2; (x+2)/2 if x ≡ 2 mod 4; (x-2)/2 if x ≡ 0 mod 4

This is where I start breaking it into actual commands. Since the value is positive for even indexes and negative for odd ones, we can use (-1)^x. However, in TI-Basic `i^(2X` (5 bytes) is shorter than `(-1)^Ans` (6 bytes). Note that parentheses are required due to order of operations.

Now that we have the way to negate the odd inputs out of the way, we move on to the mods (adding the negating back on later). I made the case of an odd input the default, so we start with `.5(Ans+1)`.

To fix the case of even input, just add one to the number in the parentheses, but only when x ≡ 0 mod 2. This could be represented as `.5(Ans+1+remainder(Ans+1,2))` or `.5(Ans+1+not(remainder(Ans,2)))`, but they have the same byte count, so it doesn't matter which.

To fix the case of multiple-of-4 input, we need to subtract 3 from the number in the parentheses, but also another 1 because all multiples of 4 are even, which would add one from our previous step, so we now have `.5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4)))`.

Now, just tack on the sign-determining part to the end to get the full program.

0

# Befunge 93, 25 bytes

Zero-indexed

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

Try it Online!

The number is given by `((2(n / 4) + 1) + !!((n % 4) % 3)) * (2(n % 2) - 1)`

0

## QBIC, 53 bytes

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

Explanation:

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

0

## Q, 52 bytes

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

0 indexed solution.

1. Gets the block number ie. which [-x x+1 -(x+1) x] block within the sequence contains the index.
2. Gets the index of the value within the block based on the index of the value within the whole sequence.
3. Creates the block.
4. Indexes into it via index derived in step 2.

Licensed under cc by-sa 3.0 with attribution required.