Đầu vào:

Chúng tôi có hai đầu vào:

• Một đầu vào bcó hai giá trị riêng biệt: Leftvà Right. †
• Và một số nguyên dương n.

Đầu ra:

Dựa trên đầu vào Trái / Phải, chúng tôi xuất một trong hai chuỗi sau trong phạm vi 1-n(trong các chuỗi bên dưới 125 mục đầu tiên được hiển thị):

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

Làm thế nào là những chuỗi được tạo ra bạn yêu cầu?

Chuỗi mặc định từ 1 đến n=10sẽ là:

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

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

Khi chúng ta kéo dài sang trái, nhị phân sẽ trở thành thế này:

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

Tại sao? Bit cuối cùng được sử dụng một lần; đơn cuối cùng được sử dụng hai lần; lần thứ hai được sử dụng ba lần; Vân vân.

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

Và các chuỗi nhị phân kéo dài bên trái mới này được chuyển đổi trở lại thành số nguyên:

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

Đối với kéo dài bên phải, bit đầu tiên được sử dụng một lần; lần thứ hai; ba lần ba; vv Như thế này:

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

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

Quy tắc thử thách:

• † Bạn có thể lấy bất kỳ hai giá trị khác biệt, nhưng nhà nước mà bạn sử dụng. Vì vậy, nó có thể được 1/0, true/false, null/undefined, "left"/"right"vv
• n luôn lớn hơn 0.
• Bạn nên hỗ trợ đầu ra tối đa ít nhất là số nguyên mặc định của ngôn ngữ của bạn (là 32 bit cho hầu hết các ngôn ngữ).
• Định dạng đầu ra là linh hoạt. Có thể được in hoặc trả lại dưới dạng mảng / danh sách. Có thể với một dấu cách, dấu phẩy, đường ống và giống nhau như dấu phân cách. Cuộc gọi của bạn. (Một lần nữa, vui lòng cho biết những gì bạn đã sử dụng.)

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn.
• Ngoài ra, xin vui lòng thêm một lời giải thích nếu cần thiết.

Thạch , 9 byte

BmxJ$mḄð€

Hãy thử trực tuyến!

-1cho trái, 1phải

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 cho trái, 1 cho phải

Hãy thử trực tuyến!

05AB1E , 14 13 byte

Đã lưu 1 byte nhờ Erik the Outgolfer

LbεIiRƶRëƶ}JC

1cho trái
0(hoặc bất cứ điều gì khác) cho đúng.

Hãy thử trực tuyến!

Giải trình

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 byte

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

Đó là rất nhiều chữ rải rác ...

Mất đầu tiên b( 0cho trái và 1phải), sau đó n. Hãy thử trực tuyến!

Giải trình

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 byte

0cho "trái", 1cho "phải". (Nó thực sự có thể lấy bất kỳ giá trị falsey hoặc giá trị trung thực nào thay cho 2.)

õȤËpV©EĪEnFlÃn2

Kiểm tra nó

Giải trình

Đầu vào ngầm định của số nguyên U& V.

õ

Tạo một mảng các số nguyên từ 1 đến U, bao gồm.

È

Truyền qua mỗi chức năng.

¤

Chuyển đổi số nguyên hiện tại thành một chuỗi nhị phân

Ë           Ã

Ánh xạ qua chuỗi, chuyển từng ký tự qua một hàm, trong đó Elà chỉ mục hiện tại và Flà chuỗi đầy đủ.

p

Lặp lại ký tự hiện tại

V©  ª

©là logic AND ( &&) và ªlà logic HOẶC ||, vì vậy ở đây chúng tôi đang kiểm tra xem Vcó trung thực (khác không) hay không.

YÄ

Nếu Vlà sự thật thì Xđược lặp đi lặp lại nhiều Y+1lần.

YnZl

Nếu Vlà falsey thì Xđược lặp lại Ytrừ đi ( n) độ dài ( l) của Zthời gian.

n2

Chuyển đổi trở lại một số nguyên 10 cơ sở.

Ngẫu nhiên mảng kết quả đầu ra.

Gaia , 15 byte

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

Sử dụng -1cho trái và 1phải.

Hãy thử trực tuyến!

Giải trình

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

0là trái, 1là phải

Hãy thử trực tuyến!

Ung dung

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 nhờ 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();})

Số lượng byte cũng bao gồm:

namespace System.Linq{}

Hãy thử trực tuyến!

Đầu vào: leftlà true, rightlàfalse

Giải trình:

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

APL Dyalog, 23 byte

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

bên trái là 1bên phải 0(được truyền vào dưới dạng đối số bên trái của hàm)

⍳ là trình tạo chỉ mục

{... }¨áp dụng chức năng trong niềng răng cho từng mục bên phải

b←2⊥⍣¯1⊢⍵b được mã hóa dưới dạng nhị phân (sử dụng nghịch đảo giải mã để lấy số bit tối thiểu cần thiết để biểu diễn ⍵trong cơ sở 2)

⍳≢btạo chỉ mục cho vectơ b ( ≢blà độ dài của b)

⌽⍣⍺⍺thời gian đảo ngược (được sử dụng có điều kiện ở đây để kéo dài trái hoặc phải)

b/⍨ b được sao chép bởi (sao chép các bit theo chỉ số (đảo ngược)

2⊥ giải mã từ cơ sở 2

Dùng thử trực tuyến

JavaScript (ES6), 131 byte

Điều này dài hơn đáng kể so với câu trả lời của Shaggy , nhưng tôi muốn thử một cách tiếp cận hoàn toàn theo bitwise.

Do giới hạn 32 bit của các hoạt động bit bit của JS, điều này chỉ hoạt động với n <128 .

Đưa đầu vào theo cú pháp currying (n)(r), trong đó r là sai cho trái / trung thực cho phải.

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

Định dạng và nhận xét

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

Bản giới thiệu

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

Ồ, điều này chỉ là quá dài! Đây là những gì xảy ra khi bạn dành cả ngày để viết JavaScript "thực", những đứa trẻ; bạn quên cách chơi golf đúng cách!

Sử dụng bất kỳ giá trị trung thực hoặc falsey cho b, với false"trái" và true"phải".

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

Thử nó

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>

Thạch , 11 byte

B€xJṚ⁹¡$$€Ḅ

Hãy thử trực tuyến!

Đối số # 1: n
Đối số 2: 1bên trái, 0bên phải.

Võng mạc , 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

Hãy thử trực tuyến! Lấy số và Lhoặc Rlà hậu tố (hoặc trên một dòng riêng). Giải trình:

\d+
$*
1
$`1¶

Chuyển đổi từ số thập phân sang đơn nguyên và đếm từ 1 đến n.

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

Chuyển đổi từ unary sang nhị phân.

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

Gói từng bit vào RvàL ký tự theo vị trí của nó trong dòng.

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

Thay thế các ký tự Rhoặc Lký tự bằng chữ số liền kề thích hợp.

¶*[RL]

1
01
+`10
011
%`1

Xóa các ký tự thừa và chuyển đổi từ nhị phân sang thập phân.

JavaScript (ES6), 130 127 byte

3 byte, cảm ơn Kevin

Tôi chắc chắn không biết đủ ES6 cho trang web này, nhưng tôi đã thử! Lặp qua từng số và lặp qua từng biểu diễn nhị phân cho số đó, lặp lại từng ký tự tuy nhiên cần nhiều lần.

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 (bị chế giễu) từ Booleanmột người tiêu dùng Integer. Tham số boolean cho biết có kéo dài sang trái (giá trị true, false). Đầu ra được in ra theo tiêu chuẩn, được phân tách bằng các dòng mới, với một dòng mới.

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

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

Dùng thử trực tuyến

Hạn mức

Bởi vì chúng được tích lũy trong ints, đầu ra bị giới hạn ở 31 bit. Do đó, các đầu vào bị giới hạn ở 7 bit, do đó, đầu vào tối đa mà chương trình hỗ trợ là 127.

Giải trình

Giải pháp này xây dựng từng số kéo dài bằng các thao tác bitwise. Vòng lặp bên ngoài lặp lại iqua các số được kéo dài, từ 1 đến n và in giá trị kéo dài sau mỗi lần lặp.

whileVòng lặp bên trong tăng stheo số bit trong ivà các lần forlặp tiếp theo lặp lại cqua từng vị trí bit. Trong vòng lặp đó, dtính đến số lần lặp lại bit hiện tại, tùy thuộc vào đầu vào l. Ở mỗi bước, ođược dịch chuyển sang trái và bit thích hợp iđược che đi và OR'd in.