# É um pouco de alongamento ․․․

18

• Uma entrada `b`com dois valores distintos: `Left`e `Right`.
• E um número inteiro positivo `n`.

Com base na entrada Esquerda / Direita, produzimos uma das duas sequências a seguir no intervalo de `1-n`(nas sequências abaixo, os primeiros 125 itens são exibidos):

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

Como essas seqüências são geradas, você pergunta?

Uma sequência padrão de 1 a `n=10`seria:

``````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 esticamos à esquerda, o binário se tornará o seguinte:

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

Por quê? O último bit é usado uma vez; o single-last é usado duas vezes; o segundo último é usado três vezes; etc.

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

E essas novas cadeias binárias esticadas à esquerda são convertidas novamente em números inteiros:

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

Quanto à direita esticada, o primeiro bit é usado uma vez; segundo duas vezes; terceiro três vezes; etc. Assim:

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

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

## Regras do desafio:

• Você pode pegar dois valores distintos, mas indicar qual deles você usa. Assim pode ser `1/0`, `true/false`, `null/undefined`, `"left"/"right"`, etc.
• `n` é sempre maior que 0.
• Você deve suportar uma saída máxima de pelo menos o número inteiro padrão do seu idioma (que é de 32 bits para a maioria dos idiomas).
• O formato de saída é flexível. Pode ser impresso ou retornado como matriz / lista. Pode ser com um espaço, vírgula, tubo e semelhante como delimitador. Sua chamada. (Novamente, indique o que você usou.)

## Regras gerais:

• Isso é , então a resposta mais curta em bytes vence.
Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, adicione uma explicação, se necessário.

1
Você consideraria aceitar respostas baseadas em bits que suportam apenas `n < 128`, para que os resultados se encaixem em números inteiros de 32 bits?
Arnauld

@ Arnauld Estive duvidando, mas desde que você perguntou, por que não? Alterará as regras de 1000 no máximo para o número inteiro do seu idioma.
Kevin Cruijssen

@KevinCruijssen Ainda recomendaria limitar isso a pelo menos 16 bits - há pelo menos um idioma por aí que suporta apenas um único bit como tipo de dados.

Respostas:

7

# Geléia , 9 bytes

``````BmxJ\$mḄð€
``````

Experimente online!

`-1`para a esquerda, `1`para a direita.

6

# 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 para a esquerda, 1 para a direita

Experimente online!

5

# 05AB1E , 14 13 bytes

Guardado 1 byte graças a Erik the Outgolfer

``````LbεIiRƶRëƶ}JC
``````

`1`para a esquerda.
`0`(ou qualquer outra coisa) por direito.

Experimente online!

Explicação

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

2
Você pode usar `ε`para -1:`LbεIiRƶRëƶ}JC`
Erik the Outgolfer

@EriktheOutgolfer: Boa ideia usando `ë`. Obtém em torno da questão de `if`numa aplica neste caso :)
Emigna

3

## Casca , 13 bytes

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

Toma primeiro `b`( `0`para esquerda e `1`para direita) e, em seguida `n`. Experimente online!

## Explicação

``````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.
``````

Você provavelmente poderia optar por tomar como `b`diretamente H ou T, poupando-lhe três bytes :)
Leo

@ Leo Hmm, é uma espécie de declive escorregadio. Eu também poderia tomar uma de duas versões de todo o programa como `b`e têm a minha solução ser apenas `I`...
Zgarb

3

# Japt , 19 18 17 bytes

`0`para "esquerda", `1`para "direita". (Ele pode, na verdade, assumir quaisquer valores falsey ou verdade no lugar daqueles 2.)

``````õÈ¤ËpV©EÄªEnFlÃn2
``````

Teste-o

## Explicação

Entrada implícita de números inteiros `U`& `V`.

``````õ
``````

Crie uma matriz de números inteiros de 1 a `U`, inclusive.

``````È
``````

Passe cada um por uma função.

``````¤
``````

Converta o número inteiro atual em uma sequência de caracteres binária

``````Ë           Ã
``````

Mapeie a string, passando cada caractere por uma função, onde `E`está o índice atual e `F`a string completa.

``````p
``````

Repita o caractere atual

``````V©  ª
``````

`©`é lógico AND ( `&&`) e `ª`é lógico OR `||`, então aqui estamos verificando se `V`é verdade (diferente de zero) ou não.

``````YÄ
``````

Se `V`é verdade, em seguida, `X`obtém `Y+1`vezes repetidas .

``````YnZl
``````

Se `V`for falsey, `X`será repetido `Y`subtraído de ( `n`) o comprimento ( `l`) de `Z`vezes.

``````n2
``````

Converta de volta para um número inteiro base 10.

Saída implícita da matriz resultante.

Eu tenho até 16 antes de perceber que era "primeiros itens n" ao invés de "item de enésimo", de modo que este não é tão ruim: P
ETHproductions

@ETHproductions: Você não foi o único a cometer esse erro;)
Shaggy

2

# Gaia , 15 bytes

``````⟪¤bw¦¤;ċ%×†_b⟫¦
``````

Usa `-1`para esquerda e `1`para direita.

Experimente online!

### Explicação

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

2

# Próton , 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]``

`0`é esquerda, `1`é direita.

Experimente 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
]``````

2

# C # (.NET Core) , 192 187 + 23 bytes

-5 bytes graças 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();})``

A contagem de bytes também inclui:

``namespace System.Linq{}``

Experimente online!

Entrada: `left`is `true`, `right`is`false`

Explicação:

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

185 + 23 ^ (foi muito tempo em um comentário)
TheLethalCoder

@TheLethalCoder Thank you! Infelizmente, porém, é 187, pois precisamos adicionar 1 ao índice, pois começa em 0 e a sequência começa em 1.
Grzegorz Puławski

Não é `using System.Linq;`mais curto que`namespace System.Linq{}` , ou estou faltando alguma coisa aqui? Há muito tempo atrás eu programado em .NET tbh ..
Kevin Cruijssen

1
@KevinCruijssen isso usa `Math`e `Convert`ambos estão no `System`espaço para nome, portanto, `namespace System.Linq`é o mais curto - permite o uso de ambos `System`e `System.Linq`classes.
Grzegorz Puławski

2

# Dyalog APL, 23 bytes

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

left is `1`right is `0`(transmitido como argumento esquerdo da função)

`⍳` é gerador de índice

`{`... `}¨`aplicar função entre chaves a cada item à direita

`b←2⊥⍣¯1⊢⍵`b é codificado como binário (usando o inverso da decodificação para obter o número mínimo de bits necessário para representar `⍵`na base 2)

`⍳≢b`gerar índices para o vetor b ( `≢b`é o comprimento de b)

`⌽⍣⍺``⍺`Tempos reversos (usados ​​condicionalmente aqui para alongamento esquerdo ou direito)

`b/⍨` b replicado por (replica os bits de acordo com o índice (reverso))

`2⊥` decodificar da base 2

TryAPL online

2

# JavaScript (ES6), 131 bytes

Isso é significativamente mais longo que a resposta de Shaggy , mas eu queria tentar uma abordagem puramente bit a bit.

Devido ao limite de 32 bits das operações JS bit a bit, isso funciona apenas para n <128 .

Recebe entrada na sintaxe de curry `(n)(r)`, em que r é falso para esquerda / verdade para direita.

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

### Demo

OK, sinto-me um pouco melhor com a extensão da minha agora, visto que você optou por uma solução mais longa do que por uma mais curta.
Shaggy

1
" (pendente de aprovação do OP). " Aprovado :) +1 de mim.
Kevin Cruijssen

2

# JavaScript (ES6), 113 bytes

Oh, isso é apenas muito tempo! É o que acontece quando você passa o dia escrevendo JavaScript "real", crianças; você esquece como jogar golfe corretamente!

Usa quaisquer valores de verdade ou falsey para `b`, `false`sendo "esquerdo" e `true`"direito".

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

## Tente

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

1

# Gelatina , 11 bytes

``````B€xJṚ⁹¡\$\$€Ḅ
``````

Experimente online!

Argumento # 1: `n`
Argumento # 2: `1`para a esquerda, `0`para a direita.

1

# Retina , 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
``````

Experimente online! Pega o número e `L`ou `R`como um sufixo (ou em uma linha separada). Explicação:

``````\d+
\$*
1
\$`1¶
``````

Converta de decimal para unário e conte de 1 a `n`.

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

Converter de unário em binário.

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

Coloque cada bit `R`e os `L`caracteres de acordo com sua posição na linha.

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

Substituir o relevante `R`ou `L`caracteres com o dígito adjacente apropriado.

``````¶*[RL]

1
01
+`10
011
%`1
``````

Remova os caracteres restantes e converta de binário para decimal.

1
Oi, você precisa gerar todos os números de `1`para `n`. Não é apenas o `n`'número th.
Kevin Cruijssen

@KevinCruijssen Bah, lá se vai minha contagem sub-100 byte ...
Neil

1

# JavaScript (ES6), 130 127 bytes

Certamente não conheço ES6 suficiente para este site, mas tentei! Faça um loop em cada número e faça um loop em cada representação binária desse número, repetindo cada caractere quantas vezes for necessário.

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

1
+1 de mim. :) Acho que você pode salvar um byte usando uma entrada de curry ( `d=>n=>`), como as outras duas respostas do JS ES6. Além disso, acho que você pode salvar outros 2 bytes alterando `k=-1,l=b.length;while(++k<l)s+=b[k].repeat(d?k+1:l-k);`para `k=0,l=b.length;while(k<l)s+=b[k++].repeat(d?k:l+~k);`(iniciando em `k=0`vez de `-1`e o `l-k-1`que é necessário é reduzido para `l+~k`). Além disso, os parênteses são `(i).toString(2)`necessários?
precisa saber é o seguinte

1
O `+~k`parece que ele deve funcionar, mas eu não consigo entender, continua ficando louco. Obrigado pelas outras dicas!
Sven escreve código

1
Ah oops, `l+~k`é incorreto, uma vez que não é `l-k-1`, mas `l-k+1`.. Meu ruim. Você ainda pode golf um byte, iniciando `k`em zero, no entanto: `k=0,l=b.length;while(k<l)s+=b[k++].repeat(d?k:l-k+1);`.
Kevin Cruijssen

1

# 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}}``

O espaço no ternário é `a{r ?a:a.reverse}`necessário?
Kevin Cruijssen

2
Sim. Os métodos Ruby podem terminar com `?`, `r?`teriam sido interpretados como um nome de método.
precisa saber é o seguinte

Ah ok, obrigado pela explicação. Nunca programado em Ruby, mas parecia um ternário regular - se eu usar em Java (ou C #), daí o meu comentário.
Kevin Cruijssen 18/08/19

1

# Java 8, 136 bytes

Lambda (ao curry) de `Boolean`para um consumidor de `Integer`. O parâmetro booleano indica se deve trecho esquerda (valores `true`, `false`). A saída é impressa na saída padrão, separada por novas linhas, com uma nova linha à direita.

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

Experimente Online

## Limites

Porque eles são acumulados em `int` s, as saídas são limitadas a 31 bits. Como resultado, as entradas são limitadas a 7 bits, portanto, a entrada máxima suportada pelo programa é 127.

## Explicação

Esta solução cria cada número estendido usando operações bit a bit. O loop externo itera `i`sobre os números a serem esticados, de 1 a n , e imprime o valor esticado após cada iteração.

O `while`loop interno é incrementado `s`para o número de bits `i`e o subsequente `for`itera `c`sobre cada posição de bit. Dentro desse loop, `d`conta até o número de vezes para repetir o bit atual, que depende da entrada `l`. A cada passo, `o`é deslocado para a esquerda e o bit apropriado `i`é mascarado e o OU é inserido.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.