"बिट-उधार" दो नंबर

20

क्या आप जानते हैं कि एक छोटी संख्या एक बड़ी संख्या से बिट्स उधार ले सकती है ? यहाँ एक उदाहरण है। मान लें कि हमारे दो नंबर 5 और 14. पहले, उन्हें बाइनरी में लिखें:

5       14
000101  001110

पहले हम छोटी से छोटी लेने पर बड़ी संख्या से दूर सा है, और हम सबसे छोटे को दे बंद अन्य नंबर पर बिट। इसलिए

This bit turns off
            |
            v
000101  001110
    ^
    |
This bit turns on

अब हमारे पास है

000111  001100

और हमारी संख्या 7 और 12 है। पहली संख्या अभी भी छोटी है, इसलिए हम जारी रखते हैं।

000111  001100
001111  001000

अब हमारे पास 15 और 8 हैं, इसलिए हम रोक सकते हैं। हम ऑपरेशन के इस सेट को "बिट-लेंडिंग" दो नंबर पर कॉल करेंगे। एक और उदाहरण करते हैं। 20 और 61।

20        61
010100    111101
010101    111100
010111    111000
111111    100000
63        32

तो हमारा अंतिम परिणाम 32, 63 है। चलो एक और करते हैं। 31, और 12. 31 पहले से ही 12 से बड़ा है, इसलिए ऐसा करने के लिए कुछ भी नहीं है! बिट-उधार 31 और 12, 31 और 12 देता है, कोई परिवर्तन नहीं।

चुनौती

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

परीक्षण IO:

Input: 2, 3
Output: 3, 2

Input: 3, 2
Output: 3, 2

Input: 8, 23
Output: 31, 0

Input: 42, 81
Output: 63, 0

Input: 38, 41
Output: 47, 32

Input: 16, 73
Output: 23, 0

Input: 17, 17
Output: 17, 17

मानक कमियां लागू होती हैं, और बाइट्स जीत में सबसे छोटा जवाब होता है!

code-golf  math  bitwise 
— DJMcMayhem
स्रोत

जवाबों:

12

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

~1¦&N$^µ</¿

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

पृष्ठभूमि

हम एक पूर्णांक एन के अंतिम सेट बिट को निम्नानुसार निकाल सकते हैं।

n + 1 के सभी अनुगामी सेट बिट्स n और आसन्न परेशान बिट के टॉगल करता है । उदाहरण के लिए, 10011 2 + 1 = 10100 2 ।

चूँकि ~ n = - (n + 1) = -n - 1 , -n = ~ n + 1 , इसलिए -n ऊपर n की बिटवाइज़ पर लागू होता है। n (जो सभी बिट्स को काटता है), इस प्रकार अंतिम से पहले सभी बिट्स को टॉगल करना। १ ।

उदाहरण के लिए, -10100 2 = ~ 10100 2 + 1 = 01011 2 + 1 = 01100 2 ।

लेने से n & -n बिटवाइज़ और के एन और -n (में असमान के बाद से अंतिम सेट बिट से पहले सभी बिट्स निरस्त माना जाता है n और -n ), इस प्रकार के अंतिम सेट बिट उपज एन ।

उदाहरण के लिए, 10100 2 और -10100 2 = 10100 2 और 01100 2 = 00100 2 ।

इस प्रकार XORing n के साथ n & -n के अंतिम सेट बिट unsets एन ।

इसके विपरीत, n के अंतिम सेट बिट को परेशान करने के लिए, यह ऊपर ~ n पर लागू करने के लिए पर्याप्त है , जहाँ से हम सूत्र n ^ (~ n & - ~ n) प्राप्त करते हैं ।

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

~1¦&N$^µ</¿  Main link. Argument: A (list of pairs)

          ¿  While loop:
        </     Condition: Reduce p by less-than. True iff x < y.
       µ       Body chain:
~1¦              Apply bitwise NOT to the x, first item of the pair.
     $           Convert the two links to the left into a monadic chain.
    N              Negate; multiply [~x, y] by -1, yielding [-~x, -y].
   &               Logical AND. Yields [-~x & ~x, -y & y].
      ^            Vectorized XOR with p. Yields [(-~x & ~x) ^ x, (-y & y) ^ y].
— डेनिस
स्रोत
6

जे, 31 26 बाइट्स

,`(($:~(OR>:))~(AND<:))@.<

पुनरावृत्ति और बिटवाइज़ ट्रिक्स का उपयोग करते हुए सीधे-आगे का दृष्टिकोण। आदेश (करने के लिए सेट बंद करने के लिए में 0 ) सबसे-दाएं पर ( 1 ) एक मूल्य के लिए बिट n , आप बिटवाइज़-और के बीच प्रदर्शन कर सकते हैं n और n -1, और (सेट करने के लिए चालू करने के लिए 1 ) सबसे-दाएं मान n के लिए ऑफ ( 0 ) बिट , आप बिटवाइज़-या n और n +1 के बीच प्रदर्शन कर सकते हैं ।

प्रयोग

इनपुट में दो पूर्णांक होते हैं, एक एलएचएस पर और दूसरा आरएचएस पर लागू होता है, और आउटपुट बिट-उधार मूल्यों की एक सूची है।

   f =: ,`(($:~(OR>:))~(AND<:))@.<
   2 f 3
3 2
   3 f 2
3 2
   8 f 23
31 0
   42 f 81
63 0
   38 f 41
47 32
   16 f 73
23 0
   17 f 17
17 17

व्याख्या

,`(($:~(OR>:))~(AND<:))@.<  Input: x on LHS, y on RHS
                            If x < y,
,                             Form a 2-element array [x, y] and return
                            Else
                   <:         Decrement y
                AND           Perform bitwise-and on y and y-1, call it y'
          >:                  Increment x
        OR                    Perform bitwise-or on x and x+1, call it x'
    $:                        Call recursively on x' and y' and return
— मील की दूरी पर
स्रोत
अच्छा उत्तर! जवाब पोस्ट करने के बाद चुनौती बदलने के लिए क्षमा करें, लेकिन मैंने चुनौती को थोड़ा सरल कर दिया है। (आपको सूची पर अधिक पुनरावृति करने की आवश्यकता नहीं है)। यह आपको इसे थोड़ा और छोटा करना चाहिए।
— DJMcMayhem
@DrGreenEggsandIronMan J वास्तव में बिना किसी स्पष्ट रैंकिंग के दो सरणियों के बीच फ़ंक्शन तत्व-वार को लागू कर रहा है, जो अच्छा है। जब तक कोई और तरकीब न हो, वह शायद वही रहेगा।
— मील
4

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

f=lambda x,y:x<y and f(x|x+1,y&y-1)or(x,y)

4 बाइट बंद करने के लिए @ jimmy23013 को धन्यवाद! 2 बाइट बंद करने के लिए @LeakyNun को धन्यवाद!

Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत
3

मैथेमेटिका, 46 बाइट्स

If[#<#2,BitOr[#,#+1]~#0~BitAnd[#2,#2-1],{##}]&

जे में मेरे समाधान में इस्तेमाल के रूप में एक ही विधि ।

@ बाइट को बचाने के लिए @ मार्टिन और इन्फिक्स एप्लिकेशन की याद दिलाने के लिए धन्यवाद ~।

प्रयोग

इनपुट में दो पूर्णांक तर्क होते हैं और आउटपुट बिट-उधार मूल्यों के साथ एक सूची है।

उदाहरण

— मील की दूरी पर
स्रोत
सोचा था कि मैं कुछ मजेदार कोशिश करूंगा, लेकिन दुर्भाग्य से यह अब बाइट है: #//.{x_,y_}/;x<y:>{BitOr[x,x+1],BitAnd[y,y-1]}&(शायद आपको पता है कि इसे कैसे छोटा किया जाए)
— मार्टिन एंडर
यह एक साफ नियम है, लेकिन मैं गोल्फ नियमों से बहुत परिचित नहीं हूं। मैं आमतौर पर केवल प्रतिस्थापन /.और स्थिति का उपयोग करता हूं /;। काश गणितज्ञ तर्क प्रकारों &&और इस तरह का निरीक्षण करके बूलियन और बिटवाइज़ के बीच स्विच कर सकता था ।
— मील
3

पायथ, 29 27 25 22 21 20 19 18 16 बाइट्स

MxG ^ 2x _ + \ 0.BG`HCm.W <FHgVZU2dC 
MxG ^ 2x_ + 0jG2HCm.W <FHgVZU2dC 
Cm.W <FH.bxN ^ 2x_ + 0jN2YZ2dC 
m.W <FH.bxN ^ 2x_ + 0jN2YZ2       <- बदली हुई इनपुट / आउटपुट प्रारूप
 mW <FH.exb ^ 2x_ + 0jb2kZ 
m.W <FH.U। bhb। & ZtZZ 
.W <FH.U।,। bhb। & ZtZZ          <- इनपुट / आउटपुट स्वरूप
 परिवर्तित करें। W <FH.U। | bhb। और ZTZ
डब्ल्यू <FH.U ,. |। Bhb एंड टी

परीक्षण सूट।

— लीक नन
स्रोत
जवाब पोस्ट करने के बाद चुनौती बदलने के लिए क्षमा करें, लेकिन मैंने चुनौती को थोड़ा सरल कर दिया है। (आपको सूची पर अधिक पुनरावृति करने की आवश्यकता नहीं है)। हालांकि शुक्र है कि यह आपको इसे छोटा करने की अनुमति देगा।
— DJMcMayhem
@DrGreenEggsandIronMan यह केवल एक बाइट बचा लिया। Pyth है कि कुशल।
— लीक नून
2

भूलभुलैया , 37 34 बाइट्स

?"
}
|=:{:
)   }
: :;-{
=&( {!;\!@

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

व्याख्या

त्वरित भूलभुलैया प्राइमर:

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

कार्यक्रम अन्य उत्तर के रूप में ही एल्गोरिथ्म का उपयोग करता: हम बदलने के (a, b)साथ (a | a+1, b & b-1)लंबे समय के रूप के रूप में a < b। जब मैंने इसे कुछ और गोल करने की कोशिश की, तो मैं इसका पूरा विवरण जोड़ूंगा।

IP दाएं से बाएं, ऊपरी बाएं कोने में शुरू होती है। ?एक पूर्णांक पढ़ता है a। फिर "एक नो-ऑप है, लेकिन आईपी को तुरंत नीचे जाने से रोकना आवश्यक है। यह भी एक मृत अंत है, इसलिए आईपी घूमता है और ?फिर से पढ़ने के लिए निष्पादित करता है b। }तब मुख्य से औक्सb तक जाता है , इसलिए अब हमें मिल गया है:

Main [ ... 0 a | b 0 ...] Aux

|तो, कुछ नहीं करता है, क्योंकि यह बिटवाइज़ या की लेता है aऔर 0। चूंकि हम जानते हैं कि aयह हमेशा सकारात्मक होता है, इसलिए आईपी पूर्व की ओर मुड़ जाता है (क्योंकि यह पश्चिम की ओर मुड़ नहीं सकता है)। यह कार्यक्रम का मुख्य लूप शुरू करता है। तुलना करने के लिए हम एक छोटे रेखीय खंड से शुरू करते हैं aऔर b:

=   Swap tops of stacks, i.e. swap a and b.
:   Duplicate b.
{   Pull a over to main.
:   Duplicate a.
}   Push one copy back to aux.
-   Compute b-a.

आईपी ​​अब एक और जंक्शन पर है। पहले, आइए उस मामले पर विचार करें जहां परिणाम सकारात्मक है। इसका मतलब है b > aऔर हमें एक और पुनरावृत्ति करने की आवश्यकता है। वह पुनरावृति भी पूरी तरह से रैखिक है। ध्यान दें कि स्टैक वर्तमान में हैं:

Main [ ... 0 b (b-a) | a 0 ...] Aux

;   Discard b-a.
:   Duplicate b.
(   Decrement.
&   Bitwise AND with b, clearing the least-significant 1.
=   Swap new b with old a.
:   Duplicate a.
)   Increment.
|   Bitwise OR with a, setting the least-significant 0.

और फिर हम लूप की शुरुआत में वापस आ गए हैं (चूंकि aफिर से सकारात्मक है, आईपी फिर से पूर्व की ओर मुड़ता है)।

यदि किसी बिंदु पर b-aअब सकारात्मक नहीं है, तो आईपी अन्य दो रास्तों में से एक ले जाएगा। ध्यान दें कि दोनों ही मामलों में हम aसाथ में आते हैं {, फिर एक कोने से टकराते हैं, जहाँ IP बेंड का अनुसरण करता है और फिर प्रिंट aकरता है !। अब स्टैक का शीर्ष फिर से है, b-aजिसका अर्थ है कि दोनों मामलों में आईपी पूर्व की ओर बढ़ जाएगा। अब जो कुछ बचा है वह एक छोटा सा रैखिक है:

;   Discard b-a.
\   Print a linefeed.
!   Print b.
@   Terminate the program.
— मार्टिन एंडर
स्रोत
1

जावा 7, 73 बाइट्स

void d(int x,int y){while(x<y){x|=x+1;y&=y-1;}System.out.print(x+","+y);}

अनगढ़ और परीक्षण के मामले:

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

public class Main{
  static void d(int x, int y){
    while(x < y){
      x |= x + 1;
      y &= y - 1;
    }
    System.out.print(x + "," + y);
  }

  public static void main(String[] a){
    print(2, 3);
    print(3, 2);
    print(8, 23);
    print(42, 81);
    print(38, 41);
    print(16, 73);
    print(17, 17);
  }

  public static void print(int a, int b){
    d(a, b);
    System.out.println();
  }
}

आउटपुट:

3,2
3,2
31,0
63,0
47,32
23,0
17,17

पुरानी चुनौती नियम [ 126 125 123 बाइट्स]:

नोट: पुरानी चुनौती के नियमों ने दो पूर्णांक पूर्णांक के बजाय दो पूर्णांक-सरणियों का उपयोग इनपुट के रूप में किया।

void d(int[]a,int[]b){int i=-1,x,y;while(++i<a.length){x=a[i];y=b[i];for(;x<y;x|=x+1,y&=y-1);System.out.println(x+","+y);}}
— केविन क्रूज़सेन
स्रोत
जवाब पोस्ट करने के बाद चुनौती बदलने के लिए क्षमा करें, लेकिन मैंने चुनौती को थोड़ा सरल कर दिया है। (आपको सूची पर अधिक पुनरावृति करने की आवश्यकता नहीं है)। हालांकि शुक्र है कि यह आपको इसे छोटा करने की अनुमति देगा।
— DJMcMayhem
@DrGreenEggsandIronMan संपादित। Btw, आमतौर पर लोगों द्वारा अपने जवाब पोस्ट किए जाने के बाद नियमों को बदलना बुरा व्यवहार है .. लेकिन जैसा कि आपने कहा, इसे बाइट-काउंट कम करना चाहिए, इसलिए मैं इसके साथ ठीक हूं। (पुनश्च: आपने हर किसी के जवाब पर ऊपर टिप्पणी नहीं की है।)
— केविन क्रूज़सेन
1
आप अपने whileलूप को इस तरह से फिर से लिख सकते हैंfor(;x<y;x|=x+1,y&=y-1);
— क्लिफरॉट
मैं जानता हूं कि यह है। -_-काश मैंने इसे शुरुआत से बेहतर लिखा होता। शुक्र है कि यह अनुचित या कठोर बदलाव नहीं है। इसके अलावा, हां मैंने हर उत्तर पर टिप्पणी नहीं की, लेकिन मैंने प्रत्येक उपयोगकर्ता को सूचित किया। मुझे एक ही उपयोगकर्ता को कई बार सूचित करने का मन नहीं था। मैंने डेनिस की पोस्ट पर कोई टिप्पणी नहीं की, लेकिन ऐसा इसलिए है क्योंकि वह उन उपयोगकर्ताओं में से एक था जिन्होंने मुझे इसे शुरू में बदलने के लिए प्रोत्साहित किया।
— DJMcMayhem
1

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

f=(n,m)=>n<m?f(n|n+1,m&m-1):[n,m]

@ मीलों द्वारा उत्तरों का सरल पोर्ट।

— नील
स्रोत
आप f=एथलीट को भूल गए : पी
— मामा फन रोल
1
आप "फिर से" भूल गए ;-)
— नील
1

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

x<|y=x<y?x|-~x<|y&~-y:[x,y]

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

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

हम <|अपने उद्देश्यों के लिए बाइनरी ऑपरेटर को परिभाषित करते हैं। यह जूलिया के हाल के संस्करणों में अपरिभाषित है, लेकिन अभी भी पार्सर द्वारा एक ऑपरेटर के रूप में मान्यता प्राप्त है। जबकि \(पूर्णांक के लिए स्पष्ट रूप से परिभाषित नहीं) एक बाइट छोटी होती है, इसकी उच्च वरीयता के x|-~x<|y&~-yसाथ (x|-~x)\(y&~-y)बाइट की गिनती बढ़ जाती है।

<|जाँच करता है कि इसका पहला तर्क दूसरे की तुलना में कड़ाई से कम है। यदि हां, तो यह अपने आप को तर्क x से पुकारता है -> x = x | (x + 1) और y & ~ -y = y & (y - 1) ।

सभी अनुगामी सेट बिट्स में 1 से x टॉगल जोड़ने के बाद से और सबसे कम परेशान बिट, x | (x + 1) सबसे कम अनसेट बिट (और अन्य बिट्स) को टॉगल करता है। इसी तरह, 1 से घटाकर y टॉगल से सभी टकराने वाले परेशान बिट्स और सबसे कम सेट बिट, y & (y + 1) सबसे कम सेट बिट को टॉगल करता है।

अंत में, जब असमानता x <y अब धारण नहीं करती है, <|तो जोड़ी [x, y] लौटाती है ।

— डेनिस
स्रोत
0

MATLAB, 67 66 बाइट्स

पाश:

function[]=f(x,y)
while x<y
x=bitor(x,x+1);y=bitand(y,y-1);end
x,y

पुनरावर्ती (67 बाइट्स):

function[]=f(x,y)
if x<y
f(bitor(x,x+1),bitand(y,y-1))
else
x,y
end

बिट के रूप में कई अन्य awers बदलते दृष्टिकोण।

— pajonk
स्रोत
0

क्लोजर, 63 बाइट्स

#(if(< % %2)(recur(bit-or %(inc %))(bit-and %2(dec %2)))[% %2])

जे में मेरे समाधान में इस्तेमाल के रूप में एक ही विधि ।

प्रयोग

=> (def f #(if(< % %2)(recur(bit-or %(inc %))(bit-and %2(dec %2)))[% %2]))
=> (f 38 41)
[47 32]
=> (map (partial apply f) [[2 3] [3 2] [8 23] [42 81] [38 41] [16 73] [17 17]])
([3 2] [3 2] [31 0] [63 0] [47 32] [23 0] [17 17])
— मील की दूरी पर
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.