La sequenza binaria-quadrata-diagonale è costruita come segue:

1. Prendi la sequenza di numeri naturali positivi:

   1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, ...

2. Converti ogni numero in binario:

   1, 10, 11, 100, 101, 110, 111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111, 10000, 10001, ...

3. Concatenali:

   11011100101110111100010011010101111001101111011111000010001 ...

4. A partire da n=1, genera quadrati con lunghezza laterale crescente nche vengono riempiti da sinistra a destra, dall'alto verso il basso con gli elementi della sequenza sopra:

   1

   1 0
   1 1

   1 0 0 
   1 0 1
   1 1 0

   1 1 1 1
   0 0 0 1
   0 0 1 1 
   0 1 0 1

   0 1 1 1 1
   0 0 1 1 0
   1 1 1 1 0
   1 1 1 1 1
   0 0 0 0 1

   ...

5. Prendi la diagonale (in alto a sinistra in basso a destra) di ogni quadrato:

   1, 11, 100, 1011, 00111, ...

6. Converti in decimale (ignorando gli zeri iniziali):

   1, 3, 4, 11, 7, ...
   

Compito

Scrivi un programma o una funzione che emetta la sequenza in uno dei seguenti modi:

• Restituisce o stampa la sequenza all'infinito.
• Dato input i, restituisce o stampa i primi ielementi della sequenza.
• Dato input i, restituisce o stampa l' ielemento th della sequenza (0 o 1 indicizzato).

Indica nella risposta quale formato di output scegli.

Questo è code-golf , vince la risposta più breve in ogni lingua.

Casi test

Ecco i primi 50 elementi della sequenza:

Buccia , 15 14 byte

zȯḋm←CtNCİ□ṁḋN

Provalo online!

Stampa continuamente i risultati come un elenco infinito.

Spiegazione

Mi chiedo se c'è un modo migliore per ottenere ogni n elemento da un elenco piuttosto che dividere l'elenco in blocchi di lunghezza n e recuperare la testa di ogni blocco.

      tN          Get a list of all natural numbers except 1. (A)

             N    Get a list of all natural numbers.
           ṁḋ     Convert each to its binary representation and join them 
                  all into a single list.
         İ□       Get a list of squares of all natural numbers.
        C         Cut the list of bits into chunks of corresponding sizes. (B)

zȯ                Zip (A) and (B) together with the following function.
     C            Split the bit list (from B) into chunks of the given length
                  (from A).
   m←             Get the head of each chunk. This is the diagonal of the
                  bit list arranged as a square.
  ḋ               Interpret the resulting bits as binary digits and return
                  the result.

Per essere chiari, estraiamo la diagonale di un quadrato nxn dividendo la sua forma lineare in blocchi di lunghezza n + 1 e recuperando il primo elemento di ciascun blocco:

[[1 , 0 , 1 , 0
  0],[1 , 0 , 1
  1 , 0],[1 , 0
  0 , 1 , 0],[1]]

Python 2 , 137 85 byte

lambda n:int(''.join(bin(x+1)[2:]for x in range(n**3))[n*~-n*(2*n-1)/6:][:n*n:n+1],2)

Provalo online!

Python 3 , 96 94 byte

lambda i:int(''.join(bin(x+1)[2:]for x in range(i**3))[sum(x*x for x in range(i))::i+1][:i],2)

Provalo online!

05AB1E , 19 17 16 byte

°LbJsLn£θs>ô€нJC

°viene sostituito da 3mnei link in quanto °tende ad essere molto lento.

Provalo online! o come una suite di test

Spiegazione

°L                 # push the range [1 ... 10^input]
  bJ               # convert each to binary and join to string
    sLn            # push the range [1 ... input]^2
       £θ          # split the binary string into pieces of these sizes and take the last
         s>ô       # split this string into chunks of size (input+1)
            €н     # get the first digit in each chunk
              JC   # join to string and convert to int

Buccia , 15 byte

Questo ha un approccio leggermente diverso alla risposta di Martin

moḋz!NCNCṘNNṁḋN

Provalo online!

Spiegazione:

              N   List of all natural numbers
            ṁḋ    Convert each to it's binary representation and flatten
         ṘNN      Repeat the list of natural numbers according the natural numbers:
                  [1,2,2,3,3,3,4,4,4,4,5,5,5,5,5...]
        C         Cut the list of bits into lists of lengths corresponding to the above
      CN          Cut that list into lists of lengths corresponding to the natural numbers
moḋz!N            For each in the list, get the diagonals and convert from binary.
m                   For each list in the list
   z!N              Zip it with natural numbers, indexing.
 oḋ                 Convert to binary

In azione

ṁḋN : [1,1,0,1,1,1,0,0,1,0,1,1,1,0,1,1,1,1,0,0,0,1,0,0,1,1,0,1,0,1...]

ṘNN : [1,2,2,3,3,3,4,4,4,4,5,5,5,5,5,6,6,6,6,6,6,7,7,7,7,7,7,7,8,8...]

C : [[1],[1,0],[1,1],[1,0,0],[1,0,1],[1,1,0],[1,1,1,1],[0,0,0,1]...]

CN : [[[1]],[[1,0],[1,1]],[[1,0,0],[1,0,1],[1,1,0]]...]

m z!N : [[1],[1,1],[1,0,0],[1,0,1,1],[0,0,1,1,1],[0,1,1,1,0,1]...]

oḋ : [1,3,4,11,7,29,56,141,343,853,321,3558,8176,3401,21845...]

Java (OpenJDK 8) , 215 212 206 202 197 byte

i->{String b="",t;int s=0,x=++i,j;for(;--x>0;s+=x*x);while(b.length()<s)b+=i.toString(++x,2);for(j=1,s=0;j<i;System.out.println(i.valueOf(t,2)),s+=j*j++)for(t="",x=s;x<s+j*j;x+=j+1)t+=b.charAt(x);}

Provalo online!

Python 2 , 91 byte

i=n=1;s=''
while 1:
 s+=bin(i)[2:];i+=1
 if s[n*n:]:print int(s[:n*n:n+1],2);s=s[n*n:];n+=1

Provalo online!

stampa la sequenza all'infinito

Gelatina , 16 byte

RBFṁ
R²SÇṫ²C$m‘Ḅ

Provalo online!

Spiegazione

RBFṁ  Helper link. Input: integer k
R     Range, [1, 2, ..., k]
 B    Convert each to a list of its binary digits
  F   Flatten
   ṁ  Mold to length k

R²SÇṫ²C$m‘Ḅ  Main link. Input: integer n
R            Range, [1, 2, ..., n]
 ²           Square each
  S          Sum
   Ç         Call helper link on the sum of the first n squares
       $     Monadic chain
     ²         Square n
      C        Complement, 1-n^2
    ṫ        Tail, take the last n^2 elements
        m    Modular indexing, take each
         ‘   (n+1)th element
          Ḅ  Convert from list of binary digits to decimal

Mathematica, 96 byte

Emette l' ielemento th della sequenza (1-indicizzato)

Diagonal@Partition[TakeList[Flatten@IntegerDigits[Range[#^3],2],Range@#^2][[#]],#]~FromDigits~2&

Provalo online!

Perl 5 , 92 + 1 ( -p) = 93 byte

$s.=sprintf'%b',++$"for 1..$_**3;map{say oct"0b".(substr$s,0,$_*$_,'')=~s/.\K.{$_}//gr}1..$_

Provalo online!

Gelatina , 18 byte

Approccio completamente diverso rispetto alla soluzione di Erik .

Ḷ²S‘ɓ*3B€Fṫ
Çm‘ḣµḄ

Provalo online!

Come funziona

Ḷ²S'ɓ * 3B € Fṫ - Collegamento di aiuto (monadico).

Ḷ - Intervallo ridotto, genera [0, N).
 ² - Quadrato vettorializzato (quadrato ciascuno).
  S - Somma.
   '- Incremento, per tenere conto dell'indicizzazione 1 di Jelly.
     ɓ - Avvia una catena diadica separata.
     * 3 - L'ingresso alla potenza di 3.
       B € - Converti ciascuno in binario.
         F - Appiattire.
          ṫ - Coda. Restituisce x [y - 1:] (1 indicizzato).

Çm'ḣµḄ - Collegamento principale (monadico).

Ç - Ultimo collegamento come monade.
 m '- Input modulare + 1. Ottieni ogni "input + 1" th elemento dell'elenco.
   ḣ - Testa. Restituisce quanto sopra con elementi con un indice più alto dell'input ritagliato.
    µḄ - Converte da binario a intero.

Salvato 1 byte grazie a Jonathan Allan !

Gelatina , 22 byte

²Rµ²Ṭ€Ẏ0;œṗBẎ$³ịs³ŒDḢḄ

Provalo online!

Pyth ,  27  20 byte

i<%hQ>s.BS^Q3s^R2QQ2

Verifica i primi casi di test.

Ottiene il I termine della sequenza, 1 indicizzato.

Come funziona?

i<%hQ>s.BS^Q3s^R2QQ2   - Full program. Q represents the input.

         S^Q3          - Generate the (inclusive) range [1, Q ^ 3].
       .B              - Convert each to binary.
      s                - Join into a single string.
     >                 - Trim all the elements at indexes smaller than:
               ^R2Q      - The elements of the range [0, Q) squared.
              s          - And summed.
  %hQ                  - Get each Q + 1 element of the list above.
 <                     - Trim all the elements at indexes higher than:
                   Q   - The input.
i                   2  - Convert from binary to integer.