Contribution:

Nous prenons deux entrées:

• Une entrée bavec deux valeurs distinctes: Leftet Right. †
• Et un entier positif n.

Production:

Sur la base de l'entrée gauche / droite, nous générons l'une des deux séquences suivantes dans la plage de 1-n(dans les séquences ci-dessous, les 125 premiers éléments sont affichés):

Left:
1, 6, 7, 56, 57, 62, 63, 960, 961, 966, 967, 1016, 1017, 1022, 1023, 31744, 31745, 31750, 31751, 31800, 31801, 31806, 31807, 32704, 32705, 32710, 32711, 32760, 32761, 32766, 32767, 2064384, 2064385, 2064390, 2064391, 2064440, 2064441, 2064446, 2064447, 2065344, 2065345, 2065350, 2065351, 2065400, 2065401, 2065406, 2065407, 2096128, 2096129, 2096134, 2096135, 2096184, 2096185, 2096190, 2096191, 2097088, 2097089, 2097094, 2097095, 2097144, 2097145, 2097150, 2097151, 266338304, 266338305, 266338310, 266338311, 266338360, 266338361, 266338366, 266338367, 266339264, 266339265, 266339270, 266339271, 266339320, 266339321, 266339326, 266339327, 266370048, 266370049, 266370054, 266370055, 266370104, 266370105, 266370110, 266370111, 266371008, 266371009, 266371014, 266371015, 266371064, 266371065, 266371070, 266371071, 268402688, 268402689, 268402694, 268402695, 268402744, 268402745, 268402750, 268402751, 268403648, 268403649, 268403654, 268403655, 268403704, 268403705, 268403710, 268403711, 268434432, 268434433, 268434438, 268434439, 268434488, 268434489, 268434494, 268434495, 268435392, 268435393, 268435398, 268435399, 268435448, 268435449

Right:
1, 4, 7, 32, 39, 56, 63, 512, 527, 624, 639, 896, 911, 1008, 1023, 16384, 16415, 16864, 16895, 19968, 19999, 20448, 20479, 28672, 28703, 29152, 29183, 32256, 32287, 32736, 32767, 1048576, 1048639, 1050560, 1050623, 1079296, 1079359, 1081280, 1081343, 1277952, 1278015, 1279936, 1279999, 1308672, 1308735, 1310656, 1310719, 1835008, 1835071, 1836992, 1837055, 1865728, 1865791, 1867712, 1867775, 2064384, 2064447, 2066368, 2066431, 2095104, 2095167, 2097088, 2097151, 134217728, 134217855, 134225792, 134225919, 134471680, 134471807, 134479744, 134479871, 138149888, 138150015, 138157952, 138158079, 138403840, 138403967, 138411904, 138412031, 163577856, 163577983, 163585920, 163586047, 163831808, 163831935, 163839872, 163839999, 167510016, 167510143, 167518080, 167518207, 167763968, 167764095, 167772032, 167772159, 234881024, 234881151, 234889088, 234889215, 235134976, 235135103, 235143040, 235143167, 238813184, 238813311, 238821248, 238821375, 239067136, 239067263, 239075200, 239075327, 264241152, 264241279, 264249216, 264249343, 264495104, 264495231, 264503168, 264503295, 268173312, 268173439, 268181376, 268181503, 268427264, 268427391

Comment ces séquences sont-elles générées, demandez-vous?

Une séquence par défaut de 1 à n=10serait:

As integer:
1, 2, 3, 4, 5, 6, 7, 8, 9, 10

As binary:
1 10 11 100 101 110 111 1000 1001 1010

Lorsque nous nous étendons à gauche, le binaire deviendra ceci:

1, 110, 111, 111000, 111001, 111110, 111111, 1111000000, 1111000001, 1111000110

Pourquoi? Le dernier bit est utilisé une fois; le dernier est utilisé deux fois; l'avant-dernier est utilisé trois fois; etc.

So `1010` will become (spaces added as clarification): `1111 000 11 0`

Et ces nouvelles chaînes binaires étirées à gauche sont reconverties en entiers:

1, 6, 7, 56, 57, 62, 63, 960, 961, 966

Quant à l'étiré à droite, le premier bit est utilisé une fois; deuxième deux fois; troisième trois fois; etc. Comme ceci:

As binary:
1, 100, 111, 100000, 100111, 111000, 111111, 1000000000, 1000001111, 1001110000

As integer:
1, 4, 7, 32, 39, 56, 63, 512, 527, 624

Règles du défi:

• † Vous pouvez prendre deux valeurs distinctes, mais indiquez celle que vous utilisez. Il peut donc être 1/0, true/false, null/undefined, "left"/"right", etc.
• n est toujours supérieur à 0.
• Vous devez prendre en charge une sortie maximale d'au moins l'entier par défaut de votre langue (qui est de 32 bits pour la plupart des langues).
• Le format de sortie est flexible. Peut être imprimé ou retourné sous forme de tableau / liste. Peut être avec un espace, une virgule, un tuyau et similaire comme délimiteur. Ton appel. (Encore une fois, veuillez indiquer ce que vous avez utilisé.)

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

Gelée , 9 octets

BmxJ$mḄð€

Essayez-le en ligne!

-1pour gauche, 1pour droite.

Python 2 , 102 96 octets

lambda d,n:[int(''.join(c*-~i for i,c in enumerate(bin(x+1)[2:][::d]))[::d],2)for x in range(n)]

-1 pour gauche, 1 pour droite

Essayez-le en ligne!

05AB1E , 14 13 octets

1 octet enregistré grâce à Erik l'Outgolfer

LbεIiRƶRëƶ}JC

1 pour gauche.
0(ou toute autre chose) pour raison.

Essayez-le en ligne!

Explication

L                # push range [1 ... first_input]
 b               # convert to binary
  ε              # apply to each
   Ii            # if second_input is true
     RƶR         # reverse, multiply each element with its 1-based index and reverse again
        ëƶ       # else, multiply each element with its 1-based index
          }      # end if
           J     # join
            C    # convert to base-10

Husk , 13 octets

mȯḋṠṘo?ḣṫ⁰Lḋḣ

Ça fait beaucoup de lettres en pointillés ...

Prend d'abord b( 0pour gauche et 1pour droite), puis n. Essayez-le en ligne!

Explication

mȯḋṠṘo?ḣṫ⁰Lḋḣ  Inputs b=1 and n=5 (implicit).
            ḣ  Range to n: [1,2,3,4,5]
mȯ             Map function over the range:
                 Argument: number k=5
           ḋ     Binary digits: [1,0,1]
   ṠṘ            Repeat each digit with respect to the list
     o    L      obtained by applying to the length (3) the function
      ?  ⁰       if b is truthy
       ḣ         then increasing range: [1,2,3]
        ṫ        else decreasing range: [3,2,1].
                 We get [1,0,0,1,1,1].
  ḋ              Convert back to integer: 39
               Final result [1,4,7,32,39], implicitly print.

Japt , 19 18 17 octets

0pour "gauche", 1pour "droite". (Cela peut en fait prendre n'importe quelle valeur de falsey ou de vérité à la place de ces 2.)

õȤËpV©EĪEnFlÃn2

Essaye-le

Explication

Saisie implicite d'entiers U& V.

õ

Créez un tableau d'entiers de 1 à Uinclus.

È

Passez chacun par une fonction.

¤

Convertir l'entier courant en une chaîne binaire

Ë           Ã

Mappez sur la chaîne, en passant chaque caractère dans une fonction, où Eest l'index actuel et Fla chaîne complète.

p

Répéter le caractère actuel

V©  ª

©est un ET logique ( &&) et un ªOU logique ||, donc ici nous Vvérifions si est véridique (non nul) ou non.

YÄ

Si Vest véridique, cela Xse répète Y+1.

YnZl

Si Vis falsey est alors Xrépété Ysoustrait de ( n) la longueur ( l) de Zfois.

n2

Revenez à un entier de base 10.

Sortie implicite du tableau résultant.

Gaia , 15 octets

⟪¤bw¦¤;ċ%׆_b⟫¦

Utilise -1pour gauche et 1pour droite.

Essayez-le en ligne!

Explication

⟪¤bw¦¤;ċ%׆_b⟫¦  Map this block over the range 1..n, with direction as an extra parameter:
 ¤                Swap, bring current number to the top
  b               List of binary digits
   w¦             Wrap each in a list
     ¤            Bring direction to the top
      ;ċ          Push the range 1..len(binary digts)
        %         Select every direction-th element of it (-1 reverses, 1 does nothing)
         ׆       Element-wise repetition
           _      Flatten
            b     Convert from binary to decimal

Proton , 79 octets

n=>d=>[int(''.join(b[x]*[l-x,x-1][d]for x:2..(l=len(b=bin(i)))),2)for i:1..n+1]

0est à gauche, à 1droite.

Essayez-le en ligne!

Non golfé

f=n=>d=>                        # Curried function
[                               # Collect the results in a list
 int(                           # Convert from a binary string to an int:
  ''.join(                       # Join together
   b[x]                           # Each character of the binary string of n
   *[l-x,x-1][d]                  # Repeated by its index or its index from the end, depending on d
   for x:2..(l=len(b=bin(i))))    
 ,2)
 for i:1..n+1                   # Do this for everything from 1 to n inclusive
]

C # (.NET Core) , 192 187 + 23 octets

-5 octets grâce à TheLethalCoder

b=>n=>new int[n].Select((_,a)=>{var g=Convert.ToString(a+1,2);return(long)g.Reverse().SelectMany((x,i)=>Enumerable.Repeat(x,b?i+1:g.Length-i)).Select((x,i)=>x>48?Math.Pow(2,i):0).Sum();})

Le nombre d'octets comprend également:

namespace System.Linq{}

Essayez-le en ligne!

Entrée: leftest true, rightestfalse

Explication:

b => n =>                                   // Take two inputs (bool and int)
    new int[n].Select((_, a) => {           // Create new collection the size of n
        var g = Convert.ToString(a + 1, 2); // Take every number in sequence 1..n and convert to base 2 (in a string)
        return (long)g.Reverse()            // Reverse the bits
               .SelectMany((x, i) =>        // Replace every bit with a collection of its repeats, then flatten the result
                   Enumerable.Repeat(x, b ? i + 1 : g.Length - i))
               .Select((x, i) => x > 48 ? Math.Pow(2, i) : 0)
               .Sum();                      // Replace every bit with a corresponding power of 2, then sum
    })

Dyalog APL, 23 octets

{2⊥b/⍨⌽⍣⍺⍳≢b←2⊥⍣¯1⊢⍵}¨⍳

left is 1right is 0(passé comme argument gauche de la fonction)

⍳ est générateur d'index

{... }¨appliquer la fonction entre accolades à chaque élément à droite

b←2⊥⍣¯1⊢⍵b est ⍵ codé en binaire (en utilisant l'inverse de décoder pour obtenir le nombre minimum de bits requis pour représenter ⍵dans la base 2)

⍳≢bgénérer des index pour le vecteur b ( ≢best la longueur de b)

⌽⍣⍺⍺temps inverse (utilisé conditionnellement ici pour l'étirement gauche ou droit)

b/⍨ b répliqué par (réplique les bits selon l'index (inverse))

2⊥ décoder à partir de la base 2

TryAPL en ligne

JavaScript (ES6), 131 octets

C'est beaucoup plus long que la réponse de Shaggy , mais je voulais essayer une approche purement au niveau du bit.

En raison de la limite 32 bits des opérations JS au niveau du bit, cela ne fonctionne que pour n <128 .

Prend une entrée dans la syntaxe de curry (n)(r), où r est faux pour gauche / vrai pour droite.

n=>r=>[...Array(n)].map((_,n)=>(z=n=>31-Math.clz32(n),g=n=>n&&(x=z(b=n&-n),r?2<<z(n)-x:b*2)-1<<x*(r?2*z(n)+3-x:x+1)/2|g(n^b))(n+1))

Formaté et commenté

n => r => [...Array(n)]       // given n and r
  .map((_, n) => (            // for each n in [0 .. n - 1]
    z = n =>                  //   z = helper function returning the
      31 - Math.clz32(n),     //       0-based position of the highest bit set
    g = n =>                  //   g = recursive function:
      n && (                  //     if n is not equal to 0:
        x = z(b = n & -n),    //       b = bitmask of lowest bit set / x = position of b
        r ?                   //       if direction = right:
          2 << z(n) - x       //         use 2 << z(n) - x
        :                     //       else:
          b * 2               //         use b * 2
      ) - 1                   //       get bitmask by subtracting 1
      << x * (                //       left-shift it by x multiplied by:
        r ?                   //         if direction = right:
          2 * z(n) + 3 - x    //           2 * z(n) + 3 - x
        :                     //         else:
          x + 1               //           x + 1
      ) / 2                   //       and divided by 2
      | g(n ^ b)              //     recursive call with n XOR b
    )(n + 1)                  //   initial call to g() with n + 1
  )                           // end of map()

Démo

let f =

n=>r=>[...Array(n)].map((_,n)=>(z=n=>31-Math.clz32(n),g=n=>n&&(x=z(b=n&-n),r?2<<z(n)-x:b*2)-1<<x*(r?2*z(n)+3-x:x+1)/2|g(n^b))(n+1))

console.log(JSON.stringify(f(10)(false)))
console.log(JSON.stringify(f(10)(true)))

JavaScript (ES6), 113 octets

Oh, c'est beaucoup trop long! C'est ce qui se passe lorsque vous passez la journée à écrire du "vrai" JavaScript, des enfants; vous oubliez comment jouer au golf correctement!

Utilise toutes les valeurs véridiques ou falsey pour b, avec falseêtre "gauche" et trueêtre "droite".

n=>b=>[...Array(n)].map(_=>eval("0b"+[...s=(++e).toString(2)].map((x,y)=>x.repeat(b?++y:s.length-y)).join``),e=0)

Essayez-le

o.innerText=(f=
n=>b=>[...Array(n)].map(_=>eval("0b"+[...s=(++e).toString(2)].map((x,y)=>x.repeat(b?++y:s.length-y)).join``),e=0)
)(i.value=10)(j.value=1);oninput=_=>o.innerText=f(+i.value)(+j.value)

label,input{font-family:sans-serif;font-size:14px;height:20px;line-height:20px;vertical-align:middle}input{margin:0 5px 0 0;width:100px;}

<label for=i>Size: </label><input id=i type=number><label for=j>Direction: </label><input id=j min=0 max=1 type=number><pre id=o>

Gelée , 11 octets

B€xJṚ⁹¡$$€Ḅ

Essayez-le en ligne!

Argument # 1: n
Argument # 2: 1pour la gauche, 0pour la droite.

Rétine , 111 octets

\d+
$*
1
$`1¶
+`(1+)\1
${1}0
01
1
.
$.%`$*R$&$.%'$*L
+s`(R?)(\d)(L?)(.*¶\1\3)$
$2$2$4
¶*[RL]

1
01
+`10
011
%`1

Essayez-le en ligne! Prend le nombre et soit Lou Rcomme suffixe (ou sur une ligne distincte). Explication:

\d+
$*
1
$`1¶

Convertissez de décimal en unaire et comptez de 1 à n.

+`(1+)\1
${1}0
01
1

Conversion d'unaire en binaire.

.
$.%`$*R$&$.%'$*L

Enveloppez chaque bit Ret les Lcaractères en fonction de sa position dans la ligne.

+s`(R?)(\d)(L?)(.*¶\1\3)$
$2$2$4

Remplacez le Rou les Lcaractères appropriés par le chiffre adjacent approprié.

¶*[RL]

1
01
+`10
011
%`1

Supprimez les caractères restants et convertissez du binaire en décimal.

JavaScript (ES6), 130 127 octets

3 octets, merci Kevin

Je ne connais pas assez ES6 pour ce site, mais j'ai essayé! Parcourez chaque nombre et parcourez chaque représentation binaire pour ce nombre, en répétant chaque caractère autant de fois que nécessaire.

d=>n=>{i=0;while(i++<n){b=i.toString(2),s="",k=-1,l=b.length;while(++k<l)s+=b[k].repeat(d?k+1:l-k);console.log(parseInt(s,2))}}

f=d=>n=>{i=0;while(i++<n){b=i.toString(2),s="",k=-1,l=b.length;while(++k<l)s+=b[k].repeat(d?k+1:l-k);console.log(parseInt(s,2))}}
f(1)(10)
f(0)(10)

Rubis, 98 octets

->n,r{t=->a{r ?a:a.reverse};(1..n).map{|k|i=0;t[t[k.to_s(2).chars].map{|d|d*(i+=1)}].join.to_i 2}}

Java 8, 136 octets

Lambda (curry) de Booleanà un consommateur de Integer. Le paramètre booléen indique s'il faut étirer à gauche (valeurs true, false). La sortie est imprimée en sortie standard, séparée par des retours à la ligne, avec un retour à la ligne de fin.

l->n->{for(int i=0,o,c,d,s=0;i++<n;System.out.println(o)){while(i>>s>0)s++;for(o=c=0;c++<s;)for(d=0;d++<(l?s-c+1:c);o|=i>>s-c&1)o<<=1;}}

Lambda non golfé

l ->
    n -> {
        for (
            int i = 0, o, c, d, s = 0;
            i++ < n;
            System.out.println(o)
        ) {
            while (i >> s > 0)
                s++;
            for (o = c = 0; c++ < s; )
                for (
                    d = 0;
                    d++ < (l ? s - c + 1 : c);
                    o |= i >> s - c & 1
                )
                    o <<= 1;
        }
    }

Essayez-le en ligne

Limites

Parce qu'elles sont accumulées en ints, les sorties sont limitées à 31 bits. Par conséquent, les entrées sont limitées à 7 bits, donc l'entrée maximale prise en charge par le programme est 127.

Explication

Cette solution crée chaque nombre étiré à l'aide d'opérations au niveau du bit. La boucle extérieure parcourt iles nombres à étirer, de 1 à n , et imprime la valeur étirée après chaque itération.

La whileboucle interne incrémente sle nombre de bits dans iet les foritérations suivantes csur chaque position de bit. Dans cette boucle, dcompte jusqu'au nombre de fois pour répéter le bit actuel, qui dépend de l'entrée l. À chaque étape, oest décalé vers la gauche et le bit approprié iest masqué et OU inséré.