Memasukkan:

Kami mengambil dua input:

• Input bdengan dua nilai berbeda: Leftdan Right. †
• Dan bilangan bulat positif n.

Keluaran:

Berdasarkan input Kiri / Kanan, kami menampilkan salah satu dari dua urutan berikut dalam kisaran 1-n(dalam urutan di bawah 125 item pertama ditampilkan):

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

Bagaimana urutan ini dihasilkan Anda bertanya?

Urutan default dari 1 hingga n=10adalah:

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

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

Ketika kita meregang ke kiri, biner akan menjadi ini:

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

Mengapa? Bit terakhir digunakan satu kali; yang terakhir digunakan dua kali; yang kedua terakhir digunakan tiga kali; dll.

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

Dan string biner kiri baru ini diubah kembali menjadi bilangan bulat:

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

Sedangkan untuk stretched right, bit pertama digunakan sekali; kedua dua kali; ketiga tiga kali; dll. Seperti ini:

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

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

Aturan tantangan:

• † Anda dapat mengambil dua nilai berbeda, tetapi nyatakan mana yang Anda gunakan. Jadi bisa 1/0, true/false, null/undefined, "left"/"right", dll
• n selalu lebih besar dari 0.
• Anda harus mendukung output maksimum setidaknya integer default bahasa Anda (yang 32-bit untuk sebagian besar bahasa).
• Format output fleksibel. Dapat dicetak atau dikembalikan sebagai array / daftar. Dapat dengan spasi, koma, pipa, dan sama sebagai pembatas. Panggilanmu. (Sekali lagi, sebutkan apa yang telah Anda gunakan.)

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa non-codegolf. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa saja'.
• Aturan standar berlaku untuk jawaban Anda, jadi Anda diperbolehkan menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat dan tipe pengembalian, program lengkap. Panggilanmu.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda.
• Juga, silakan tambahkan penjelasan jika perlu.

Jelly , 9 byte

BmxJ$mḄð€

Cobalah online!

-1untuk kiri, 1kanan.

Python 2 , 102 96 byte

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 untuk kiri, 1 untuk kanan

Cobalah online!

05AB1E , 14 13 byte

Disimpan 1 byte berkat Erik the Outgolfer

LbεIiRƶRëƶ}JC

1untuk kiri.
0(atau apa pun) untuk benar.

Cobalah online!

Penjelasan

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

Sekam , 13 byte

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

Itu banyak surat bertitik ...

Diambil pertama b( 0untuk kiri dan 1kanan), lalu n. Cobalah online!

Penjelasan

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

0untuk "kiri", 1untuk "kanan". (Ini benar-benar dapat mengambil nilai-nilai falsey atau kebenaran di tempat mereka 2.)

õȤËpV©EĪEnFlÃn2

Menguji

Penjelasan

Input bilangan bulat implisit U& V.

õ

Buat array bilangan bulat dari 1 hingga Uinklusif.

È

Lewati setiap fungsi.

¤

Ubah integer saat ini menjadi string biner

Ë           Ã

Peta di atas string, melewati setiap karakter melalui fungsi, di mana Eindeks saat ini dan Fadalah string penuh.

p

Ulangi karakter saat ini

V©  ª

©logis AND ( &&) dan ªlogis OR ||, jadi di sini kami memeriksa apakah Vbenar (tidak nol) atau tidak.

YÄ

Jika Vbenar maka Xakan diulang Y+1kali.

YnZl

Jika Vfalsey maka Xdiulang Ydikurangi dari ( n) panjang ( l) Zkali.

n2

Konversi kembali ke basis 10 integer.

Secara implisit menampilkan array yang dihasilkan.

Gaia , 15 byte

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

Penggunaan -1untuk kiri dan 1kanan.

Cobalah online!

Penjelasan

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

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]

0kiri, 1benar.

Cobalah online!

Tidak disatukan

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 byte

-5 byte terima kasih kepada 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();})

Hitungan byte juga mencakup:

namespace System.Linq{}

Cobalah online!

Input: leftadalah true, rightadalahfalse

Penjelasan:

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 byte

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

kiri adalah 1kanan adalah 0(dilewatkan sebagai argumen fungsi kiri)

⍳ adalah generator indeks

{... }¨terapkan fungsi di kawat gigi untuk setiap item di sebelah kanan

b←2⊥⍣¯1⊢⍵b adalah ⍵ disandikan sebagai biner (menggunakan kebalikan dari decode untuk mendapatkan jumlah bit minimum yang diperlukan untuk mewakili ⍵dalam basis 2)

⍳≢bmenghasilkan indeks untuk vektor b ( ≢bpanjang b)

⌽⍣⍺⍺waktu mundur (digunakan secara kondisional untuk peregangan kiri atau kanan)

b/⍨ b direplikasi oleh (mereplikasi bit sesuai indeks (kebalikan))

2⊥ decode dari basis 2

TryAPL online

JavaScript (ES6), 131 byte

Ini jauh lebih lama dari jawaban Shaggy , tetapi saya ingin mencoba pendekatan bitwise murni.

Karena batas operasi bitwise JS 32 bit, ini hanya berfungsi untuk n <128 .

Mengambil input dalam sintaks currying (n)(r), di mana r adalah falsy untuk kiri / kebenaran untuk kanan.

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

Diformat dan dikomentari

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

Demo

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 byte

Oh, ini terlalu lama! Inilah yang terjadi ketika Anda menghabiskan hari menulis JavaScript "asli", kiddies; Anda lupa cara bermain golf dengan benar!

Gunakan nilai-nilai yang benar atau salah untuk b, dengan falsemenjadi "kiri" dan true"benar".

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

Cobalah

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>

Jelly , 11 byte

B€xJṚ⁹¡$$€Ḅ

Cobalah online!

Argumen # 1: n
Argumen # 2: 1untuk kiri, 0untuk kanan.

Retina , 111 byte

\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

Cobalah online! Mengambil nomor dan salah satu Latau Rsebagai sufiks (atau pada baris terpisah). Penjelasan:

\d+
$*
1
$`1¶

Konversi dari desimal ke unary dan hitung dari 1 ke n.

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

Konversi dari unary ke binary.

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

Bungkus setiap bit Rdan Lkarakter sesuai dengan posisinya di baris.

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

Ganti karakter yang relevan Ratau Ldengan angka berdekatan yang sesuai.

¶*[RL]

1
01
+`10
011
%`1

Hapus karakter sisa dan konversi dari biner ke desimal.

JavaScript (ES6), 130 127 byte

3 byte, terima kasih Kevin

Saya yakin tidak cukup tahu ES6 untuk situs ini, tetapi saya sudah mencoba! Loop melalui setiap angka, dan loop melalui setiap representasi biner untuk nomor itu, ulangi setiap karakter berapa kali dibutuhkan.

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 byte

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

Lambda (kari) dari Booleanke konsumen Integer. Parameter boolean menunjukkan apakah akan merentangkan ke kiri (nilaitrue , false). Output dicetak ke standar keluar, dipisahkan oleh baris baru, dengan baris tambahan tambahan.

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 yang tidak tersentuh

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

Cobalah secara Online

Batas

Karena semuanya terakumulasi int s, output dibatasi hingga 31 bit. Akibatnya, input dibatasi hingga 7 bit, sehingga input maksimum yang didukung program adalah 127.

Penjelasan

Solusi ini membangun setiap nomor yang diregangkan menggunakan operasi bitwise. Lingkaran luar berulang ipada angka yang akan diregangkan, dari 1 ke n , dan mencetak nilai yang diregangkan setelah setiap iterasi.

whileLingkaran dalam bertambah sdengan jumlah bit i, dan foriterasi berikutnya cpada setiap posisi bit. Dalam loop itu, dmenghitung hingga berapa kali untuk mengulangi bit saat ini, yang tergantung pada input l. Pada setiap langkah, obergeser ke kiri dan sedikit yang sesuai iditutup dan OR masuk.