रेंज में गिनती

20

चुनौती :

1एक सीमा के बीच सभी संख्याओं के द्विआधारी प्रतिनिधित्व में लोगों की संख्या की गणना करें ।

इनपुट:

दो गैर-दशमलव सकारात्मक पूर्णांक

आउटपुट:

1दो संख्याओं के बीच सीमा में सभी s का योग ।

उदाहरण :

4 , 7        ---> 8
4  = 100 (adds one)   = 1
5  = 101 (adds two)   = 3
6  = 110 (adds two)   = 5
7  = 111 (adds three) = 8

10 , 20     ---> 27
100 , 200   ---> 419
1 , 3       ---> 4
1 , 2       ---> 2
1000, 2000  ---> 5938

मैंने केवल पहले उदाहरण की व्याख्या की है अन्यथा यदि मैंने उन सभी के लिए समझाने की कोशिश की तो बहुत बड़ी मात्रा में जगह ले ली होगी।

ध्यान दें :

  • संख्या 1000 से अधिक हो सकती है
  • सभी इनपुट मान्य होंगे।
  • न्यूनतम आउटपुट एक होगा।
  • आप संख्या को दो तत्वों की एक सरणी के रूप में स्वीकार कर सकते हैं।
  • आप चुन सकते हैं कि संख्याओं का आदेश कैसे दिया जाता है।

जीत मापदंड:

यह प्रत्येक भाषा की जीत के लिए बाइट्स में कोड-गोल्फ इतना छोटा कोड है।

code-golf  math  number  binary 
— मुहम्मद सलमान
स्रोत
1
— लीक नून
1
क्या हम इनपुट को कुछ प्रकार के रेंज प्रकार ( IntRangeकोटलिन में, Rangeरूबी में) के रूप में ले सकते हैं?
— घोंघा_
मजेदार तथ्य: केस की 1000 - 2000पैदावार 5938 है, लेकिन मामले को 1000 से कम कर देता है, परिणाम भी 1000 तक गिर जाता है 0-1000 = 4938:। प्रमाण
— १:00

जवाबों:

9

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

करी सिंटैक्स में इनपुट लेता है (a)(b)।

a=>b=>(g=c=>a>b?0:1+g(c^c&-c||++a))(a)

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

टिप्पणी की गई

a => b => (         // given the input values a and b
  g = c =>          // g = recursive function taking c = current value
    a > b ?         // if a is greater than b:
      0             //   stop recursion and return 0
    :               // else:
      1 +           //   add 1 to the final result
      g(            //   and do a recursive call to g() with:
        c ^ c & -c  //     the current value with the least significant bit thrown away
        || ++a      //     or the next value in the range if the above result is 0
      )             //   end of recursive call
)(a)                // initial call to g() with c = a
— Arnauld
स्रोत
5

जावा (JDK 10) , 55 बाइट्स

a->b->{int c=0;for(;a<=b;)c+=a.bitCount(b--);return c;}

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

— ओलिवियर ग्रेजायर
स्रोत
IntStream.range(a,b+1).map(Integer::bitCount).sum()
— शक 1029
@ saka1029 आयात अनिवार्य है। तो यह वास्तव में a->b->java.util.stream.IntStream.range(a,b+1).map(Integer::bitCount).sum(), पूरे 74 बाइट्स के लिए है। यहां तक ​​कि अगर आयात अनिवार्य नहीं था, तो पैरामीटर हैं, इसलिए हमें लिखना होगा a->b->IntStream.range(a,b+1).map(Integer::bitCount).sum(), जो 57 बाइट्स के रूप में गिना जाता है
— ओलिवियर ग्रेजायर
आप a->b->IntStream.range(a,b+1).map(Long::bitCount).sum()1 बाइट सुधार के लिए भी हो सकते हैं । सीमांत, लेकिन फिर भी एक।
— NotBaal
@NotBaal जैसा कि ऊपर टिप्पणी में ओलिवियर ने उल्लेख किया है, आयात अनिवार्य है, इसलिए यह a->b->java.util.stream.IntStream.range(a,b+1).map(Long::bitCount).sum()(71 बाइट्स) होना चाहिए ।
— केविन क्रूज़सेन 13
4

आर , 41 34 बाइट्स

function(a,b)sum(intToBits(a:b)>0)

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

भारी रूप से एनजीएम द्वारा अन्य आर समाधान से प्रेरित है । बिट्स में रूपांतरण के बाद यह एक अलग दृष्टिकोण का उपयोग करता है। एक संभावित 34 बाइट्स समाधान पर इशारा करने के लिए Giuseppe के लिए बहुत धन्यवाद।

— Jayce
स्रोत
34 बाइट संभव है! मैं भूल जाता हूं कि मैंने कहां देखा था (मुझे पता है कि मैं इसके साथ नहीं आया था), लेकिन एक sumमिलिबल वेक्टर के लिए एक ट्रिकियर रूपांतरण है - मैं पोस्ट करूंगा यदि आप / एनजीएम इसे नहीं पा सकते हैं।
— ग्यूसेप
@Giuseppe वास्तव में!
— JayCe
2
मैंने इसे 37 बाइट्स में एक तकनीक का उपयोग करके प्राप्त किया जो अन्यथा उपयोगी हो सकता है। यह भी पता चला है कि sdऔर varकुछ भी वे दोगुना करने के लिए मजबूर कर सकते हैं।
— एनजीएम
आप pryr::f4 बाइट बचाने के लिए उपयोग कर सकते हैं : tio.run/##K/qfZvu/…
— पजाकों
@ पाजोंक अच्छी बात! लेकिन मैं R + pryr की बजाय बेस R पैकेज से चिपकना चाह रहा हूं। मैं मेटा पर खोज करने जा रहा हूं जिसे "शुद्ध आर" माना जा सकता है।
— JayCe
3

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

rBFS

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

व्याख्या

rBFS - पूर्ण कार्यक्रम। कमांड लाइन तर्क से दो इनपुट लेता है।
आर - रेंज।
 बी - प्रत्येक के लिए, बाइनरी में कनवर्ट करें।
  एफएस - समतल और योग।
— श्री Xcoder
स्रोत
O_o, यह तेज़ था?
— मुहम्मद सलमान
@MuhammadSalman खैर, चुनौती भी तुच्छ IMO की तरह है।
— श्री एक्सकोडर
यह हो सकता है, लेकिन पोस्ट करने के एक मिनट बाद एक उत्तर।
— मुहम्मद सलमान
1
@MuhammadSalman हाँ, यह वास्तव में इस तरह की तुच्छ चुनौतियों के लिए उपवास नहीं है; जेली का ज्ञान भी बढ़ता है। वास्तविक प्रयास इस महीने की भाषा में जाता है, QBasic। ;-)
— आउटगोल्फ़र
@EriktheOutgolfer: क्या आप इसका उत्तर QBasic / BrainF ** k में दे सकते हैं?
— मुहम्मद सलमान
2

बैश + आम उपयोगिताओं, 50

jot -w%o - $@|tr 247356 1132|fold -1|paste -sd+|bc

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

पूर्णांक को बाइनरी स्ट्रिंग्स में कनवर्ट करना हमेशा बैश में थोड़ा दर्द होता है। यहां दृष्टिकोण थोड़ा अलग है - पूर्णांक को ऑक्टल में परिवर्तित करें, फिर प्रत्येक ओक्टल अंक को बाइनरी 1s की संख्या से बदलें जिसमें यह शामिल है। तब हम सभी परिवर्तित अंकों को जोड़ सकते हैं

— डिजिटल आघात
स्रोत
2

एपीएल + विन, 33 26 बाइट्स

पूर्णांक के वेक्टर के लिए संकेत:

+/,((↑v)⍴2)⊤(1↓v)+0,⍳-/v←⎕

इसे ऑनलाइन आज़माएं! दलोग क्लासिक के सौजन्य से

स्पष्टीकरण:

v←⎕ prompt for input of a vector of two integers max first

(v←1↓v)+0,⍳-/ create a vector of integers from min to max

(↑v)⍴2 set max power of 2 to max 

⊤ convert integers to a matrix of binaries

+/, convert matrix to a vector and sum
— ग्राहम
स्रोत
2

संचार टूलबॉक्स के साथ ऑक्टेव , 21 बाइट्स

@(a,b)nnz(de2bi(a:b))

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

कोड काफी स्पष्ट होना चाहिए। श्रेणी में प्रत्येक संख्या के द्विआधारी प्रतिनिधित्व में गैर-अक्षीय तत्वों की संख्या।

यह @(a,b)nnz(dec2bin(a:b)-48)बिना कम्युनिकेशन टूलबॉक्स के होगा।

— स्टीवी ग्रिफिन
स्रोत
1

PHP, 97 बाइट्स

(सुनिश्चित करें कि इसे छोटा किया जा सकता है, लेकिन कार्यों का उपयोग करना चाहते हैं)

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

कोड

<?=substr_count(implode(array_map(function($v){return decbin($v);},
 range($argv[0],$argv[1]))),1);

व्याख्या

<?=
 substr_count(   //Implode the array and count every "1"
  implode(
    array_map(function($v){return decbin($v);}, //Transform every decimal to bin
          range($argv[0],$argv[1])   //generate a range between the arguments
     )
),1);   //count "1"'s
— फ्रांसिस्को हैन
स्रोत
यह तुम सिर्फ कर सकते हैं लगता है इस
— dzaima
एक सेकंड के लिए मैं बिल्कुल भूल गया कि आप php फ़ंक्शन का नाम सीधे एक पैरामीटर के रूप में सेट कर सकते हैं :-(
— फ्रांसिस्को हैन
$argv[0]कार्यक्रम का नाम या "-" है; आप साथ काम करना चाहिए $argv[1]और $argv[2]। और आप joinइसके बजाय implode68 बाइट्स को छोटा करने के लिए उपयोग कर सकते हैं :<?=substr_count(join(array_map(decbin,range($argv[1],$argv[2]))),1);
— टाइटस
1

पॉवरशेल , 72 बाइट्स

param($x,$y)$x..$y|%{$o+=([convert]::ToString($_,2)-replace0).length};$o

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

लंबे समय से बाइनरी में रूपांतरण [convert]::ToString($_,2)और शून्य से छुटकारा पाने के कारण -replace0। अन्यथा हम केवल इनपुट नंबर लेते हैं, एक सीमा बनाते हैं $x..$yऔर सीमा में प्रत्येक संख्या के लिए इसे द्विआधारी में परिवर्तित करते हैं, शून्य हटाते हैं, .lengthइसके लिए (यानी शेष लोगों की संख्या) लेते हैं, और इसे हमारे $output में जोड़ते हैं ।

— AdmBorkBork
स्रोत
countइसके बजाय उपयोग करने का प्रयास करें length:)
— mazzy
1
@ माज़ी countहमेशा होगा 1क्योंकि हम lengthएक स्ट्रिंग की गिनती कर रहे हैं , एक सरणी नहीं।
— AdmBorkBork
स्ट्रिंग! तुम सही हो। धन्यवाद। -replace0चतुर है।
— माज़ी
1

बैश + कोरुटिल्स, 38 32 बाइट्स

seq -f2o%.fn $*|dc|tr -d 0|wc -c

6 बाइट बंद करने के लिए @Cowsquack को धन्यवाद!

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

— डेनिस
स्रोत
अच्छा दृष्टिकोण, आप 6 बाइट्स दाढ़ी बनाने के लिए dc का उपयोग कर सकते हैं,seq -f2o%fp $*|dc|tr -cd 1|wc -c
— Kritii Lithos
1

के (ngn / k) , 19 13 बाइट्स

{+//2\x_!1+y}

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

{ }तर्कों के साथ एक समारोह है xऔरy

!1+y सूची 0 1 ... y है

x_ पहले एक्स तत्वों को गिराता है

2\ प्रत्येक इंट को समान लंबाई के द्विआधारी अंकों की सूची के रूप में एनकोड करता है (यह ngn / k के लिए विशिष्ट है)

+/ योग

+//अभिसरण तक योग; इस मामले में सभी बाइनरी अंक सूचियों का योग है

— NGN
स्रोत
1

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

ब्रैड गिल्बर्ट के लिए -1 बाइट्स धन्यवाद

{[…](@_)>>.base(2).comb.sum}

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

स्पष्टीकरण:

[…](@_)    #Range of parameter 1 to parameter 2
       >>    #Map each number to
                      .sum  #The sum of
                 .comb      #The string of
         .base(2)    #The binary form of the number
— मजाक कर रहा है
स्रोत
1
आप इसे एक बाइट से कम कर सकते हैं यदि आप [...](@_)इसके बजाय का उपयोग करते हैं($^a..$^b)
— ब्रैड गिल्बर्ट b2gills
1

जे , 16, 15 14 बाइट्स

1 बाइट FrownyFrog के लिए धन्यवाद बचा लिया!

+/@,@#:@}.i.,]

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

स्पष्टीकरण:

एक डाइएडिक क्रिया, बाएं तर्क सीमा mकी निचली सीमा है, सही एक - ऊपरी n।

            ,    append                      
             ]   n to the
          i.     list 0..n-1
         }.      drop m elements from the beginning of that list 
      #:@        and convert each element to binary 
    ,@           and flatten the table
 +/@             and find the sum
— गैलेन इवानोव
स्रोत
क्या आप इसे 14 बना सकते हैं?
— फ्राउनफ्रॉग
@FrownyFrog मैं आज बाद में कोशिश करूँगा (जाहिरा तौर पर यह संभव है, जब से आप पूछ रहे हैं :))
— गैलेन इवानोव
@FrownyFrog 15 अभी के लिए, मैं अभी भी कोशिश कर रहा हूं ...
— गेलन इवानोव
1
14
— FrownyFrog
@FrownyFrog आह, इतना आसान! मैं के बारे में सोच रहा था, }.लेकिन हमेशा कांटे में और हुक में नहीं। धन्यवाद!
— गैलेन इवानोव
1

QBasic, 95 93 83 82 बाइट्स

@ डॉल्स ने मुझे कुछ बाइट्स से बचाया !

इस तकनीक का उपयोग करके एक अन्य बाइट को बचाया !

INPUT a,b
FOR i=a TO b
k=i
FOR j=i TO 0STEP-1
x=k>=2^j
s=s-x
k=k+x*2^j
NEXT j,i
?s

महीने की भाषा FTW!

व्याख्या

INPUT a,b           Ask user for lower and upper bound
FOR i=a TO b        Loop through that range
k=i                 we need a copy of i to not break the FOR loop
FOR j=i TO 0STEP-1  We're gonna loop through exponents of 2 from high to low.
                    Setting the first test up for 4 to 2^4 (etc) we know we're overshooting, but that 's OK
x=k>=2^j            Test if the current power of 2 is equal to or smaller than k 
                    (yields 0 for false and -1 for true)
s=s-x               If k is bigger than 2^j, we found a 1, so add 1 to our running total s
                    (or sub -1 from the total s...)
k=k+x*2^j           Lower k by that factor of 2 if the test is true, else by 0
NEXT                Test the next exponent of 2
NEXT                process the next number in range
?s                  print the total

1000 से 2000 का अंतिम टेस्टकेस वास्तव में काम करता है, क्यूबासिक 4.5 में डॉसबॉक्स पर चल रहा है: Hij doet हेत!

— steenbergh
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.