बिट बिट संचालन

Question

मुझे गोल्फ खेलना पसंद है dc, लेकिन मुझे कभी-कभी निराशा होती है क्योंकि dcबिटवाइज़ ऑपरेशन नहीं होते हैं।

चुनौती

चार नामित कार्य करता है जो ग बिटवाइज़ आपरेशन के बराबर लागू प्रदान करें &, |, ~और ^(बिटवाइज़ और, या, नहीं और XOR)। प्रत्येक फ़ंक्शन दो ऑपरेंड लेगा ( ~केवल एक लेता है) जो कम से कम 32-बिट अहस्ताक्षरित पूर्णांक हैं। प्रत्येक फ़ंक्शन ऑपरेंड के समान बिट-चौड़ाई का एक अहस्ताक्षरित पूर्णांक लौटाएगा।

बंधन

आप केवल उन ऑपरेशनों का उपयोग कर सकते हैं जिनका समर्थन किया जाता है dc। य़े हैं:

• + - * / अंकगणित जोड़, घटाव, गुणा और भाग
• ~ modulo (या divmod अगर आपकी भाषा इसका समर्थन करती है)
• ^ घातांक
• | मॉड्यूलर घातांक
• v वर्गमूल
• > >= == != <= < मानक समानता / असमानता ऑपरेटरों
• >> <<बिट शिफ्ट ऑपरेटरों। dcइनमें से नहीं है, लेकिन जब से इन्हें 2 की शक्तियों द्वारा विभाजन / गुणन के संदर्भ में तुच्छ रूप से लागू किया जाता है, तब मैं इन्हें अनुमति दूंगा।

dcमेरी संरचना में नियंत्रण संरचनाएं (पुनरावर्ती) मैक्रोज़ और (इन) समानता संचालन का उपयोग करके निर्मित की जाती हैं। आप अपनी भाषा में जो भी अंतर्निर्मित नियंत्रण संरचनाएं उपयोग कर सकते हैं।

आप तार्किक परिचालकों का भी उपयोग कर सकते हैं && || ! , भले ही ये सीधे उपलब्ध न हों dc।

आप बिटवाइज़ ऑपरेटर्स उपयोग नहीं करना चाहिए & , |, ~और ^या किसी कार्यों कि तुच्छता से उन्हें लागू।

इसके अलावा आपको अंतर्निहित आधार-रूपांतरण-के-स्ट्रिंग ऑपरेटरों या कार्यों का उपयोग नहीं करना चाहिए।

---

कृपया अपने उत्तर को सत्यापित करने में सहायता के लिए एक परीक्षण कार्यक्रम या ऑनलाइन संकलक स्निपेट (गोल्फ स्कोर में शामिल नहीं) प्रदान करने पर विचार करें।

Comments

क्या हम एक फ़ंक्शन को लागू कर सकते हैं जो पैरामीटर के रूप में वांछित संचालन लेता है? इसके अलावा, क्या हम बिट-शिफ्ट के लिए स्टैंड-इन के रूप में 2 से पूर्णांक-विभाजित कर सकते हैं?

— xnor

@xnor आपको 4 सार्वजनिक कार्य प्रदान करने होंगे जो प्रत्येक चार ऑपरेटरों को कार्यान्वित करें। आपके पास सामान्य / सहायक निजी तरीके / फ़ंक्शन भी हो सकते हैं, जिन्हें सभी चार सार्वजनिक कार्यों द्वारा बुलाया जाता है, लेकिन इन सभी को गोल्फ स्कोर में शामिल करने की आवश्यकता होगी।

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

@xnor आपको और आपको केवल xnor ऑपरेटर को लागू करना होगा ;-)

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

क्या मैं चार अनाम कार्यों की सूची तैयार कर सकता हूं?

— xnor

@MariaTidalTug चार कार्यों की सूची को वापस करने और मैन्युअल रूप से चयन करने और लागू करने के बीच प्रभावी अंतर क्या है (जैसा कि xnor ने सुझाव दिया है) बनाम एक फ़ंक्शन होने से जो चयन पैरामीटर को स्वीकार करता है और चयन स्वयं करता है (जैसा कि वुल्फामर ने उत्तर दिया)? वे दोनों समान रूप से चार नामित कार्यों के बिंदु को कम करते हैं, क्योंकि वे उपयोगकर्ता कोड पर कोड आकार को ऑफलोड करते हैं। मैं यह भी तर्क दूंगा कि पूर्व इसे और कम करता है, क्योंकि उपयोगकर्ता कोड शायद बाद के मामले की तुलना में उस मामले में अधिक जटिल है।

— Runer112

Answer 1

सी, 134

सी प्रीप्रोसेसर दुर्व्यवहार के लिए बहुत मजेदार है। मूल रूप से इस मैक्रो 3 कार्यों को परिभाषित करता है, a, o, और x, के लिए and, or, और xorक्रमशः। इन ऑपरेशनों के लिए एल्गोरिथ्म में एकमात्र अंतर परिणाम में बिट स्थापित करने के लिए मानदंड है।

notकार्य है n।

#define f(n,c)n(a,b){for(r=0,i=31;i+1;--i)if(((a>>i)%2+(b>>i)%2)c)r+=1<<i;return r;}
i,r;n(a){return 0xffffffff-a;}f(a,/2)f(o,)f(x,%2)

परीक्षक कार्यक्रम (एक लंबा समय लगता है, मैंने किसी भी समय इसे अनुकूलित करने में कोई समय खर्च नहीं किया, लेकिन यह MAX_INT संबंधित लोगों के साथ हर संभव परीक्षण का परीक्षण करता है):

#define m_assert(expected, condition, actual)\
    if(!((expected) condition (actual)))\
        printf("assert fail @ line %i, expected: %x, actual %x, condition "#condition"\n", __LINE__, expected, actual);

int main()  {
    unsigned int j,k;
    for(j=0; j<0xffff; ++j)    {
        m_assert(~j, ==, n(j));
        for(k=0; k<0xffff; ++k)    {
            m_assert(j & k, ==, a(j,k));
            m_assert(j | k, ==, o(j,k));
            m_assert(j ^ k, ==, x(j,k));
        }
    }

Comments

उफ़। उस के बारे में भूल गया। अब तय हो गया है।

— छद्म नाम

Answer 2

बीड 76 बाइट्स है

आइड में भी बिटवाइज़ ऑपरेशन नहीं होते हैं - आमतौर पर कष्टप्रद, लेकिन अब आपका स्वागत है, क्योंकि हमें वास्तव में उन्हें लागू करने की आवश्यकता है।

फ़ंक्शंस गिने हुए मेमोरी स्लॉट (कोई क्रिया नाम नहीं) में संग्रहीत किए जाएंगे।

बाइनरी से और इससे रूपांतरण:

@5{:x/2^[32]%2:};
@6{:x@:2^[32]:};

नहीं हो सकता है, @1{:$6::{1-$5::x}:}लेकिन यह स्पष्ट रूप से सिर्फ घटाना आसान है:

@1{:2^32-x-1:};

या:

@2{:$6::{$5::{x_0}:+$5::{x_1}>0}:};

तथा:

@3{:$6::{$5::{x_0}:*$5::{x_1}}:};

XOR:

@4{:$6::{$5::{x_0}:<>$5::{x_1}}:};

यह हमें 156 बाइट्स (न्यूलाइन्स और सेमीकोलन के साथ) में लाएगा। एक परीक्षण कोड सिर्फ होगा (नहीं, या, उत्तराधिकार में XOR, $ 1, $ 2, $ 3, $ 4 नामों के तहत पाया गया):

> $1::{6}
4294967289
> $2::{12 11}
15
> $3::{12 11}
8
> $4::{12 11}
7

---

लेकिन निश्चित रूप से या नहीं और हम सभी की जरूरत है और चीजों को सरल बनाया जा सकता है:

@1{:2^32-x-1:};
@2{:@+{2^U{?{$5::x}%32}}:};
@3{:${1 2 1}::x:};
@4{:$3::{$2::x${1 2}::x}:};
@5{:x/2^[32]%2:};

वह 109 वर्ण की है। जब नई कड़ियों और अर्धविरामों को छोड़ दिया जाता है, और थोड़ा अधिक गोल्फिंग के साथ, हमारे पास 76 वर्ण होते हैं:

@3{@1{:2^32-x-1:}@2{:@+{2^U{?{x/2^[32]%2}%32}}:}$1}@4{{:$2::x${1 2}::x:}$3};

Answer 3

निम (537) (490)

निम कंपाइलर 0.10.2

मैं निम सीखने के लिए एक कारण की तलाश में हूँ ताकि हम यहाँ जाएँ।

कोड गोल्फ के लिए, मैंने चर मापदंडों और निहित रिटर्न का लाभ उठाया है। प्रलेखन के अनुसार चर पैरामीटर, कम स्टैक कुशल हैं। व्यक्तिगत रूप से, मुझे लगता है कि निहित रिटर्न को पढ़ना मुश्किल है और शायद केवल तुच्छ प्रक्रियाओं में उनका उपयोग करेगा।

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

मुझे यकीन नहीं था कि अगर हमें दो या बूलियन शर्तों का उपयोग करने के लिए अंतर्निहित OR का उपयोग करने की अनुमति दी गई थी, तो notZero प्रक्रिया को उनके स्थान पर रखा गया था।

proc s(x, y, b: var int)=
  x = x div 2
  y = y div 2
  b *= 2

proc n(x: var int): int =
  return -(x+1)

proc a(x, y: var int): int =
  var b = 1
  while x > 0 and y > 0:
    if (x mod 2  + y mod 2) == 2:
      result += b

    s(x,y,b)

proc o(x, y: var int): int =
  var b = 1
  while x + y > 0:
    if (x mod 2 + y mod 2) >= 1:
      result += b

    s(x,y,b)

proc r(x, y: var int): int =
  var b = 1
  while x + y > 0:
    if (x mod 2 + y mod 2) == 1:
      result += b

    s(x,y,b)

फिर भी बेहतर तरीके की तलाश ...

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

Comments

@MariaTidalTug स्पष्ट करने के लिए धन्यवाद!

— cory.todd 5

मैं ऐसा नहीं कर सकता। क्या आपका कैलकुलेटर बेस -16 मोड में है?

— cory.todd

मैंने pseudonym117 के समान एक परीक्षण दोहन जोड़ा।

— cory.todd

Answer 4

सीजेएम, 71 बाइट्स

{:F;0{:R;2md@2md@+F~!2I#*R+}64fI\;\;}:B{"2-"B}:A{'!B}:O{0SB}:N{'(B}:X];

व्याख्या

"B : UInt64 UInt64 String -> UInt64
 Computes a bitwise operation on the two given unsigned integers. The operation
 is defined by the logical inverse of the result of evaluating the given string
 given the sum of two input bits.";
{
  :F;             "Save the operation string.";
  0               "Initialize the result to 0.";
  {               "For I from 0 through 63:";
    :R;             "Save the result.";
    2md@2md@        "Divide each input by 2 and collect the remainders as the
                     next pair of bits to process.";
    +F~!            "Compute the logical inverse of the result of evaluating
                     the operation string given the sum of the two bits.";
    2I#*            "Adjust the resulting bit to be in the correct output
                     position by multiplying it by 2^I.";
    R+              "Add the location-adjusted bit to the result.";
  }64fI
  \;\;            "Clean up.";
}:B

"A : UInt64 UInt64 -> UInt64
 Computes the bitwise AND of the two given unsigned integers.
 This is done by passing the inputs along to B with an operation such that:
   bit_out = !((bit_in_1 + bit_in_2) - 2)";
{"2-"B}:A

"O : UInt64 UInt64 -> UInt64
 Computes the bitwise OR of the two given unsigned integers.
 This is done by passing the inputs along to B with an operation such that:
   bit_out = !(!(bit_in_1 + bit_in_2))";
{'!B}:O

"N : UInt64 -> UInt64
 Computes the bitwise NOT of the given unsigned integer.
 This is done by passing the input and 0 along to B with an operation such that:
   bit_out = !((bit_in + 0))";
{0SB}:N

"X : UInt64 UInt64 -> UInt64
 Computes the bitwise XOR of the two given unsigned integers.
 This is done by passing the inputs along to B with an operation such that:
   bit_out = !((bit_in_1 + bit_in_2) - 1)";
{'(B}:X

];              "Clean up.";

परीक्षण सूट

यह कोड मेरे और प्रत्येक, या, नहीं, और xor के प्रत्येक कार्य को 100 बार समान रूप से वितरित 64-बिट अहस्ताक्षरित इनपुट के साथ चलाता है और निर्मित ऑपरेटर द्वारा उत्पादित परिणाम के साथ तुलना करता है। Eval ऑपरेटर के गंभीर उपयोग के कारण, यह काफी धीमा है और ऑनलाइन इंटरप्रेटर के साथ लगभग एक मिनट तक का समय लग सकता है। लेकिन अगर सब ठीक हो जाता है, तो निष्पादन बिना किसी आउटपुट के समाप्त होना चाहिए, क्योंकि जो भी विसंगतियां पाई गई हैं, वे मुद्रित हैं।

N:L;
{:F;0{:R;2md@2md@+F~!2I#*R+}64fI\;\;}:B{"2-"B}:A{'!B}:O{0SB}:N{'(B}:X];
{;Y32#__mr*\mr+}2e2%2/{~:U;:V;"A&O|X^"2/{[{US@SV" = "UV5$~L}/9$2$={];}{]oLo}?}/"N~"[{U" = "U3$~Y64#(&L}/6$2$={];}{]oLo}?}/

Answer 5

जावास्क्रिप्ट 294 267

@ AlexA. और @ kennytm के सुझावों के साथ कुछ और बाइट्स निकालने में सक्षम था।

कार्य:

B=(n,m,t)=>{for(var p=4294967296,y=0;p>=1;p/=2)y+=t=='x'&&(n>=p||m>=p)&& !(n>=p&&m>=p)?p:0,y+=t=='a'&&n>=p&&m>=p?p:0,y+=t=='o'&&(n>=p||m>=p)?p:0,n-=n>=p?p:0,m-=m>=p?p:0
return y}
N=(n)=>{return 4294967295-n}
A=(n,m)=>B(n,m,'a')
O=(n,m)=>B(n,m,'o')
X=(n,m)=>B(n,m,'x')

उदाहरण:

var n = 300;
var m = 256;
console.log(X(n,m) + ", " + (n ^ m));
console.log(O(n,m) + ", " + (n | m));
console.log(A(n,m) + ", " + (n & m));
console.log(N(n) + ", " + (~n>>>0));
console.log(N(m) + ", " + (~m>>>0));

उत्पादन:

44, 44
300, 300
256, 256
4294966995, 4294966995
4294967039, 4294967039

Comments

आपको चार सार्वजनिक फ़ंक्शन प्रदान करने की आवश्यकता है - AND, OR के लिए प्रत्येक। नहीं और XOR। (आपके पास सामान्य / सहायक निजी तरीके / कार्य भी हो सकते हैं, जिन्हें सभी चार सार्वजनिक कार्यों द्वारा बुलाया जाता है)। इसके अलावा, आप नहीं याद कर रहे हैं - शायद इन सब के लिए सबसे आसान है

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

धन्यवाद @ अलेक्सा। मैंने बाइट्स को जोड़ा है और इसे कुछ और बढ़ाया है।

— वोल्फहैमर

आप के बाद forऔर के function B(n,m,t)साथ जगह खो सकते हैं B=(n,m,t)=>। इसी तरह अन्य कार्यों के लिए।

— एलेक्स ए।

29 आप 4*(1<<30)4294967296 और 4294967295 के लिए उपयोग कर सकते हैं -1>>>0। vartruly क्या वास्तव में यहाँ आवश्यक है? ③ आप के (n,m)=>B(n,m,'a')बजाय लिख सकते हैं(n,m)=>{return B(n,m,'a')}

— kennytm