Eingang:

Wir nehmen zwei Eingaben:

• Eine Eingabe bmit zwei unterschiedlichen Werten: Leftund Right. †
• Und eine positive ganze Zahl n.

Ausgabe:

Basierend auf der Eingabe von Links / Rechts geben wir eine der beiden folgenden Sequenzen im Bereich von aus 1-n(in den Sequenzen unter werden die ersten 125 Elemente angezeigt):

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

Wie werden diese Sequenzen generiert?

Eine Standardsequenz von 1 bis n=10wäre:

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

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

Wenn wir uns nach links strecken, wird die Binärdatei folgendermaßen aussehen:

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

Warum? Das letzte Bit wird einmal verwendet. der Single-Last wird zweimal verwendet; der vorletzte wird dreimal verwendet; etc.

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

Und diese neuen binären Zeichenfolgen mit linker Ausdehnung werden zurück in Ganzzahlen konvertiert:

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

Wie für rechts gestreckt, wird das erste Bit einmal verwendet; zweimal Sekunde; dreimal dritter; usw. So:

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

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

Herausforderungsregeln:

• † Sie können zwei verschiedene Werte annehmen, aber angeben, welchen Sie verwenden. So soll es sein kann 1/0, true/false, null/undefined, "left"/"right"etc.
• n ist immer größer als 0.
• Sie sollten eine maximale Ausgabe von mindestens der Standard-Ganzzahl Ihrer Sprache unterstützen (32-Bit für die meisten Sprachen).
• Das Ausgabeformat ist flexibel. Kann ausgedruckt oder als Array / Liste zurückgegeben werden. Kann mit einem Leerzeichen, Komma, Pipe und ähnlichem als Begrenzer angegeben werden. Ihr Anruf. (Bitte geben Sie noch einmal an, was Sie verwendet haben.)

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie ggf. auch eine Erklärung hinzu.

Gelee , 9 Bytes

BmxJ$mḄð€

Probieren Sie es online!

-1für links, 1für rechts.

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 für links, 1 für rechts

Probieren Sie es online!

05AB1E , 14 13 Bytes

Dank Erik the Outgolfer 1 Byte gespeichert

LbεIiRƶRëƶ}JC

1für links.
0(oder irgendetwas anderes) für richtig.

Probieren Sie es online!

Erläuterung

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

Schale , 13 Bytes

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

Das sind viele gepunktete Buchstaben ...

Nimmt zuerst b( 0für links und 1für rechts), dann n. Probieren Sie es online!

Erläuterung

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

0für "links", 1für "rechts". (Es können tatsächlich falsche oder wahrheitsgemäße Werte anstelle dieser 2 verwendet werden.)

õȤËpV©EĪEnFlÃn2

Probier es aus

Erläuterung

Implizite Eingabe von ganzen Zahlen U& V.

õ

Erstellen Sie ein Array von ganzen Zahlen von 1 bis Ueinschließlich.

È

Führen Sie jeweils eine Funktion durch.

¤

Konvertiert die aktuelle Ganzzahl in eine Binärzeichenfolge

Ë           Ã

Ordnen Sie die Zeichenfolge zu, indem Sie jedes Zeichen durch eine Funktion leiten. Dabei Ehandelt es sich um den aktuellen Index und Fum die vollständige Zeichenfolge.

p

Wiederholen Sie das aktuelle Zeichen

V©  ª

©ist logisch UND ( &&) und ªist logisch ODER ||, also prüfen wir hier, ob Vwahr ist (nicht Null) oder nicht.

YÄ

Wenn Ves wahr ist, Xwird es mehrmals wiederholt Y+1.

YnZl

Wenn VFalsch ist, Xwird wiederholt Yvon ( n) die Länge ( l) der ZZeiten abgezogen .

n2

Konvertieren Sie zurück in eine Ganzzahl zur Basis 10.

Das resultierende Array wird implizit ausgegeben.

Gaia , 15 Bytes

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

Verwendet -1für links und 1rechts.

Probieren Sie es online!

Erläuterung

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

0ist links, 1ist rechts.

Probieren Sie es online!

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 Byte

-5 Bytes dank 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();})

Die Byteanzahl umfasst auch:

namespace System.Linq{}

Probieren Sie es online!

Eingabe: leftist true, rightistfalse

Erläuterung:

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(wird als linkes Argument der Funktion übergeben)

⍳ ist Indexgenerator

{... }¨wenden Sie die Funktion in geschweiften Klammern auf jedes Element rechts an

b←2⊥⍣¯1⊢⍵b ist ⍵ binär codiert (unter Verwendung der Umkehrung der Decodierung, um die minimale Anzahl von Bits zu erhalten, die für die Darstellung ⍵in Basis 2 erforderlich sind )

⍳≢bgeneriere Indizes für Vektor b ( ≢bist Länge von b)

⌽⍣⍺Umkehrzeiten ⍺(hier bedingt für linke oder rechte Strecke)

b/⍨ b repliziert von (repliziert die Bits gemäß dem (umgekehrten) Index)

2⊥ Dekodiere von Basis 2

TryAPL online

JavaScript (ES6), 131 Byte

Dies ist deutlich länger als Shaggys Antwort , aber ich wollte einen rein bitweisen Ansatz versuchen.

Aufgrund der 32-Bit-Beschränkung der bitweisen JS-Operationen funktioniert dies nur für n <128 .

Nimmt Eingaben in der Curry-Syntax vor (n)(r), wobei r für links / für rechts falsch ist.

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

Formatiert und kommentiert

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, das ist einfach viel zu lang! Dies ist, was passiert, wenn Sie den Tag damit verbringen, "echtes" JavaScript zu schreiben, Kinder; Sie vergessen, wie man richtig Golf spielt!

Verwendet alle truthy oder Falsey Werte für b, mit zu falsesein „links“ und trueseinem „Recht“.

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

Versuch es

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 Bytes

B€xJṚ⁹¡$$€Ḅ

Probieren Sie es online!

Argument 1: n
Argument 2: 1für links, 0für rechts.

Netzhaut , 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

Probieren Sie es online! Nimmt die Nummer und entweder Loder Rals Suffix (oder in einer separaten Zeile). Erläuterung:

\d+
$*
1
$`1¶

Konvertiere von dezimal nach unär und zähle von 1 nach n.

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

Konvertieren von unär zu binär.

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

Binde jedes Bit Rund jedes LZeichen entsprechend seiner Position in der Zeile ein.

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

Ersetzen Sie die relevanten Roder LZeichen durch die entsprechende benachbarte Ziffer.

¶*[RL]

1
01
+`10
011
%`1

Entfernen Sie die verbleibenden Zeichen und konvertieren Sie sie von binär nach dezimal.

JavaScript (ES6), 130 127 Byte

3 Bytes, danke Kevin

Ich kenne nicht genug ES6 für diese Seite, aber ich habe es versucht! Durchlaufen Sie jede Zahl und durchlaufen Sie jede Binärdarstellung für diese Zahl, wobei Sie jedes Zeichen so oft wiederholen, wie es erforderlich ist.

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) von Booleanzu einem Verbraucher von Integer. Der boolesche Parameter gibt an, ob nach links gedehnt werden soll (Werte true, false). Die Ausgabe wird standardmäßig ausgegeben und durch Zeilenumbrüche mit einem abschließenden Zeilenumbruch getrennt.

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

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

Probieren Sie es online

Grenzen

Weil sie sich angesammelt haben int s , sind die Ausgaben auf 31 Bit begrenzt. Infolgedessen sind die Eingaben auf 7 Bit begrenzt, sodass das Programm maximal 127 Eingaben unterstützt.

Erläuterung

Diese Lösung baut jede gedehnte Zahl mit bitweisen Operationen auf. Die äußere Schleife durchläuft idie zu streckenden Zahlen von 1 bis n und gibt den gestreckten Wert nach jeder Iteration aus.

Die innere whileSchleife wird sum die Anzahl der eingegebenen Bits erhöht i, und die darauffolgende Schleife fordurchläuft cjede Bitposition. dZählt in dieser Schleife bis zu der Häufigkeit, mit der das aktuelle Bit wiederholt wird, was von der Eingabe abhängt l. Bei jedem Schritt owird nach links verschoben und das entsprechende Bit von iwird ausgeblendet und ODER-verknüpft.