Ingresso:

Prendiamo due input:

• Un input bcon due valori distinti: Lefte Right. †
• E un numero intero positivo n.

Produzione:

Sulla base dell'input Left / Right, produciamo una delle due seguenti sequenze nell'intervallo di 1-n(nelle sequenze sotto sono visualizzati i primi 125 elementi):

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

Come vengono generate queste sequenze che chiedi?

Una sequenza predefinita da 1 a n=10sarebbe:

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

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

Quando allunghiamo a sinistra, il binario diventerà questo:

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

Perché? L'ultimo bit viene utilizzato una volta; l'ultimo singolo viene usato due volte; il penultimo è usato tre volte; eccetera.

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

E queste nuove stringhe binarie allungate a sinistra vengono riconvertite in numeri interi:

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

Per quanto riguarda allungato a destra, il primo bit viene utilizzato una volta; secondo due volte; terzo tre volte; ecc. In questo modo:

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

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

Regole della sfida:

• † Puoi prendere due valori distinti, ma indica quale usi. Così può essere 1/0, true/false, null/undefined, "left"/"right", etc.
• n è sempre maggiore di 0.
• Dovresti supportare un output massimo almeno dell'intero predefinito della tua lingua (che è a 32 bit per la maggior parte delle lingue).
• Il formato di output è flessibile. Può essere stampato o restituito come matrice / elenco. Può essere con uno spazio, virgola, pipe e simili come delimitatore. La tua chiamata. (Ancora una volta, per favore, indica cosa hai usato.)

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

Gelatina , 9 byte

BmxJ$mḄð€

Provalo online!

-1per sinistra, 1per destra.

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 per sinistra, 1 per destra

Provalo online!

05AB1E , 14 13 byte

Salvato 1 byte grazie a Erik the Outgolfer

LbεIiRƶRëƶ}JC

1per sinistra.
0(o qualsiasi altra cosa) per il diritto.

Provalo online!

Spiegazione

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

Buccia , 13 byte

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

Sono molte lettere tratteggiate ...

Prende prima b( 0per sinistra e 1per destra), quindi n. Provalo online!

Spiegazione

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

0per "sinistra", 1per "destra". (Può effettivamente prendere qualsiasi valore di falsità o verità al posto di quei 2.)

õȤËpV©EĪEnFlÃn2

Provalo

Spiegazione

Immissione implicita di numeri interi UeV .

õ

Crea una matrice di numeri interi da 1 a U , incluso.

È

Passa attraverso una funzione.

¤

Converti il ​​numero intero corrente in una stringa binaria

Ë           Ã

Mappa sopra la stringa, passando ogni carattere attraverso una funzione, dove Eè l'indice corrente eF è la stringa completa.

p

Ripeti il ​​personaggio attuale

V©  ª

©è AND logico ( &&) ed ªOR logico ||, quindi qui stiamo verificando se Vè true (diverso da zero) o no.

YÄ

Se Vè vero, allora Xviene ripetuto Y+1volte.

YnZl

Se Vè falso, Xviene ripetuto Ysottratto da ( n) la lunghezza ( l) delle Zvolte.

n2

Converti indietro in un numero intero di base 10.

Output implicito dell'array risultante.

Gaia , 15 byte

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

Utilizza -1per sinistra e1 per destra.

Provalo online!

Spiegazione

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

0è a sinistra, 1è a destra.

Provalo 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 byte grazie 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();})

Il conteggio dei byte include anche:

namespace System.Linq{}

Provalo online!

Input: leftè true, rightèfalse

Spiegazione:

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⊢⍵}¨⍳

left is 1right is 0(passato come argomento sinistro della funzione)

⍳ è un generatore di indice

{... }¨applica la funzione tra parentesi graffe per ogni elemento a destra

b←2⊥⍣¯1⊢⍵b è ⍵ codificato come binario (usando l'inverso della decodifica per ottenere il numero minimo di bit richiesto per rappresentare ⍵in base 2)

⍳≢b generare indici per il vettore b (≢b è la lunghezza di b)

⌽⍣⍺ inverso ⍺tempi (usati qui condizionatamente per tratto sinistro o destro)

b/⍨ b replicato da (replica i bit secondo l'indice (inverso))

2⊥ decodifica dalla base 2

TryAPL online

JavaScript (ES6), 131 byte

Questo è significativamente più lungo della risposta di Shaggy , ma volevo provare un approccio puramente bit a bit.

A causa del limite di 32 bit delle operazioni bit per bit di JS, funziona solo per n <128 .

Accetta input nella sintassi del curry (n)(r), dove r è falsy per left / verità per right.

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

Formattato e commentato

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

dimostrazione

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, è troppo lungo! Questo è ciò che accade quando passi la giornata a scrivere "veri" JavaScript, kiddies; dimentichi come giocare a golf correttamente!

Usi eventuali valori truthy o Falsey per b, con falseessere "di sinistra" e truedi essere "giusto".

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

Provalo

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>

Gelatina , 11 byte

B€xJṚ⁹¡$$€Ḅ

Provalo online!

Argomento n. 1: n
Argomento n. 2: 1a sinistra, 0a destra.

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

Provalo online! Prende il numero e o Lo Rcome suffisso (o su una riga separata). Spiegazione:

\d+
$*
1
$`1¶

Converti da decimale a unario e conta da 1 a n.

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

Converti da unario a binario.

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

Avvolgi ogni bit Re Lcaratteri in base alla sua posizione nella linea.

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

Sostituisci i caratteri Roi Lcaratteri pertinenti con la cifra adiacente appropriata.

¶*[RL]

1
01
+`10
011
%`1

Rimuovi i caratteri rimasti e converti da binario a decimale.

JavaScript (ES6), 130 127 byte

3 byte, grazie Kevin

Di sicuro non conosco abbastanza ES6 per questo sito, ma ci ho provato! Passa attraverso ogni numero e passa attraverso ogni rappresentazione binaria per quel numero, ripetendo ogni carattere ogni volta che è necessario.

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)

Rubino, 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 (al curry) da Booleana un consumatore di Integer. Il parametro booleano indica se allungare a sinistra (valori true, false). L'output viene stampato su standard out, separato da newline, con una nuova riga finale.

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 ungolfed

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

Provalo online

limiti

Poiché sono accumulati in ints, le uscite sono limitate a 31 bit. Di conseguenza, gli ingressi sono limitati a 7 bit, quindi l'ingresso massimo supportato dal programma è 127.

Spiegazione

Questa soluzione crea ogni numero allungato usando operazioni bit a bit. Il ciclo esterno scorre ii numeri da allungare, da 1 a n , e stampa il valore allungato dopo ogni iterazione.

Il whileloop interno aumenta sin base al numero di bit in entrata ie la successiva forscorre csu ogni posizione di bit. All'interno di quel loop, dconta fino al numero di volte per ripetere il bit corrente, che dipende dall'input l. Ad ogni passaggio, oviene spostato a sinistra e il bit appropriato iviene mascherato e inserito.