Considera la seguente sequenza numerica:

$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$

Enumera tutte le frazioni binarie nell'intervallo unitario $[0, 1)$ .

(Per facilitare questa sfida, il primo elemento è facoltativo: puoi saltarlo e considerare che la sequenza inizia con 1/2.)

Compito

Scrivi un programma (programma completo o una funzione) che ...

Scegli uno di questi comportamenti:

• Input n, output ennesimo elemento della sequenza (0-indicizzato o 1-indicizzato);
• Input n, output primi n elementi della sequenza;
• Non inserire nulla, generare l'infinita sequenza numerica che si può prendere uno per uno;

Regola

• Il tuo programma dovrebbe almeno supportare i primi 1000 articoli;
• Puoi scegliere di produrre decimali o frazioni (built-in, coppia intera, stringhe) come preferisci;
  • Input / Output come cifre binarie non è consentito in questa domanda;
• Questo è code-golf , vincono i codici più brevi;
• Scappatoie standard non consentite.

Casi test

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

Questi esempi si basano su una sequenza con indice 0 con lo 0 iniziale incluso. Dovresti regolare l'input per adattare la tua soluzione.

Leggi di più

• OEIS A006257
  • Problema di Giuseppe Flavio: . (Nome precedente: 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
  • : per n > 0 , a n = 2 ⌊ l o g 2 n + 1 ⌋ o a n = 2 a ⌊ $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, ...) enumera tutte le frazioni binarie nell'intervallo unitario [0, 1). - Fredrik Johansson, 14 agosto 2006

Haskell , 25 byte

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

Provalo online!

Decimali di output, uno indicizzati senza il termine zero iniziale.

Aggiunge 0,5 all'input, quindi dimezza fino a quando i risultati non sono inferiori a 2, quindi sottrae 1. L'uso di un'espressione senza punti consente di risparmiare 1 byte

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

Java 10, 68 64 byte

Prima prova a code golf!

Opzione 1: trova l' elemento n -esimo (1 indicizzato)

-4 byte grazie a @Kevin Cruijssen

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

Questo è un metodo anonimo che trova il n -esimo termine rimuovendo il bit più significativo da n , raddoppiando e aggiungendo uno, successivamente diviso per il successivo più potenza di 2.

Provalo online!

Procedura dettagliata del codice:

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`

Modificherà se è necessario stampare il valore finale invece di restituirlo.

MathGolf , 5 4 byte

╫\╨]

Provalo online!

Come sarebbe se l'operatore funzionasse correttamente

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

Provalo online!

Spiegazione

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

Mi sono ispirato a questa domanda per risolvere il problema, penso che la mia "soluzione" fosse di circa 10-12 byte.

Avevo previsto che il arrotondamento alla potenza più vicina di 2 restituisse il numero stesso se fosse un numero di due, ma a causa di un errore si arrotonda alla potenza successiva di due (ad esempio 4 -> 8 invece di 4 -> 4 ). Questo dovrà essere risolto in seguito, ma ora mi fa risparmiare un byte.

Java 10, 89 85 70 69 68 byte

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

Porto di @Emigma risposta 05AB1E 's , quindi uscite decimali all'infinito pure.
-15 byte grazie a @Arnauld .

Provalo online.

Spiegazione:

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 byte

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

Provalo online!

Python 3 , 33 byte

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

Provalo online!

Decimali di output, uno indicizzati senza il termine zero iniziale.

Java (JDK 10) , 30 byte

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

Provalo online!

Restituisce il n ^° elemento nella sequenza.

Questa risposta è originariamente un susseguirsi di campi da golf della risposta Java del TCFP . Alla fine, i golf non sembravano più la risposta originale (anche se la matematica usata è la stessa), quindi ho deciso di pubblicare i golf come risposta separata invece di commentare semplicemente la risposta del TCFP. Quindi, se ti piace questa risposta, vota la risposta del TCFP ! ;-)

I golf intermedi erano:

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 byte

Salvato 3 byte grazie a Kevin Cruijssen .

∞oDÅÉs/˜

Provalo online!

Spiegazione

∞         # 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

Gelatina , 9 byte

Bṙ1Ḅ,æċ2$

Provalo online!

PowerShell , 40 byte

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

Provalo online!

Emette la sequenza infinita come valori decimali. Date le limitazioni linguistiche, alla fine si verificheranno problemi di precisione, ma gestisce facilmente le prime 1000 voci.

Inizia impostando $i=2, quindi entra in un forciclo. Ogni iterazione, costruiamo un intervallo da 1..$ie tiriamo fuori i valori dispari con |?{$_%2}. Questi vengono inseriti nel loro ciclo interno, dove dividiamo ciascuno per ottenere il decimale |%{$_/$i}. Questi vengono lasciati sulla pipeline e inviati quando la pipeline viene scaricata dopo ogni foriterazione. Ogni iterazione stiamo semplicemente incrementando $ida $i*=2per ottenere il prossimo go-round.

Haskell, 35 32 byte

Modifica: -3 byte grazie a @ Delfad0r.

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

Questo è un elenco infinito di coppie di numeri interi.

Provalo online!

Haskell , 40 byte

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

Provalo online!

Sequenza infinita come coppie di numeri interi (a partire da (1,2)).

Un po 'più lungo della risposta di @nimi , ma l'approccio è completamente diverso, quindi ho deciso di pubblicarlo comunque.

Questa soluzione si basa sulla seguente osservazione.

• $\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\}$$

Nota come torni alla sequenza con cui hai iniziato!

La soluzione sfrutta questo fatto (insieme alla pigrizia di Haskell) per calcolare la sequenza s.

Python 2 - 68 66 byte

-2 byte grazie a Kevin

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

Provalo online!

Python 3 , 53 51 byte

• Salvato due byte grazie a mypetlion ; riutilizzo dei parametri predefiniti da ripristinare n.

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

Provalo online!

R , 42 byte

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

Provalo online!

Restituisce una coppia Denominator,Numerator. Usa la formula $\begin{equation}N = 2*\left(n-2^{\lfloor \log_2(n)\rfloor}\right)+1\end{equation}$ dalla sequenza di Giuseppe Flavio e $\begin{equation}D = 2^{\lfloor \log_2(n)\rfloor+1}\end{equation}$dall'altra sequenza. Fortunatamente siamo in grado di riutilizzare il denominatore poiché le due formule hanno molto in comune!

Racchetta , 92 91 byte

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

Provalo online!

• Salvataggio di un byte grazie a Giuseppe - rimozione di spazi bianchi superflui.

MATL , 8 byte

BnWGEy-Q

Provalo online!

Restituisce Numeratore, quindi Denominatore. Utilizza lo stesso metodo di mia risposta R , anche se è un po 'più efficiente.

Spiegazione, con input 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

Shakespeare Programming Language , 426 byte

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

Provalo online!

Emette la sequenza all'infinito come entrambi i numeri separati da uno spazio, con ogni elemento separato da una nuova riga.

Python 2 , 44 byte

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

Provalo online!

La funzione restituisce una tupla di (numeratore, denominatore). Un input di 0 non viene gestito (era facoltativo).

Eccellere 48 28 byte

Risparmiato 20 byte (!) Grazie a tsh

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

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

Presuppone il valore in A1, l'output è in decimale. Se vuoi che l'output sia in frazione, puoi creare un formato personalizzato per la cella di output come "0 / ### 0" e lo mostrerà come frazione.

Spiegazione: Difficile da spiegare, poiché è stata presa una scorciatoia per arrivare a questa formula. Fondamentalmente il numeratore è un bit shift a sinistra dell'ingresso, e il denominatore è la potenza successiva di 2 superiore all'ingresso del numero.

Inizialmente ho iniziato con le funzioni integrate di Excel per BITLSHIFT e BITRSHIFT, ma queste sposteranno gli interi 48 bit che non sono quelli desiderati. Le funzioni DEC2BIN (e BIN2DEC) hanno un limite da -512 a 511 (10 bit), quindi non funzionerebbe. Invece ho dovuto ricostruire il numero con un modulo del numero originale, quindi due volte, quindi aggiungere 1 (poiché la cifra sinistra sarebbe sempre 1 prima di uno spostamento).

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

Esempi:

C ++, 97 75 71 byte

-26 byte grazie a 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;}

Codice di prova:

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 byte

Nessun input, stampa una sequenza infinita:

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

Provalo online!

JavaScript (ES6), 44 byte

Restituisce il $n$-th term, 1-indexed.

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

Provalo online!

Rubino , 42 byte

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

Provalo online!

Stampa coppie intere all'infinito, a partire da 1/2.

JavaScript (Node.js) , 30 byte

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

Provalo online! 0-indicizzati. Iniziato come una porta della mia risposta batch, ma sono stato in grado di calcolare in multipli di$\frac{1}{2}$ che ha salvato diversi byte.

Rubino , 31 byte

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

Provalo online!

> <> , 19 18 byte

Usando l'idea di xnor , risolto da Jo King, -1 byte sfruttando meglio i mirror e altri -2 byte da Jo King perché !era superfluo e ;non è necessario.

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

Provalo online!

Wolfram Language (Mathematica) , 22 byte

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

Provalo online!

APL (Dyalog Unicode) , 15 byte

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

Provalo online!

Prefisso anonimo lambda.

Grazie ad Adám per 4 byte e al ciarlatano Cows per 2 byte.

Come:

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 byte

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

Provalo online!

Ungolfed:

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
}