Dado un entero N> = 1, genera el número medio de bits en un entero de 0 a N - 1

Especificación

• La salida se puede calcular como la suma del número de bits en la representación binaria de cada entero de 0 a N-1, dividido por N.
• La representación binaria de un entero no tiene ceros a la izquierda en este contexto, con la excepción de cero, que se representa como 0 en binario.
• La salida debe ser precisa al menos a 7 cifras significativas.

Ejemplo

N = 6

0: 0   : 1 bit
1: 1   : 1 bit
2: 10  : 2 bits
3: 11  : 2 bits
4: 100 : 3 bits
5: 101 : 3 bits

Número medio de bits = (1 + 1 + 2 + 2 + 3 + 3) / 6 = 2

Casos de prueba

Entrada => salida

1 => 1
2 => 1
3 => 1.3333333
4 => 1.5
5 => 1.8
6 => 2
7 => 2.1428571

Fragmento de la tabla de posiciones

(desde aquí )

var QUESTION_ID=80586,OVERRIDE_USER=20283;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:400px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Tenga en cuenta que la suma (antes de dividir para encontrar la media) es una secuencia en OEIS .

Pyth, 6 bytes

.Oml.B

Pruébelo en línea aquí .

.Oml.BdUQ              Filling in implict vars

.O                     Average of list
 m   UQ                Map over [0..input)
  l                    Length of
   .B                  Binary string representation of int
    d                  Lambda var

Jalea, 6 bytes

R’BFL÷

Pruébalo en línea!

R’BFL÷  Main monadic chain. Argument: n

R       yield [1, 2, ..., n]
 ’      decrement; yield [0, 1, ..., n-1]
  B     convert to binary; yield [[0], [1], [1,0], [1,1], ...]
   F    flatten list; yield [0, 1, 1, 0, 1, 1, ...]
    L   length of list
     ÷  divide [by n]

Octava, 29 bytes

@(n)1+sum(fix(log2(1:n-1)))/n

Explicación

              log2(1:n-1)       % log2 of numbers in range [1..n-1]
                                % why no 0? because log2(0) = -Inf  :/
          fix(           )      % floor (more or less, for positive numbers)
      sum(                )     % sum... wait, didn't we miss a +1 somewhere?
                                % and what about that missing 0?
                           /n   % divide by n for the mean
    1+                          % and add (1/n) for each of the n bit lengths 
                                % (including 0!)

Ejecución de muestra en ideone .

Python 3, 43 bytes

def f(n):x=len(bin(n))-2;return(2-2**x)/n+x

Hace uso de la fórmula en la página OEIS . Sorprendentemente, una función con nombre es de alguna manera más barata aquí debido a la asignación a x.

Enfoque alternativo para 46 bytes:

lambda n:-~sum(map(int.bit_length,range(n)))/n

Desafortunadamente, -~es necesario ya que (0).bit_length()es 0, pero incluso entonces sería un byte demasiado largo.

Julia, 27 bytes

n->endof(prod(bin,0:n-1))/n

Pruébalo en línea!

Cómo funciona

Como *es la concatenación de cadenas en Julia, prodse puede usar para concatenar una matriz de cadenas. Opcionalmente, toma una función como primer argumento que asigna sobre el segundo antes de tomar el "producto" real, por lo que prod(bin,0:n-1)es la cadena de la representación binaria de todos los enteros en el rango deseado. Tomar la longitud con endofy dividir entre n produce la media.

Julia, 28 bytes

n->mean(ceil(log2([2;2:n])))

Como binno se asigna automáticamente a las matrices, estamos usando ceil(log2(n))para obtener el número de bits n-1. Esto funciona bien porque la a:bnotación de Julia es inclusiva en ambos extremos, por lo que 2:nes un rango de 2 a n, pero realmente estamos calculando el número de bits para los números en el rango 1:n-1. Sin embargo, desafortunadamente, necesitamos agregar un extra 2para dar cuenta de 0.

Pruébalo en línea!

MATL, 9 bytes

q:ZlksG/Q

Pruébalo en línea!

Versión modificada con todos los casos de prueba.

Explicación

    % Implicitly grab input (N)
q:  % Create array from 1:N-1
Zl  % Compute log2 for each element of the array
k   % Round down to the nearest integer
s   % Sum all values in the array
G   % Explicitly grab input again
/   % Divide by the input
Q   % Add 1 to account for 0 in [0, ... N - 1]
    % Implicitly display the result

MATL, 9 bytes

:qBYszQG/

Pruébalo en línea!

Explicación

:qBYszQG/
:               % take vector [1..n]
 q              % decrement by 1 to get [0..n-1]
  B             % convert from decimal to binary
   Ys           % cumulative sum (fills in 0's after first 1)
     z          % number of nonzero elements
      Q         % increment by 1 to account for zero
       G        % paste original input (n)
        /       % divide for the mean

Jalea, 8 bytes

No es un algoritmo más corto, pero interesante, y mi primer envío de Jelly:

Rl2Ċ»1S÷

R         1 to n
 l2       log2
   Ċ      ceiling
    »1    max of 1 and...
      S   sum
       ÷  divided by n

Jalea, 10 bytes

BL©2*2_÷+®

De la sugerencia de Sp3000.

Pruébalo aquí.

Jalea, 11 bytes

æḟ2’Ḥ÷_BL$N

No muy corto pero necesito algunos consejos.

Pruébalo aquí.

Usando la misma fórmula que en la respuesta de Sp3000 . (No es muy difícil obtenerlo usted mismo, diferenciando la progresión geométrica).

Java, 135 95 90 bytes

float a(int n){int i=0,t=0;for(;i<n;)t+=Integer.toString(i++,2).length();return t/(n+0f);}

Python 3, 46 bytes

lambda x:sum(len(bin(i))-2for i in range(x))/x

Llámalo como

f = lambda x: sum(len(bin(i))-2for i in range(x))/x
print(f(6))
# 2.0

Tuve que revertir la revisión del mapa porque falló para la entrada de 5

05AB1E, 9 7 bytes

Código:

L<bJg¹/

Explicación:

L<         # range from 0..input-1
  b        # convert numbers to binary
   J       # join list of binary numbers into a string
    g      # get length of string (number of bits)
     ¹/    # divide by input

Pruébalo en línea

Editar: guardado 2 bytes gracias a @Adnan

C #, 87 bytes

double f(int n){return Enumerable.Range(0,n).Average(i=>Convert.ToString(i,2).Length);}

Escribí una respuesta de C # porque no la vi. Esta es mi primera publicación en una de estas, así que avíseme si estoy haciendo algo mal.

JavaScript (ES7), 38 32 bytes

n=>(l=-~Math.log2(n))-(2**l-2)/n

Usando la fórmula de @ sp3000 (la versión anterior era una solución recursiva). Versión ES6 para 34 bytes:

n=>(l=-~Math.log2(n))-((1<<l)-2)/n

Explicación de la fórmula: considere el caso de N = 55. Si escribimos los números binarios (verticalmente para ahorrar espacio), obtenemos:

                                11111111111111111111111
                111111111111111100000000000000001111111
        11111111000000001111111100000000111111110000000
    111100001111000011110000111100001111000011110000111
  11001100110011001100110011001100110011001100110011001
0101010101010101010101010101010101010101010101010101010

El tamaño de este rectángulo es nl, por lo que el promedio es solo l, pero debemos excluir los espacios en blanco. Cada fila de espacios en blanco es dos veces más larga que la anterior, por lo que el total es 2 + 4 + 8 + 16 + 32 = 64 - 2 = 2 ^l - 2.

J, 21 17 15 bytes

De 17 bytes a 15 bytes gracias a @Dennis.

+/@:%~#@#:"0@i.

¿Alguien puede ayudarme a jugar golf? ...

Versión sin golf

range        =: i.
length       =: #
binary       =: #:
sum          =: +/
divide       =: %
itself       =: ~
of           =: @
ofall        =: @:
binarylength =: length of binary "0
average      =: sum ofall divide itself
f            =: average binarylength of range

Perl 6 ,  34  32 bytes

{$_ R/[+] map *.base(2).chars,^$_}

{$_ R/[+] map {(.msb||0)+1},^$_}

Explicación:

{ 
  $_  # the input
  R/  # divides ( ｢$a R/ $b｣ is the same as ｢$b / $a｣ )
  [+] # the sum of:
  map
    {
      (
       .msb # the most significant digit (0 based)
       || 0 # which returns Nil for ｢0.msb｣ so use 0 instead
            # should be ｢(.msb//0)｣ but the highlighting gets it wrong
            # it still works because it has the same end result 
      ) 
      + 1   # make it 1 based
    },
    ^$_ # ｢0 ..^ $_｣ all the numbers up to the input, excluding the input
}

Prueba:

use v6.c;

# give it a name
my &mean-bits = {$_ R/[+] map {(.msb||0)+1},^$_}

for 1..7 {
  say .&mean-bits
}

say '';

say mean-bits(7).perl;
say mean-bits(7).base-repeating(10);

1
1
1.333333
1.5
1.8
2
2.142857

<15/7>
(2. 142857)

Dyalog APL , 14 bytes

(+/1⌈(⌈2⍟⍳))÷⊢

range ← ⍳
log   ← ⍟
log2  ← 2 log range
ceil  ← ⌈
bits  ← ceil log2
max   ← ⌈
fix0  ← 1 max bits
sum   ← +/
total ← sum fix0
self  ← ⊢
div   ← ÷
mean  ← sum div self

Clojure, 71 64 63 bytes

Parece que las relaciones están bien de acuerdo con ¿Qué formatos de número son aceptables en la salida?

(fn[n](/(inc(apply +(map #(.bitLength(bigint %))(range n))))n))

• n = 1 => 1
• n = 7 => 15/7

no golfed (y ligeramente reescrito para facilitar la explicación)

(fn [n]
 (->
  (->>
   (range n)                      ;;Get numbers from 0 to N
   (map #(.bitLength (bigint %))) ;;Cast numbers to BigInt so bitLength can be used
   (apply +)                      ;;Sum the results of the mapping
   (inc))                         ;;Increment by 1 since bitLength of 0 is 0
  (/ n)))                         ;;Divide the sum by N

vieja respuesta que usaba (flotante):

(fn[n](float(/(inc(apply +(map #(..(bigint %)bitLength)(range n))))n)))

la salida es como:

• n = 1 => 1.0
• n = 7 => 2.142857

Minkolang 0.15 , 23 bytes

n$z1z[i1+2l$M$Y+]kz$:N.

Pruébalo aquí!

Explicación

n$z                       Take number from input and store it in register (n)
   1                      Push 1 onto the stack
    z[                    For loop that repeats n times
      i1+                 Loop counter + 1
         2l$M             log_2
             $Y           Ceiling
               +          Add top two elements of stack
                ]         Close for loop
                 z$:      Float divide by n
                    N.    Output as number and stop.

Implementación bastante directa.

JavaScript ES5, 55 bytes

n=>eval(`for(o=0,p=n;n--;o+=n.toString(2).length/p);o`)

Explicación

n =>   // anonymous function w/ arg `n`
  for( // loop
      o=0,  // initalize bit counter to zero
      p=n   // copy the input
    ;n-- // will decrease input every iteration, will decrease until it's zero
    ;o+=    // add to the bitcounter
        n.toString(2)  // the binary representation of the current itearations's
                     .length // length
        /p   // divided by input copy (to avergage)
   );o       // return o variable  

Hoon , 71 bytes

|=
r/@
(^div (sun (roll (turn (gulf 0 (dec r)) xeb) add)) (sun r)):.^rq

... Estoy bastante seguro de que esta es la primera vez que uso los núcleos de coma flotante de Hoon. En realidad, es una implementación escrita en Hoon que se lanza a SoftFloat, ya que los únicos tipos de datos en Hoon son átomos y células.

Crear una función que toma un átomo, r. Cree una lista a partir de [0 .. (r - 1)], asigne un mapa sobre la lista tomando el logaritmo binario del número, luego doble esa lista con ++add. Convierta tanto la salida del pliegue como ra @rq(números de coma flotante de precisión cuádruple) con++sun:rq , y luego divida uno por el otro.

Lo más extraño de este fragmento es :.^rqel final. a:ben Hoon significa "evaluar a en el contexto de b". ++rqes el núcleo que contiene toda la implementación de precisión cuádruple, como una biblioteca. Entonces correr (sun 5):rqes lo mismo que hacer (sun:rq 5).

Afortunadamente, los núcleos en Hoon son como muñecas de anidación; cuando ++rqevalúas el brazo para obtener el núcleo, también agrega todo el stdlib, para que puedas seguir rodando y girando y abriéndote y todas esas cosas divertidas en lugar de quedarte atrapado solo con los brazos definidos ++rq. Desafortunadamente, rq se redefine ++addpara ser una adición de punto flotante, junto con no tener ren su contexto. .(todo el contexto actual), sin embargo.

Al evaluar una expresión en un contexto, el compilador busca primero la profundidad del miembro. En nuestro caso a:[. rq], buscaría en todo el contexto actual aantes de pasar a buscar rq. Entonces addbuscará la función que funciona en los átomos en lugar de los números de coma flotante ... pero también lo hará div. Hoon también tiene una función en la que el uso ^nameignorará la primera referencia encontrada y buscará la segunda.

A partir de ahí, es simplemente usar el azúcar sintáctico de a^bser igual a [a b]para evaluar nuestro fragmento con nuestro contexto actual y la biblioteca flotante de precisión cuádruple, ignorando el div atómico a favor de ++div:rq.

> %.  7
  |=
  r/@
  (^div (sun (roll (turn (gulf 0 (dec r)) xeb) add)) (sun r)):.^rq
.~~~2.1428571428571428571428571428571428

En realidad, 7 bytes:

;r♂├Σl/

Pruébalo en línea!

Explicación:

;r♂├Σl/
;        duplicate input
 r       push range(0, n) ([0, n-1])
  ♂├     map binary representation
    Σ    sum (concatenate strings)
     l/  divide length of string (total # of bits) by n

Si no fuera por un error que acabo de descubrir, esta solución funcionaría para 6 bytes:

r♂├♂læ

æ es el comando medio incorporado.

Vitsy, 26 bytes

Este es un primer intento, jugaré más y agregaré una explicación más adelante.

0vVV1HV1-\[2L_1+v+v]v1+V/N

Pruébalo en línea!

PowerShell v2 +, 64 bytes

param($n)0..($n-1)|%{$o+=[convert]::ToString($_,2).Length};$o/$n

Implementación muy sencilla de la especificación. Bucles de 0a $n-1con |%{...}. Cada iteración, ingresamos [convert]nuestro número de entrada $_a una base de cadena 2y tomamos su length. Acumulamos eso en $o. Después de los bucles, simplemente dividimos $o/$n, dejando eso en la tubería, y la salida es implícita.

Mientras esto sea así, en realidad es más corto que la fórmula que usan Sp y otros, [math]::Ceiling()y [math]::Log()es ridículamente prolijo. La conversión de base en PowerShell es asquerosa.

Perl 5.10, 54 bytes

for(1..<>){$u+=length sprintf"%b",$_;$n++}$u/=$n;say$u

Bastante sencillo. sprintf"%b"es una forma ordenada de generar un número en binario en Perl sin usar bibliotecas adicionales.

Pruébalo en línea!

CJam, 13 12 11 bytes

Un byte guardado gracias a @ Sp3000, y otro gracias a @ jimmy23013

rd_,2fbs,\/

Pruébalo en línea!

Explicación

Sencillo. Aplica la definición.

rd      e# read input and convert to double 
_       e# duplicate 
,       e# range from 0 to input minus 1
2fb     e# convert each element of the array to binary 
s       e# convert to string. This flattens the array
,       e# length of array 
\       e# swap 
/       e# divide 

Jolf, 10 bytes

/uΜr0xdlBH

Pruébalo aquí!

Explicación

/uΜr0xdlBH
  Μr0x      map range 0..x
      dlBH  over lengths of binary elements
/u          divide sum of this
            by implicit input (x)

Swift, 72 bytes

func f(n:Double)->Double{return n<1 ?1:f(n-1)+1+floor(log2(n))}
f(N-1)/N

J, 15 bytes

%~[:+/#@#:"0@i.

Este es un verbo monádico, usado de la siguiente manera:

   f =: %~[:+/#@#:"0@i.
   f 7
2.14286

Pruébalo aquí!

Explicación

Implementé la especificación de desafío literalmente. Hay otros enfoques, pero todos resultaron ser más largos.

%~[:+/#@#:"0@i.  Input is y
             i.  Range from 0 to y-1.
          "0@    For each number in this range:
      #@           Compute the length of
        #:         its base-2 representation.
  [:+/           Take the sum of the lengths, and
%~               divide by y.