다음과 같은 숫자 순서를 고려하십시오.

$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 개 항목을 지원해야합니다.
• 원하는대로 소수 또는 분수 (내장, 정수 쌍, 문자열)를 출력하도록 선택할 수 있습니다.
  • 이 질문에서는 이진수로 입력 / 출력 할 수 없습니다.
• 이것은 code-golf 이며, 가장 짧은 코드가 이깁니다.
• 표준 허점은 허용되지 않습니다.

테스트 케이스

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
  • $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, 16, 32, 32, 32, ...

• A006257 (n) / A062383 (n) = (0, 0.1, 0.01, 0.11, 0.001, ...)은 단위 간격 [0, 1)의 모든 이진 분수를 열거합니다. -Fredrik Johansson, 2006 년 8 월 14 일

하스켈 , 25 바이트

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

온라인으로 사용해보십시오!

초기 0 항없이 1 인덱싱 된 소수를 출력합니다.

입력에 0.5를 더한 다음 결과가 2보다 작을 때까지 반으로 줄인 다음 1을 뺍니다. 무점 식을 사용하면 1 바이트가 절약됩니다.

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

자바 10, 68 64 바이트

먼저 코드 골프를보십시오!

옵션 1 : n 번째 요소 찾기 (1- 인덱스)

@Kevin Cruijssen 덕분에 -4 바이트

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

이는 발견 익명의 방법으로 n 개의 가장 중요한 비트를 제거 번째 항을 N 다음 (2)의 다음으로 높은 전력으로 나누어, 그 배로 한 추가.

온라인으로 사용해보십시오!

코드 연습 :

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-> 4 대신 4-> 8) ). 이것은 나중에 수정해야하지만 이제는 1 바이트를 절약합니다.

자바 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 응답 포트 이므로 소수점도 무한정 출력합니다. @Arnauld
덕분에 -15 바이트 .

온라인으로 사용해보십시오.

설명:

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`

펄 6 , 19 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 33 바이트

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

온라인으로 사용해보십시오!

초기 0 항없이 1 인덱싱 된 소수를 출력합니다.

자바 (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}}

온라인으로 사용해보십시오!

무한 시퀀스를 10 진수 값으로 출력합니다. 언어 제한이 주어지면 결국 정밀도 문제가 발생하지만 처음 1000 개의 항목을 쉽게 처리 할 수 ​​있습니다.

설정 $i=2으로 시작한 다음 for루프 를 시작합니다 . 반복 할 때마다 범위를 구성 1..$i하고로 홀수 값을 빼냅니다 |?{$_%2}. 그것들은 그들 자신의 내부 루프로 공급되며, 여기서 우리는 decimal을 얻기 위해 각각을 나눕니다 |%{$_/$i}. 이것들은 파이프 라인에 남아 있고 매 for반복 마다 파이프 라인이 플러시 될 때 출력됩니다 . 각 반복은 단순히 다음 단계로 넘어 가기 위해 증가 $i하고 $i*=2있습니다.

하스켈, 35 32 바이트

편집 : @ Delfad0r 덕분에 -3 바이트.

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

이것은 정수 쌍의 무한 목록입니다.

온라인으로 사용해보십시오!

하스켈 , 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\}$$

시작한 순서로 돌아가는 방법에 주목하십시오!

솔루션은 시퀀스를 계산하기 위해이 사실을 이용합니다 (하스켈의 게으름과 함께) s.

파이썬 2-68 66 바이트

Kevin 덕분에 -2 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 53 51 바이트

• mypetlion 덕분에 2 바이트를 절약했습니다 . 기본 매개 변수를 다시 사용하여 재설정 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)))

온라인으로 사용해보십시오!

• 불필요한 공백을 제거 하는 주세페 덕분에 바이트를 절약했습니다 .

MATL , 8 바이트

BnWGEy-Q

온라인으로 사용해보십시오!

분자를 반환 한 다음 분모를 반환합니다. 조금 더 효율적이지만 내 R answer 와 동일한 방법을 사용합니다 .

입력과 함께 설명 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.

온라인으로 사용해보십시오!

두 항목을 공백으로 구분하여 각 항목을 줄 바꿈으로 구분하여 시퀀스를 무한대로 출력합니다.

파이썬 2 , 44 바이트

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

온라인으로 사용해보십시오!

함수는 (분자, 분모)의 튜플을 반환합니다. 0의 입력은 처리되지 않습니다 (선택적).

엑셀 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의 값을 가정하고 출력은 10 진수입니다. 출력을 분수로 만들려면 출력 셀에 대한 사용자 지정 형식을 "0 / ### 0"으로 만들면 분수로 표시됩니다.

설명 : 이 수식을 사용하는 데 필요한 바로 가기가 있으므로 설명하기가 어렵습니다. 기본적으로 분자는 입력에서 왼쪽으로 조금 이동하고 분모는 숫자 입력보다 다음으로 2의 거듭 제곱입니다.

나는 원래 BITLSHIFT와 BITRSHIFT를위한 내장 함수를 Excel로 시작했지만 원하는 48 비트가 아닌 전체 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 바이트

tsh, ceilingcat, Zacharý 덕분에 -26 바이트

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);}

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 44 바이트

$n$

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

온라인으로 사용해보십시오!

루비 , 42 바이트

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

온라인으로 사용해보십시오!

1/2부터 시작하여 정수 쌍을 무한대로 인쇄합니다.

자바 스크립트 (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 바이트

사용 XNOR의 생각 (가) 때문에 거울과 조 왕에 의해 다른 -2 바이트보다 효율적으로 사용하여 조 왕에 의해 고정, -1 바이트를 !불필요이고 ;필요하지 않습니다.

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

온라인으로 사용해보십시오!

Wolfram Language (Mathematica) , 22 바이트

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

온라인으로 사용해보십시오!

APL (Dyalog Unicode) , 15 바이트

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

온라인으로 사용해보십시오!

익명 접두사 람다.

Adám 덕분에 4 바이트, Cows ck은 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 코어) , 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
}