Étant donné un entier n, affichez les premiers nnombres binaires en pente, indexés 0 ou 1. Ils sont appelés ainsi en raison de la façon dont ils sont générés:

Écrivez les nombres en binaire les uns sous les autres (justifiés à droite):

........0
........1
.......10
.......11
......100
......101
......110
......111
.....1000
.........

Ensuite, vous devez prendre chaque diagonale du bas à gauche au haut à droite, de sorte que chaque chiffre final soit le dernier chiffre d'une diagonale. Voici la quatrième diagonale (indexée zéro) marquée par x's, qui est100 :

........0
........1
.......10
.......11
......10x
......1x1
......x10
......111
.....1000
.........

Les diagonales inclinées vers le haut dans l'ordre sont:

0
11
110
101
100
1111
1010
.......

Ensuite, convertissez en décimal, donnant 0, 3, 6, 5, 4, 15, 10, ...

OEIS A102370

Il s'agit de code-golf , donc le code le plus court en octets l'emporte.

Gelée, 11 octets

ḤḶBUz0ŒDUḄḣ

Essayez-le en ligne!

Explication

ḤḶBUz0ŒDUḄḣ    Main link. Argument: n
Ḥ              Double the argument. This ensures there are enough
               rows, since n + log2(n) <= 2n.
 Ḷ             Get range [0 .. 2n-1].
  B            Convert each number to binary.
   U           Reverse each list of digits. 
    z0         Transpose, padding with zeroes to a rectangle.
      ŒD       Get the diagonals of the rectangle, starting from the
               main diagonal. This gets the desired numbers, reversed,
               in binary, with some extras that'll get dropped.
        U      Reverse each diagonal.
         Ḅ     Convert each diagonal from binary to a number.
          ḣ    Take the first n numbers.

La transposition est le moyen le plus simple de remplir le tableau pour que les diagonales intégrées fonctionnent. Ensuite, les revers sont ajoutés pour tout remettre dans le bon ordre.

JavaScript (ES6), 53 octets

n=>[...Array(n)].map(g=(j=1,i)=>j>i?0:j&i|g(j+j,i+1))

0 indexé. Ce n'est pas souvent que j'arrive à utiliser une fonction récursive comme paramètre map.

Mathematica, 46 octets

Plus@@@Table[BitAnd[n+k,2^k],{n,0,#},{k,0,n}]&

Fonction sans nom prenant un entier non négatif #en entrée et renvoyant la séquence d'index 0 jusqu'au #terme. Construit les nombres binaires en pente en utilisant BitAnd(bit à bit "et") avec les puissances appropriées de 2.

Python3, 63 61 octets

lambda i:[sum(n+k&2**k for k in range(n+1))for n in range(i)]

Utilise la formule d'OEIS.

-2 octets grâce à Luis Mendo ! i+1->i

PHP, 68 octets

for(;$n++<$argv[1];print$s._)for($s=$i=0;$i<$n;)$s|=$n+$i-1&1<<$i++;

prend l'entrée de l'argument de la ligne de commande, imprime les nombres séparés par des traits de soulignement. Courez avec -r.

MATL , 18 17 octets

:q"@tt:+5MW\~fWs+

Essayez-le en ligne!

Il utilise la formule d'OEIS:

a(n) = n + Sum_{ k in [1 2... n] such that n + k == 0 mod 2^k } 2^k

Code:

:q"     % For k in [0 1 2 ...n-1], where n is implicit input
  @     %   Push k
  tt    %   Push two copies
  :     %   Range [1 2 ... k]
  +     %   Add. Gives [n+1 n+2 ... n+k]
  5M    %   Push [1 2... k] again
  W     %   2 raised to that
  \     %   Modulo
  ~f    %   Indices of zero entries
  W     %   2 raised to that
  s     %   Sum of array
  +     %   Add
        % End implicitly. Display implicitly

Perl 6 , 59 43 octets

{map ->\n{n+sum map {2**$_ if 0==(n+$_)%(2**$_)},1..n},^$_}

{map {sum map {($_+$^k)+&2**$k},0..$_},^$_}

Utilise la formule de la page OESIS.
Mise à jour: Passé à la formule au niveau du bit et basée sur la réponse Python de TuukkaX .

Perl 6 , 67 octets

{map {:2(flip [~] map {.base(2).flip.comb[$++]//""},$_..2*$_)},^$_}

Solution naïve.
Convertit les nombres faisant partie de la diagonale en base 2, prend le chiffre correct de chacun et reconvertit le résultat en base 10.

Gelée , 15 octets

2*ḍ+
ḶçЀḶUḄ+Ḷ’

Ce serait plus court que l'autre réponse Jelly si nous devions imprimer uniquement le n ^ème terme.

Essayez-le en ligne!

R, 66 octets

function(n,k=0:length(miscFuncs::bin(n-1)))sum(bitwAnd(k+n-1,2^k))

Fonction sans nom qui utilise la binfonction du miscFuncspackage pour calculer la longueur de nreprésentée en binaire, puis en utilisant l'une des formules OEIS.