การป้อนข้อมูล:

เรารับสองอินพุต:

• การป้อนข้อมูลbที่มีสองค่าที่แตกต่างกันและLeft †Right
• nและเป็นจำนวนเต็มบวก

เอาท์พุท:

ขึ้นอยู่กับอินพุตซ้าย / ขวาเราแสดงเอาต์พุตสองซีเควนต่อไปนี้ในช่วงของ1-n(ในลำดับด้านล่างที่แสดง 125 รายการแรก):

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

คุณสร้างลำดับเหล่านี้อย่างไร

ลำดับเริ่มต้นจาก 1 ถึงn=10จะเป็น:

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

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

เมื่อเรายืดซ้ายไบนารีจะกลายเป็นสิ่งนี้:

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

ทำไม? บิตสุดท้ายใช้ครั้งเดียว ใช้ครั้งเดียวครั้งสุดท้าย ครั้งที่สองที่ผ่านมามีการใช้สามครั้ง; เป็นต้น

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

และสตริงไบนารี่ที่ยืดออกใหม่เหล่านี้จะถูกแปลงกลับไปเป็นจำนวนเต็ม:

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

สำหรับการยืดขวาบิตแรกจะถูกใช้เพียงครั้งเดียว ที่สองครั้งที่สอง; สามครั้ง เช่นนี้

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

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

กฏท้าทาย:

• †คุณสามารถรับค่าสองค่าที่แตกต่างกัน แต่ระบุว่าคุณใช้ค่าใด เพื่อที่จะสามารถ1/0, true/false, null/undefined, "left"/"right"ฯลฯ
• n มากกว่า 0 เสมอ
• คุณควรรองรับเอาต์พุตสูงสุดอย่างน้อยจำนวนเต็มเริ่มต้นของภาษาของคุณ (ซึ่งเป็น 32- บิตสำหรับภาษาส่วนใหญ่)
• รูปแบบผลลัพธ์มีความยืดหยุ่น สามารถพิมพ์หรือคืนเป็นอาร์เรย์ / รายการ สามารถมีช่องว่างเครื่องหมายจุลภาคท่อและเหมือนตัวคั่น การโทรของคุณ (โปรดระบุสิ่งที่คุณใช้อีกครั้ง)

กฎทั่วไป:

• นี่คือcode-golfดังนั้นคำตอบที่สั้นที่สุดในจำนวนไบต์ชนะ
  อย่าปล่อยให้ภาษาที่ใช้รหัสกอล์ฟกีดกันคุณจากการโพสต์คำตอบด้วยภาษาที่ไม่ codegolfing พยายามหาคำตอบสั้น ๆ ที่เป็นไปได้สำหรับภาษาโปรแกรม 'ใด ๆ '
• กฎมาตรฐานจะใช้สำหรับคำตอบของคุณดังนั้นคุณจึงได้รับอนุญาตให้ใช้ STDIN / STDOUT ฟังก์ชั่น / วิธีการที่มีพารามิเตอร์ที่เหมาะสมและชนิดผลตอบแทนโปรแกรมเต็มรูปแบบ การโทรของคุณ
• ช่องโหว่เริ่มต้นเป็นสิ่งต้องห้าม
• หากเป็นไปได้โปรดเพิ่มลิงค์พร้อมทดสอบรหัสของคุณ
• นอกจากนี้โปรดเพิ่มคำอธิบายหากจำเป็น

เยลลี่ขนาด 9 ไบต์

BmxJ$mḄð€

ลองออนไลน์!

-1สำหรับซ้าย1สำหรับขวา

Python 2 , 102 96 ไบต์

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 สำหรับซ้าย 1 สำหรับขวา

ลองออนไลน์!

05AB1E , 14 13 ไบต์

บันทึก 1 ไบต์ขอบคุณErik the Outgolfer

LbεIiRƶRëƶ}JC

1สำหรับซ้าย
0(หรือสิ่งอื่นใด) เพื่อสิทธิ

ลองออนไลน์!

คำอธิบาย

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 ไบต์

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

นั่นเป็นตัวอักษรประจำนวนมาก ...

ใช้เวลาครั้งแรกb( 0สำหรับซ้ายและ1เพื่อสิทธิ) 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 ไบต์

0สำหรับ "ซ้าย" 1สำหรับ "ขวา" (สามารถใช้ค่าเท็จหรือค่าความจริงใด ๆ แทน 2. )

õȤËpV©EĪEnFlÃn2

ทดสอบมัน

คำอธิบาย

อินพุตโดยนัยของจำนวนเต็มU& V.

õ

สร้างอาร์เรย์ของจำนวนเต็มตั้งแต่ 1 ถึงUรวม

È

ผ่านแต่ละฟังก์ชั่น

¤

แปลงจำนวนเต็มปัจจุบันเป็นสตริงไบนารี

Ë           Ã

แม็พเหนือสตริงผ่านอักขระแต่ละตัวผ่านฟังก์ชันโดยที่EดัชนีปัจจุบันและFเป็นสตริงแบบเต็ม

p

ทำซ้ำตัวละครปัจจุบัน

V©  ª

© เป็นตรรกะและ (&& ) และªเป็นตรรกะหรือ||ดังนั้นที่นี่เรากำลังตรวจสอบว่าVเป็นความจริง (ไม่เป็นศูนย์) หรือไม่

YÄ

ถ้า Vเป็นความจริงแล้วXได้รับY+1เวลาซ้ำ

YnZl

ถ้าVเป็นเท็จก็Xจะได้รับการทำซ้ำYลบจาก ( n) ความยาว ( l) Zครั้ง

n2

แปลงกลับเป็นจำนวนเต็ม 10 ฐาน

ส่งออกอาร์เรย์ผลลัพธ์โดยปริยาย

Gaiaขนาด 15 ไบต์

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

ใช้-1สำหรับซ้ายและ1ขวา

ลองออนไลน์!

คำอธิบาย

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

โปรตอน , 79 ไบต์

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]

0เหลือ1อยู่ถูกต้อง

ลองออนไลน์!

Ungolfed

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 ไบต์

-5 ไบต์ขอบคุณ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();})

จำนวนไบต์ยังรวมถึง:

namespace System.Linq{}

ลองออนไลน์!

อินพุต: leftis true, rightisfalse

คำอธิบาย:

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 ไบต์

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

left is 1right is 0(ส่งผ่านเป็นอาร์กิวเมนต์ด้านซ้ายของฟังก์ชัน)

⍳ เป็นตัวสร้างดัชนี

{... }¨ใช้ฟังก์ชันเป็นวงเล็บปีกกากับแต่ละรายการทางด้านขวา

b←2⊥⍣¯1⊢⍵b ถูกเข้ารหัสเป็นเลขฐานสอง (ใช้การกลับด้านของการถอดรหัสเพื่อให้ได้จำนวนบิตต่ำสุดที่ต้องใช้เพื่อแสดง⍵ในฐาน 2)

⍳≢bสร้างดัชนีสำหรับเวกเตอร์ b ( ≢bความยาวของ b)

⌽⍣⍺กลับ⍺เวลา (ใช้แบบมีเงื่อนไขที่นี่เพื่อยืดซ้ายหรือขวา)

b/⍨ b จำลองแบบโดย (ทำซ้ำบิตตามดัชนี (ย้อนกลับ))

2⊥ ถอดรหัสจากฐาน 2

TryAPL ออนไลน์

JavaScript (ES6), 131 ไบต์

นี่นานกว่าคำตอบของ Shaggy อย่างมาก แต่ฉันต้องการลองใช้วิธีการที่ค่อนข้างบริสุทธิ์

เนื่องจากข้อ จำกัด 32 บิตของการดำเนินการ JS bitwise สิ่งนี้ใช้ได้กับn <128เท่านั้น

รับอินพุตในรูปแบบ currying (n)(r)โดยที่rเป็นเท็จสำหรับซ้าย / จริงสำหรับขวา

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

จัดรูปแบบและแสดงความคิดเห็น

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

การสาธิต

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 ไบต์

โอ้นี่มันนานเกินไปแล้ว! นี่คือสิ่งที่เกิดขึ้นเมื่อคุณใช้เวลาทั้งวันในการเขียน JavaScript, kiddies "ของจริง"; คุณลืมวิธีการเล่นกอล์ฟอย่างถูกต้อง!

ใช้ truthy หรือ falsey ค่าใด ๆbกับfalseการเป็น "ซ้าย" และtrueเป็น "สิทธิ"

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

ลองมัน

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>

เยลลี่ 11 ไบต์

B€xJṚ⁹¡$$€Ḅ

ลองออนไลน์!

อาร์กิวเมนต์ # 1: n
อาร์กิวเมนต์ # 2: 1สำหรับซ้าย0สำหรับขวา

เรติน่า , 111 ไบต์

\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

ลองออนไลน์! ใช้เวลาจำนวนและทั้งสองLหรือRเป็นคำต่อท้าย (หรือบนเส้นที่แยกต่างหาก) คำอธิบาย:

\d+
$*
1
$`1¶

แปลงจากทศนิยมให้เป็นเอกและนับตั้งแต่ 1 nถึง

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

แปลงจากนารี่เป็นไบนารี

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

ห่อแต่ละบิตในRและLอักขระตามตำแหน่งของมันในบรรทัด

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

แทนที่ที่เกี่ยวข้องRหรือLตัวละครด้วยตัวเลขที่อยู่ติดกันที่เหมาะสม

¶*[RL]

1
01
+`10
011
%`1

ลบอักขระที่เหลือไปและแปลงจากเลขฐานสองเป็นทศนิยม

JavaScript (ES6) 130 127 ไบต์

3 ไบต์ขอบคุณเควิน

ฉันแน่ใจว่าไม่รู้จัก ES6 เพียงพอสำหรับไซต์นี้ แต่ฉันลองแล้ว! วนซ้ำแต่ละตัวเลขและวนซ้ำแต่ละการแทนเลขฐานสองของตัวเลขนั้นซ้ำแต่ละอักขระอย่างไรก็ตามจำเป็นต้องใช้หลายครั้ง

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 ไบต์

->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 ไบต์

แลมบ์ดา (แกงกะหรี่) จากไปของผู้บริโภคBoolean Integerพารามิเตอร์บูลระบุว่าทางด้านซ้ายยืด (ค่าtrue, false) เอาต์พุตถูกพิมพ์ไปยังเอาต์พุตมาตรฐานคั่นด้วยบรรทัดใหม่ด้วยบรรทัดใหม่ต่อท้าย

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

แลมบ์ดา

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

ลองใช้ออนไลน์

ขีด จำกัด

เพราะพวกมันสะสมอยู่ int s เอาต์พุตจึง จำกัด เพียง 31 บิต ดังนั้นอินพุตจะ จำกัด เพียง 7 บิตดังนั้นอินพุตสูงสุดที่โปรแกรมรองรับคือ 127

คำอธิบาย

โซลูชันนี้สร้างหมายเลขที่ยืดออกโดยใช้การดำเนินการระดับบิต ลูปด้านนอกวนซ้ำiตัวเลขที่จะยืดจาก 1 ถึงnและพิมพ์ค่าที่ยืดออกหลังจากการวนซ้ำแต่ละครั้ง

การwhileวนซ้ำภายในเพิ่มขึ้นsเป็นจำนวนบิตในiและforiterates ที่ตามมาcในแต่ละตำแหน่งบิต ภายในห่วงว่านับถึงจำนวนครั้งที่จะทำซ้ำบิตในปัจจุบันซึ่งขึ้นอยู่กับการป้อนข้อมูลd lในแต่ละขั้นตอนoจะถูกเลื่อนไปทางซ้ายและบิตที่เหมาะสมiถูกปิดบังและหรือ