स्प्लिट, फ्लिप और पुनः संयोजक पूर्णांक

16

पृष्ठभूमि

यह गणित में अच्छी तरह से ज्ञात है कि पूर्णांकों के जोड़े के साथ पूर्णांक को एक-से-एक पत्राचार में रखा जा सकता है। ऐसा करने के कई संभावित तरीके हैं, और इस चुनौती में, आप उनमें से एक और इसके उलटा ऑपरेशन को लागू करेंगे ।

काम

आपका इनपुट एक सकारात्मक पूर्णांक है n > 0। यह ज्ञात है कि a, b ≥ 0इस तरह के अद्वितीय गैर-नकारात्मक पूर्णांक मौजूद हैं । आपका आउटपुट सकारात्मक पूर्णांक का "फ़्लिप्ड संस्करण" है ।n == 2a * (2*b + 1)n2b * (2*a + 1)

आप मान सकते हैं कि इनपुट और आउटपुट आपकी भाषा के मानक अहस्ताक्षरित डेटाटाइप में फिट हैं।

नियम और स्कोरिंग

आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

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

ये प्रारूप में दिए गए हैं in <-> out, क्योंकि फ़ंक्शन को लागू किया जाना अपना स्वयं का व्युत्क्रम है: यदि आप आउटपुट को इसे वापस फीड करते हैं, तो आपको मूल इनपुट प्राप्त करना चाहिए।

1 <-> 1
2 <-> 3
4 <-> 5
6 <-> 6
7 <-> 8
9 <-> 16
10 <-> 12
11 <-> 32
13 <-> 64
14 <-> 24
15 <-> 128
17 <-> 256
18 <-> 48
19 <-> 512
20 <-> 20
28 <-> 40
30 <-> 384
56 <-> 56
88 <-> 224
89 <-> 17592186044416

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है। यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई दे रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

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

code-golf  number  number-theory 
— Zgarb
स्रोत
1
— feersum
@ Faersum ओह, मुझे पता नहीं था। क्या संयोग है।
— जर्गब
2
अनिवार्य xkcd.com/153
— corsiKa

जवाबों:

11

जेली , 17 16 15 बाइट्स

BUi1µ2*³:2*×Ḥ’$

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

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

BUi1µ2*³:2*×Ḥ’$    Main link. Input: n

B                  Convert n to base 2.
 U                 Reverse the array of binary digits.
  i1               Get the first index (1-based) of 1.
                   This yields a + 1.
    µ              Begin a new, monadic chain. Argument: a + 1
     2*            Compute 2 ** (a+1).
       ³:          Divide n (input) by 2 ** (a+1).
                   : performs integer division, so this yields b.
         2*        Compute 2 ** b.
              $    Combine the two preceding atoms.
            Ḥ      Double; yield 2a + 2.
             ’     Decrement to yield 2a + 1.
           ×       Fork; multiply the results to the left and to the right.
— डेनिस
स्रोत
रुको, क्या आप जेली में ऑपरेटरों को समस्या के अनुरूप लागू कर रहे हैं? उस स्थिति में एलओएल
— अलेक्जेंडर टॉर्स्टलिंग
मैं नहीं हूँ। केवल प्रतिबद्ध जेली के बाद इस चुनौती पोस्ट किया गया दस्तावेज के अपडेट था, और सभी इस जवाब में इस्तेमाल ऑपरेटर कम से कम एक महीने के लिए लागू किया गया है। सत्यापित करने के लिए स्वतंत्र महसूस करें
— डेनिस
कोई चिंता नहीं, मैं नियमों या किसी भी चीज से परिचित नहीं हूं, मुझे लगा कि यह अच्छा है कि गोल्फ अपनी भाषा का आविष्कार करने वाले लोगों के लिए आया है!
— अलेक्जेंडर टॉर्टलिंग
2
— डेनिस
10

पायथ, 16 15 बाइट्स

*hyJ/PQ2^2.>QhJ

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

परीक्षण सूट

स्पष्टीकरण:

*hyJ/PQ2^2.>QhJ
                    Implicit: Q = eval(input())
     PQ             Take the prime factorization of Q.
    /  2            Count how many 2s appear. This is a.
   J                Save it to J.
  y                 Double.
 h                  +1.
          .>QhJ     Shift Q right by J + 1, giving b.
        ^2          Compute 2 ** b.
*                   Multiply the above together, and print implicitly.
— isaacg
स्रोत
7

MATL , 22 बाइट्स

Yft2=XK~)pq2/2w^Ks2*Q*

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

व्याख्या

Yf      % factor
t       % duplicate
2=      % compare to 2 (yields a logical array)
XK      % save a copy of that to variable K
~)      % keep only values != 2 in the factors array
p       % multiply that factors
q2/     % product - 1 / 2
2w^     % 2^x

K       % load variable K (the logical array)
s       % sum (yields the number of 2s)
2*Q     % count * 2 + 1

*       % multiply both values
— रेनर पी।
स्रोत
बहुत अच्छा! आप उपयोग कर सकते हैं Qके लिए 1+(यह हाल ही में शुरू किया गया है) और qके लिए 1-। यह एक स्थान भी बचाता है (जिसे आप किसी Hभी तरह से बचा सकते हैं )। यहां
— लुइस मेंडो
@LuisMendo धन्यवाद। उस सुविधा को नहीं जानता था।
— रेनर पी।
5
अच्छी तरह से किया MATL का उपयोग कर लुइस की पिटाई!
— स्टिव ग्रिफिन
6

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

lambda n:2*len(bin(n&-n))-5<<n/2/(n&-n)

n & -n2 की सबसे बड़ी शक्ति देता है जो विभाजित करता है n। यह काम करता है क्योंकि में अंकगणित two's-पूरक -n == ~n + 1। अगर nहै कश्मीर अनुगामी शून्य, इसके पूरक लेने यह है करने के लिए कारण होगा कश्मीर अनुगामी वाले। फिर 1 को जोड़ने से सभी अनुगामी लोगों को शून्य में बदल दिया जाएगा, और 2 ^ k को 0 से 1 में बदल दिया जाएगा । इसलिए -n1 के साथ समाप्त होता है, जिसके बाद k 0's (जैसा n) होता है, जबकि nसभी उच्च स्थानों से विपरीत बिट होता है।

— feersum
स्रोत
क्या आप शीघ्र ही बता सकते हैं कि कैसे n&-nकाम करता है ? मैं देख रहा हूँ कि यह चाल क्या है लेकिन कैसे नहीं :(
— इरवान
n&-n2 की उच्चतम शक्ति देता है जो विभाजित करता है n।
— नील
@ इरान के बारे में मैंने बताया n & -n।
— फ़ेरसम २ fe
मैं अराजकता गोल्फ पर इसी कार्यक्रम मिल गया था n=1;exec"c=n&-n;print n,':',2*len(bin(c))-5<<n/2/c;n+=1;"*100, लेकिन यह सबसे अच्छा समाधान के पीछे दो आकर्षण है।
— xnor
@ एक्सनॉर संकेत: 59-बाइट समाधान (ठीक है, मेरा कम से कम) सभी मूल्यों के लिए काम नहीं करता है n।
— फ़ेरसम
6

MATL , 25 26 बाइट्स

:qt2w^w!2*Q*G=2#f2*q2bq^*

यह भाषा / संकलक की वर्तमान रिलीज़ (10.2.1) का उपयोग करता है ।

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

व्याख्या

बहुत सीधा, क्रूर बल पर आधारित है। कोशिश करता है के सभी संयोजनों एक और ख , उचित एक का चयन करता है और आवश्यक गणना करता है।

:q          % implicit input "n". Generate row vector [0,1,...,n-1], say "x"
t2w^        % duplicate and compute 2^x element-wise
w!2*Q       % swap, transpose to column vector, compute 2*x+1
*           % compute all combinations of products. Gives 2D array
G=2#f       % find indices where that array equals n
2*q2bq^*    % apply operation to flipped values
— लुइस मेंडो
स्रोत
1
हा! :-P अपनी भाषा में ... पहली बार पीटा?
— स्टिव ग्रिफिन
@StewieGriffin हां! एक अच्छा मील का पत्थर :-)
— लुइस मेंडो
5

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

n->2^(n>>(a=get(factor(n),2,0)+1))*(2a-1)

यह एक अनाम फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और पूर्णांक देता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

हम a1 के मूल कारक के रूप में 2 के घातांक को परिभाषित करते हैं n। चूंकि factora रिटर्न देता है Dict, हम get0 के डिफ़ॉल्ट मान के साथ उपयोग कर सकते हैं यदि अभाज्य गुणनखंडन में 2 नहीं है। हम इसके nद्वारा बिट बिट शिफ्ट करते हैं a, और इस पावर में 2 लेते हैं। हम उस 2a-1परिणाम को प्राप्त करने के लिए गुणा करते हैं ।

— एलेक्स ए।
स्रोत
4

पर्ल 5, 40 बाइट्स

38 बाइट्स प्लस 2 के लिए -p

$i++,$_/=2until$_%2;$_=2*$i+1<<$_/2-.5

-pSTDIN को वैरिएबल में पढ़ता है $_।

$i++,$_/=2until$_%2वेतन वृद्धि $i(जो 0 से शुरू होती है) और नॉनवेज मोड 2 $_तक $_घटती है। उसके बाद, $_मूल संख्या का विषम कारक है, और $i2 का घातांक है।

$_=2*$i+1<<$_/2-.5- के दाहिने हाथ की =मांग की संख्या के लिए सिर्फ सूत्र है: {1 से अधिक दो बार 2} के घातांक {2 बार {आधा विषम कारक शून्य से आधा}} की शक्ति। लेकिन "गुना {2 की शक्ति ...}" को "बिट-शिफ्टेड लेफ्ट बाय बाय ..." के रूप में रखा जाता है। और उस दाहिने हाथ को सौंपा गया है $_।

और -pप्रिंट करता है $_।

— msh210
स्रोत
2

जावास्क्रिप्ट ईएस 6, 36 33 बाइट्स

n=>63-2*Math.clz32(b=n&-n)<<n/b/2

मेरी समझ यह है कि Math.clz32चारों ओर की तुलना में कमतर होने वाली हैtoString(2).length ।

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

— नील
स्रोत
अच्छा लगा। आप कुछ बाइट्स n&-nको एक चर पर सेट करके भी बचा सकते हैं :n=>63-2*Math.clz32(x=n&-n)<<n/x/2
— user81655
@ user81655 धन्यवाद; मैं केवल इच्छा करता हूं कि मैं इस्तेमाल कर सकता हूं n&=-n, लेकिन मुझे nफिर से जरूरत है ...
— नील
1

PARI / GP , 38 बाइट्स

f(n)=k=valuation(n,2);(2*k+1)<<(n>>k\2)

ध्यान दें कि >>और \एक ही पूर्वता है और बाएं से दाएं गणना की जाती है, इसलिए अंतिम भाग इसके n>>k\2बजाय हो सकता है (n>>k)\2। Ungolfed संस्करण के kसाथ शाब्दिक होगा my:

f(n)=
{
  my(k=valuation(n,2));
  (2*k+1) << ((n>>k)\2);
}
— चार्ल्स
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.