请考虑以下数字顺序：

$0, \frac{1}{2}, \frac{1}{4}, \frac{3}{4}, \frac{1}{8}, \frac{3}{8}, \frac{5}{8}, \frac{7}{8}, \frac{1}{16}, \frac{3}{16}, \frac{5}{16}, \frac{7}{16}, \frac{9}{16}, \frac{11}{16}, \frac{13}{16}, \frac{15}{16}, \frac{1}{32}, \frac{3}{32}, \frac{5}{32}, \dots$

它枚举单位间隔中的所有二进制分数。$[0, 1)$

（为简化此挑战，第一个元素是可选的：您可以跳过它，并考虑序列以1/2开头。）

任务

编写一个程序（完整的程序或功能），以...

选择以下行为之一：

• 输入n，输出序列的第n个元素（0索引或1索引）；
• 输入n，输出序列的前n个元素；
• 不输入任何内容，输出可以一一取整的无限数序列；

规则

• 您的程序至少应支持前1000个项目；
• 您可以根据需要选择输出小数或分数（内置，整数对，字符串）。
  • 此问题中不允许输入/输出为二进制数字；
• 这是代码高尔夫球，最短的代码获胜；
• 不允许出现标准漏洞。

测试用例

input output
1     1/2     0.5
2     1/4     0.25
3     3/4     0.75
4     1/8     0.125
10    5/16    0.3125
100   73/128  0.5703125
511   511/512 0.998046875
512   1/1024  0.0009765625

这些示例基于0索引序列，其中包括前导0。您需要调整输入以适合您的解决方案。

阅读更多

• OEIS A006257
  • 约瑟夫斯问题：。（以前为M2216）$a_{2n} = 2a_n-1, a_{2n+1} = 2a_n+1$
  • 0、1、1、3、1、3、5、7、1、3、5、7、9、11、13、15、1、3、5，...
• OEIS A062383
  • ：对于 Ñ > 0，一个Ñ = 2 ⌊ 升ø 克2 Ñ + 1 ⌋或一个ñ = 2 一个⌊ $a_0 = 1$$n>0$$a_n = 2^{\lfloor log_2n+1 \rfloor}$。$a_n = 2a_{\lfloor \frac{n}{2} \rfloor}$
  • 1，2，4，4，8，8，8，8，16，16，16，16，16，16，16，32，32，32，...

• A006257（n）/ A062383（n）=（0，0.1，0.01，0.11，0.001，...）枚举单位间隔[0，1）中的所有二进制分数。-Fredrik Johansson，2006年8月14日

Haskell，25个字节

pred.until(<2)(/2).(+0.5)

在线尝试！

输出小数，一个索引，不带初始零项。

将0.5加到输入，然后减半直到结果低于2，然后减1。使用无点表达式可节省1个字节

f n=until(<2)(/2)(n+0.5)-1

Java 10、68 64字节

首先尝试打码高尔夫！

选项1：找到第n个元素（1-索引）

-4个字节，感谢@Kevin Cruijssen

n->{int x=0;for(;n>>++x!=1;);return((~(1<<x)&n)*2.+1)/(1<<x+1);}

这是一种匿名方法，它通过从n中删除最高有效位，将其加倍并加一个，然后除以第二高位次幂来找到第n个项。

在线尝试！

代码演练：

n->{                      // builds anonymous function with input n
int x=0;                  // stores floor of log(n) (base 2) for most significant digit
for(;n>>++x!=1;);         // calculates floor of log(n) by counting right shifts until 1
return((~(1<<x)&n)        // removes most significant digit of n
*2.+1)                     // multiplies 2 and adds 1 to get the odd numerator
/(1<<x+1);}               // divides by the next highest power of 2 and returns`

如果需要打印最终值而不是返回最终值，将进行编辑。

MathGolf，5 4字节

╫\╨]

在线尝试！

操作员正常工作时的外观

╫\)╨]   (")" adds 1 to TOS, making rounding behave as expected)

在线尝试！

说明

╫     Left-rotate all bits in input
 \    Swap top two elements on stack, pushing the input to the top
  ╨   Round up to nearest power of 2
   ]  Wrap in array (just for pretty printing)

我从这个问题中得到了启发来解决问题，我认为“自己的”解决方案约为10-12个字节。

我原本打算四舍五入到最接近的2的幂以返回数字本身（如果它是2的话），但是由于错误，它会四舍五入到2的下一个幂（例如4-> 8而不是4-> 4 ）。稍后必须解决此问题，但是现在它为我节省了一个字节。

Java 10、89 85 70 69 68字节

v->{for(float j,t=2;;t*=2)for(j=1;j<t;j+=2)System.out.println(j/t);}

@Emigma的05AB1E答案的端口，因此也将无限期地输出小数。
-15个字节，感谢@Arnauld。

在线尝试。

说明：

v->{                      // Method with empty unused parameter and no return-type
  for(float j,t=2;;       //  Loop `t` from 2 upwards indefinitely,
                   t*=2)  //  doubling `t` after every iteration
    for(j=1;j<t;          //   Inner loop `j` in the range [1, `t`),
                j+=2)     //   in steps of 2 (so only the odd numbers)
      System.out.println( //    Print with trailing new-line:
        j/t);}            //     `j` divided by `t`

Perl 6，19个字节

{($_+.5)/2**.msb-1}

在线尝试！

Python 3，33个字节

lambda n:(8*n+4)/2**len(bin(n))-1

在线尝试！

输出小数，一个索引，不带初始零项。

Java（JDK 10），30字节

n->(n+.5)/n.highestOneBit(n)-1

在线尝试！

返回序列中的第n ^个项目。

该答案最初是TCFP Java答案的一连串高尔夫球。最后，高尔夫球看起来不再像原始答案一样（尽管使用的数学是相同的），所以我决定将高尔夫球作为单独的答案发布，而不是简单地评论TCFP的答案。因此，如果您喜欢此答案，请同时支持TCFP的答案！;-)

中级高尔夫是：

n->{int x=0;for(;n>>++x!=1;);return((~(1<<x)&n)*2.+1)/(1<<x+1);} // 64 bytes (TCFP's answer when I started golfing)
n->{int x=0;for(;n>>++x!=1;);x=1<<x;return((~x&n)*2.+1)/x/2;}    // 61 bytes
n->{int x=n.highestOneBit(n);return((~x&n)*2.+1)/x/2;}           // 54 bytes
n->{int x=n.highestOneBit(n);return((~x&n)+.5)/x;}               // 50 bytes
n->((n&~(n=n.highestOneBit(n)))+.5)/n                            // 37 bytes
n->(n-(n=n.highestOneBit(n))+.5)/n                               // 34 bytes
n->(n+.5)/n.highestOneBit(n)-1                                   // 30 bytes, current score

05AB1E，11 8字节

感谢Kevin Cruijssen保存了3个字节。

∞oDÅÉs/˜

在线尝试！

说明

∞         # start an infinite list [1...
 o        # calculate 2**N
  D       # duplicate
   ÅÉ     # get a list of odd numbers up to 2**N
     s/   # divide each by 2**N
       ˜  # flatten

果冻，9个字节

Bṙ1Ḅ,æċ2$

在线尝试！

PowerShell，40字节

for($i=2;;$i*=2){1..$i|?{$_%2}|%{$_/$i}}

在线尝试！

将无限序列输出为十进制值。给定语言限制，最终会遇到精度问题，但可以轻松处理前1000个条目。

从设置开始$i=2，然后进入for循环。每次迭代时，我们都会从构造一个范围，1..$i并使用提取出奇数值|?{$_%2}。它们被送入它们自己的内部循环，在这里我们将每个循环除以得到小数|%{$_/$i}。每次for迭代后，这些都将留在管道上并在管道被冲洗时输出。每次迭代，我们只是简单地增加$i通过$i*=2获得下一个去轮。

Haskell，35 32字节

编辑：-3个字节，感谢@ Delfad0r。

[(y,2^x)|x<-[1..],y<-[1,3..2^x]]

这是整数对的无限列表。

在线尝试！

Haskell，40个字节

s=(1,2):[(i*2+u,j*2)|(i,j)<-s,u<-[-1,1]]

在线尝试！

无限序列为整数对（从开始(1,2)）。

比@nimi的答案要长一些，但是方法完全不同，所以我还是决定将其发布。

该解决方案基于以下观察。

• 替换每个数字 $\frac{i}{j}$ 按照列表的顺序 $\left\{\frac{2i-1}{2j},\frac{2i+1}{2j}\right\}$： $$\left\{\left\{\frac{1}{4},\frac{3}{4}\right\},\left\{\frac{1}{8},\frac{3}{8}\right\},\left\{\frac{5}{8},\frac{7}{8}\right\},\left\{\frac{1}{16},\frac{3}{16}\right\},\ldots\right\}$$
• 将所有列表合并为一个序列： $$\left\{\frac{1}{4},\frac{3}{4},\frac{1}{8},\frac{3}{8},\frac{5}{8},\frac{7}{8},\frac{1}{16},\frac{3}{16},\ldots\right\}$$
• 加 $\frac{1}{2}$ 在序列的开头： $$\left\{\frac{1}{2},\frac{1}{4},\frac{3}{4},\frac{1}{8},\frac{3}{8},\frac{5}{8},\frac{7}{8},\frac{1}{16},\frac{3}{16},\ldots\right\}$$

请注意，您如何回到开始的顺序！

该解决方案利用这一事实（连同Haskell的惰性）来计算序列s。

Python 2-68 66字节

-2字节感谢Kevin

from math import*
def g(n):a=2**floor(log(n,2));print(n-a)*2+1,2*a

在线尝试！

Python 3中，53 51个字节的

• 由于mypetlion节省了两个字节；重用默认参数进行重置 n。

def f(m=2,n=1):n<m and print(n/m)&f(m,2+n)or f(m+m)

在线尝试！

R，42个字节

function(n)c(y<-2^(log2(n)%/%1)*2,2*n-y+1)

在线尝试！

返回一对Denominator,Numerator。使用公式 $\begin{equation}N = 2*\left(n-2^{\lfloor \log_2(n)\rfloor}\right)+1\end{equation}$ 从约瑟夫斯序列和 $\begin{equation}D = 2^{\lfloor \log_2(n)\rfloor+1}\end{equation}$从另一个序列。令人高兴的是，我们能够重用分母，因为这两个公式有很多共同点！

球拍，92 91字节

(define(f k(m 2)(n 1))(if(> k 0)(if(=(+ n 1)m)(f(- k 1)(+ m m))(f(- k 1)m(+ n 2)))(/ n m)))

在线尝试！

• 感谢Giuseppe，节省了一个字节-删除了多余的空格。

MATL，8字节

BnWGEy-Q

在线尝试！

返回分子，然后分母。使用与我的R答案相同的方法，尽管效率更高一些。

输入说明5：

           # implicit input 5
B          # convert to array of bits
           # STACK: [[1 0 1]]
n          # length (place of Most Significant Bit)
           # STACK: [3]
W          # elementwise raise 2^x
           # STACK: [8]
G          # paste input
           # STACK: [8, 5]
E          # double
           # STACK: [8, 10]
y          # copy from below
           # STACK: [8, 10, 8]
-          # subtract
           # STACK: [8, 2]
Q          # increment
           # STACK: [8, 3]
           # implicit end of program, display stack contents

莎士比亚编程语言，426字节

,.Ajax,.Ford,.Act I:.Scene I:.[Exeunt][Enter Ajax and Ford]Ajax:You be the sum ofyou a cat.Ford:You cat.Scene V:.Ford:Is twice you nicer I?If solet usScene X.You be twice you.Let usScene V.Scene X:.Ford:Remember twice you.You be the sum oftwice the remainder of the quotient betweenI you a cat.Open heart.You big big big big big cat.Speak thy.Recall.Open heart.You be twice the sum ofa cat a big big cat.Speak thy.Let usAct I.

在线尝试！

将序列无限地输出为两个数字，两个数字之间用空格隔开，每个项目之间用换行符隔开。

Python 2，44字节

def f(n):m=2**len(bin(n))/4;return 2*n-m+1,m

在线尝试！

函数返回一个元组（分子，分母）。输入0不会被处理（这是可选的）。

Excel 48 28字节

由于tsh，节省了20个字节（！）

=(A1+0.5)/2^INT(LOG(A1,2))-1

= MOD（A1 + 0.5,2 ^（INT（LOG（A1,2））））/ 2 ^ INT（LOG（A1,2））

假设A1中的值，输出为十进制。如果希望输出为小数，则可以为输出单元格创建一个自定义格式为“ 0 / ### 0”，并将其显示为小数。

说明： 难以解释，因为采用了捷径可到达此公式。分子基本上是输入的左移，分母是输入数字的下一个2的幂。

我最初是从Excel内置的BITLSHIFT和BITRSHIFT函数开始的，但是它们会移位整个48位，这不是您想要的。函数DEC2BIN（和BIN2DEC）的限制是-512到511（10位），因此这是行不通的。取而代之的是，我不得不用原始数字的模数来重建数字，然后乘以2，然后加1（因为左位数字在移位前总是1）。

=MOD(A1                        Use MOD for finding what the right digits are
       +0.5                    this will later add the left "1" to the right digits
           ,2^INT(LOG(A1,2)))) Take Log base 2 number of digits on the right
                               this creates the numerator divided by 2 (explained later)
/ 2^INT(LOG(A1,2))             The denominator should be 2^ (Log2 + 1) but instead of 
                               adding a 1 here, we cause the numerator to be divided by 2 instead
                               This gives us a fraction.  In the numerator, we also added .5
                               instead of 1 so that we wouldn't need to divide it in both the
                               numerator and denominator
Then tsh showed how I could take the int/log out of the mod and remove it from numerator/denominator. 

例子：

C ++，97 75 71字节

-26字节，感谢tsh，ceilingcat，Zacharý

float f(int i){float d=2,n=1;while(--i)n=d-n==1?d*=2,1:n+2;return n/d;}

测试代码：

std::cout << "1\t:\t" << f(1) << '\n';
std::cout << "2\t:\t" << f(2) << '\n';
std::cout << "3\t:\t" << f(3) << '\n';
std::cout << "4\t:\t" << f(4) << '\n';
std::cout << "10\t:\t" << f(10) << '\n';
std::cout << "100\t:\t" << f(100) << '\n';
std::cout << "511\t:\t" << f(511) << '\n';
std::cout << "512\t:\t" << f(512) << '\n';

C（gcc），63个字节

无输入，打印无限顺序：

f(i,j){for(i=1,j=2;;i+=2,i>j&&(j*=2,i=1))printf("%d/%d ",i,j);}

在线尝试！

JavaScript（ES6），44个字节

返回 $n$-第一项，以1为索引。

f=(n,p=q=1)=>n?f(n-1,p<q-2?p+2:!!(q*=2)):p/q

在线尝试！

Ruby，42个字节

1.step{|i|(1..x=2**i).step(2){|j|p [j,x]}}

在线尝试！

从1/2开始无限打印整数对。

JavaScript（Node.js），30字节

f=(n,d=.5)=>d>n?n/d:f(n-d,d*2)

在线尝试！0索引。最初是我的批处理答案的端口，但是我能够以$\frac{1}{2}$ 节省了几个字节。

红宝石，31个字节

->x{(2r*x+1)/2**x.bit_length-1}

在线尝试！

> <>，19 18字节

使用由乔·金（Jing）固定的xnor的想法，可以更好地利用镜子，从而减少-1个字节，而乔·金（Jo King）!则另加-2个字节，因为多余了，;不是必需的。

2*1+\1-n
2:,2/?(

在线尝试！

Wolfram语言（Mathematica），22字节

2^Mod[Log2[2#+1],1]-1&

在线尝试！

APL（Dyalog Unicode），15字节

1-⍨.5∘+÷2*∘⌊2⍟⊢

在线尝试！

匿名前缀lambda。

感谢Adám提供4个字节，并感谢Cows quack提供2个字节。

怎么样：

1-⍨.5∘+÷2*∘⌊2⍟⊢ ⍝ Anonymous lambda, argument ⍵ → 10
            2⍟⊢ ⍝ Log (⍟) of ⍵ in base 2. 2⍟10 → 3.32192809489...
           ⌊     ⍝ Floor. ⌊3.32192809489... → 3
        2*∘      ⍝ Take that power of 2. 2³ → 8
       ÷         ⍝ Use that as denominator
   .5∘+          ⍝ ⍵ + 0.5 → 10.5. Using that as numerator: 10.5÷8 → 1.3125
1-⍨              ⍝ Swap the arguments (⍨), then subtract. 1-⍨1.3125 → 1.3125-1 → 0.3125

C＃（.NET Core），69字节

a=>{int b=1,c=2;while(a-->1){b+=2;if(b>c){b=1;c*=2;}}return b+"/"+c;}

在线尝试！

取消高尔夫：

a=> {
    int b = 1, c = 2;   // initialize numerator (b) and denominator (c)
    while (a-- > 1)     // while a decrements to 1
    {
        b += 2;         // add 2 to b
        if (b > c)      // if b is greater than c:
        {
            b = 1;      // reset numerator to 1
            c *= 2;     // double denominator
        }
    }
    return b + "/" + c; // return fraction as string
}