दो की दो शक्तियों का योग या अंतर

Question

आपकी चुनौती, क्या आपको इसे स्वीकार करने का विकल्प चुनना चाहिए, एक पूर्णांक दिया गया है, K >= 1गैर-नकारात्मक पूर्णांक खोजें Aऔर B इस तरह कि पकड़ के बाद कम से कम दो स्थितियों में से एक:

1. K = 2^A + 2^B
2. K = 2^A - 2^B

यदि ऐसा मौजूद नहीं है Aऔर B, आपका कार्यक्रम किसी भी फैशन में व्यवहार कर सकता है। (स्पष्ट करने के लिए, Aऔर Bबराबर हो सकता है।)

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

किसी संख्या में अक्सर कई समाधान होते हैं, लेकिन यहां कुछ हैं:

K => A, B
1 => 1, 0
15 => 4, 0                      ; 16 - 1 = 15
16 => 5, 4                      ; 32 - 16 = 16; also 3, 3: 8 + 8 = 16
40 => 5, 3                      ; 2^5 + 2^3 = 40
264 => 8, 3
17179867136 => 34, 11           ; 17179869184 - 2048 = 17179867136 

अंतिम परीक्षण के मामले में, 17179867136, 10 सेकंड से कम में चलाना चाहिए किसी भी अपेक्षाकृत आधुनिक मशीन पर। यह एक कोड गोल्फ है, इसलिए बाइट्स में सबसे छोटा कार्यक्रम जीत जाता है। आप एक पूर्ण कार्यक्रम या एक समारोह का उपयोग कर सकते हैं।

Comments

Can एक बराबर बी ?

— डेनिस

@ डेनिस मैं नहीं देखता कि क्यों।

— कॉनर ओ'ब्रायन ने

... और के लिए 16, दोनों 5,4और 3,3मान्य हैं।

— टाइटस

वास्तव में अब मैं इसके बारे में लगता है कि, कर सकते हैं A, Bनकारात्मक हो सकता है? (उदाहरण के -1, -1लिए 1)

— Sp3000 14

@ Sp3000 नहीं, अच्छी बात है।

— कॉनर ओ'ब्रायन

Answer 1

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

;0+N&$BL€’

पायथन उत्तर से @xnor द्वारा बिट ट्विडलिंग ट्रिक को लागू करना

TryItOnline पर इसका
परीक्षण करें सभी परीक्षण मामले TryItOnline पर भी हैं

कैसे?

;0+N&$BL€’ - main link takes an argument, k, e.g 15
;0         - concatenate k with 0, e.g. [15, 0]
     $     - last two links as a monad
   N       - negate, e.g. -15
    &      - bitwise and, e.g. -15&15=1 since these two are called as a monad (one input)
  +        - add, vectorises, e.g. [16,1]
      B    - convert to binary, vectorises, e.g. [[1,0,0,0,0],[1]]
       L€  - length for each, e.g. [5,1]
         ’ - decrement, vectorises, e.g. [4,0]

Answer 2

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

lambda n:[len(bin((n&-n)+k))-3for k in n,0]

कहो कि के n==2^a ± 2^bसाथ a>b। फिर, सबसे बड़ी शक्ति का -2 कारक nहै 2^b, और हम इसे बिट-ट्रिक का उपयोग करके पा सकते हैं 2^b = n&-n। इससे हमें गणना 2^b + nहोती है, जो 2^a + 2 * 2^bया तो बराबर होती है 2^a। या तो किसी की लंबाई समान लंबाई- a* है। तो, हम उत्पादन बिट लंबाई n&-nऔर (n&-n)+n, उनके बाइनरी अभ्यावेदन की लंबाई से गणना की। पाइथन 3 एक एक बाइट है जो अंदर के परनों के लिए लंबा है for k in(n,0)]।

* सिवाय इसके कि इसके 2^a + 2^bसाथ a==b+1एक लंबा सा लंबाई है, लेकिन यह ठीक है क्योंकि हम इसकी व्याख्या कर सकते हैं 2^(a+1)-2^b।

Comments

अद्भुत - मैंने थोड़ी सी बेला की तलाश की, लेकिन यह काम नहीं कर सका, सिर्फ जेली को चित्रित किया।

— जोनाथन एलन

प्रयास करें n=4या 8या 16खुश।

— टाइटस

@ टिट्स f(2**n)लौटता है (n+1,n)और 2**(n+1)-2**n=2**nइसलिए कोई समस्या नहीं है।

— जोनाथन एलन

आह ... bin()पायथन में प्रारूप क्या है ?

— टाइटस

@ यह एक अग्रणी के साथ एक स्ट्रिंग है 0b, इसलिए -3।

— जोनाथन एलन

Answer 3

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

(n,[s,f,z]=/^1+(.*1)?(0*)$/.exec(n.toString(2)))=>[s.length-!!f,z.length]

घटाव मामले के लिए, पहली संख्या द्विआधारी प्रतिनिधित्व में अंकों की संख्या है और दूसरी संख्या अनुगामी शून्य की संख्या है। इसके अलावा मामले के लिए, हम पहले नंबर से 1 घटाते हैं। यदि बाइनरी प्रतिनिधित्व कुछ 0 के बाद सभी 1s है तो जोड़ मामले को ग्रहण किया जाता है अन्यथा घटाव का मामला मान लिया जाता है। @ Xnor के संस्करण का 36-बाइट पोर्ट जो केवल जावास्क्रिप्ट में B in30 के लिए काम करता है:

n=>[(l=Math.log2)(n+(n&=-n))|0,l(n)]

Comments

@ETHproductions ज़रूर, लेकिन मैंने इसे 36 तक नीचे पहुंचा दिया।

— नील 14

मेरा बुरा, मैंने सोचा कि 36-बाइट संस्करण 17 बिलियन परीक्षण के मामले में काम नहीं करता था।

— ETHproductions

@ETHproductions यह नहीं है, लेकिन तब न तो आपके पोर्ट, जैसा कि मुझे याद है (हटाए जाने के बाद से टिप्पणी, आह), क्योंकि यह बिटवाइज़ ऑपरेशन का उपयोग करता था।

— नील

क्षमा करें, यहां यह फिर से है: n=>[n,0].map(k=>((n&-n)+k).toString(2).length-1)और दोनों संस्करण [34,11]अंतिम परीक्षण मामले पर वापस आ रहे हैं (मैं एफएफ 48 का उपयोग कर रहा हूं)।

— ETHproductions

@ETHproductions अहा, और अधिक सटीक रूप से वे काम करते हैं जब दूसरा परिणाम 30 या उससे कम होता है।

— नील

Answer 4

पर्ल, 52 49 32 बाइट्स

पुराना समाधान (49 बाइट्स)

के लिए +1 शामिल है -p

STDIN पर इनपुट दें:

pow2.pl <<< 17179867136

pow2.pl

#!/usr/bin/perl -p
$_=reverse sprintf"%b",$_;/()1(?:1+|0*)/;$_="@+"

हालाँकि, xnor के एल्गोरिथ्म का उपयोग करना और एक मोड़ जोड़ना 32 बाइट्स देता है:

perl -nE 'say 13/9*log|0for$;=$_&-$_,$_+$'

बस कोड:

say 13/9*log|0for$;=$_&-$_,$_+$

यह गंभीर राउंडिंग त्रुटि से ग्रस्त है क्योंकि 13/9 = 1.444...काफी ऊपर है 1/log 2 = 1.44269...( logखुद भी एक राउंडिंग त्रुटि है लेकिन यह इतना छोटा है कि हम इसे 13/9 के विश्लेषण में लपेट सकते हैं)। लेकिन जब से कोई भी लॉग 2**big - 2** smallकरने 2** bigसे पहले सही हो जाता है तो यह मैटर नहीं करता है और 2**big + 2 * 2**smallनीचे की गणना के लिए गणना भी सुरक्षित है .. और सीमा के दूसरी तरफ सीमा 2**n+2**(n-1)में पर्याप्त वृद्धि नहीं होती है [0,64](मैं ठीक से नहीं कर सकता &एक गलत परिणाम के लिए) के उपयोग की वजह से पूर्णांक सीमा से अधिक का समर्थन करता है (गुणक 1.5हालांकि बड़ी संख्या के लिए बहुत दूर होगा)।

Answer 5

ब्रेकीलॉग , 23 बाइट्स

,A:B#+.:2rz:^a{+|-}?,.=

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

यह आवश्यकता से बहुत तेज है, उदाहरण के लिए यह अभी भी TIO पर 10 सेकंड से कम है ।

व्याख्या

यह मूल रूप से सूत्र का प्रत्यक्ष प्रतिलेखन है जिसमें कोई अनुकूलन नहीं है:

,A:B     The list [A, B]
#+       Both A and B are greater than or equal to 0
.        Output = [A, B]
:2rz     The list [[2, A], [2, B]]
:^a      The list [2^A, 2^B]
{+|-}?   2^A + 2^B = Input OR 2^A - 2^B = Input
,.=      Assign a value to A and B which satisfy those constraints

Comments

ऐसा लगता है कि यह चुनौती भाषा के लिए बनाई गई थी: डी

— कॉनर ओ'ब्रायन

Answer 6

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

def f(k):b=bin(k)[::-1];return len(b)-2-(b.count('1')==2),b.find('1')

टेस्ट आइडोन पर हैं

चूंकि गैर-वैध इनपुट कुछ भी कर सकता है, हम जानते हैं कि यदि इनपुट में 2 बिट्स हैं, तो यह 2 की उन 2 शक्तियों का योग है, और अन्यथा (यदि वैध है) तो यह कुछ संख्या में बिट्स (सहित) का एक रन होगा केवल 1 बिट की संभावना) और MSB और LSB सेट की तुलना में 2 की अगली उच्चतम शक्ति के बीच का अंतर होगा।

Answer 7

जावा 7,142 ,140, 134 BYTES

यह पीपीसीजी पर मेरी पहली पोस्ट है! मैं वास्तव में 2 बाइट्स बचाने के लिए जमे हुए सुझावों के लिए गोल्फ सुझावों पर प्रतिक्रिया के लिए सराहना करूंगा

void f(long n){for(int i=-1,j;i++<31;)for(j=0;j++<34;){long a=1,x=a<<i,y=a<<j;if(x+y==n|y-x==n){System.out.println(j+" "+i);return;}}}

UNGOLF

void f(long n){
    for(int i=-1,j;i++<31;)
         for(j=0;j++<34;){
          long a=1,x=a<<i,y=a<<j;
            if(x+y==n|y-x==n){
            System.out.println(j+" "+i);
        return;
        }
            }
    }

ideone

Comments

हाय अंकन! मैं देख रहा हूँ puzzling से एक और पथिक। 40=2**3+2**5उदाहरण के लिए , यह काम नहीं करता है । इसे देखते हुए, मैं नहीं देख सकता कि क्यों नहीं, शायद मैंने एक प्रतिलेखन त्रुटि की ...

— जोनाथन एलन

@JonathanAllan अब यह ठीक काम करता है। आमतौर पर कोष्ठक इस पंक्ति में अनुपस्थित थे यदि ((a << i) + (a << j) == n | (a << j) - (a << i) == n | ) और धन्यवाद।

— 14

क्या आप 1इसके लिए एक चर घोषित करने के बजाय एक शाब्दिक का उपयोग कर सकते हैं ?

— टाइटस

@TItus अगर मैं शाब्दिक 1 का उपयोग करता हूं तो यह टेस्टकेस (17179867136) संभव नहीं होगा क्योंकि यदि आप शाब्दिक 1 का उपयोग करते हैं तो जावा स्वचालित रूप से इसे एक INT मेमोरी स्पेस असाइन करता है।

— नंबर

आप i के साथ j की घोषणा कर सकते हैं:for(int i=-1,j;[...]

— Frozn

Answer 8

गणितज्ञ, ५hem ५४ बाइट्स

3 बाइट्स LegionMammal978 के लिए धन्यवाद!

Do[Abs[2^a-#]==2^b&&Print@{a,b},{a,2Log@#+1},{b,0,a}]&

वास्तव में सभी ¹ उपयुक्त जोड़े {a, b} को प्रिंट करता है । 2Log@#+1सबसे बड़ी के लिए एक ऊपरी सीमा है जो aसंभवतः इनपुट का प्रतिनिधित्व करते समय दिखाई दे सकती है #(तंग ऊपरी बाध्य लॉग है [2 #] / लॉग [2] = 1.44 ... लॉग [#] + 1)। परीक्षण इनपुट पर लगभग तुरंत चलता है, और 100 अंकों के इनपुट पर एक चौथाई सेकंड (मेरे नए लेकिन ऑफ-द-शेल्फ कंप्यूटर पर) से भी कम समय में।

¹ दे a1 बजाय 0 के डिफ़ॉल्ट मान पर शुरू दो बाइट्स की बचत होती है; यह इनपुट 2 होने पर आउटपुट {0,0} को मिस करने का कारण बनता है, लेकिन उस स्थिति में आउटपुट {2,1} पाता है, जो काफी अच्छा है।

Comments

सभी * उपयुक्त जोड़े? (इसके अलावा, 3 बाइट्स को बचाने के लिए If[Abs[2^a-#]==2^b,Print@{a,b}]प्रतिस्थापित किया जा सकता है Abs[2^a-#]==2^b&&Print@{a,b}।)

— लीजनमैमल 978

अच्छा अवलोकन है, मैं समझ गया! "ऑल" "एक फुटनोट था, लेकिन अब यह स्पष्ट है।

— ग्रेग मार्टिन

Answer 9

MATL , 23 22 बाइट्स

BnQ:qWtG-|ym)1)tG-|hZl

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

B      % Implicit input. Convert to binary. Gives n digits
nQ:q   % Range [1 ... n+1]
W      % 2 raised to that, element-wise: gives [1 2 4 ... 2^(n+1)] (*)
tG-|   % Duplicate. Absolute difference with input, element-wise (**)
y      % Push a copy of (*)
m      % True for elements of (**) that are members of (*)
)      % Use as logical index to select elements from (*)
1)     % Take the first element. Gives power of the first result
tG-|   % Duplicate. Absolute difference with input. Gives power of the second result
hZl    % Concatenate. Take binary logarithm. Implicit display

Answer 10

पर्ल 6 , 41 बाइट्स

{.base(2).flip~~/1[1+|0*]/;$/.to,$/.from}

(एल्गोरिथ्म बेशर्मी से पर्ल 5 उत्तर से कॉपी किया गया )

स्पष्टीकरण:

# bare block lambda with implicit parameter ｢$_｣
{
  # turn into binary
  # ( implicit method call on ｢$_｣ )
  .base(2)

  # flip the binary representation
  .flip

  ~~ # smartmatch that against:

  /
    1      # a ｢1｣
    [
      | 1+ # at least one ｢1｣
      | 0* # or any number of ｢0｣
    ]
  /;

  # returns a list comprised of

  # the position of the end of the match (larger of the two)
  $/.to,
  # the position of the beginning of the match
  $/.from
}

उपयोग:

# give it a lexical name for clarity
my &bin-sum-diff = {.base(2).flip~~/1[1+|0*]/;$/.to,$/.from}

say bin-sum-diff 15; # (4 0)
say bin-sum-diff 16; # (5 4)

say bin-sum-diff 20; # (4 2)
# 2**4==16, 2**2==4; 16+4 == 20

say bin-sum-diff 40; # (5 3)
say bin-sum-diff 264; # (8 3)
say bin-sum-diff 17179867136; # (34 11)

Answer 11

PHP, 73 बाइट्स

मैं 54 बाइट्स (+13 ओवरहेड) के लिए जोनाथन पायथन 2 समाधान की नकल कर सकता
था , लेकिन कुछ अलग करना चाहता था।

फाइल करने के लिए सहेजें, फिर phpया के साथ निष्पादित करें php-cgi।

<?=strlen($n=decbin($argv[1]))-!!strpos($n,'01')._.strpos(strrev($n),49);

प्रिंट aऔर bएक अंडरस्कोर द्वारा अलग, बिना समाधान के लिए कुछ भी।

विशिष्ट समाधान, 96 बाइट्स

<?=preg_match('#^(10*1|(1+))(0*)$#',decbin($argv[1]),$m)?strlen($m[0])-!$m[2]._.strlen($m[3]):_;

प्रिंट aऔर bएक अंडरस्कोर द्वारा अलग; कोई समाधान नहीं के लिए एकमात्र अंडरस्कोर।

यहां तक ​​कि यह आपको 11 और बाइट्स के लिए ऑपरेशन बताता है:
कोड के साथ पहले अंडरस्कोर को बदलें '-+'[!$m[2]]।

Comments

अगर मैं इको स्ट्रेलेन ($ n = डेसीबिन ($ argv [1])) में 67 आज़माता हूँ - एल स्ट्रैप्स ($ n, '01 ') ।'- +' [$ n [2]]। strpos (स्ट्रिव) $ एन), 49); यह मुझे 6 + 0 वापस देता है जो कि 65 है

— जोर्ज हल्सरमन

@ JörgHülsermann: 67 का कोई हल नहीं है; बिना किसी समाधान के व्यवहार अपरिभाषित है; इसलिए यह मायने नहीं रखता है कि यह 67 के लिए क्या छापता है।

— टाइटस

Answer 12

PHP, 117 बाइट्स

if(preg_match("#^(1+|(10*1))0*$#",$b=decbin($k=$argv[1]),$t))echo($l=strlen($b))-($t[2]?1:0).",",$l+~strrpos($b,"1");

विस्तारित संस्करण 4 मामले

$l=strlen($b=decbin($k=$argv[1]));
// Case 1: n=2(n-1)=n+n or n=n*(2-1)=2n-n 
if(preg_match('#^100*$#',$b))echo($l-2).'a+'.($l-2).':'.$l.'a-'.($l-1);
// Case 2: n-m
elseif(preg_match('#^1+0*$#',$b)){echo $l.'b-',strpos($b,"0")?$l-strpos($b,"0"):0;}
// Case 3: n+m 
elseif(preg_match('#^10*10*$#',$b))echo ($l-1).'c+',$l-strrpos($b,"1")-1;
else echo "Nothing";

लघु संस्करण यूनियन केस 1 और 3 और केस 3 में अंतर बनाता है और दोनों संस्करणों में केस 4 कोई आउटपुट नहीं देता है।