La plus ancienne mine de sel polonaise, située à Bochnia *, a été inaugurée en 1248, que nous pouvons considérer comme un nombre magique . On peut voir qu'il est égal à 4 chiffres de la séquence de exponentiations: .

Comme la date est en fait à 4 chiffres de la séquence, nous pourrions l'allonger. Nous pourrions répéter le processus jusqu'à atteindre l'infini. La séquence ressemblerait à ceci, si nous la limitons au nombre2048

124816326412825651210242048

Pour le rendre un peu meilleur, nous pouvons séparer les chiffres:

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

Essayons une séquence personnalisée plus longue que la date. Disons que nous voulons qu'il ait 5 chiffres - il y a plus d'une possibilité:

• 24816
• 81632
• 64128

Ou à 3 chiffres:

• 124
• 248
• 816

Nous pourrions également ajouter les nombres à 3 chiffres à cela, mais disons qu'une séquence doit avoir au moins deux nombres .

^{* Il n'y a aucune information à ce sujet sur Wikipedia anglais. Si vous entrez la version polonaise - alors il y en a. Si vous visitez la mine, les ouvriers vous diront également qu'elle a commencé en 1248.}

Le défi

Créez une séquence d'exponentiation comme dans les exemples ci-dessus avec 2 comme base.

Étant donné un nombre compris entre 2 et 27, sortez toutes les parties possibles de la séquence (celle de 2048 ou plus si vous le souhaitez) avec un nombre de chiffres égal à l'entrée. Vous ne pouvez pas couper un nombre, la sortie comme 481n'est donc pas valide, car 16 est coupé en deux.

Règles:

• Les failles standard sont interdites.
• Vous pouvez supposer que l'entrée est un nombre à l'intérieur de la plage.
• Votre programme peut accepter des entrées supérieures à la plage (28+), mais cela n'augmentera / ne diminuera pas le score.
• Les espaces en sortie sont ignorés. Vous pouvez sortir comme 124ou comme 4 8 16.
• Différentes possibilités doivent être séparées par n'importe quel caractère de la liste: ,./|ou un saut de ligne.
• Vous pouvez sortir sous forme de tableau.
• Chaque possibilité doit inclure au moins 2 numéros différents .
• Vous devez sortir une partie de la séquence, vous ne pouvez pas mélanger des nombres qui ne sont pas côte à côte, comme:14 .
• La sortie codée en dur n'est pas autorisée, cependant, vous pouvez coder en dur une chaîne / un nombre / un tableau contenant la séquence complète.
• L'entrée 27 doit renvoyer la séquence 2048 complète.
• Comme déjà mentionné précédemment, ne coupez pas les chiffres . Ex.16doit rester 16- vous ne pouvez pas utiliser 481- vous devez utiliser 4816.
• ÉDITER: J'aurais peut-être dit quelque chose de mal là-bas; 2048 est le dernier nombre que votre programme devrait prendre en charge, vous pouvez ajouter la prise en charge des int plus gros.

Cas de test

Contribution: 2

12, 24, 48

Contribution: 3

124, 248, 816

Contribution: 4

1248, 4816, 1632, 3264

Contribution: 5

24816, 81632, 64128

Contribution: 27

124816326412825651210242048

Et des chiffres plus tard ...

Si j'ai fait une erreur dans l'un des cas de test, dites-le-moi ou modifiez la question.

C'est le code-golf , donc le code le plus court en octets gagne!

05AB1E , 12 11 10 octets

Prend en charge la séquence jusqu'à 2^95 = 39614081257132168796771975168

₃ÝoŒʒg≠}Jù

Essayez-le en ligne!

Explication

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

1 octet enregistré grâce à Erik the Outgolfer
1 octet enregistré grâce à Riley

Pyth, 22 21 20 17 octets

fqQlTjLkt#.:^L2yT

Essayez-le en ligne

Explication

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ée ,  19 18  16 octets

^{Il peut y avoir une solution plus courte maintenant que nous pouvons utiliser n'importe quelle coupure (pas seulement 2048), bien que cette modification de la spécification ait permis une sauvegarde d'un octet de cette implémentation en passant à une coupure de 32768.
--yep. ..}

-2 octets grâce à Erik l'Outgolfer (utilisation de Vpour permettre l'argument droit implicite du filtre et du serrage) -
oui, il est très similaire à son inefficace maintenant;aller voter pour lui !

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

Un lien monadique prenant un numéro et renvoyant une liste de numéros.

Essayez-le en ligne!

Comment?

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

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

Essayez-le en ligne!

Japt , 22 20 19 16 octets

Prend en charge l'entrée jusqu'à 639mais des lacunes commencent à apparaître dans la séquence après 234(voir la liste complète des plages d'entrée prises en charge ici ). Génère un tableau de chaînes.

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

Essaye-le

I(64) pourrait être remplacé par L(100) mais nous entrerions dans la notation scientifique et les inexactitudes de précision. Le fait de les filtrer augmenterait évidemment le nombre d'octets et n'augmenterait que l'entrée maximale à 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 octets

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]

Essayez-le en ligne!

Husk , 18 17 octets

La sortie est séparée par des retours à la ligne

fo=⁰LmṁsftQ↑12¡D1

Essayez-le en ligne!

Comment?

           ↑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

Gelée , 16 octets

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

Essayez-le en ligne!

Remarque: très inefficace. Renvoie une liste de nombres.

JavaScript (ES7), 102100 octets

Imprime toutes les sous-séquences correspondantes avec 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)))

Démo

NB : Cet extrait met les résultats en mémoire tampon et les imprime sur la console pour plus de convivialité.

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 octets

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

Essayez-le en ligne!

5 octets enregistrés grâce à Laikoni

J'ai utilisé une limite de 99car 2^99a une longueur > 27.

Mathematica, 122 octets

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

Contribution

[27]

Production

{879609302220817592186044416, 134217728268435456536870912, 524288104857620971524194304, 163843276865536131072262144, 204840968192163843276865536, 25651210242048121281282081281264

Input [1000]
Output  1441151880758558722882303761517117445764607523034234881152921504606846976230584300921369395246116860184273879049223372036854775808184467440737095516163689348814741910323273786976294838206464147573952589676412928295147905179352825856590295810358705651712118059162071741130342423611832414348226068484722366482869645213696944473296573929042739218889465931478580854784377789318629571617095687555786372591432341913615111572745182864683827230223145490365729367654460446290980731458735308812089258196146291747061762417851639229258349412352483570327845851669882470496714065569170333976494081934281311383406679529881638685626227668133590597632773712524553362671811952641547425049106725343623905283094850098213450687247810566189700196426901374495621121237940039285380274899124224247588007857076054979824844849517601571415210995964968969903520314283042199192993792198070406285660843983859875843961408125713216879677197516879228162514264337593543950336158456325028528675187087900672316912650057057350374175801344

C, 170 octets

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

Essayez-le en ligne!

Déroulé:

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 octets

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

Essayez-le en ligne!

Perl 5 , 76 octets

75 octets de code + 1 pour -a

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

Essayez-le en ligne!

Japt, 24 octets

Ne votez pas trop

Maintenant, je me suis rendu compte que c'était la même façon de faire que @Shaggy, mais moins de jouer au golf. (Dois-je supprimer la réponse?)

Après un long moment depuis la publication de cette question, j'ai appris ma première langue de golf. Pour cette raison, j'ai décidé de tenter ma chance ici.

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

Essayez-le en ligne!

Le score n'est pas le meilleur, ce n'est même pas bon, mais cela m'a pris beaucoup de temps .-.

Je perds beaucoup de score, car pour certaines raisons, ã ne peut renvoyer que des tableaux de longueur x ... Cela pourrait même être ~ 10 octets, sinon cela.

Explication:

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

Rubis , 94 octets

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

Essayez-le en ligne!