Inspiré par ce défi

Pour un nombre entier compris dans la plage 0 <= n < 2**64, indiquez le conteneur de taille minimale dans lequel il peut être inséré

• bit: 1
• grignotage: 4
• octet: 8
• court: 16
• int: 32
• long: 64

Testcases:

0 -> 1
1 -> 1
2 -> 4
15 -> 4
16 -> 8
123 -> 8
260 -> 16
131313 -> 32
34359750709 -> 64

C'est du code-golf , donc la réponse la plus courte en octets est gagnante.

05AB1E , 10 octets

bg.²îD1Q+o

Explication

bg         Push the length of the binary representation of input without leading zeros
  .²î      Push x = ceil(log2(length))
     D1Q+  Add 1 if x == 1 or add 0 otherwise
         o Push pow(2,x) and implicitly display it

Essayez-le en ligne!

Python, 39 octets

f=lambda n:4**(n>1)*(n<16)or 2*f(n**.5)

Compte combien de fois on doit prendre la racine carrée pour nêtre en dessous 16, avec quelques casse spéciale pour éviter des sorties de 2.

Si 2 étaient inclus, nous pourrions faire

f=lambda n:n<2or 2*f(n**.5)

avec True pour 1.

41 octets:

f=lambda n,i=1:i*(2**i>n)or f(n,i<<1+i%2)

Double à plusieurs reprises l'exposant ijusqu'à 2**i>n. Saute de i=1à i=4en décalant un bit supplémentaire quand iest étrange.

Alt 45 octets:

f=lambda n,i=4:4**(n>1)*(2**i>n)or 2*f(n,i*2)

J, 19 octets

Verbe monadique prenant le numéro à droite et recrachant la taille du conteneur. Il y a deux façons équivalentes de l'écrire, alors j'ai inclus les deux.

2^2(>.+1=>.)@^.#@#:
2^s+1=s=.2>.@^.#@#:

Expliqué par explosion:

2^2(>.+1=>.)@^.#@#: NB. takes one argument on the right...
                 #: NB. write it in binary
               #@   NB. length (i.e. how many bits did that take?)
  2          ^.     NB. log base 2 of that
   (>.     )@       NB. ceiling
      +1=>.         NB. +1 if needed (since no container is two bits wide)
2^                  NB. base 2 exponential

Ce qui est cool, c’est que nous voyons deux manières différentes de prendre log base 2 en J. La première est l’évident 2^., qui est un logarithme numérique. La seconde est #@#:, qui peut être lue comme "longueur de la représentation en base 2". Cela équivaut presque à one-plus-floor-of-log-base-2, à la différence que #:0c'est la liste à un élément 0, qui correspond exactement à ce que nous souhaitons. Cela bat 1+2<.@^.1&>.par 8 octets.

En usage sur le REPL:

   f =: 2^2(>.+1=>.)@^.#@#:
   f 131313
32
   f 34359750709
64
   (,.f"0) 0 1 2 15 16 123 260
  0  1
  1  1
  2  4
 15  4
 16  8
123  8
260 16

Ancienne solution de 20 octets trop astucieuse.

2&^.(>.+1=>.&.)@#@#: NB. takes one argument on the right...
                #@#: NB. how many bits
2&^.                 NB. log base 2 of that
     >.              NB. ceiling
       +1=>.         NB. +1 if needed (since no container is two bits wide)
    (       &.)      NB. undo log base 2

Python, 53 50 49 octets

lambda n:[w for w in[1,4,8,16,32,64]if n<2**w][0]

Mathematica, 44 39 38 octets

Merci @ orlp pour 5 octets et @MartinEnder pour 1 octet.

FirstCase[{1,4,8,16,32,64},x_/;2^x>#]&

Trouve en premier les éléments de la liste {1, 4, 8, 16, 32, 64}tels que 2 ^ nombre est supérieur à l'entrée.

Pip , 19 octets

(a<2**_FI2**,7RM2i)

Essayez-le en ligne!

Comment ça marche

                     a is 1st cmdline arg, i is 0 (implicit)
         2**,7       Construct powers of 2 from 0 to 6 [1 2 4 8 16 32 64]
              RM2    Remove 2
       FI            Filter for elements for which:
 a<2**_                a is less than 2 to that element
(                i)  Get 0th item of resulting list and autoprint

JavaScript (ES7), 35 octets

n=>[1,4,8,16,32,64].find(b=>2**b>n)

Mathematica, 46 43 38 octets

Merci à JungHwan Min et Martin Ender pour avoir économisé 3 octets! Merci à ngenisis pour une grosse économie de 5 octets!

2^⌈Log2@BitLength@#⌉/.{2->4,0->1}&

Fonction sans nom prenant un entier non négatif en entrée et renvoyant un entier positif. BitLength@#calcule le nombre de bits dans l'entrée, puis 2^⌈Log2@...⌉calcule la plus petite puissance de 2 égale au moins au nombre de bits. Enfin, /.{2->4,0->1}s'occupe du cas particulier où il n'y a pas de "niblit" entre bit et nybble, et corrige également la réponse pour l'entrée étrange 0.

Julia, 40 octets

n->filter(x->n<big(2)^x,[1;2.^(2:6)])[1]

Il s'agit d'une fonction anonyme qui génère un tableau des puissances de 2 de 0 à 6, à l'exclusion de 2, et le filtre uniquement aux éléments x tels que 2 ^x soit supérieur à l'entrée. Le premier élément de ce type est la réponse. Malheureusement, cela nécessite la promotion de 2 en a BigIntpour éviter le débordement sur x = 64.

Ceci est en fait assez similaire à la réponse Python de orlp, bien que je ne l'aie pas vue avant de concocter cette approche.

Essayez-le en ligne!

Perl 6 , 30 octets

{first 1+<*>$_,1,4,8,16,32,64}

+<est l'opérateur de décalage de bits à gauche de Perl 6, que beaucoup d'autres langues appellent <<.

Haskell, 31 octets

f n=[2^i|i<-0:[2..],2^2^i>n]!!0

32 octets alt:

f n|n<2=1|n<16=4|1>0=2*f(sqrt n)

Java, 143 octets.

int f(long a){a=Long.toBinaryString(a).length();if(a<2)return 1;if(a<5)return 4;if(a<9)return 8;if(a<17)return 16;if(a<33)return 32;return 64;}

Haskell, 43 octets

f x=head$filter((>x).(2^))$[1,4,8,16,32,64]

Ruby, 39 36 octets

->n{2**[0,*2..6].find{|p|2**2**p>n}}

Merci GB d'aider à jouer au golf

Java 8, 65 à 55 octets

C'est une expression lambda qui prend un longet retourne un int. Jamais joué en Java auparavant, cela devrait donc être facile à battre:

x->{int i=1;while(Math.pow(2,i)<=x)i<<=1+i%2;return i;}

Essayez-le en ligne!

Pour 47 octets , nous pourrions avoir:

x->{int i=1;while(1L<<i<=x)i<<=1+i%2;return i;}

Toutefois, les 1L<<idébordements pour les valeurs de retour supérieures à 32 sont résolus, de sorte que cela échoue pour le test final.

Mathematica, 30 octets

2^(f=BitLength)[f@#-1]/. 2->4&

Explication:

Soit Nl'ensemble des entiers non négatifs. Définissez deux fonctions sur N, BitLengthet NextPowercomme suit:

BitLength(n) := min {x in N : 2^x - 1 >= n}
NextPower(n) := 2^(min {x in N : 2^x >= n})

Cette solution calcule essentiellement à partir d' NextPower(BitLength(n))un entier n >= 0. Car n > 0, on peut voir ça NextPower(n) = 2^BitLength(n-1), alors NextPower(BitLength(n)) = 2^BitLength(BitLength(n)-1).

Mathematica est désormais BitLengthconforme à la définition que j'ai donnée n >= 0. Pour n < 0, BitLength[n] == BitLength[BitNot[n]] == BitLength[-1-n], donc BitLength[-1] == BitLength[0] == 0. Nous obtenons ainsi la réponse souhaitée de 1pour n==0.

Puisque nous passons directement de mors en mordillés, nous devons remplacer les réponses 2par 4.

bash, 49 octets 48 octets

for((y=1;$[y==2|$1>=1<<y];$[y*=2])){ :;};echo $y

ou

for((y=1;$[y==2|$1>=1<<y];)){ y=$[y*2];};echo $y

Enregistrez dans un script et transmettez le nombre à tester en tant qu'argument.

Edit: Remplacé || avec |, ce qui fonctionne car les arguments sont toujours 0 ou 1.

Note: Ceci fonctionne pour les entiers jusqu'au plus grand entier positif que votre version de bash peut gérer. Si j'en ai le temps, je le modifierai pour qu'il fonctionne jusqu'à 2 ^ 64-1 dans les versions de bash utilisant une arithmétique signée 32 bits.

En attendant, voici une solution de 64 octets qui fonctionne pour des nombres arbitrairement grands (dans toute version bash):

for((x=`dc<<<2o$1n|wc -c`;$[x==2||x&(x-1)];$[x++])){ :;};echo $x

Empilés, 34 30 octets

@n 1 2 6|>2\^,:n 2 log>keep 0#

ou

{!1 2 6|>2\^,:n 2 log>keep 0#}

Le premier prend en entrée le TOS et laisse la sortie en TOS; la seconde est une fonction. Essayez-le ici!

Explication

@n 1 2 6|>2\^,:n 2 log>keep 0#
@n                               set TOS to `n`
   1 2 6|>2\^,                   equiv. [1, ...2 ** range(2, 6)]
              :                  duplicate it
               n                 push `n`
                 2 log           log base-2
                      >          element-wise `>`
                       keep      keep only truthy values
                            0#   yield the first element

Voici un exemple de travail sur le repl :

> 8    (* input *)
(8)
> @n 1 2 6|>2\^,:n 2 log>keep 0#    (* function *)
(4)
>    (* output *)
(4)

Cas de test

> {!1 2 6|>2\^,:n 2 log>keep 0#} @:f
()
> (0 1 2 15 16 123 260 131313 34359750709) $f map
((1 1 4 4 8 8 16 32 64))
> 

Ou, en tant que programme complet:

{!1 2 6|>2\^,:n 2 log>keep 0#} @:f

(0 1 2 15 16 123 260 131313 34359750709) $f map

out

Raquette 45 octets

(findf(λ(x)(>(expt 2 x)m))'(1 4 8 16 32 64))

Ungolfed:

(define (f m)
  (findf (λ (x) (> (expt 2 x) m))          ; find first function
         '(1 4 8 16 32 64)))

Autres versions:

(define (f1 m)
  (for/last ((i '(1 4 8 16 32 64))         ; using for loop, taking last item
             #:final (> (expt 2 i) m))     ; no further loops if this is true
    i))

et en utilisant la longueur de la chaîne:

(define (f2 m)
  (for/last
      ((i '(1 4 8 16 32 64))
       #:final (<= (string-length
                    (number->string m 2))  ; convert number to binary string
                   i))
    i))

Essai:

(f 0)
(f 1)
(f 2)
(f 15)
(f 16)
(f 123)
(f 260)
(f 131313)
(f 34359750709)

Sortie:

1
1
4
4
8
8
16
32
64

Octave, 40 36 31 29 octets

Fonction anonyme simple. Il est supposé que la valeur d'entrée est un entier - voir l'avertissement à la fin.

@(a)(b=2.^[0 2:6])(a<2.^b)(1)

Le code fonctionne comme suit:

• Tout d'abord, un tableau des longueurs de bits autorisées (1,4,8,16,32,64) est créé et enregistré b.

• Ensuite, nous trouvons le nombre de bits requis pour stocker le nombre saisi aen comparant la taille maximale de chaque conteneur bpour déterminer ceux qui sont assez gros.

• Nous utilisons ensuite le vecteur d’index résultant pour extraire à nouveau la taille du conteneur b.

• Enfin, prenons le premier élément du tableau résultant qui sera le plus petit conteneur possible.

Vous pouvez l'essayer en ligne ici .

Il suffit de lancer le code suivant, puis faites-le ans(x).

La seule réserve à cela est que la double précision est utilisée par défaut pour les constantes, ce qui signifie qu'elle ne fonctionne qu'avec des nombres allant jusqu'à la valeur la plus élevée pouvant être représentée par un flottant double précision inférieur à 2 ^ 64.

Cela peut être corrigé en s'assurant que le nombre fourni à la fonction est un entier et non un double. Ceci peut être réalisé en appelant la fonction par exemple avec: ans(uint64(x)).

PHP, 49 46 44 octets

echo(2**ceil(log(log(1+$argn,2),2))-2?:2)+2;

Courez comme ça:

echo 16 | php -R 'echo(2**ceil(log(log(1+$argv[1],2),2))-2?:2)+2;';echo

Explication

echo                       # Output the result of the expression
  (
    2**                    # 2 to the power
      ceil(log(            # The ceiling of the power of 2 of bitsize
        log(1+$argn,2),    # Number of bits needed
        2
      ))
      - 2 ?:               # Subtract 2 (will be added back again)
      2;                   # If that results in 0, result in 2 (+2=4).
  ) + 2                    # Add 2.

Tweaks

• Sauvegardé 3 octets en se débarrassant de la $r=tâche
• 2 octets enregistrés en utilisant -Rpour rendre $argndisponible

CJam , 18 octets

2ri2b,2mLm]_({)}|#

Essayez-le en ligne!

Explication

2                   Push 2
 ri                 Read an integer from input
   2b,              Get the length of its binary representation
      2mLm]         Take the ceiling of the base-2 log of the length
           _(       Duplicate it and decrement it
             {)}|   Pop the top element, if it's 0, increment the next element
                     Effectively, if ceil(log2(input)) was 1, it's incremented to 2,
                     otherwise it stays the same.
                 #  Raise 2 to that power

C, 71 52 octets

i;f(long long n){for(i=1;n>>i;i*=2);return i-2?i:4;}

QBIC , 27 octets

:~a<2|_Xq]{~a<2^t|_Xt\t=t*2

Explication

:        Get cmd line parameter N, call it 'a'
~a<2     IF 'a' is 0 or 1 (edge case)
|_Xq]    THEN quit, printing 1 ('q' is auto-initialised to 1). ']' is END-IF
{        DO - infinite loop
    2^t  't' is our current number of bits, QBIC sets t=4 at the start of the program.
         2^t gives the maximum number storable in t bytes.
 ~a<     IF the input fits within that number,
|_Xt     THEN quit printing this 't'
\t=t*2   ELSE jump to the next bracket (which are spaced a factor 2 apart, from 4 up)
         DO-loop is auto-closed by QBIC.

Pyke, 13 octets

7Zm@2-#2R^<)h

Essayez-le ici!

7Zm@          -   [set_bit(0, i) for i in range(7)] <- create powers of 2
    2-        -  ^.remove(2)
      #    )h - filter(^, V)[0]
       2R^    -   2 ** i
          <   -  input < ^

PHP, 43 octets

for(;1<<2**$i++<=$argn;);echo 2**$i-=$i!=2;

Courez avec echo <number> | php -R '<code>'.

boucle $ijusqu'à 2**(2**$i)est plus grand que l'entrée. (Tweak: <<au lieu d' **éliminer les parens)
Après la boucle, $ i est trop élevé; il obtient donc une décrémentation avant de calculer la sortie
- mais pas pour $i==2.