La più antica miniera di sale polacca, situata a Bochnia *, fu iniziata nell'anno 1248, che possiamo considerare un numero magico . Possiamo vedere che è pari a 4 cifre della sequenza di exponentiations: .

Dato che la data è in realtà di 4 cifre dalla sequenza, potremmo allungarla. Potremmo ripetere il processo fino a raggiungere l'infinito. La sequenza sarebbe simile a questa, se la limitassimo al numero2048

124816326412825651210242048

Per renderlo un po 'migliore, possiamo separare i numeri:

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

Proviamo una sequenza personalizzata più lunga della data. Diciamo, vogliamo che abbia 5 cifre - ci sono più di una possibilità:

• 24816
• 81632
• 64128

O quelli a 3 cifre:

• 124
• 248
• 816

Potremmo anche aggiungere i numeri di 3 cifre a questo, ma diciamo che una sequenza deve avere almeno due numeri .

^{* Non ci sono informazioni al riguardo su Wikipedia in inglese. Se inserisci la versione polacca, allora c'è. Se visiti la miniera, anche i lavoratori ti diranno che è iniziata nel 1248.}

La sfida

Crea una sequenza esponenziale come negli esempi sopra con 2 come base.

Dato un numero compreso nell'intervallo 2-27, emettere tutte le parti possibili della sequenza (quella del 2048 o più grande se lo si desidera) con una quantità di cifre pari all'input. Non è possibile tagliare un numero, quindi l'output come 481non è valido, perché 16 è tagliato a metà.

Regole:

• Sono vietate le scappatoie standard .
• Si può presumere che l'ingresso sia un numero all'interno dell'intervallo.
• Il tuo programma può accettare input maggiori dell'intervallo (28+), ma ciò non aumenta / diminuisce il punteggio.
• Gli spazi nell'output vengono ignorati. Puoi produrre come 124o come 4 8 16.
• Diverse possibilità dovrebbero essere separate da qualsiasi carattere dall'elenco: ,./| o da un avanzamento riga.
• È possibile eseguire l'output come un array.
• Ogni possibilità dovrebbe includere almeno 2 numeri diversi .
• Devi generare una parte della sequenza, non puoi mescolare numeri che non sono vicini l'uno all'altro, come:14 .
• L'output codificato non è consentito, tuttavia, è possibile codificare in modo rigido una stringa / numero / matrice contenente l'intera sequenza.
• L'ingresso 27 dovrebbe restituire l'intera sequenza 2048.
• Come già accennato in precedenza, non tagliare i numeri . Ex. 16devi rimanere 16- non puoi usare 481- devi usare 4816.
• EDIT: avrei potuto dire qualcosa di sbagliato lì; 2048 è l'ultimo numero che il tuo programma dovrebbe supportare, puoi aggiungere il supporto per int più grandi.

Casi test

Ingresso: 2

12, 24, 48

Ingresso: 3

124, 248, 816

Ingresso: 4

1248, 4816, 1632, 3264

Ingresso: 5

24816, 81632, 64128

Ingresso: 27

124816326412825651210242048

E numeri successivi ...

Se ho commesso un errore in uno dei casi di test, dimmelo o modifica la domanda.

Questo è code-golf , quindi vince il codice più corto in byte!

05AB1E , 12 11 10 byte

Supporta la sequenza fino a 2^95 = 39614081257132168796771975168

₃ÝoŒʒg≠}Jù

Provalo online!

Spiegazione

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

Salvato 1 byte grazie a Erik the Outgolfer
Salvato 1 byte grazie a Riley

Pyth, 22 21 20 17 byte

fqQlTjLkt#.:^L2yT

Provalo online

Spiegazione

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

Gelatina ,  19 18  16 byte

^{Potrebbe esserci una soluzione più breve ora che possiamo usare qualsiasi cut-off (non solo 2048), sebbene questa modifica alle specifiche abbia consentito un salvataggio di un byte da questa implementazione passando a un cut-off di 32768.
--yep. ..}

-2 byte grazie a Erik the Outgolfer (uso di Vper consentire l'argomentazione corretta implicita del filtro e del restringimento) -
sì, è molto simile al suo inefficiente ora;vai a votare il suo !

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

Un collegamento monadico che prende un numero e restituisce un elenco di numeri.

Provalo online!

Come?

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

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

Provalo online!

Japt , 22 20 19 16 byte

Supporta input fino a, 639ma gli spazi vuoti iniziano ad apparire nella sequenza successiva 234(vedere l'elenco completo degli intervalli di input supportati qui ). Emette un array di stringhe.

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

Provalo

I(64) potrebbe essere sostituito con L(100), ma entreremmo in notazione scientifica e imprecisioni di precisione. Filtrare quelli fuori aumenterebbe, ovviamente, il conteggio dei byte e aumenterebbe solo l'input massimo 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 byte

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]

Provalo online!

Buccia , 18 17 byte

L'output è separato da newline

fo=⁰LmṁsftQ↑12¡D1

Provalo online!

Come?

           ↑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 byte

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

Provalo online!

Nota: molto inefficiente. Restituisce un elenco di numeri.

JavaScript (ES7), 102 100 byte

Stampa tutte le sub-sequenze corrispondenti 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)))

dimostrazione

NB : questo frammento memorizza i risultati nel buffer e li stampa sulla console per facilità d'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 byte

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

Provalo online!

5 byte salvati grazie a Laikoni

Ho usato un limite di 99perché 2^99ha una lunghezza > 27.

Mathematica, 122 byte

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

Ingresso

[27]

Produzione

{879609302220817592186044416, 134217728268435456536870912, 524288104857620971524194304, 163843276865536131072262144, 2048409681240484040404040404040404048

Input [1000]
Output  1441151880758558722882303761517117445764607523034234881152921504606846976230584300921369395246116860184273879049223372036854775808184467440737095516163689348814741910323273786976294838206464147573952589676412928295147905179352825856590295810358705651712118059162071741130342423611832414348226068484722366482869645213696944473296573929042739218889465931478580854784377789318629571617095687555786372591432341913615111572745182864683827230223145490365729367654460446290980731458735308812089258196146291747061762417851639229258349412352483570327845851669882470496714065569170333976494081934281311383406679529881638685626227668133590597632773712524553362671811952641547425049106725343623905283094850098213450687247810566189700196426901374495621121237940039285380274899124224247588007857076054979824844849517601571415210995964968969903520314283042199192993792198070406285660843983859875843961408125713216879677197516879228162514264337593543950336158456325028528675187087900672316912650057057350374175801344

C, 170 byte

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

Provalo online!

srotolato:

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 byte

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

Provalo online!

Perl 5 , 76 byte

75 byte di codice + 1 per -a

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

Provalo online!

Japt, 24 byte

Non votare

Ora mi sono reso conto che è lo stesso modo di farlo come ha fatto @Shaggy, solo meno golfato. (Devo rimuovere la risposta?)

Dopo un po 'di tempo da quando ho pubblicato questa domanda, ho imparato la mia prima lingua da golf. Per questo motivo, ho deciso di tentare la fortuna qui.

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

Provalo online!

Il punteggio non è il migliore, non è nemmeno buono, ma mi ci è voluto molto tempo per farlo .-.

Perdo molto il punteggio, perché per alcuni motivi, ã può restituire solo matrici di lunghezza x ... Potrebbe essere anche ~ 10 byte, se non quello.

Spiegazione:

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

Rubino , 94 byte

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

Provalo online!