अलग संख्या, एक ही वजन

Question

पृष्ठभूमि

आलोचनात्मक वजन एक पूर्णांक के अपने द्विआधारी प्रतिनिधित्व में लोगों की संख्या है। इस चुनौती के लिए, पूर्णांक 32 बिट्स के साथ प्रस्तुत किए जाते हैं, और वे अहस्ताक्षरित होते हैं।

चुनौती

0 और 2 ^ 32-1 (गैर-समावेशी) के बीच एक पूर्णांक को देखते हुए, एक ही सीमा के भीतर एक अलग पूर्णांक का उत्पादन करते हैं , और एक ही हैमिंग वजन के साथ भी।

उदाहरण

Input (Decimal) | Input (Binary) | Hamming weight | Possible output (Decimal)
       46       |   0b0010 1110  |       4        |      15
       12       |   0b0000 1100  |       2        |      3
        1       |   0b0000 0001  |       1        |      2
        3       |   0b0000 0011  |       2        |      6
      2^31      |   0b1000....0  |       1        |      1
      2^31+2    |   0b1000...10  |       2        |      3
      2^32-5    |   0b1111..011  |       31       |      2^31-1
      2^32-2    |   0b1111....0  |       31       |      2^31-1
        0       |   0b0000 0000  |       0        | None (This case need not be handled)
      2^32-1    |   0b1111....1  |       32       | None (This case need not be handled)

स्कोरिंग

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

Comments

मेरा सुझाव है कि 2 ^ 31 + 1 और 2 ^ 32-3 के बीच एक विषम संख्या को जोड़ना, क्योंकि कुछ उत्तर उस पर विफल हो रहे हैं।

— अर्जन जोहानसन

सम्बंधित।

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

चूंकि आपने अभी जोड़ा है 2^31+2, इसलिए मैं दोहराऊंगा कि मैंने एक विषम संख्या कहा है । प्रश्न के उत्तर केवल तभी विफल हुए जब उच्चतम और निम्नतम बिट दोनों हैं 1।

— अर्जन जोहानसन

मै बुद्धू हूँ। धन्यवाद। तय करेंगे कि

— musicman523

@ musicman523 मैं सिर्फ सक्रिय प्रश्नों को ब्राउज़ करने के लिए हुआ और इसे देखा। और देखा कि आपने अभी भी अनुरोधित परीक्षण मामलों को नहीं जोड़ा है।

— ड्रेको 18 एसपी

Answer 1

x86-64 विधानसभा, 5 4 बाइट्स

   0:   97                      xchg   %eax,%edi
   1:   d1 c0                   rol    %eax
   3:   c3                      retq   

C कॉलिंग कन्वेंशन का उपयोग करने वाला एक फ़ंक्शन जो बिटवाइज़ 1 से बाएं उसके तर्क को घुमाता है।

Comments

डेमिट - मैं इसके बारे में ठीक-ठीक पोस्ट करने वाला था - अच्छी तरह से किया गया :)

— डिजिटल ट्रॉमा

असेंबली बीट्स जेली: ओ

— उरियल

क्या यह 2 से गुणा नहीं है? यदि ऐसा है, तो मेरे 2 बाइट पाइथ उत्तर शायद जीतते हैं

— NoOneIsHere

@NoOneIsHere नहीं, यह 2 से गुणा नहीं है। 2 से गुणा करना आवश्यक सीमा से बाहर के आधे इनपुटों को भेजता है, और यदि आप बाईं ओर अतिप्रवाह बिट को अनदेखा करते हैं, तो आपने 1. हेमिंग के वजन में कमी की है। यह एक बिटवाइज़ है। रोटेशन , जो दाहिने से ओवरफ्लो बिट को वापस लाता है।

— एंडर्स केसरग

@DigitalTrauma जीसीसी 4.9.0 और बाद में बहुत चालाक संकलित करने के लिए कर रहे हैं n << 1 | n >> 31में rolके बजाय ror(एक बाइट बचत)।

— एंडर्स केसरग

Answer 2

पायथन, 20 बाइट्स

lambda x:x*2%~-2**32

बिटकॉइन रोटेशन 1 बिट द्वारा छोड़ा गया।

Answer 3

MATL , 9 बाइट्स

32&B1YSXB

32-अंकों के द्विआधारी प्रतिनिधित्व को परिपत्र रूप से दाईं ओर स्थानांतरित करता है।

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

Answer 4

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

‘&~^^N&$

कम से कम महत्वपूर्ण सेट और परेशान बिट स्वैप करता है।

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

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

‘&~^^N&$  Main link. Argument: n

‘         Increment; yield n+1, toggling all trailing set bits and the rightmost
          unset bit.
  ~       Bitwise NOT; yield ~n, toggling ALL bits of n.
 &        Bitwise AND; yield (n+1)&~n, keeping the only bit that differs in n+1 and
          ~n, i.e., the rightmost unset bit.
   ^      Perform bitwise XOR with n, toggling the rightmost unset bit.
       $  Combine the two links to the left into a monadic chain.
     N        Negate; yield -n. Since ~n = -(n+1) in 2's complement, -n = ~n+1.
      &       Take the bitwise AND of n and -n. Since -n = ~n + 1 and n = ~~n, the
              same reasoning that applied for (n+1)&~n applies to -n&n; it yields
              the rightmost unset bit of ~n, i.e., the rightmost set bit of n.
    ^      XOR the result to the left with the result to the right, toggling the
           rightmost set bit of the left one.

Answer 5

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

पहले बिट संक्रमण के लिए दिखता है (0 → 1 या 1 → 0) और इसे निष्क्रिय कर देता है।

f=(n,k=3)=>(n&k)%k?n^k:f(n,k*2)

डेमो

f=(n,k=3)=>(n&k)%k?n^k:f(n,k*2)

;[ 46, 12, 255, 2**32-2 ]
.map(n => {
  r = f(n);
  console.log((n >>> 0), '=', (n >>> 0).toString(2), '-->', (r >>> 0), '=', (r >>> 0).toString(2));
})

बिट रोटेशन, 14 बाइट्स

बहुत कम लेकिन कम मजेदार।

n=>n>>>31|n<<1

डेमो

let f =

n=>n>>>31|n<<1

;[ 46, 12, 255, 2**32-2 ]
.map(n => {
  r = f(n);
  console.log((n >>> 0), '=', (n >>> 0).toString(2), '-->', (r >>> 0), '=', (r >>> 0).toString(2));
})

Comments

जावास्क्रिप्ट बिटवाइज़ ऑपरेटर अहस्ताक्षरित के बजाय 32-बिट हस्ताक्षरित पूर्णांक देते हैं। उदाहरण के लिए, f(2147483647)है -1073741825और (n=>n>>>31|n<<1)(2147483647)है -2।

— एंडर्स कासोर्ग

यह तब तक ठीक है जब तक कि 32 बिट्स से अधिक न हों।

— संगीतज्ञ ५२३

क्या आप पहले एक के लिए स्पष्टीकरण जोड़ सकते हैं? मैं जावास्क्रिप्ट सीखने की कोशिश कर रहा हूं, और इस तरह का नुकसान कर रहा हूं कि आप किस तरह से k को अपरिभाषित कह रहे हैं और फिर भी एक उचित उत्तर प्राप्त कर रहे हैं!

— संगीतज्ञ ५२३

@ musicman523 यहाँ इसी टिप है। मूल रूप से, kशुरू में सेट किया गया है undefinedऔर हम इस तथ्य का लाभ उठाते हैं कि ~undefinedबराबर है -1।

— अरनुलद

@ musicman523 (मैं अपडेट किए गए संस्करण में अब इस टिप का उपयोग नहीं कर रहा हूं। लेकिन यह पूछने में संकोच न करें कि क्या आपके पास मूल उत्तर के अन्य प्रश्न हैं।)

— अरनौल्ड

Answer 6

ब्रेन-फ्लैक , 78 बाइट्स

(([()()])[[]()]){((){}<({({})({}())}{})>)}{}([(({}(({}){})())<>)]){({}())<>}{}

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

2 एन रिटर्न अगर n <2 ^ 31, और 2 एन + 1-2 ^ 32 अन्यथा। दुर्भाग्य से, क्योंकि ब्रेन-फ्लैक के पास किसी संख्या के संकेत को निर्धारित करने का कोई तेज़ तरीका नहीं है, टीआईओ पर कार्यक्रम का समय यदि इनपुट 2 ^ 31 से लगभग 500000 से अधिक है।

व्याख्या

सबसे पहले, स्टैक पर -2 ^ 32 पुश करें:

(([()()])[[]()])                               push (initial value) -2 and (iterator) -5
                {((){}<                >)}     do 5 times:
                       ({({})({}())}{})        replace the current (negative) value with the negation of its square
                                            {}   pop the (now zero) iterator

फिर, वांछित आउटपुट की गणना करें:

      (({}){})                        replace n by 2n on left stack
   ({}        ())                     push 2n+1-2^32 on left stack
  (              <>)                  push again on right stack
([                  ])                push its negation on right stack
                      {({}())<>}      add 1 to the top value of each stack until one of them reaches zero
                                {}    pop this zero, and implicitly print the number below it on the stack

Answer 7

डीसी, १०

?2~z31^*+p

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

यह एक 32 बिट दाएं घूमने का एक अंकगणितीय कार्यान्वयन है:

?           # input
 2~         # divmod by 2 - quotient pushed first, then the remainder
   z        # z pushes the size of the stack which will be 2 (quotient and remainder) ...
    31^     #  ... and take that 2 to the 31st power
       *    # multiply the remainder by 2^31
        +   # add
         p  # output

Answer 8

जावा 8, 117 17 29 बाइट्स

n->n*2%~-(long)Math.pow(2,32)

बदलकर 12 बाइट्स intके लिए long, क्योंकि intके अधिकतम आकार है2³¹-1

@AndersKaseorg के अद्भुत पायथन उत्तर का एक पोर्ट बनाकर 100 89 बाइट्स बचाए गए ।

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

आउटपुट:

46 (101110):                                     92 (1011100)
12 (1100):                                       24 (11000)
1 (1):                                           2 (10)
3 (11):                                          6 (110)
10000 (10011100010000):                          20000 (100111000100000)
987654 (11110001001000000110):                   1975308 (111100010010000001100)
2147483648 (10000000000000000000000000000000):   1 (1)
4294967294 (11111111111111111111111111111110):   4294967293 (11111111111111111111111111111101)

पुराना उत्तर ( 117 118 बाइट):

n->{long r=0;for(;!n.toBinaryString(++r).replace("0","").equals(n.toBinaryString(n).replace("0",""))|r==n;);return r;}

बदलकर +1 बाइट intके लिए long, क्योंकि intके अधिकतम आकार है2³¹-1

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

आउटपुट:

46 (101110):                                     15 (1111)
12 (1100):                                       3 (11)
1 (1):                                           2 (10)
3 (11):                                          5 (101)
10000 (10011100010000):                          31 (11111)
987654 (11110001001000000110):                   255 (11111111)
2147483648 (10000000000000000000000000000000):   1 (1)

Answer 9

गणितज्ञ, 29 बाइट्स

Mod@##+Quotient@##&[2#,2^32]&

इसे वुल्फ्राम सैंडबॉक्स पर आज़माएं

अंकगणित को बाएं से घुमाएं: पहले 2 से गुणा करें, जो संभवतः संख्या को सीमा से बाहर स्थानांतरित करता है, फिर आउट-ऑफ-रेंज अंक को काटकर Mod[...,2^32]दाईं ओर वापस जोड़ देता है +Quotient[...,2^32]।

(मैथेमेटिका में एक एकल बिल्डिन है जो एक ही बार में मापांक और भागफल देता है, लेकिन यह QuotientRemainderएक गोल्फिंग बाधा का एक सा है ...)

Comments

मॉड 2 ^ 32-1? (4 और जाने के लिए)

— user202729

Answer 10

एपीएल, 12 बाइट्स

(2⊥32⍴1)|2×⊢

कैसे?

           ⊢  ⍝ monadic argument
         2×   ⍝ shift left (×2)
(2⊥32⍴1)|     ⍝ modulo 2^32 - 1

Answer 11

05AB1E , 5 बाइट्स

·žJ<%

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

व्याख्या

बाइनरी प्रतिनिधित्व को घुमाने के लिए चाल का उपयोग करता है एंडर्स कसेर्ग के अजगर जवाब से 1 बिट द्वारा छोड़ा गया ।

·       # input * 2
    %   # modulus
 žJ<    # 2^32-1

Answer 12

आर, 42 63 बाइट्स

function(x){s=x;while(s==x){sample(binaryLogic::as.binary(x))}}

बिट्स को बेतरतीब ढंग से इधर-उधर कर देता है, लेकिन यह सुनिश्चित करने के लिए जांच करता है कि यह संयोग से उसी नंबर को वापस नहीं करता है।

Answer 13

व्हॉट्सएप , 81 80 बाइट्स

(1 बाइट की बदौलत @ byrjan जोहानसन ने मुझे याद दिलाया कि डुबकी लगाना पुश 0 से कम है)

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

मूल रूप से पूर्णांक अंकगणित का उपयोग करके चक्रीय दाहिने बिटशिफ्ट को लागू करता है। व्हॉट्सएप में एक बड़ा स्थिरांक महंगा है, इसलिए हम 2 ^ 8 को धक्का देकर और इसे दो बार चुकाने से कुछ बाइट्स बचाते हैं। (1 बाइट ओवर से बचाता है (2 ^ 16) ^ 2 और 10 बाइट्स 2 ^ 32 सीधे धक्का पर।)

व्याख्या

sssn  ; push 0
sns   ; dup
tntt  ; getnum from stdio
ttt   ; retrieve n from heap and put it on the stack
sns   ; dup
ssstsn ; push 2
tstt  ; mod - check if divisible by 2 (i.e. even)
ntsn  ; jez "even"
ssstssssssssn ; push 2^8
sns   ; dup
tssn  ; mul - square it to get 2^16
sns   ; dup
tssn  ; mul - square it to get 2^32
tsss  ; add 2^32 so MSB ends up set after the divide
nssn  ; even:
ssstsn ; push 2
tsts  ; divide by 2, aka shift right
tnst  ; putnum - display result

Comments

मुझे लगता है कि आप दूसरी जगह ले सकता है push 0एक साथ dupएक आदेश पहले।

— अर्जन जोहानसन

आप ठीक कह रहे हैं, मैंने अभी-अभी अपने ट्रांसपिलर में शॉर्टकट सिंटैक्स जोड़ना समाप्त किया है, इसलिए मैं इसे बहुत अधिक उपयोग कर रहा हूं ...

— इफथा

Answer 14

पायथन 2.7, 89 बाइट्स

पूरा कार्यक्रम:

from random import*;a=list(bin(input())[2:].zfill(32));shuffle(a);print int(''.join(a),2)

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

सुझावों का स्वागत है! :)

Comments

यह मान्य नहीं है क्योंकि यह संयोग से उसी संख्या को फिर से वापस कर सकता है।

— अर्जन जोहान्सन

Answer 15

परी / जीपी , 15 बाइट्स

n->2*n%(2^32-1)

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

Answer 16

जाप , 5 बाइट्स

Ñ%3pH

बिटकॉइन रोटेशन, यहां अधिकांश उत्तरों की तरह।

कोशिश करो

Answer 17

पर्ल 5 -p , 39 बाइट्स

$_=sprintf'0b%b',$_;$_=oct$_.int s/10//

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

Answer 18

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

lambda i:int(f'{i:32b}'[1:]+f'{i:32b}'[:1],2)

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

Answer 19

सी ++ (जीसीसी) , 45 39 बाइट्स

-6 बाइट्स thanx to छतनाट

auto h(unsigned x){return x%2<<31|x/2;}

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