Giriş:

İki girdi alıyoruz:

• bİki farklı değere sahip bir girdi : Leftve Right. †
• Ve pozitif bir tamsayı n.

Çıktı:

Sol / Sağ girişine dayanarak, aşağıdaki iki diziden birini 1-n(ilk 125 öğenin altındaki dizilerde görüntülenir) çıkarırız:

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

Bu sekanslar nasıl sorulur?

1 ile 1 arasında varsayılan bir sıra 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

Sola gerildiğinde, ikili bu olacak:

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

Neden? Son bit bir kez kullanılır; tek son iki kez kullanılır; ikinci son üç kez kullanılır; vb.

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

Ve bu yeni sol uzatılmış ikili dizeler tamsayılara dönüştürülür:

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

Gergin sağa gelince, ilk bit bir kez kullanılır; ikincisi iki kez; üçüncü üç kez; Bu şekilde:

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

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

Zorluk kuralları:

• † İki farklı değer alabilir, ancak hangisini kullandığınızı belirtebilirsiniz. O olabilir Yani 1/0, true/false, null/undefined, "left"/"right", vb
• n her zaman 0'dan büyüktür.
• En azından dilinizin varsayılan tamsayısının (çoğu dil için 32 bit) maksimum çıktısını desteklemelisiniz.
• Çıktı formatı esnektir. Dizi / liste olarak yazdırılabilir veya iade edilebilir. Boşluk, virgül, boru ve sınırlayıcı olarak kullanılabilir. Çağrınız. (Yine, lütfen ne kullandığınızı belirtin.)

Genel kurallar:

• Bu kod golf , bayt en kısa cevap kazanır.
  Kod golf dillerinin, kod yazmayan dillerle yanıt göndermenizi engellemesine izin vermeyin. Herhangi bir programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT, fonksiyon / yöntemi uygun parametreler ve dönüş tipi, tam programlar ile kullanmanıza izin verilir. Çağrınız.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuz için test içeren bir bağlantı ekleyin.
• Ayrıca, gerekirse bir açıklama ekleyin.

Jöle , 9 bayt

BmxJ$mḄð€

Çevrimiçi deneyin!

-1sol 1için, sağ için.

Python 2 , 102 96 bayt

lambda d,n:[int(''.join(c*-~i for i,c in enumerate(bin(x+1)[2:][::d]))[::d],2)for x in range(n)]

Sol için -1, sağ için 1

Çevrimiçi deneyin!

05AB1E , 14 13 bayt

Outgolfer Erik sayesinde 1 bayt tasarruf edildi

LbεIiRƶRëƶ}JC

1sol için.
0(veya başka herhangi bir şey) doğru.

Çevrimiçi deneyin!

açıklama

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

Kabuk , 13 bayt

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

Bu bir sürü noktalı harf ...

Önce alır b( 0sola ve 1sağa), sonra n. Çevrimiçi deneyin!

açıklama

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 bayt

0"sol" 1için, "sağ" için. (Aslında bu 2 yerine herhangi bir falsey veya doğruluk değeri alabilir.)

õȤËpV©EĪEnFlÃn2

Dene

açıklama

Örtük tamsayı girişi U& V.

õ

1 ile U(dahil) arasında bir tamsayı dizisi oluşturun .

È

Her birini bir işlevden geçirin.

¤

Geçerli tamsayıyı ikili dizeye dönüştür

Ë           Ã

Her bir karakteri Egeçerli işlev ve Ftam dize olan bir işlevden geçirerek dizenin üzerinde eşleyin.

p

Geçerli karakteri tekrarla

V©  ª

©mantıklı VE ( &&) veª mantıksal VEYA mantıksaldır ||, bu yüzden burada Vdoğru (sıfır olmayan) olup olmadığını kontrol ediyoruz .

YÄ

Eğer V doğruysa o Xzaman tekrarlanır Y+1.

YnZl

Eğer Vo zaman Falsey olduğunu Xtekrarlayan alır Yçıkarılır (n ) uzunluğunun ( larasında) Zkat.

n2

Bir temel 10 tamsayıya dönüştürün.

Sonuç dizisini dolaylı olarak çıktılar.

Gaia , 15 bayt

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

-1Sol ve 1sağ için kullanır .

Çevrimiçi deneyin!

açıklama

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

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]

0sol, 1sağ.

Çevrimiçi deneyin!

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 Çekirdek) , 192 187 + 23 bayt

TheLethalCoder sayesinde -5 bayt

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

Bayt sayısı ayrıca şunları içerir:

namespace System.Linq{}

Çevrimiçi deneyin!

Girdi: leftolduğunu true,right olupfalse

Açıklama:

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 bayt

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

left is 1right 0(işlevin sol argümanı olarak iletilir)

⍳ endeks üreteci

{... }¨sağdaki her öğeye parantez içinde işlev uygula

b←2⊥⍣¯1⊢⍵b ikili olarak kodlanır ( ⍵taban 2'de temsil etmek için gereken minimum bit sayısını elde etmek için kod çözmenin tersini kullanarak )

⍳≢bb vektörü için dizinler üretin (b'nin ≢buzunluğu)

⌽⍣⍺ ters ⍺ zamanlar (burada sol veya sağ esneme için şartlı olarak kullanılır)

b/⍨ b tarafından çoğaltılır (bitleri (ters) dizinine göre çoğaltır)

2⊥ tabandan kod çözme 2

TryAPL çevrimiçi

JavaScript (ES6), 131 bayt

Bu Shaggy'nin cevabından çok daha uzun , ama tamamen bitsel bir yaklaşım denemek istedim.

JS bitsel işlemlerinin 32 bit sınırı nedeniyle, bu yalnızca n <128 için çalışır .

Kıvrım sözdiziminde girdi alır (n)(r), burada r sol için yanlıştır / sağ için doğrudur.

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

Biçimlendirilmiş ve yorumlanmış

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

gösteri

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 bayt

Oh, bu çok uzun! Gününüzü "gerçek" JavaScript yazarak geçirdiğinizde olan budur; düzgün golf nasıl unutmak!

Kullanımları için herhangi truthy veya Falsey değerlerini bbirlikte, false"sol" olmak ve true"doğru" olmak.

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

Dene

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>

Jöle , 11 bayt

B€xJṚ⁹¡$$€Ḅ

Çevrimiçi deneyin!

Bağımsız değişken # 1: n
Bağımsız değişken # 2: 1sol 0için, sağ için.

Retina , 111 bayt

\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

Çevrimiçi deneyin! Sayıyı ya Lda Rson eki (ya da ayrı bir satırda) alır. Açıklama:

\d+
$*
1
$`1¶

Ondalıktan tekliye dönüştürme ve 1'den sayma n.

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

Dönüştürmek için unary'den ikiliye.

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

Her biti Rve Lkarakterleri satırdaki konumuna göre sarın .

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

Alakalı Rveya Lkarakterleri uygun bitişik rakamla değiştirin.

¶*[RL]

1
01
+`10
011
%`1

Soldaki karakterleri kaldırın ve ikili karakterden ondalığa dönüştürün.

JavaScript (ES6), 130 127 bayt

3 bayt, teşekkürler Kevin

Bu site için yeterince ES6 bilmiyorum ama denedim! Her sayıyı döngüye sokun ve bu sayının her bir ikili gösterimi arasında dolaşarak her karakteri gerektiği kadar tekrarlayı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 bayt

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

Lambda (curried) 'dan Booleantüketiciye Integer. Boole parametresi, sola doğru uzanıp uzanmayacağını (değerler true, false) gösterir. Çıktı standart çıkışa, yeni satırlarla ayrılmış ve sondaki yeni satırla yazdırılır.

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

Çevrimiçi Deneyin

Sınırları

Çünkü içinde birikmişler intS cinsinden çıktılar 31 bit ile sınırlıdır. Sonuç olarak, girişler 7 bit ile sınırlıdır, bu nedenle programın desteklediği maksimum giriş 127'dir.

açıklama

Bu çözüm, her gerilmiş sayıyı bitsel işlemler kullanarak oluşturur. Dış döngü i, 1'den n'ye gerilecek sayıların üzerinde yinelenir ve her yinelemeden sonra gerilmiş değeri yazdırır.

İç whiledöngü s, içindeki bit sayısına artar .i , ve daha sonra fordolaşır cher bir bit konumu üzerinde. Bu döngü içinde d, girdiye bağlı olarak geçerli bitin kaç kez tekrarlanacağını sayar l. Her adımda osola kaydırılır ve uygun biti imaskelenir ve OR olur.