La mina de sal polaca más antigua , ubicada en Bochnia *, se inició en el año 1248, que podemos considerar un número mágico . Podemos ver que es igual a 4 dígitos de la secuencia de exponenciación: .

Como la fecha es en realidad 4 dígitos de la secuencia, podríamos alargarla. Podríamos repetir el proceso hasta llegar al infinito. La secuencia se vería así, si la limitamos a número2048

124816326412825651210242048

Para que se vea un poco mejor, podemos separar los números:

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

Probemos una secuencia personalizada más larga que la fecha. Digamos que queremos que tenga 5 dígitos; hay más de una posibilidad:

• 24816
• 81632
• 64128

O los de 3 dígitos:

• 124
• 248
• 816

También podríamos agregar los números de 3 dígitos a esto, pero digamos que una secuencia debe tener al menos dos números .

^{* No hay información sobre esto en la Wikipedia en inglés. Si ingresa la versión polaca, entonces la hay. Si visita la mina, los trabajadores también le dirán que comenzó en 1248.}

El reto

Cree una secuencia de exponenciación como en los ejemplos anteriores con 2 como base.

Dado un número del rango 2-27, salida todas las partes posibles de la secuencia (la 2048 o más grande si lo desea) con una cantidad de dígitos igual a la entrada. No puede cortar un número, por lo que la salida como 481no es válida, porque 16 se corta por la mitad.

Reglas:

• Lagunas estándar están prohibidas.
• Puede suponer que la entrada es un número dentro del rango.
• Su programa puede aceptar entradas mayores que el rango (28+), pero eso no aumentará / disminuirá la puntuación.
• Los espacios en la salida se ignoran. Puede generar like 124o like 4 8 16.
• Las diferentes posibilidades deben estar separadas por cualquier carácter de la lista: ,./|o un avance de línea.
• Se puede generar como una matriz.
• Cada posibilidad debe incluir al menos 2 números diferentes .
• Debe salida de una parte de la secuencia, no se puede mezclar números que no están uno al lado del otro, como: 14.
• La salida codificada no está permitida, sin embargo, puede codificar una cadena / número / matriz que contenga la secuencia completa.
• La entrada 27 debería devolver la secuencia completa de 2048.
• Como ya se mencionó anteriormente, no corte los números . Ex. 16debe quedarse 16, no puede usar 481, debe usar 4816.
• EDITAR: Podría haber dicho algo mal allí; 2048 es el último número que su programa debería admitir, puede agregar soporte para int's más grandes.

Casos de prueba

Entrada: 2

12, 24, 48

Entrada: 3

124, 248, 816

Entrada: 4

1248, 4816, 1632, 3264

Entrada: 5

24816, 81632, 64128

Entrada: 27

124816326412825651210242048

Y luego números ...

Si cometí un error en alguno de los casos de prueba, dígame o edite la pregunta.

Este es el código de golf , por lo que gana el código más corto en bytes.

05AB1E , 12 11 10 bytes

Soporta la secuencia hasta 2^95 = 39614081257132168796771975168

₃ÝoŒʒg≠}Jù

Pruébalo en línea!

Explicación

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

Guardado 1 byte gracias a Erik the Outgolfer
Guardado 1 byte gracias a Riley

Pyth, 22 21 20 17 bytes

fqQlTjLkt#.:^L2yT

Pruébalo en línea

Explicación

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

Jalea ,  19 18  16 bytes

^{Puede haber una solución más corta ahora que podemos usar cualquier límite (no solo 2048), aunque este cambio en la especificación ha permitido un ahorro de un byte de esta implementación al pasar a un límite de 32768.
--yep. ..}

-2 bytes gracias a Erik the Outgolfer (uso Vpara permitir el argumento correcto implícito del filtro y el ajuste)
: sí, es muy similar a su ineficiente ahora; ¡Vota el suyo !

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

Un enlace monádico que toma un número y devuelve una lista de números.

Pruébalo en línea!

¿Cómo?

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

Pruébalo en línea!

Japt , 22 20 19 16 bytes

Admite entrada hasta, 639pero las brechas comienzan a aparecer en la secuencia después 234(consulte la lista completa de rangos de entrada admitidos aquí ). Emite una matriz de cadenas.

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

Pruébalo

I(64) podría ser reemplazado por L(100) pero estaríamos entrando en notación científica e inexactitudes de precisión. Filtrarlos, obviamente, aumentaría el recuento de bytes y solo aumentaría la entrada máxima a 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]

Pruébalo en línea!

Casco , 18 17 bytes

La salida está separada por líneas nuevas

fo=⁰LmṁsftQ↑12¡D1

Pruébalo en línea!

¿Cómo?

           ↑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

Jalea , 16 bytes

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

Pruébalo en línea!

Nota: muy ineficiente. Devuelve una lista de números.

JavaScript (ES7), 102 100 bytes

Imprime todas las subsecuencias coincidentes con 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)))

Manifestación

NB : este fragmento almacena los resultados y los imprime en la consola para facilitar su uso.

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]

Pruébalo en línea!

Guardado 5 bytes gracias a Laikoni

Usé un límite de 99porque 2^99tiene una longitud > 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]

Salida

{879609302220817592186044416, 134217728268435456536870912, 524288104857620971524194304, 163843276865536131072262144, 204840968192163843276865536, 256512102420484096819216384, 641282565121024204840968192, 163264128256512102420484096, 124816326412825651210242048}

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

Pruébalo en línea!

Desenrollado:

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

Pruébalo en línea!

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}

Pruébalo en línea!

Japt, 24 bytes

No votar

Ahora me di cuenta de que es la misma forma de hacerlo que @Shaggy, solo que menos golf. (¿Debo eliminar la respuesta?)

Después de mucho tiempo desde que publiqué esta pregunta, aprendí mi primer idioma de golf. Debido a esto, decidí probar suerte aquí.

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

Pruébalo en línea!

La puntuación no es la mejor, ni siquiera es buena, pero me llevó mucho tiempo hacer esto.

Pierdo mucho puntaje, porque por alguna razón, ã solo puede devolver matrices de longitud x ... Podría ser incluso ~ 10 bytes, si no es así.

Explicación:

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}}$/}

Pruébalo en línea!