औसत बिट्स: एक औसत चुनौती

30

एक पूर्णांक N> = 1 को देखते हुए, पूर्णांक में बिट्स की औसत संख्या को 0 से N - 1 तक आउटपुट करते हैं

विशिष्टता

  • आउटपुट को बी द्वारा विभाजित प्रत्येक पूर्णांक के बाइनरी प्रतिनिधित्व में 0 से एन -1 तक बिट्स की संख्या के योग के रूप में गणना की जा सकती है।
  • पूर्णांक के द्विआधारी प्रतिनिधित्व में शून्य के अपवाद के साथ इस संदर्भ में कोई अग्रणी शून्य नहीं है, जिसे द्विआधारी में 0 के रूप में दर्शाया गया है।
  • आउटपुट कम से कम 7 महत्वपूर्ण आंकड़ों के लिए सटीक होना चाहिए।

उदाहरण

एन = 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

बिट्स की औसत संख्या = (1 + 1 + 2 + 2 + 3 + 3) / 6 = 2

परीक्षण के मामलों

इनपुट => आउटपुट

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

लीडरबोर्ड स्निपेट

( यहां से )

कोड स्निपेट दिखाएं

ध्यान दें कि योग (माध्य को खोजने के लिए विभाजित करने से पहले) OEIS पर एक अनुक्रम है ।

code-golf  math  binary  bitwise  statistics 
— trichoplax
स्रोत
6
अच्छा नाम है, बहुत दंडनीय ।
— R
3
जो कोई नहीं जानता है, मैं एक स्पष्टीकरण के साथ समाधान को
— बढ़ाने की
4
पर्याप्त दंड नहीं, इसके लिए आपको पूर्ण होने के लिए थोड़ा और अधिक चाहिए।
— clismique
1
मैं मान रहा हूँ कि "प्रत्येक संख्या" से आपका मतलब है "प्रत्येक पूर्णांक "?
— साइओस
@Cyoce हाँ, यह इंगित करने के लिए धन्यवाद - मैंने स्पष्ट करने के लिए संपादन किया है।
— ट्राइकोप्लेक्स

जवाबों:

13

अजगर, 6 बाइट्स

.Oml.B

इसे यहाँ ऑनलाइन आज़माएँ ।

.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
— Maltysen
स्रोत
संयुक्त प्रथम स्थान पर आप लीडरबोर्ड पर दिखाई नहीं दे रहे थे - मैंने इसे ठीक करने के लिए हेडर में एक मामूली संपादन किया है।
— ट्राइकोप्लेक्स
7

ऑक्टेव, 29 बाइट्स

@(n)1+sum(fix(log2(1:n-1)))/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!)

नमूना विचारधारा पर चलता है ।

— बीकर
स्रोत
6

पायथन 3, 43 बाइट्स

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

OEIS पृष्ठ पर सूत्र का उपयोग करता है । हैरानी की बात है, असाइनमेंट की वजह से एक नामित फ़ंक्शन किसी तरह यहां सस्ता है x।

46 बाइट्स के लिए वैकल्पिक दृष्टिकोण:

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

दुर्भाग्य से, के -~बाद से आवश्यक (0).bit_length()है 0, लेकिन फिर भी यह एक बाइट बहुत लंबा होगा।

— Sp3000
स्रोत
6

जूलिया, 27 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

चूंकि *जूलिया में स्ट्रिंग समवर्ती है, prodइसका उपयोग स्ट्रिंग्स की एक सरणी को समेटने के लिए किया जा सकता है। यह वैकल्पिक रूप से एक फ़ंक्शन को पहले तर्क के रूप में लेता है जो वास्तविक "उत्पाद" लेने से पहले दूसरे पर मैप करता है, इसलिए prod(bin,0:n-1)वांछित सीमा में सभी पूर्णांकों के बाइनरी प्रतिनिधित्व का स्ट्रिंग है। लंबाई के साथ ले जाने endofऔर n से विभाजित करने से माध्य होता है।

— डेनिस
स्रोत
5

जूलिया, 28 बाइट्स

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

चूंकि binस्वचालित रूप से सरणियों पर मैप नहीं होता है, हम ceil(log2(n))बिट्स की संख्या प्राप्त करने के लिए उपयोग कर रहे हैं n-1। यह अच्छी तरह से काम करता है क्योंकि जूलिया का a:bअंकन दोनों छोरों पर समावेशी है, इसलिए 2:n2 से लेकर एक सीमा है n, लेकिन हम वास्तव में सीमा में संख्याओं के लिए बिट्स की संख्या की गणना कर रहे हैं 1:n-1। हालांकि दुर्भाग्य से, हमें 20 के लिए खाते में एक अतिरिक्त से निपटने की आवश्यकता है ।

इसे ऑनलाइन आज़माएं!

— Sp3000
स्रोत
5

MATL, 9 बाइट्स

q:ZlksG/Q

इसे ऑनलाइन आज़माएं!

सभी परीक्षण मामलों के साथ संशोधित संस्करण

व्याख्या

    % 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
— Suever
स्रोत
स्नैप !! (फिलर)
— डेविड
@ दाविद दरअसल, आपका सही था। शुरुआत में इनपुट डुप्लिकेट करना अन्य मूल्यों के लिए काम नहीं करता है ... आपको G/Qअंत में इसकी आवश्यकता है ।
— बीकर
5

MATL, 9 बाइट्स

:qBYszQG/

इसे ऑनलाइन आज़माएं!

व्याख्या

: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
— बीकर
स्रोत
5

जेली, 8 बाइट्स

कम नहीं, लेकिन दिलचस्प एल्गोरिथ्म, और मेरी पहली जेली प्रस्तुत:

Rl2Ċ»1S÷

R         1 to n
 l2       log2
   Ċ      ceiling
    »1    max of 1 and...
      S   sum
       ÷  divided by n
— एडम
स्रोत
4

जेली, 10 बाइट्स

BL©2*2_÷+®

Sp3000 के सुझाव से।

इसे यहाँ आज़माएँ।

जेली, 11 बाइट्स

æḟ2’Ḥ÷_BL$N

बहुत कम नहीं लेकिन मुझे कुछ टिप्स की जरूरत है।

इसे यहाँ आज़माएँ।

Sp3000 के उत्तर में उसी सूत्र का उपयोग करना । (ज्यामितीय प्रगति में अंतर करके इसे स्वयं प्राप्त करना बहुत कठिन नहीं है।)

— jimmy23013
स्रोत
को देखो मेरे जेली जवाब आपके संदर्भ के लिए।
— लीक नन
@LeakyNun यह एक अलग दृष्टिकोण का उपयोग कर रहा है, जो मुझे नहीं लगता कि यह कभी भी आपके मुकाबले छोटा होगा। लेकिन _BL$Nकाफी लंबा लग रहा था ...
— jimmy23013
तो मूल रूप से, आपका कोड "फर्श की निकटतम शक्ति 2, शून्य से 1, डबल, इनपुट से विभाजित, इनपुट की शून्य से द्विआधारी लंबाई, नकारात्मक" है?
— लीक नन
@LeakyNun हां ..
— jimmy23013
3
केवल मामूली रूप से बेहतर:BL©2*2_÷+®
— Sp3000
4

जावा, 135 95 90 बाइट्स

float a(int n){int i=0,t=0;for(;i<n;)t+=Integer.toString(i++,2).length();return t/(n+0f);}
— शॉन वाइल्ड
स्रोत
मुझे लगता है कि आप इंटरफ़ेस से छुटकारा पा सकते हैं और बस एक फ़ंक्शन या लैम्ब्डा बना सकते हैं। इसके अलावा आप इसे
— स्टडआउट
ठीक है, मैं उन नियमों के साथ फिर से लागू करूंगा।
— शॉन वाइल्ड
मुझे लगता है कि इसकी अनुमति दी जानी चाहिए। जैसा कि ओपी ने कुछ भी निर्दिष्ट नहीं किया है जो मुझे लगता है कि मानक I / O नियम लागू होते हैं।
— फ्रोज़न
हां एक फ़ंक्शन ठीक है - आपको एक पूर्ण कार्यक्रम की आवश्यकता नहीं है। ध्यान दें कि लीडरबोर्ड पहली पंक्ति पर स्कोर उठाता है, इसलिए आपका स्कोर वर्तमान में 95 के बजाय 135 के रूप में दिखाता है।
— ट्राइकोप्लेक्स
@trichoplax अभी भी अंतिम स्थान पर है। मैं व्यक्तिगत रूप से जावा को दोष देता हूं ...
— शॉन वाइल्ड
3

पायथन 3, 46 बाइट्स

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

जैसे बुलाओ

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

मुझे मानचित्र संशोधन को वापस करना पड़ा क्योंकि यह 5 के इनपुट के लिए विफल रहा

— Keatinge
स्रोत
3

05AB1E, 9 7 बाइट्स

कोड:

L<bJg¹/

स्पष्टीकरण:

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

इसे ऑनलाइन आज़माएं

संपादित करें: @Adnan के लिए 2 बाइट्स सहेजे गए

— Emigna
स्रोत
@ अदनान: धन्यवाद! जे के बारे में भूल गए
— एमिग्ना
3

सी #, 87 बाइट्स

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

मैंने एक C # उत्तर लिखा क्योंकि मैंने एक नहीं देखा। यह इनमें से किसी एक के लिए मेरी पहली पोस्ट है, इसलिए कृपया मुझे बताएं कि क्या मैं कुछ गलत कर रहा हूं।

— raive
स्रोत
प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है। यह एक महान पहला उत्तर है, +1। क्या आप एक बाइट को बचाने के doubleलिए बदल सकते हैं float, या क्या आपको परिशुद्धता की आवश्यकता है?
— wizzwizz4
2
@ wizzwizz4 धन्यवाद! मेरा भी यही विचार था, लेकिन औसत () दोगुना रिटर्न देता है। अगर मैं अपने रिटर्न टाइप को फ्लोट में बदलता हूं, तो मुझे स्पष्ट रूप से डबल कास्ट करना होगा और उस पर 7 बाइट्स हासिल करना होगा।
— उठाएं
2

जावास्क्रिप्ट (ईएस 7), 38 32 बाइट्स

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

@ Sp3000 के सूत्र का उपयोग करना (पिछला संस्करण एक पुनरावर्ती समाधान था)। ES6 संस्करण 34 बाइट्स के लिए:

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

सूत्र की व्याख्या: एन = 55 के मामले पर विचार करें। यदि हम द्विआधारी संख्या लिखते हैं (लंबवत रूप से स्थान बचाने के लिए), तो हम प्राप्त करते हैं:

                                11111111111111111111111
                111111111111111100000000000000001111111
        11111111000000001111111100000000111111110000000
    111100001111000011110000111100001111000011110000111
  11001100110011001100110011001100110011001100110011001
0101010101010101010101010101010101010101010101010101010

इस आयत का आकार nl है इसलिए औसत सिर्फ l है लेकिन हमें रिक्त स्थान को बाहर करने की आवश्यकता है। रिक्त की प्रत्येक पंक्ति पहले की तुलना में दोगुनी है, इसलिए कुल 2 + 4 + 8 + 16 + 32 = 64 - 2 = 2 l - 2 है।

— नील
स्रोत
2

जे, २१ 17 15 बाइट्स

17 बाइट्स से लेकर 15 बाइट्स @ डेनिस की बदौलत।

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

किसी ने मुझे यह गोल्फ में मदद कर सकते हैं? ...

अनप्लग्ड संस्करण

range        =: i.
length       =: #
binary       =: #:
sum          =: +/
divide       =: %
itself       =: ~
of           =: @
ofall        =: @:
binarylength =: length of binary "0
average      =: sum ofall divide itself
f            =: average binarylength of range
— लीक नन
स्रोत
मैंने एक वैकल्पिक दृष्टिकोण की कोशिश की, बाइनरी अंकों की सूची को कड़ा करके, और 25 बाइट्स के साथ बाहर आया %~>:@#@([:":10#.[:#:i.)-]:। आपका समाधान बल्कि इष्टतम दिख रहा है।
— कॉनर ओ'ब्रायन
2

पर्ल 6 ,  34  32 बाइट्स

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

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

स्पष्टीकरण:

{ 
  $_  # 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
}

परीक्षा:

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)
— ब्रैड गिल्बर्ट b2gills
स्रोत
2

क्लोजर, 71 64 63 बाइट्स

ऐसा लगता है कि अनुपात ठीक है जिसके अनुसार आउटपुट में कौन से संख्या प्रारूप स्वीकार्य हैं?

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

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

अपुष्ट (और स्पष्टीकरण की आसानी के लिए फिर से लिखा गया)

(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

पुराना उत्तर जो इस्तेमाल किया गया (फ्लोट):

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

आउटपुट जैसा है:

  • n = 1 => 1.0
  • n = 7 => 2.142857
— निशान
स्रोत
यह प्रश्न कि क्या अंश या अनुपात स्वीकार्य हैं, पहले नहीं उठाए गए थे। इस चुनौती के लिए मैं डिफ़ॉल्ट रूप से जो होना चाहिए उस पर जो भी सहमति बनती है उसे स्वीकार करूंगा ।
— ट्राइकोप्लेक्स
1

मिन्कोलांग 0.15 , 23 बाइट्स

n$z1z[i1+2l$M$Y+]kz$: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.

बहुत सीधा-सादा कार्यान्वयन।

— एलेंडिया स्ट्राटन
स्रोत
1

जावास्क्रिप्ट ईएस 5, 55 बाइट्स

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

व्याख्या

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
— Downgoat
स्रोत
1

हून , 71 बाइट्स

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

... मुझे पूरा यकीन है कि यह वास्तव में पहली बार है जब मैंने हून के फ्लोटिंग पॉइंट कोर का उपयोग किया है। यह वास्तव में हून में लिखा गया एक कार्यान्वयन है जो शीतलफ्लोत के लिए बाहर निकलता है, क्योंकि हून में एकमात्र डेटा प्रकार परमाणु और कोशिकाएं हैं।

एक फंक्शन बनाएं जो एक परमाणु लेता है r,। [0 .. (r - 1)] से एक सूची बनाएं, संख्या के द्विआधारी लघुगणक लेने वाली सूची पर नक्शा करें, फिर उस सूची के साथ गुना करें ++add। गुना और दोनों उत्पादन कन्वर्ट rकरने के लिए @rqके साथ (क्वाड-परिशुद्धता चल बिन्दु संख्या)++sun:rq , और उसके बाद अन्य के बाद एक विभाजित करते हैं।

इस स्निपेट में सबसे अजीब बात :.^rqअंत में है। a:bहून में इसका अर्थ है "बी के संदर्भ में एक का मूल्यांकन करें"। ++rqवह कोर है जिसमें एक पुस्तकालय की तरह संपूर्ण चतुर्थ-सटीक कार्यान्वयन होता है। इसलिए दौड़ना (sun 5):rqएक ही काम है (sun:rq 5)।

सौभाग्य से, हून में कोर घोंसले के शिकार गुड़िया की तरह हैं; जब आप ++rqकोर को प्राप्त करने के लिए हाथ का मूल्यांकन करते हैं, तो यह पूरे stdlib को भी इसमें जोड़ देता है, इसलिए आपको रोल और टर्न और खाड़ी और उस सभी मज़ेदार सामान को केवल हथियार से परिभाषित किए जाने के बजाय रखने के लिए मिलता है ++rq। इसके संदर्भ में ++addनहीं होने के साथ-साथ, अस्थायी रूप से , rq को फ़्लोटिंग-पॉइंट ऐड होना चाहिए r।.(संपूर्ण वर्तमान संदर्भ), हालांकि करता है।

एक संदर्भ में एक अभिव्यक्ति का मूल्यांकन करते समय, संकलक अंग की गहराई-पहले की तलाश करता है। हमारे मामले में a:[. rq]यह देखने के लिए aआगे बढ़ने से पहले पूरे वर्तमान संदर्भ में दिखेगा rq। तो addचल समारोह देखेंगे जो फ्लोटिंग-पॉइंट नंबरों के बजाय परमाणुओं पर काम करता है ... लेकिन ऐसा होगा div। हून में एक विशेषता भी है जहां उपयोग ^nameकरने से पहले पाए गए संदर्भ को नजरअंदाज किया जाएगा, और दूसरे की तलाश की जाएगी।

वहां से, यह केवल हमारे वर्तमान संदर्भ और क्वाड-सटीक फ्लोट लाइब्रेरी के साथ हमारे स्निपेट का मूल्यांकन a^bकरने के [a b]लिए समान होने के लिए समान मात्रा में चीनी की चीनी का उपयोग कर रहा है, जिसके पक्ष में परमाणु div की अनदेखी है ++div:rq।

> %.  7
  |=
  r/@
  (^div (sun (roll (turn (gulf 0 (dec r)) xeb) add)) (sun r)):.^rq
.~~~2.1428571428571428571428571428571428
— RenderSettings
स्रोत
1

दरअसल, 7 बाइट्स:

;r♂├Σl/

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

;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

यदि यह मेरे द्वारा खोजे गए बग के लिए नहीं था, तो यह समाधान 6 बाइट्स के लिए काम करेगा:

r♂├♂læ

æ बिलिन मीन कमांड है।

— मेगो
स्रोत
क्या यह 10 बाइट्स नहीं है? मैंने bytesizematters.com पर जाँच की।
— m654
1
@ m654 वास्तव में UTF-8 का उपयोग नहीं करता है, यह CP437 (या ऐसा कुछ) का उपयोग करता है।
— एलेक्स ए
@AlexA। ओह, वह नहीं जानता था।
— m654
1
@ m654 बाइटिज़िममैटर्स पूरी तरह से निर्मित एन्कोडिंग का उपयोग करता है जो अभ्यास में मौजूद नहीं है (और नहीं कर सकता है )। UTF-8 के लिए, mothereff.in/byte-counter का उपयोग करें ।
— डेनिस
@ डेनिस जानकारी के लिए धन्यवाद, मैं इसे ध्यान में रखूंगा।
— m654
1

PowerShell v2 +, 64 बाइट्स

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

युक्ति का बहुत सीधा कार्यान्वयन। से लूप्स 0के $n-1साथ |%{...}। प्रत्येक पुनरावृत्ति, हम एक स्ट्रिंग आधार पर [convert]हमारे इनपुट नंबर $_को 2लेते हैं और इसे लेते हैं length। हम उस में जमा होते हैं $o। छोरों के बाद, हम बस विभाजित करते हैं $o/$n, जो कि पाइपलाइन पर छोड़ते हैं, और आउटपुट निहित है।

जब तक यह है, यह वास्तव में उस फॉर्मूले से छोटा है जिसे Sp & others उपयोग कर रहे हैं, क्योंकि [math]::Ceiling()और [math]::Log()हास्यास्पद रूप से चिंताजनक हैं। PowerShell में बेस रूपांतरण यकी है।

— AdmBorkBork
स्रोत
1

पर्ल 5.10, 54 बाइट्स

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

बहुत सीधा है। sprintf"%b"अतिरिक्त पुस्तकालयों का उपयोग किए बिना पर्ल में बाइनरी में एक संख्या को आउटपुट करने का एक साफ तरीका है।

इसे ऑनलाइन आज़माएं!

— पॉल पिकार्ड
स्रोत
1

सीजाम, 13 12 11 बाइट्स

एक बाइट ने @ Sp3000 को धन्यवाद दिया, और दूसरा @ @ jimmy23013 को धन्यवाद दिया

rd_,2fbs,\/

इसे ऑनलाइन आज़माएं!

व्याख्या

सीधा। परिभाषा लागू करता है।

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
— लुइस मेंडो
स्रोत
1

स्विफ्ट, 72 बाइट्स

func f(n:Double)->Double{return n<1 ?1:f(n-1)+1+floor(log2(n))}
f(N-1)/N
— जॉन मैकडॉवल
स्रोत
2
आपको फ़ंक्शन को कॉल करने की आवश्यकता नहीं है, इसे परिभाषित फ़ंक्शन के रूप में छोड़ देना ठीक है। अच्छी पहली पोस्ट।
— Rɪᴋᴇʀ
1

जे, 15 बाइट्स

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

यह एक राक्षसी क्रिया है, जिसका उपयोग इस प्रकार है:

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

यहाँ कोशिश करो!

व्याख्या

मैंने सचमुच चुनौती चुनौती लागू की। अन्य दृष्टिकोण हैं, लेकिन सभी लंबे समय तक बने रहे।

%~[:+/#@#:"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.
— Zgarb
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.