您的任务是实现一个函数¹，该函数在正整数上形成置换（从正整数到自身的双射）。这意味着每个正整数在排列中应该恰好出现一次。最重要的是，您的函数输出奇数而不是偶数的可能性更大。

现在，这似乎很奇怪或不可能。当然，奇数和偶数一样多吗？虽然这种直觉对于有限集是正确的，但实际上对于无限集并不成立。例如，采用以下排列：

1 3 2 5 7 4 9 11 6 13 15 8 17 19 10 21 23 12 25 27 14 29 31 16 33 35 18 37 39 20 41 43 22 45 47 24 49 51 26 53 55 ...

如果对序列中的任何一个子部分的大小大于，则奇数至少与偶数一样多，因此，似乎任何随机项为奇数的概率都大于偶数。您还会注意到，每个数字最终都会在序列中出现奇数或偶数，并且只能出现一次。因此，该序列是真正的排列。$1$

概率的定义

为了避免混淆或模棱两可，我将清楚地阐明该问题中概率的含义。

让我们说我们有一个函数。当趋于无穷大时，一个数字为奇数的概率将定义为该集合的奇数成员与集合的大小之比的极限。$f$$f\{1\dots n\}$$n$

例如，前述函数将具有$2/3$奇数的可能性。

这是代码高尔夫球，因此答案将以字节计分，而字节数越少越好。

额外挑战

这里有一些有趣的想法，可以尝试并尝试实现。这些只是为了娱乐，不会以任何方式影响得分。其中一些甚至不是针对此挑战的有效解决方案，仅包含对挑战2或3的解决方案的答案不是有效答案，可能会被删除。

• 写一个奇数为$1$的排列。（这个有可能）

• 对于任何，写一个排列，该排列的奇数个数比偶数个数更多，但奇数概率为。$f\{1\dots n\}$$n$$1/2$

• 编写没有定义概率（没有限制）的排列。

^{1：这里的功能表示程序或功能。这只是一段需要输入并产生输出的代码。}

果冻，7个字节

Æf^<¥4P

在输入的素数分解中交换2 s和3 s。几率是2/3。

在线尝试！

这个怎么运作

Æf^<¥4P  Main link. Argument: n

Æf       Compute all prime factors of n, with duplicates.
    ¥4   Combine the two links to the left into a dyadic chain and call it with
         right argument 4.
   <       Compare each prime factor with 4. Yields 1 for 2 and 3, 0 otherwise.
  ^        Bitwise XOR the results with the corresponding prime factors.
         This maps 2 to 3, 3 to 2, and all other primes to themselves.
      P  Take the product of the resulting primes.

外壳，11个10字节

-1字节归功于Leo，功能略有不同

这有一个奇数的可能性 1

!uΣz:NCNİ1

在线尝试！

它索引序列：

[1,2,3,5,7,9,11,4,13,15,17,19,21,23,25,27,29,6,31,33]
1 odd, 1 even, 5 odd, 1 even, 9 odd, 1 even, 13 odd...

说明

!               Index the following sequence (1-indexed)
 u              remove duplicates                     [1,2,3,5,7,9,11,4,13,15...]
  Σ              Concatenate                          [1,1,2,3,5,3,7,9,11,4,13..]
   z:            Zipwith append                       [[1,1],[2,3,5],[3,7,9,11]..
     N          Natural numbers
      CNİ1      Odd numbers cut into lists of lengths [[1],[3,5],[7,9,11]...]
                corresponding to the Natural numbers

Haskell，35 34 32字节

f n=n:2*n+1:2*n+3:f(n+2)
(f 0!!)

实现示例序列[1,3,2,5,7,4,9,11,6,13,15,8,17,19,10,21,...]。

在线尝试！

供参考：旧版本，34字节（由于@ xnor，-1字节）：

(!!)$do e<-[0,2..];[e,2*e+1,2*e+3]

在线尝试！

外壳，8字节

!uΣzeİ1N

在线尝试！

这实现了示例序列（1,3,2,5,7,4...）。

说明

!uΣzeİ1N
   ze       zip together
     İ1       the odd numbers
       N      with the natural (positive) numbers
  Σ         flatten the resulting list
 u          remove duplicates
!           index into the obtained sequence with the input

每个人都进行挑战1，所以让我们做另外两个。

Perl 6，26个字节-挑战2

{($_==1)+$_-(-1)**($_%%2)}

在线尝试！

就1 3 2 5 4 7 6...偶数而言，总是比偶数多2个奇数。奇数，再加1。但是，这显然有的限制(n+2)/(2n+2) -> ½。

Perl 6，70个字节-挑战3

{((1,),(2,4),->@a,@ {@(map(@a[*-1]+2*(*+1),^(4*@a)))}...*).flat[$_-1]}

在线尝试！

诚然，这是可怕的打高尔夫球。它索引一个包含2个奇数，然后2个偶数，然后2个2奇数，然后2个偶数等等的序列。

如果n为奇数，则在n个这样的“块”之后的概率为（2⁰+2²+2⁴+ ... +2ⁿ⁻¹）/（2ⁿ-1）。分子的总和等于⅓（^{4½（n + 1）} -1）=⅓（2 ^{n +} 1-1）。因此，奇数块之后的概率为⅔（在限制范围内）。

但是，如果我们再增加一个块（并且使它们的偶数个数为n + 1），则不会添加任何奇数（分子保持不变），但是现在总共有（2 ^{n +} 1-1）个数字。括号取消，我们得到probability的概率（在极限内）。

显然应该假定有两个不同的聚类点⅓和to，以确保不存在该限制，但这并不能真正证明这一点。在Math.SE的答案中可以找到我尝试做一个可靠的证明：https ://math.stackexchange.com/a/2416990/174637 。扑打错误是值得欢迎的。

Perl 6，39个字节—核心挑战。

{my$l=$_ div 3;$_%3??2*($_-$l)-1!!2*$l}

在线尝试！

尽管由于挑战2和3给出了一个令人愉悦的数学难题，所以我发布了这个答案，但严格要求所有答案都包含针对核心挑战的解决方案。就是这里。

这是示例序列。

脑筋急转弯，120字节

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

在线尝试！

执行以下功能：

该函数生成序列

2 4 1 6 3 5 7 8 9 11 13 15 17 19 21 10 23 25 27 29...

该函数的奇数概率为 1

R，82个字节（额外挑战1）

f<-function(n){if(sqrt(n)==floor(sqrt(n))){2*sqrt(n)}else{2*(n-floor(sqrt(n)))-1}}

在线尝试！

如果输入是一个理想的平方，则给出一个偶数。否则，给出一个奇数。理想正方形的自然密度为0，这意味着此序列给出的奇数的概率为1。

C（gcc），29个字节

f(n){return n&3?n+n/2|1:n/2;}

在线尝试！

第四个数字是偶数：

1 3 5   7 9 11   13 15 17   19 21 23   25 27 29
      2        4          6          8          10

额外挑战1，52个字节

f(n,i){for(i=0;n>>i/2;i+=2);return n&n-1?2*n-i-1:i;}

在线尝试！

如果n等于2 ^x，则返回2 *（x + 1），否则返回连续的奇数：

    1   3 5 7   9 11 13 15 17 19 21    23 25
2 4   6       8                     10      

脑高射炮，140个 138 136字节

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

在线尝试！

说明

这执行与问题中建议的功能类似的功能。

2 3 1 4 7 5 6 11 9 8 15 13 10 17 15 ...

它的工作原理主要基于我将片段堆叠为3叠的片段。

(({}(({}({}))[({}[{}])]))[({}[{}])])

我们建立了两个堆栈，一个堆栈具有累加器值（两个奇数一个偶数），另一个带有数字4 4 2。每次迭代时，我们都滚动两个堆栈，并将左侧堆栈的顶部添加到右侧堆栈的顶部。

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

这将使每个奇数增加4，使一个偶数增加2。在循环中，我们得到2个奇数1偶数的模式，每个正整数都被命中。因此，我们只是循环n时间与n被输入。这具有2/3的渐近概率。

果冻，10字节

ÆE;0ṭ2/FÆẸ

几率是2/3。

在线尝试！

这个怎么运作

ÆE;0ṭ2/FÆẸ  Main link. Argument: n

ÆE          Compute the exponents of n's prime factorization.
  ;0        Append a 0.
     2/     Reduce all pairs by...
    ṭ         tack, appending the left argument to the right one.
            This inverts all non-overlapping pairs of exponents.
       F    Flatten the result.
        ÆẸ  Consider the result a prime factorization and compute the corresponding
            integer.

C，80字节

#define R if(k++==n)return
i,j,k;f(n){for(i=k=1,j=2;;i+=4,j+=2){R i;R i+2;R j;}}

从问题中实现示例排列。

在线尝试！

批次，36个字节

@cmd/cset/an=%1*2,(-~n*!!(n%%3)+n)/3

执行问题中给定的顺序。

JavaScript，23个字节

n=>n/2+n/2%2+(n%4&&n-1)

输出：1，3，5，2，7，9，11，4，13，15，17，6，19，21，23，8 ...

• 对于所有n = 4k：
  • f（n）= n / 2 = 2k
• 对于所有n = 4k + b
  • f（n）= n / 2 + b / 2 + n-1 = 3/2 *（4k + b）+ 1/2 * b-1 = 6k + 2b-1

挑战2：

n=>n^(n>1)

输出：1、3、2、5、4、7、6、9、8、11、10、13、12、15、14

CJam（21字节）

{2b_(&!\_,2*\1$~+2b?}

在线演示显示前32个输出。这是一个匿名块（函数）。

这也是挑战1的解决方案：映射到偶数的数字为2的幂，因此前n个输出中偶数的密度为lg（n）/ n，趋于零。

解剖

{         e# Declare a block; let's call the input x
  2b      e#   Convert to base 2
  _(&     e#   Copy, pull out first digit (1) and set intersection with rest
  !       e#   Boolean not, so empty set (i.e. power of 2) maps to 1 and non-empty
          e#   to 0
  \_,2*   e#   Take another copy, find its length, and double it
  \1$~+   e#   Take the original base 2 array and append ~(2L) = -2L-1
  2b      e#   Convert from base 2, to get 2x-2L-1
  ?       e#   Take the 2L if it was a power of 2, and the 2x-2L-1 otherwise
}

Perl 40字节

$,=$";$i=4;{say$i-3,$i/2,($i+=4)-5;redo}

脑通气，88字节

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

在线尝试！

说明

这实现了与我上一个答案相同的功能，但是使用了Brain-Flueue的FIFO模型来减少一些麻烦。这是它生成的前几个术语。

2 3 1 4 7 5 6 11 9 8 15 13 10 17 15 ...

代码的第一部分只是设置的一部分，我们分别放在0,-1,-3第一个堆栈和2,4,4第二个堆栈上。在2,4,4将通过偶数和奇数正如我在脑高射炮答案确实被用来循环。

然后，我们循环n次，每次将左侧堆栈的顶部添加到右侧堆栈。由于Brain-Flueue使用队列而不是堆栈，因此当我们触摸它们时，值自然会滚动，从而无需额外的代码。

Python 2中，46 104 55个字节

lambda n:2*((n-int(n**.5))+.5,n**.5-1)[n!=1>0==n**.5%1]

在线尝试！

误解了这个问题，现在正确实现了可用于生成序列的函数，而不是用于生成序列的函数。也0从可能的输出集中排除。

找到奇数正整数的概率现在收敛到1。

果冻，9字节

Ḥ€’ĖUẎQ⁸ị

在线尝试！

实施1, 3, 2, 5, 7, 4, 9, 11, 6, ...（概率2/3）。

05AB1E，11个字节

·ÅÉā‚ø˜Ù¹<è

在线尝试！

Pyth，9个字节

*Fmxd<d4P

在这里尝试！或一次测试更多！

您可以使用此代码来验证直到某一点的奇数比率。10000用您想要的限制代替（不要将其设置得更高，因为它会出现内存错误）。

Km*Fmxk<k4PdS10000clf%T2KlK

在这里尝试。

上面给出的大致为0.667。奇数次出现的真实概率为2/3。这种方法等效于Dennis的答案。

说明

*Fmxd<d4P   Full program.

        P   Prime factors.
  m         Map over ^.
   x        Bitwise XOR between:
    d          The current prime factor.
     <d4       The integer corresponding to the boolean value of current factor < 4.
*F          Product of the list.

Java 8，20字节

n->n%4>0?n+n/2|1:n/2

@nwellnhof的C答案端口。
我尝试过的一些事情最终变得更长或稍微不正确。

实现：1,3,5,2,7,9,11,4,13,15,17,6,19,21,23,8,25,27,29,10,31,33,35,12,37,...
的概率为3/4。

在这里尝试。

Lua，67 53字节

当我打完高尔夫球时来解释:)

该程序通过命令行参数将整数作为输入，并将示例序列的第n个元素输出到STDOUT

n=...print(n%3<1 and n/3*2or n+math.floor(n/3)+n%3-1)

说明

n=...                              -- shorthand for the argument
print(                             -- prints out the result of the following ternary
     n%3<1                         -- if n is divisible by 3
       and n/3*2                   -- prints out the corresponding even number
       or n+math.floor(n/3)+n%3-1) -- else prints out the odd number

该序列的偶数既是n偶数又n是3 的倍数，因此公式n%3*2足以生成它们。

对于奇数，它要难一些。基于我们可以根据电流找到它们的事实n，我们有下表：

n       |  1   2   4   5   7   8   10   11  
target  |  1   3   5   7   9   11  13   15
target-n|  +0  +1  +1  +2  +2  +3  +3   +4

让我们调用的值target-n i，我们可以看到，每一次n%3==2，i递增。我们的公式如下：

n+math.floor(n/3)+n%3-1

奇数是基于n加的i。

i增量值与欧几里德除以3的速率相同，但有一个偏移量。math.floor(n/3)给我们增加的速率并n%3-1给我们偏移，使它发生在n%3==2而不是n%3==0。