波兰最古老的盐矿位于Bochnia *，始于1248年，我们可以认为这是一个神奇的数字。从求幂序列中可以看到它等于4位数字。

由于日期实际上是序列中的4位数字，因此我们可以将其延长。我们可以重复此过程，直到达到无穷大。如果我们将其限制为数字，则序列看起来像这样2048

124816326412825651210242048

为了使外观更好一点，我们可以将数字分开：

1|2|4|8|16|32|64|128|256|512|1024|2048

让我们尝试一个比日期更长的自定义序列。假设我们希望它有5位数字-可能性不止一种：

• 24816
• 81632
• 64128

或3位数字：

• 124
• 248
• 816

我们也可以在上面加上3位数字，但是，说一个序列必须至少有两个数字。

^{*英文维基百科上没有关于此的信息。如果您输入波兰语版本-那就有。如果您参观该矿，工人也会告诉您，该矿始于1248年。}

挑战

像上面的示例一样，以2为基数创建一个幂序列。

给定范围为2-27的数字，请输出该序列的所有可能部分（如果需要，可以为2048或更大），且位数等于输入。您无法截断数字，因此输出之类481的无效，因为16被截成两半。

规则：

• 禁止出现标准漏洞。
• 您可以假设输入的数字是范围内的数字。
• 您的程序可以接受大于范围（28+）的输入，但是不会增加/减少得分。
• 输出中的空格将被忽略。您可以输出like 124或like 4 8 16。
• 列表中的任何字符应分隔不同的可能性：,./|或换行。
• 您可以输出为数组。
• 每种可能性都应至少包括2个不同的数字。
• 您必须输出序列的一部分，不能混合不相邻的数字，例如：14。
• 不允许硬编码输出，但是，您可以硬编码包含完整序列的字符串/数字/数组。
• 输入27应该返回完整的2048序列。
• 如前所述，请勿减少数字。例如 16必须停留16-您不能使用481-您必须使用4816。
• 编辑：我可能在那说错了；2048是您的程序应支持的最后一个数字，您可以添加对更大int的支持。

测试用例

输入： 2

12, 24, 48

输入： 3

124, 248, 816

输入： 4

1248, 4816, 1632, 3264

输入： 5

24816, 81632, 64128

输入： 27

124816326412825651210242048

还有后来的数字...

如果我在任何测试用例中都犯了一个错误，请告诉我或编辑问题。

这是代码高尔夫球，因此以字节为单位的最短代码胜出！

05AB1E，12 11 10字节

最多支持序列 2^95 = 39614081257132168796771975168

₃ÝoŒʒg≠}Jù

在线尝试！

说明

₃Ý            # push range [0 ... 95]
  o           # raise 2 to the power of each
   Π         # get a list of all sublists
    ʒ         # filter, keep elements that satisfy:
     g        # length
      ≠       # false (not equal to 1)
       }      # end filter
        J     # join each
         ù    # keep numbers of length matching the input

感谢Outgolfer
保存了1个字节感谢Riley保存了1个字节

Pyth，22 21 20 17字节

fqQlTjLkt#.:^L2yT

在线尝试

说明

fqQlTjLkt#.:^L2yT
            ^L2yT  Get the powers of 2 up to 2^20
        t#.:       Get all consecutive sequences of at least 2
     jLk           Concatenate each
fqQlT              Get the ones whose length is the input

果冻， 19 18  16 字节

^{现在可能有一个更短的解决方案，我们可以使用任何截止值（不只是2048），尽管对规范的更改允许通过将截止值
移至32768来从该实现中节省一个字节。--yep。 ..}

-2个字节，感谢Outgolfer的Erik（使用V来允许对过滤器进行隐式正确的论证和加强）–
是的，这与他现在效率低下的非常相似；去投票吧！

⁴Ḷ2*Ẇṫ17VDL$⁼¥Ðf

单数链接，获取一个数字并返回一个数字列表。

在线尝试！

怎么样？

⁴Ḷ2*Ẇṫ17VDL$⁼¥Ðf - Link: number, n        e.g. 3
⁴                - literal sixteen             16
 Ḷ               - lowered range               [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
  2              - literal two                 2
   *             - exponentiate                [1,2,4,8,16,32,...,32768]
    Ẇ            - all sublists                [[1],[2],...,[1,2],[2,4],...,[1,2,4],...]
      17         - literal seventeen           17
     ṫ           - tail from index             [[1,2],[2,4],...,[1,2,4],...]]
        V        - evaluate as Jelly code      [12,24,...,124,...]
              Ðf - filter keep:
             ¥   -   last two links as a dyad
           $     -     last two links as a monad:
         D       -       decimal list (of entry) (i.e. 816 -> [8,1,6] or 24 -> [2,4])
          L      -       length                  (i.e. 816 -> 3, or 24 -> 2)
            ⁼    -   equals (n)                  (i.e. 816 -> 1, or 24 -> 0)
                 - ...resulting in             [816, 124, 248]

Perl 6的，62 59个字节

{grep *.comb==$_,map {[~] 2 X**[...] $_},combinations 12,2}

在线尝试！

Japt，22 20 19 16字节

最多支持输入，639但之后的间隔会开始出现间隙234（请参阅此处的支持的输入范围的完整列表）。输出字符串数组。

IÆIo!²ãX m¬lUäc

测试一下

I（64）可以用L（100）代替，但是我们会陷入科学计数法和精确度误差的境地。过滤掉那些显然会增加字节数，而只会将最大输入增加到736。

                     :Implicit input of integer U
I                    :64
 Æ                   :Map each X in [0,64)
  Io                 :  Range [0,64)
    !²               :  Raise 2 to the power of each
      ãX             :  Subsections of length X
         m           :  Map
          ¬          :    Join
           lU        :  Filter elements of length U
             Ã       :End map
              ¤      :Slice off the first 2 elements
               c     :Flatten

Python 2，105个字节

lambda l,r=range:[x for x in[''.join(`2**n`for n in r(i,j+2))for i in r(13)for j in r(i,11)]if len(x)==l]

在线尝试！

外壳，18 17字节

输出以换行符分隔

fo=⁰LmṁsftQ↑12¡D1

在线尝试！

怎么样？

           ↑12¡D1    The sequence [1,2,4...2048]
              ¡      Repeatedly apply function, collecting results in a list
               D     double
                1    initially applying to 1
           ↑12       Take the first 12 elements
          Q          Get all sublists
        ft           With a length greater than 1
     mṁs             Convert each list into a string, e.g [4,8,16] -> "4816"
fo=⁰L                Keep only those whose length is equal to the input

果冻，16字节

ȷḶ2*ẆṫȷḊVDL$⁼¥Ðf

在线尝试！

注意：效率很低。返回数字列表。

的JavaScript（ES7），102个 100字节

用打印所有匹配的子序列alert()。

l=>[...1e11+''].map((_,k,a)=>a.map((_,x)=>(s=(g=n=>x<=k|n<k?'':g(n-1)+2**n)(x)).length-l||alert(s)))

演示版

注意：此代码段正在缓冲结果并将其打印到控制台，以方便用户使用。

let f =

l=>[...1e11+''].map((_,k,a)=>a.map((_,x)=>(s=(g=n=>x<=k|n<k?'':g(n-1)+2**n)(x)).length-l||alert(s)))

alert = s => res += ' ' + s;

for(l = 2; l <= 27; l++) {
  res = '';
  f(l);
  console.log('L = ' + l + ' -->' + res);
}

Haskell，72 67字节

f n=[s|i<-[0..99],j<-[i+1..99],s<-[show.(2^)=<<[i..j]],length s==n]

在线尝试！

感谢Laikoni，节省了5个字节

我使用了一个限制，99因为2^99有一个长度> 27。

Mathematica，122个字节

(s=#;FromDigits@F[f/@#]&/@Select[Subsequences[Array[2^#&,99,0]],l@#>1&&(l=Length)@(F=Flatten)[(f=IntegerDigits)/@#]==s&])&  

输入值

[27]

输出量

{879609302220817592186044416、134217728268435456536870912、524288104857620971524194304、163843276865536131072262144、204840968192163843276865536、256512102420484096819216384、6412825651210242048204840968192、163264128256512102420484096、1248163264128204840968192

Input [1000]
Output  1441151880758558722882303761517117445764607523034234881152921504606846976230584300921369395246116860184273879049223372036854775808184467440737095516163689348814741910323273786976294838206464147573952589676412928295147905179352825856590295810358705651712118059162071741130342423611832414348226068484722366482869645213696944473296573929042739218889465931478580854784377789318629571617095687555786372591432341913615111572745182864683827230223145490365729367654460446290980731458735308812089258196146291747061762417851639229258349412352483570327845851669882470496714065569170333976494081934281311383406679529881638685626227668133590597632773712524553362671811952641547425049106725343623905283094850098213450687247810566189700196426901374495621121237940039285380274899124224247588007857076054979824844849517601571415210995964968969903520314283042199192993792198070406285660843983859875843961408125713216879677197516879228162514264337593543950336158456325028528675187087900672316912650057057350374175801344

C，170字节

i,j;f(n){char t[99],s[12][5]={"1"};for(i=j=1;i<12;)sprintf(s+i++,"%d",j*=2);for(i=0;i<12;++i,strlen(t)-n||j>1&&puts(t))for(j=*t=0;strlen(t)<n&&j+i<12;)strcat(t,s+i+j++);}

在线尝试！

展开：

i,j;
f(n)
{
    char t[99], s[12][5] = {"1"};
    for (i=j=1; i<12;)
        sprintf(s+i++, "%d", j*=2);
    for (i=0; i<12; ++i, strlen(t)-n || j>1 && puts(t))
        for (j=*t=0; strlen(t)<n && j+i<12;)
            strcat(t, s+i+j++);
}

R，99个字节

function(n)for(i in 1:11)for(j in i:11+1)if(sum(nchar(x<-2^(0:11))[i:j])==n)cat(x[i:j],"\n",sep="")

在线尝试！

Perl 5，76个字节

75个字节的代码+ 1个 -a

for$i(0..10){$/='',(map$/.=2**$_,$i..$_)&&$F[0]-length$/||say$/for$i+1..11}

在线尝试！

Japt，24个字节

不要投票

现在我意识到，这与@Shaggy的操作方式相同，只是打高尔夫球的次数减少了。（我应该删除答案吗？）

自从发布此问题很长时间以来，我学习了我的第一门高尔夫球语言。因此，我决定在这里尝试运气。

2oI,@IÆ2pYÃãX ®q
c f_Ê¥N

在线尝试！

分数不是最好的，甚至不是很好，但是我花了很多时间来做..。

我损失了很多分，因为某些原因，ã只能返回x长度数组...甚至可能是10个字节，如果不是这样的话。

说明：

2oI,@IÆ2pYÃãX ®q # All 2^ combinations:
2oI              # Range 2-64
   ,@            # Map (X as index)
     IÆ          #   Range 0-64, map (Y as index)
       2pY       #   2^Y
          Ã      #   End function (map)
                 #   this = array of powers.
           ãX    #   All combinations with X length
              ®q # Join then (arrays to numbers)

c f_Ê¥N          # Filter length to input:
c                # Flatten
  f_             # Filter
    Ê            #  Length
     ¥           #  ==
      N          #  Parsed input

红宝石，94字节

->n{a=*b=1;a<<b*=2until b>3**n;(2..n).flat_map{|x|a.each_cons(x).map &:join}.grep /^.{#{n}}$/}

在线尝试！