पतला इंटीजर रकम

Question

एक सकारात्मक पूर्णांक को द्विआधारी विस्तार में दो बिट्स के बीच सम्मिलित करके पतला किया जा सकता है 0। इसका मतलब यह है कि एक n-बिट संख्या में n-1dilutions है, जो जरूरी नहीं कि सभी अलग हैं।

उदाहरण के लिए, 12(या 1100बाइनरी में), dilutions हैं

11000 = 24
   ^

11000 = 24
  ^

10100 = 20
 ^

इस चुनौती में, हम मूल संख्या से अनन्य सभी dilutions का योग लेने जा रहे हैं। के लिए 12, 24, 24, 20परिणामों का योग लेना 68, इसलिए 68इसके लिए आउटपुट होना चाहिए 12।

चुनौती

n > 1इनपुट, आउटपुट के रूप में एक सकारात्मक पूर्णांक दिया गया है।

उदाहरण

in    out
---   ---
2       4
3       5
7      24
12     68
333  5128
512  9216

नियम

• इनपुट और आउटपुट को आपकी भाषा के मूल पूर्णांक प्रकार में फिट करने के लिए ग्रहण किया जा सकता है।
• इनपुट और आउटपुट किसी भी सुविधाजनक प्रारूप में दिए जा सकते हैं ।
• या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

क्या "किसी भी सुविधाजनक प्रारूप" में एक बाइनरी स्ट्रिंग शामिल है?

— झबरा

@ शैगी "किसी भी सुविधाजनक प्रारूप" का उद्देश्य इनपुट / आउटपुट के तरीकों का समावेश करना है , प्रारूप का नहीं । जैसे, मैं नहीं कहने जा रहा हूं, आपको पूर्णांक या उस पूर्णांक का प्रतिनिधित्व करने वाले स्ट्रिंग के रूप में इनपुट लेना चाहिए।

— AdmBorkBork

अच्छी चुनौती!

— मनीष कुंडू

यह अनुक्रम वर्तमान में (30 जनवरी 2018) OEIS में नहीं है

— Giuseppe

Answer 1

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

f=lambda n,i=2:n/i and n*2-n%i+f(n,i*2)

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

---

कैसे?

पुनरावर्ती फ़ंक्शन की प्रत्येक कॉल एक एकल कमजोर पड़ने की गणना करती है। सम्मिलित की स्थिति 0है log2(i)। फ़ंक्शन तब तक पुनरावृत्ति करता है जब तक कि iइससे बड़ा नहीं हो जाता है nऔर सम्मिलन संख्या के बाईं ओर होगा। यदि i>n, n/iमूल्यांकन करता है 0, जो कि पायथन में एक मिथ्या मूल्य है।

n*2पूरे नंबर एक बाइनरी अंक को छोड़ देता है, n%iया n % 2**(position of insertion)उस भाग के मूल्य की गणना करता है जिसे बाएं नहीं स्थानांतरित किया जाना चाहिए। यह मान स्थानांतरित संख्या से घटाया जाता है।

उदाहरण (n = 7)

call       n/i          bin(n)  n*2     n%i   dilution       return value

f(7, i=2)  3 => truthy  0b111   0b1110  0b1   0b1101 = 13    13 + f(7, 2*2) = 13 + 11 = 24
f(7, i=4)  1 => truthy  0b111   0b1110  0b11  0b1011 = 11    11 + f(7, 4*2) = 11 + 0 = 11
f(7, i=8)  0 => falsy                                        0

Answer 2

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

BJṖ2*ɓdḅḤ}S

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

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

BJṖ2*ɓdḅḤ}S  Main link. Argument: n (integer)

B            Binary; convert n to base 2. This yields a digit array A.
 J           Indices; yield [1, ..., len(A)].
  Ṗ          Pop; remove the last element, yielding [1, 2, ..., len(A)-1].
   2*        Elevate 2 to these powers, yielding [2, 4, ..., 2**(len(A)-1)].
             Let's call the result B.
     ɓ       Begin a new, dyadic chain, with left argument n and right argument B.
      d      Divmod; yield [n/b, n%b], for each b in B.
        Ḥ}   Unhalve right; yield 2b for each b in B, i.e., [4, 8, ..., 2**len(A)].
       ḅ     Unbase; convert each [n/b, n%b] from base 2b to integer, yielding
             (2b)(n/b) + (n%b).
          S  Take the sum.

Answer 3

MATL , 13 बाइट्स

tZl:W&\5ME*+s

MATL ऑनलाइन पर यह कोशिश करो ! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

12उदाहरण के रूप में इनपुट पर विचार करें ।

t     % Implicit input. Duplicate
      % STACK: 12, 12
Zl    % Binary logarithm
      % STACK: 12, 3.584962500721156
:     % Range (rounds down)
      % STACK: 12, [1 2 3]
W     % Power with base 2, element-wise
      % STACK: 12, [2 4 8]
&\    % 2-output modulus, element-wise: pushes remainders and quotients
      % STACK: [0 0 4], [6 3 1]
5M    % Push array of powers of 2, again
      % STACK: [0 0 4], [6 3 1], [2 4 8]
E     % Multiply by 2
      % STACK: [0 0 4], [6 3 1], [4 8 16]
*     % Multiply, element-wise
      % STACK: [0 0 4], [24 24 16]
+     % Add, element-wise
      % STACK: [24 24 20]
s     % Sum of array. Implicit display
      % STACK: 68

Answer 4

सी,  58  56 बाइट्स

दो बाइट बचाने के लिए @ डेनिस का धन्यवाद!

s,k;f(n){for(s=0,k=2;k<=n;k*=2)s+=n/k*k*2+n%k;return s;}

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

सी (जीसीसी) , 50 बाइट्स

s,k;f(n){for(s=0,k=2;k<=n;)s+=n%k+n/k*(k+=k);k=s;}

द्वारा लौटाना k=s;अपरिभाषित व्यवहार है, लेकिन अनुकूलन के अक्षम होने पर जीसीसी के साथ काम करता है। इसके अलावा, n%k+n/k*(k+=k)है अनिर्दिष्ट व्यवहार है, लेकिन जीसीसी के साथ काम ठीक लगता है।

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

Comments

s,k;f(n){for(s=0,k=2;k<=n;)s+=n%k+n/k*(k*=2);return s;}(55 बाइट्स)

— केविन क्रूज़सेन

कोई भी नहीं बता रहा है कि पहले किसका मूल्यांकन किया जाता है n%kया n/k*(k*=2)।

— १

@KevinCruijssen किस पक्ष का मूल्यांकन किया गया है पहले अनिर्दिष्ट है। C ऐसा ही है ...

— Steadybox

आह, मुझे लगता है कि आपने अपने उत्तर में वास्तव में जोड़ा है। नहीं जानता था कि इस तरह के अपरिभाषित व्यवहार सी में हुआ था। मुझे सी में तीन घंटे का अनुभव है, इसलिए मुझे इसके बारे में कुछ भी पता नहीं है। TIL :) जावा for(s=0,k=2;k<=n;)s+=n%k+n/k*(k*=2);return s;में पूरी तरह से ठीक है, और n%kहमेशा पहले मूल्यांकन किया जाएगा n/k*(k*=2)और पहले n/kभी मूल्यांकन करेगा k*=2। स्पष्टीकरण के लिए धन्यवाद। (अव्यवस्था को कम करने के लिए अब मैं अपनी कुछ टिप्पणियों को हटा दूंगा।)

— केविन क्रूज़सेन

मुझे एक सुविधा के रूप में यूबी का उपयोग करना पसंद है। और एक वास्तविक जीवन की भाषा में कोड गोल्फिंग वैसे भी एक और श्रेणी में होनी चाहिए :)

— रेगिस पोर्टालेज़

Answer 5

जेली , ९ by बाइट्स

BḊḄÐƤạḤS

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

B                        to binary          42 -> 1 0 1 0 1 0
 Ḋ                       drop first                 0 1 0 1 0
  ḄÐƤ                    each suffix to decimal   10 10 2 2 0
      Ḥ                  double the input                  84
     ạ                   absolute difference   74 74 82 82 84
       S                 add them up                      396

इसके विपरीत B¹ƤṖ+BḄS,: उपसर्ग प्राप्त करें, अंतिम छोड़ें, उन्हें इनपुट और योग में जोड़ें।

Answer 6

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

+/@}:@:+[\&.#:

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

15 बाइट्स

1#.-,+:-#.\.@#:

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

     +:             Input×2
       -            Subtract
        #.\.@#:     The list of binary suffixes of input (in decimal)
   -,               Append negative input
1#.                 Add them up

Comments

डबल माइनस फॉर्मूला क्यों काम करता है? यह dilutions के बराबर क्यों है?

— जोनाह

@ जोना के कमजोर पड़ने से एक निश्चित बाइनरी प्रीफ़िक्स (संख्या "राउंड डाउन डाउन") संख्या में जुड़ जाती है, जो पूरी संख्या को अपने आप में जोड़ने के बराबर है (प्रीफ़िक्स और शेष दोनों) और फिर शेष को घटाते हुए।

— FrownyFrog

Answer 7

जाप , 12 11 बाइट्स

¢¬£¢iYTÃÅxÍ

कोशिश करो

---

व्याख्या

                 :Implicit input of integer U
¢                :Convert to base-2 string
 ¬               :Split to an array of individual characters/digits
  £    Ã         :Map over the elements, with Y being the current 0-based index
   ¢             :  Convert U to a base-2 string
    iYT          :  Insert a 0 in that string at index Y
        Å        :Slice off the first element of the array
          Í      :Convert each element to a base-10 integer
         x       :Reduce by addition

Answer 8

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

सहेजा गया 1 बाइट Mr.Xcoder का धन्यवाद

f=(n,k=1)=>k<n&&(n&k)+2*(n&~k)+f(n,k-~k)

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

f=(n,k=1)=>k<n&&(n&k)+2*(n&~k)+f(n,k-~k)

console.log(f(2  )) //    4
console.log(f(3  )) //    5
console.log(f(7  )) //   24
console.log(f(12 )) //   68
console.log(f(333)) // 5128
console.log(f(512)) // 9216

Answer 9

रेटिना , 53 50 47 बाइट्स

.+
*
+`(_+)\1
$1O
O_
_
L$`\B
$`O$'
+%`\B
¶$`¶
_

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। संपादित करें: @MartinEnder के लिए 3 बाइट्स सहेजे गए। स्पष्टीकरण:

.+
*
+`(_+)\1
$1O
O_
_

दशमलव से बाइनरी में कनवर्ट करें, लेकिन 0 का प्रतिनिधित्व करने के लिए ओ का उपयोग करना, क्योंकि यह एक अंक नहीं है, और _ 1 का प्रतिनिधित्व करने के लिए, क्योंकि यह रेटिना 1 में डिफ़ॉल्ट पुनरावृत्ति चरित्र है।

L$`\B
$`O$'

अंकों की प्रत्येक जोड़ी के बीच एक ओ डालें, और सूची के रूप में परिणाम एकत्र करें।

+%`\B
¶$`¶

बाइनरी से यूनरी में परिवर्तित करें। (यह रूपांतरण अतिरिक्त Oएस उत्पन्न करता है , लेकिन हमें परवाह नहीं है।)

_

योग करें और दशमलव में परिवर्तित करें।

Comments

बाइनरी से दशमलव रूपांतरण 12 बाइट्स में किया जा सकता है (3 की बचत): tio.run/##K0otycxLNPz/… यह उत्तर देखें कि यह कैसे काम करता है।

— मार्टिन एंडर

@MartinEnder धन्यवाद, मैं उस के बारे में भूल रहा हूँ। (मैं थोड़ा निराश भी हुआ कि वैकल्पिक संस्करण केवल एक ही नंबर पर काम करता है।)

— नील

ठीक है, उस स्थिति में जहां आपको प्रत्येक संख्या अपनी लाइन पर मिली है आप इसे अतिरिक्त के साथ काम कर सकते हैं %। यदि यह अधिक जटिल है तो आपको कुछ पसंद करना होगा /[O_]+/_।

— मार्टिन एंडर

Answer 10

पायथ , 13 बाइट्स

smiXd.BQZ2Ssl

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

व्याख्या

smiXd.BQZ2Ssl | पूरा कार्यक्रम।

           एसएल | इनपुट का आधार -2 लघुगणक, एक पूर्णांक पर तैरता है।
          एस | पूर्णांक श्रेणी बनाएं [1 ... फ़्लॉइड लॉगरिथम]।
 एम | और इसके ऊपर एक फंक्शन को मैप करें।
------------ + - + ----------------------------------- ------------------
  iXd.BQZ2 | मैप किया जाने वाला फ़ंक्शन (एक चर d का उपयोग करता है)।
     .BQ | इनपुट के बाइनरी प्रतिनिधित्व में ...
   XZ | ... एक शून्य डालें ...
    डी | ... इंडेक्स में डी।
  मैं २ | और परिणाम को आधार 2 से पूर्णांक में बदलें।
------------ + - + ----------------------------------- ------------------
s | परिणामी सूची को जोड़ो।

Answer 11

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

BµLḤ_J’×µḄ

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

वर्तमान में सबसे छोटा नहीं है, लेकिन ऐसा हो सकता है कि कोई रास्ता हो Bµ µḄ...

व्याख्या

BµLḤ_J’×µḄ    Main link. Argument: n (integer)
B             Binary; convert n to an binary of binary digits. Call this A.
 µ            Start a new monadic link with argument A.
  L           Length; yield len(A). We'll call this l.
   Ḥ          Unhalve; yield l * 2.
     J        Length range; yield [1, 2, ..., l].
    _         Subtract; yield [l*2 - 1, l*2 - 2, ..., l].
      ’       Decrement; subtract one from each item.
       ×      Multiply each item by the corresponding item in A. Call this B.
        µ     Start a new monadic link with argument B.
         Ḅ    Unbinary; convert from a binary array to a decimal.

मूल रूप से, यह प्रत्येक बाइनरी अंक को एक जादुई संख्या से गुणा करके काम करता है। मैं इसे देखे बिना इसकी व्याख्या नहीं कर सकता, इसलिए यहाँ हम जिस बाइनरी नंबर के साथ काम कर रहे हैं:

1111

जैसा कि चुनौती से समझाया गया है, वह चाहता है कि हम इन बाइनरी नंबरों का योग करें:

10111  = 2^4 + 2^2 + 2^1 + 2^0
11011  = 2^4 + 2^3 + 2^1 + 2^0
11101  = 2^4 + 2^3 + 2^2 + 2^0

हालांकि, हमें वास्तव में शून्य सम्मिलित करने की आवश्यकता नहीं है: जेली का "अनबिन्टरी" परमाणु सिर्फ 0और केवल के अलावा अन्य संख्याओं को स्वीकार करेगा 1। जब हम खुद को उपयोग करने की अनुमति देते हैं 2, तो यह पैटर्न सरल हो जाता है:

2111   = 2*2^3 + 1*2^2 + 1*2^1 + 1*2^0
2211   = 2*2^3 + 2*2^2 + 1*2^1 + 1*2^0
2221   = 2*2^3 + 2*2^2 + 2*2^1 + 1*2^0

जब हम प्रत्येक कॉलम में अंकों को जोड़ते हैं, तो हम प्राप्त करते हैं

6543   = 6*2^3 + 5*2^2 + 4*2^1 + 3*2^0 = 48 + 20 + 8 + 3 = 79.

इस उत्तर का उपयोग इस चाल को उत्पन्न करने के लिए किया जाता है, और आवश्यक कॉलम को रद्द करने के लिए मूल में इसी अंक से प्रत्येक अंक को गुणा करें। 12, उदाहरण के लिए, के रूप में प्रतिनिधित्व किया जाएगा

 1100
×6543
=6500  = 6*2^3 + 5*2^2 + 0*2^1 + 0*2^0 = 48 + 20 + 0 + 0 = 68.

Answer 12

जावा 8, 55 बाइट्स

n->{int r=0,i=2;for(;i<=n;r+=n%i+n/i*(i*=2));return r;}

Steadybox C उत्तर के पोर्ट , और इस प्रक्रिया में 3 बाइट्स को गढ़ा।

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

Answer 13

भूसी , 13 12 बाइट्स

-1 बाइट @Mr को धन्यवाद। Xcoder!

ṁḋ§z·+Θḣotṫḋ

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

व्याख्या

ṁḋ§z·+Θḣ(tṫ)ḋ  -- example input: 6
            ḋ  -- convert to binary: [1,1,0]
  §            -- fork argument
        (tṫ)   -- | tail of tails: [[1,0],[0]]
       ḣ       -- | heads: [[1],[1,1],[1,1,0]]
   z           -- and zipWith the following (example with [1,0] [1])
    · Θ        -- | prepend 0 to second argument: [0,1]
     +         -- | concatenate: [1,0,0,1]
               -- : [[1,0,1,0],[1,1,0,0]]
ṁ              -- map the following (example with [1,0,1,0]) and sum
 ḋ             -- | convert from binary: 10
               -- : 22

Answer 14

05AB1E , 14 बाइट्स

.²LoDŠ‰ø`r·*+O

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

Answer 15

पिप , 21 18 बाइट्स

2*a-a%2**_MS1,#TBa

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

व्याख्या

हमारे इनपुट नंबर पर कॉल करें a। प्रत्येक बाइनरी इंडेक्स के iलिए जिस पर हम एक शून्य सम्मिलित करना चाहते हैं, हम सम्मिलन बिंदु के बचे हुए बिट्स की गणना कर सकते हैं a // 2**i(जहां //पूर्णांक विभाजन है और **घातांक है), सम्मिलन बिंदु के दाईं ओर बिट्स a % 2**i, और इसलिए के रूप में पतला पूर्णांक 2 * (a // 2**i) * 2**i + (a % 2**i)। लेकिन (a // 2**i) * 2**iइसके बराबर है a - (a % 2**i), और इसलिए हम एक छोटे सूत्र को पुनर्व्यवस्थित कर सकते हैं: 2 * (a - a % 2**i) + a % 2**i= 2 * a - a % 2**i।

2*a-a%2**_MS1,#TBa
                       a is 1st command-line argument (implicit)
               TBa     Convert a to binary
              #        Length of the binary expansion
            1,         Range from 1 up to (but not including) that number
          MS           Map this function to the range and sum the results:
2*a-a%2**_              The above formula, where _ is the argument of the function
                       The final result is autoprinted

Answer 16

आर , 141 48 बाइट्स

function(n,l=2^(1:log2(n)))sum(n%%l+(n%/%l*2*l))

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

या तो मैं वास्तव में कुछ गलत कर रहा हूं या आर थोड़ा सा हेरफेर में भयानक है। पोर्टिंग लुइस मेंडो का दृष्टिकोण आसान, सही और गोल्फ है।

लेकिन अगर आप वास्तव में बस थोड़ा सा ऑपरेशन करना चाहते हैं, तो मिकी ने निम्नलिखित 105 बायटर का सुझाव दिया:

function(i)sum(sapply(1:max(which(b<-intToBits(i)>0)),function(x)packBits(head(append(b,F,x),-1),"i")))-i

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

Comments

यहाँ एक 111 बाइट है जो मुझे यकीन है कि आप कुछ और ले सकते हैं।

— मिकी टीटी

@ मिक्की चियर्स! बहुत अच्छा है, हालांकि एक पूरी तरह से अलग दृष्टिकोण पोर्टिंग बेहतर है!

— ग्यूसेप

Answer 17

पायथन 3, 92 80 78 बाइट्स

def b(x):x=f'{x:b}';return sum(int(x[:i]+'0'+x[i:],2)for i in range(1,len(x)))

यह ऑनलाइन की कोशिश करो

क्रमशः 12 बाइट्स और -2 बाइट्स के लिए Mr.XCoder और ovs का धन्यवाद ।

Comments

80 बाइट्स

— श्री एक्सकोडर

Answer 18

बैच, 92 77 बाइट्स

@set/an=2,t=0
:l
@if %1 geq %n% set/at+=%1*2-(%1%%n),n*=2&goto l
@echo %t%

संपादित करें: अन्य सभी के लिए समान सूत्र पर स्विच किया गया।

Answer 19

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

BLḊṬœṗ¥€Bj€0ḄS

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

Answer 20

पर्ल 5 , 36 + 1 ( -p) = 37 बाइट्स

$\+=$_*2-($_&$.-1)while($.*=2)<=$_}{

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

Answer 21

अटैची , 57 बाइट्स

Sum##UnBin=>{Join[Join=>_,"0"]}=>SplitAt#1&`:@{#_-1}##Bin

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

मैंने सोचा कि मैं एक गैर-बिट हेरफेर दृष्टिकोण से समस्या का सामना करूंगा, क्योंकि इस तरह का दृष्टिकोण अटैच में अव्यवहारिक है। मुझे विकल्प के लिए इस दृष्टिकोण के कुछ हिस्सों की जांच करनी होगी।

व्याख्या

यहाँ एक विस्तारित संस्करण है:

Define[$joinByZero, {Join[Join=>_,"0"]}]

Define[$insertionPoints,
    SplitAt#1&`:@{#_-1}
]

Define[$f,
Sum##UnBin=>joinByZero=>insertionPoints##Bin
]

यह बस संख्या का द्विआधारी प्रतिनिधित्व लेता है, इसे कुछ बिंदुओं पर विभाजित करता है, वहां शून्य डालता है, दशमलव में वापस धर्मान्तरित करता है, और उन्हें एक साथ जोड़ता है।

Answer 22

जे , 33 बाइट्स

1#.[:}:#.@(<\;@(,0;])"0<@}.\.)@#:

ज्यादातर शायद आगे गोल्फ के लिए बहुत जगह है।

कैसे?

@#: बाइनरी में कनवर्ट करें और

<@}.\. - सभी प्रत्ययों को ढूंढें, प्रत्येक और बॉक्स से पहला अंक छोड़ें

<\ - सभी उपसर्गों को ढूंढें और उन्हें बॉक्स करें

(,0;])"0 - प्रत्येक उपसर्ग परिशिष्ट 0 के बाद संबंधित बीहड प्रत्यय संलग्न करें

;@ रेज़ (अनबॉक्स)

1#.[:}:#.@ - दशमलव, वक्र और योग में परिवर्तित करें

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