Entrada:

Tomamos dos entradas:

• Una entrada bcon dos valores distintos: Lefty Right. †
• Y un entero positivo n.

Salida:

Según la entrada izquierda / derecha, mostramos cualquiera de las siguientes dos secuencias en el rango de 1-n(en las secuencias a continuación se muestran los primeros 125 elementos):

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

¿Cómo se generan estas secuencias, preguntas?

Una secuencia predeterminada de 1 a través n=10sería:

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

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

Cuando nos estiramos a la izquierda, el binario se convertirá en esto:

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

¿Por qué? El último bit se usa una vez; el single-last se usa dos veces; el penúltimo se usa tres veces; etc.

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

Y estas nuevas cadenas binarias estiradas a la izquierda se convierten de nuevo a enteros:

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

En cuanto a la derecha extendida, el primer bit se usa una vez; segundo dos veces; tercero tres veces; etc. Así:

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

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

Reglas de desafío:

• † Puede tomar dos valores distintos, pero indique cuál usa. Así que puede ser 1/0, true/false, null/undefined, "left"/"right", etc.
• n siempre es mayor que 0.
• Debe admitir una salida máxima de al menos el entero predeterminado de su idioma (que es de 32 bits para la mayoría de los idiomas).
• El formato de salida es flexible. Se puede imprimir o devolver como matriz / lista. Puede ser con un espacio, una coma, una tubería y similares como delimitadores. Tu llamada. (Nuevamente, indique lo que ha usado).

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

Jalea , 9 bytes

BmxJ$mḄð€

Pruébalo en línea!

-1por izquierda, 1por derecha.

Python 2 , 102 96 bytes

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 para la izquierda, 1 para la derecha

Pruébalo en línea!

05AB1E , 14 13 bytes

Guardado 1 byte gracias a Erik the Outgolfer

LbεIiRƶRëƶ}JC

1por izquierda
0(o cualquier otra cosa) por derecho.

Pruébalo en línea!

Explicación

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

Casco , 13 bytes

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

Son muchas letras punteadas ...

Toma primero b( 0para la izquierda y 1para la derecha), luego n. Pruébalo en línea!

Explicación

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 bytes

0para "izquierda", 1para "derecha". (En realidad, puede tomar cualquier valor falso o verdadero en lugar de esos 2.)

õȤËpV©EĪEnFlÃn2

Pruébalo

Explicación

Entrada implícita de enteros Uy V.

õ

Cree una matriz de enteros de 1 a U, inclusive.

È

Pase cada uno a través de una función.

¤

Convierte el entero actual en una cadena binaria

Ë           Ã

Asigne sobre la cadena, pasando cada carácter a través de una función, donde Eestá el índice actual y Fes la cadena completa.

p

Repite el personaje actual

V©  ª

©es lógico AND ( &&) yª es lógico OR ||, así que aquí estamos comprobando si Ves verdadero (no cero) o no.

YÄ

Si V es verdad, entonces Xse repite Y+1veces.

YnZl

Si Ves falsey, entonces Xse repite Ysustraído de (n ) la longitud ( l) de Zveces.

n2

Convertir de nuevo a un entero de base 10.

Salida implícita de la matriz resultante.

Gaia , 15 bytes

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

Usos -1para izquierda y 1para derecha.

Pruébalo en línea!

Explicación

⟪¤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

Protón , 79 bytes

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á a la izquierda, 1está a la derecha.

Pruébalo en línea!

Sin 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 bytes

-5 bytes gracias a 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();})

El recuento de bytes también incluye:

namespace System.Linq{}

Pruébalo en línea!

Entrada: leftes true, rightesfalse

Explicación:

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 bytes

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

left is 1right is 0(se pasa como argumento izquierdo de la función)

⍳ es generador de índice

{... }¨aplica la función entre llaves a cada elemento de la derecha

b←2⊥⍣¯1⊢⍵b está codificado como binario (usando el inverso de decodificación para obtener el número mínimo de bits necesarios para representar ⍵en la base 2)

⍳≢bgenerar índices para el vector b ( ≢bes la longitud de b)

⌽⍣⍺ marcha atrás ⍺tiempos (usados ​​condicionalmente aquí para estiramiento izquierdo o derecho)

b/⍨ b replicado por (replica los bits según el índice (inverso))

2⊥ decodificar desde la base 2

TryAPL en línea

JavaScript (ES6), 131 bytes

Esto es significativamente más largo que la respuesta de Shaggy , pero quería probar un enfoque puramente bit a bit.

Debido al límite de 32 bits de las operaciones JS bitwise, esto funciona solo para n <128 .

Toma entrada en la sintaxis de curry (n)(r), donde r es falso para izquierda / verdad para derecha.

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

Formateado y comentado

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

Manifestación

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 bytes

¡Oh, esto es demasiado tiempo! Esto es lo que sucede cuando pasas el día escribiendo JavaScript "real", niños; te olvidas de jugar al golf correctamente!

Usos cualquier valor o Truthy Falsey para b, con falseser "izquierda" y true"tener razón".

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

Intentalo

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>

Jalea , 11 bytes

B€xJṚ⁹¡$$€Ḅ

Pruébalo en línea!

Argumento # 1: n
Argumento # 2: 1para la izquierda, 0para la derecha.

Retina , 111 bytes

\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

Pruébalo en línea! Toma el número y, o bien Lo Rcomo un sufijo (o en una línea separada). Explicación:

\d+
$*
1
$`1¶

Convierte de decimal a unario y cuenta de 1 a n.

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

Convierte de unario a binario.

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

Envuelva cada bit Ry Lcaracteres de acuerdo con su posición en la línea.

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

Reemplazar el relevante R o Lcaracteres con el dígito adyacente apropiado.

¶*[RL]

1
01
+`10
011
%`1

Elimine los caracteres sobrantes y conviértalos de binario a decimal.

JavaScript (ES6), 130 127 bytes

3 bytes, gracias Kevin

Seguro que no conozco suficiente ES6 para este sitio, ¡pero lo intenté! Recorre cada número y recorre cada representación binaria para ese número, repitiendo cada carácter cuantas veces sea necesario.

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)

Ruby, 98 bytes

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

Lambda (curry) de Booleana un consumidor de Integer. El parámetro booleano indica si estirar a la izquierda (valores true,false ). La salida se imprime en salida estándar, separada por nuevas líneas, con una nueva línea final.

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

Pruébalo en línea

Límites

Porque se acumulan en int s, las salidas están limitadas a 31 bits. Como resultado, las entradas están limitadas a 7 bits, por lo que la entrada máxima que admite el programa es 127.

Explicación

Esta solución acumula cada número estirado utilizando operaciones bit a bit. El bucle externo itera isobre los números a estirar, de 1 a n , e imprime el valor estirado después de cada iteración.

El whilebucle interno se incrementa sal número de bits iy el siguiente foritera csobre cada posición de bit. Dentro de ese ciclo, dcuenta hasta el número de veces que se repite el bit actual, que depende de la entrada l. En cada paso, ose desplaza hacia la izquierda y ise enmascara el bit apropiado y se introduce OR.