A mina de sal polonesa mais antiga , localizada em Bochnia *, foi iniciada no ano de 1248, o que podemos considerar um número mágico . Podemos ver que é igual a 4 dígitos da seqüência de exponenciações: .

Como a data é na verdade 4 dígitos da sequência, poderíamos torná-la mais longa. Poderíamos repetir o processo até alcançarmos o infinito. A sequência ficaria assim, se a limitarmos ao número2048

124816326412825651210242048

Para torná-lo um pouco melhor, podemos separar os números:

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

Vamos tentar uma sequência mais longa e personalizada que a data. Digamos que queremos que ele tenha 5 dígitos - há mais de uma possibilidade:

• 24816
• 81632
• 64128

Ou 3 dígitos:

• 124
• 248
• 816

Também podemos adicionar os números de três dígitos, mas digamos que uma sequência deve ter pelo menos dois números .

^{* Não há informações sobre isso na Wikipedia em inglês. Se você digitar a versão polonesa - então existe. Se você visitar a mina, os trabalhadores também lhe dirão que tudo começou em 1248.}

O desafio

Crie uma sequência de exponenciação como nos exemplos acima, com 2 como base.

Dado um número do intervalo 2-27, imprima todas as partes possíveis da sequência (a 2048, uma ou mais, se desejar) com uma quantidade de dígitos igual à entrada. Você não pode cortar um número, portanto, a saída 481é inválida, porque 16 é cortado pela metade.

Regras:

• As brechas padrão são proibidas.
• Você pode assumir que a entrada é um número dentro do intervalo.
• Seu programa pode aceitar entradas maiores que o intervalo (28+), mas isso não aumenta / diminui a pontuação.
• Os espaços na saída são ignorados. Você pode imprimir como 124ou gostar 4 8 16.
• Possibilidades diferentes devem ser separadas por qualquer caractere da lista: ,./|ou um avanço de linha.
• Você pode imprimir como uma matriz.
• Toda possibilidade deve incluir pelo menos 2 números diferentes .
• Você deve saída de uma parte da seqüência, você não pode misturar números que não são próximas umas das outras, como: 14.
• A saída codificada permanentemente não é permitida, no entanto, você pode codificar uma sequência / número / matriz que contém a sequência completa.
• A entrada 27 deve retornar a sequência 2048 completa.
• Como já mencionado anteriormente, não corte números . Ex. 16deve ficar 16- você não pode usar 481- você deve usar 4816.
• Edição: Eu poderia ter dito algo errado lá; 2048 é o último número que seu programa deve suportar; você pode adicionar suporte para int maiores.

Casos de teste

Entrada: 2

12, 24, 48

Entrada: 3

124, 248, 816

Entrada: 4

1248, 4816, 1632, 3264

Entrada: 5

24816, 81632, 64128

Entrada: 27

124816326412825651210242048

E números posteriores ...

Se eu cometi algum erro em algum dos casos de teste, diga-me ou edite a pergunta.

Isso é código-golfe , então o código mais curto em bytes vence!

05AB1E , 12 11 10 bytes

Suporta a sequência até 2^95 = 39614081257132168796771975168

₃ÝoŒʒg≠}Jù

Experimente online!

Explicação

₃Ý            # 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

Guardou 1 byte graças a Erik the Outgolfer Guardou
1 byte graças a Riley

Pitão, 22 21 20 17 bytes

fqQlTjLkt#.:^L2yT

Experimente Online

Explicação

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

Geléia ,  19 18  16 bytes

^{Pode haver uma solução mais curta agora que podemos usar qualquer corte (não apenas 2048), embora essa alteração na especificação tenha permitido economizar um byte nessa implementação, passando para um corte de 32768. -
sim. ..}

-2 bytes graças a Erik the Outgolfer (uso de Vpara permitir argumentos implícitos e corretos do filtro e aperto) -
sim, é muito semelhante ao ineficiente agora; Voto a favor !

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

Um link monádico que pega um número e retorna uma lista de números.

Experimente online!

Quão?

⁴Ḷ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 bytes

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

Experimente online!

Japt , 22 20 19 16 bytes

Suporta entrada até, 639mas as lacunas começam a aparecer na sequência após 234(Veja a lista completa dos intervalos de entrada suportados aqui ). Produz uma matriz de seqüências de caracteres.

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

Teste-o

I(64) poderia ser substituído por L(100), mas estaríamos entrando em notação científica e imprecisões de precisão. A filtragem desses recursos aumentaria obviamente a contagem de bytes e aumentaria apenas a entrada máxima para 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 bytes

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]

Experimente online!

Casca , 18 17 bytes

A saída é separada por novas linhas

fo=⁰LmṁsftQ↑12¡D1

Experimente online!

Quão?

           ↑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

Gelatina , 16 bytes

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

Experimente online!

Nota: muito ineficiente. Retorna uma lista de números.

JavaScript (ES7), 102 100 bytes

Imprime todas as sub sequências correspondentes com 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)))

Demo

Nota : este fragmento está armazenando em buffer os resultados e imprimindo-os no console para facilitar a utilização.

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 bytes

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

Experimente online!

Guardado 5 bytes graças a Laikoni

Eu usei um limite de 99porque 2^99tem um comprimento > 27.

Mathematica, 122 bytes

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

Entrada

[27]

Resultado

{879609302220817592186044416, 134217728268435456536870912, 524288104857620971524194304, 163843276865536131072262144, 2048409681921612121212122512121225

Input [1000]
Output  1441151880758558722882303761517117445764607523034234881152921504606846976230584300921369395246116860184273879049223372036854775808184467440737095516163689348814741910323273786976294838206464147573952589676412928295147905179352825856590295810358705651712118059162071741130342423611832414348226068484722366482869645213696944473296573929042739218889465931478580854784377789318629571617095687555786372591432341913615111572745182864683827230223145490365729367654460446290980731458735308812089258196146291747061762417851639229258349412352483570327845851669882470496714065569170333976494081934281311383406679529881638685626227668133590597632773712524553362671811952641547425049106725343623905283094850098213450687247810566189700196426901374495621121237940039285380274899124224247588007857076054979824844849517601571415210995964968969903520314283042199192993792198070406285660843983859875843961408125713216879677197516879228162514264337593543950336158456325028528675187087900672316912650057057350374175801344

C, 170 bytes

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

Experimente online!

Desenrolado:

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 bytes

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

Experimente online!

Perl 5 , 76 bytes

75 bytes de código + 1 para -a

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

Experimente online!

Japt, 24 bytes

Não voto a favor

Agora eu percebi que é a mesma maneira de fazer isso que o @Shaggy, apenas menos jogado no golfe. (Devo remover a resposta?)

Depois de muito tempo desde que postei essa pergunta, aprendi minha primeira língua no golfe. Por isso, decidi tentar a sorte aqui.

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

Experimente online!

A pontuação não é a melhor, nem sequer é boa, mas levei muito tempo para fazer isso .-.

Eu perco muitas pontuações, porque, por algumas razões, ã pode retornar apenas matrizes de comprimento x ... Pode ser até ~ 10 bytes, se não for isso.

Explicação:

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

Ruby , 94 bytes

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

Experimente online!