एक समता बिट उत्पन्न करें

18

एक समता बिट , चेकसम का सरलतम रूपों में से एक है। पहले, आपको समता को चुनना होगा, सम या विषम। मान लीजिए हम भी उठाते हैं। अब, हमें प्रेषित होने के लिए एक संदेश की आवश्यकता है। मान लीजिए कि हमारा संदेश "फू" है। यह बाइनरी में लिखा है:

01000110 01101111 01101111

अब, हम वहां कुल संख्या की गिनती करते हैं 1, जो 15. है। 15 चूंकि एक विषम संख्या है, हमें अपने संदेश के अंत में एक अतिरिक्त बिट जोड़ना होगा, और अब हमारे पास बिट्स पर एक समान संख्या होगी। । यह अंतिम जोड़ा बिट "समता बिट" के रूप में जाना जाता है। यदि हमने अपने चेकसम के लिए एक विषम समता को चुना है, तो हमें एक अतिरिक्त '0' जोड़ना होगा ताकि बिट्स की संख्या विषम बनी रहे।

चुनौती:

आपको एक प्रोग्राम या फ़ंक्शन लिखना होगा जो यह निर्धारित करता है कि स्ट्रिंग के लिए सही समानता क्या है। आपके प्रोग्राम को दो इनपुट लेने होंगे:

  • एक तार s,। यह संदेश है कि चेकसम की गणना की जाएगी। यह 95 प्रिंट करने योग्य ASCII वर्णों तक सीमित रहेगा।

  • एक चरित्र या एकल चरित्र स्ट्रिंग p, जो या तो eसमता के लिए होगा , या oविषम समता के लिए।

और सही समता बिट का प्रतिनिधित्व करने वाले एक सत्य -गलत मूल्य का उत्पादन करते हैं। सत्य अगर यह है 1, और यदि यह है तो गलत है 0।

किसी स्ट्रिंग या वर्ण में "ऑन" बिट्स की संख्या गिनने वाले बिल्डरों को अनुमति नहीं है। उदाहरण के लिए, एक फ़ंक्शन fजो ऐसा करता है: f('a') == 3या f('foo') == 16प्रतिबंधित है। आधार रूपांतरण जैसे कुछ भी, निष्पक्ष खेल है।

परीक्षण IO:

(without the quotes)
s: "0"
p: 'e'
output: 0

s: "Foo"
p: 'e'
output: 1

s: "Hello World!"
p: 'o'
output: 0

s: "Alex is right"
p: 'e'
output: 1

s: "Programming Puzzles and Code-Golf" 
p: 'e'
output: 0

s: "Programming Puzzles and Code-Golf" 
p: 'o'
output: 1

यह कोडगोल्फ है, इसलिए मानक खामियां लागू होती हैं, और बाइट्स में सबसे कम जवाब जीतता है।

लीडरबोर्ड

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

code-golf  string  bitwise  checksum 
— DJMcMayhem
स्रोत
10
गुस्सा करने के बजाय, oसमता भी है।
— नील
क्या आप स्पष्ट कर सकते हैं "एक स्ट्रिंग या चरित्र में बिट्स" पर "की संख्या की गणना करने वाले बिल्डरों को अनुमति नहीं है।" थोड़ा - सा बेहतर? अंतर्निहित आधार रूपांतरण के बारे में क्या? आदि ..
— orlp
@DrGreenEggsandWeDJ स्टैक साइटों पर टिप्पणियां अस्थिर हैं और बिना किसी सक्षम उपयोगकर्ता के व्हाट्सएप पर चेतावनी के बिना गायब हो सकती हैं। नतीजतन, यह अत्यधिक प्रोत्साहित करता है कि चुनौती का अभिन्न अंग है, टिप्पणी अनुभाग में ही नहीं ।
— बिल्ली
1
@ उदाहरण के लिए, अजगर में str(int(s, 2)).count('1'):? नहीं, मैं उस नियम का उल्लंघन करने वाले एकल बिलिन फ़ंक्शन होने पर विचार नहीं करूंगा । क्या मेरा संपादन अधिक स्पष्ट है?
— DJMcMayhem
1
@cat जहां तक ​​मेरा सवाल है char == single_char_string। मैंने उस पोस्ट को संपादित भी किया।
— DJMcMayhem

जवाबों:

9

MATL , 8 7 बाइट्स

8\hBz2\

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

8\    % Implicitly take first input ('e' or 'o'), and compute modulo 8. Inputs 'e' and 'o' 
      % give 5 or 7 respectively, which have an even or odd number of `1` bits resp.
h     % Implicitly take second input, and concatenate
B     % Convert to binary. Gives 2D array, with one row for each original entry 
z     % Number of nonzero values in that 2D array
2\    % Modulo 2, i.e. compute parity
— लुइस मेंडो
स्रोत
9

जावा, 97 बाइट्स

क्योंकि, फिर पता है, जावा।

(s,c)->{boolean e=1>0;for(int i:s.getBytes())while(i>0){if(i%2==1)e=!e;i/=2;}return c=='o'?e:!e;}

यह एक लंबोदर है a BiFunction<String, Character, Boolean>।

eऔर oवापसी कथन में उलटा प्रतीत होता है क्योंकि स्पष्ट रूप से मेरा तर्क पीछे की ओर था।

— CAD97
स्रोत
5

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

lambda s,p:`map(bin,map(ord,p+s))`[9:].count('1')%2

यह प्रत्येक चरित्र के लिए सारांश के बजाय द्विआधारी में वर्ण कोड की सूची के स्ट्रिंग प्रतिनिधित्व में गिनती करने के लिए Sp3000 के विचार पर आधारित है ।

नई ट्रिक को संभालना है eऔर इसमें oभी। यदि eयह विषम था और oयहां तक ​​कि, हम केवल गिनती करने से पहले स्ट्रिंग को समता का संकेत दे सकते थे (उन्हें फैंकना क्योंकि '1' सत्य है)। दुर्भाग्य से, वे नहीं हैं। लेकिन, अगर हम सभी को हटा दें लेकिन उनके अंतिम दो बिट्स हैं, तो यह अब सच है।

e 0b11001|01
o 0b11011|11

यह 9स्ट्रिंग प्रतिनिधित्व के पहले चरित्र को हटाकर किया जाता है ।

['0b11001|01',
— XNOR
स्रोत
वाह, यह एक बहुत साफ तरीका है eo!
— Sp3000
4

जेली, ९ by बाइट्स

OBFSḂ⁼V}

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

O         convert each character in argument 1 (left arg) to its codepoint (ord)
 B        convert to binary (list of 0s and 1s)
  F       flatten
   S      sum the entire list, giving the number of 1s in the entire string
    Ḃ     mod 2 (take the last bit)
       }  now, with the second (right) argument...
      V   eval with no arguments. This returns...
            1 for e because it expands to 0e0 (i.e., does 0 exist in [0])
            0 for o because it expands to 0o0 (0 OR 0, false OR false, false)
     ⁼    test equality between the two results

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

— Doorknob
स्रोत
1
मैं खुद एक जेली उत्तर के साथ आने की कोशिश कर रहा था, लेकिन उन नियमों का पालन करते हुए मुझे बहुत खुशी हुई :-)
— लुइस
2
@LuisMendo मैं एक ही नाव में हूँ; पी: यह बहुत लंबे समय के लिए ... जिस तरह से यह जानने की कोशिश कर रहा करने के बाद मेरा पहला जेली जवाब है
— दरवाज़े
वो V}… वो सच में मस्त थी !!! (डेनिस एक वास्तविक गोल्फर है) +1 यह मेरी हर कोशिश को हरा देता है।
— आउटगॉल्फ
4

सी, 62 बाइट्स

  • 12 बाइट्स ने @LevelRiverSt और @TonHharma को धन्यवाद दिया।

XOR की अच्छी संपत्ति है कि इसका उपयोग समानता को संरक्षित करते हुए, एक तार के नीचे तार को कम करने के लिए किया जा सकता है।

f(s,p)char*s;{for(p/=8;*s;)p^=*s>>4^*s++;p^=p/4;return p%4%3;}

Ideone।

— डिजिटल आघात
स्रोत
1
27030>>((p^p>>4)&15)&1 पी की समता की गणना करनी चाहिए और यहां तक ​​कि 1 बाइट छोटी है
— टन हास्पेल
1
में अंतरिक्ष char *suneeded है
— टन Hospel
2
62 बाइट्स: हमेशा एक 0 के लिए 0 वापस आ जाएगी, लेकिन एक 1. के लिए 1 या 2 वापस आ सकते हैं यह नियमों के तहत स्वीकार्य है:f(s,p)char*s;{for(p/=8;*s;)p^=*s>>4^*s++;p^=p/4;return p%4%3;}%3truthy if it's a 1
— स्तर नदी सेंट
1
27030>>((p^p>>4)&15)&1। खैर, गलत, जाहिर है। ;-)
— डिजिटल ट्रामा
@LevelRiverSt शानदार! धन्यवाद!
— डिजिटल ट्रामा
4

पायथन, 58 57 बाइट्स

lambda s,p:sum(bin(ord(c)).count("1")for c in s)&1!=p>'e'
— orlp
स्रोत
1
53 (पायथन 2 केवल):lambda s,p:`map(bin,map(ord,s))`.count('1')%2^(p>'e')
— Sp3000
आप के साथ एक बाइट बचा सकते हैं !=p>'e'।
— xnor
रुको, मेरी बाइट-सेव वास्तव में काम नहीं करती है क्योंकि पायथन इसे जंजीर असमानता के रूप में मानता है।
— xnor
lambda s,p:`map(bin,map(ord,p+s))`[8:].count('1')%2
— xnor
@xnor बस अपना जवाब पोस्ट करें।
— orlp
3

पायथ, 12 बाइट्स

q@"oe"sjCz2w

परीक्षण सूट।

         z    take a line of input
        C     convert to int
       j  2   convert to base 2, array-wise (so, array of 0s and 1s)
      s       sum (count the number of ones)
 @"oe"        modular index into the string to get either "o" or "e"
q          w  test equality to second line of input
— Doorknob
स्रोत
3

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

(s,p)=>(t=p>'e',[...s].map(c=>t^=c.charCodeAt()),t^=t/16,t^=t/4,t^t/2)&1

बेस ट्विस्टिंग और काउंटिंग 1एस की तुलना में बिट ट्विडलिंग कम निकला ।

— नील
स्रोत
2

पर्ल, 29 बाइट्स

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

STDIN पर इनपुट के साथ पैरिटी कैरेक्टर स्पेस स्ट्रिंग, उदाहरण के लिए चलाएं

parity.pl <<< "p Programming Puzzles and Code-Golf"

parity.pl

#!/usr/bin/perl -p
$_=unpack"B*",$_|b;$_=1&y;1;
— टन हास्पेल
स्रोत
2

जे, 27 बाइट्स

'oe'&i.@[=[:~:/^:2@#:3&u:@]

प्रयोग

   f =: 'oe'&i.@[=[:~:/^:2@#:3&u:@]
   'e' f '0'
0
   'e' f 'Foo'
1
   'o' f 'Hello World!'
0
   'e' f 'Alex is right'
1
   'e' f 'Programming Puzzles and Code-Golf'
0
   'o' f 'Programming Puzzles and Code-Golf'
1
— मील की दूरी पर
स्रोत
1

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

(s,p)=>[...s].map(c=>{for(n=c.charCodeAt();n;n>>=1)r^=n&1},r=p>"e")|r
— user81655
स्रोत
1

PowerShell v2 +, 91 बाइट्स

/ मुझे एक कोने में रोता है

param([char[]]$a,$b)$b-eq'o'-xor(-join($a|%{[convert]::toString(+$_,2)})-replace0).length%2

हाँ ... तो, PowerShell के लिए आधार रूपांतरण एक मजबूत सूट नहीं है। इनपुट स्ट्रिंग से बाइनरी प्रतिनिधित्व $a|%{[convert]::toString(+$_,2)}में रूपांतरण 32 बाइट्स में और अपने आप में है ...

इनपुट लेता है $aऔर $b, स्पष्ट $aरूप से प्रक्रिया में चार-सरणी के रूप में कास्टिंग करता है। हम तो जाँच करें कि क्या $bहै -eqकरने के लिए UAL o, और -xorकार्यक्रम के दूसरे आधे के साथ कि। उस भाग के लिए, हम इनपुट स्ट्रिंग लेते हैं $a, प्रत्येक अक्षर को बाइनरी में बदलने के लिए इसे एक लूप के माध्यम से पाइप करते हैं, -joinउन सभी को एक साथ मिलकर एक ठोस स्ट्रिंग बनाते हैं, और -replaceसभी 0कुछ भी नहीं के साथ। हम तो गिनती .lengthकि स्ट्रिंग की और यह आधुनिक -2 निर्धारित करने के लिए अगर यह सम या विषम है लेते हैं, जो आसानी से या तो हो जाएगा 0या 1के लिए सही -xor।

उसी के अनुसार Trueया लौटेंगे False। नीचे देखें परीक्षण के मामले:

PS C:\Tools\Scripts\golfing> .\generate-parity-bit.ps1 "0" e
False

PS C:\Tools\Scripts\golfing> .\generate-parity-bit.ps1 "Foo" e
True

PS C:\Tools\Scripts\golfing> .\generate-parity-bit.ps1 "Hello World!" o
False

PS C:\Tools\Scripts\golfing> .\generate-parity-bit.ps1 "Alex is right" e
True

PS C:\Tools\Scripts\golfing> .\generate-parity-bit.ps1 "Programming Puzzles and Code-Golf" e
False

PS C:\Tools\Scripts\golfing> .\generate-parity-bit.ps1 "Programming Puzzles and Code-Golf" o
True
— AdmBorkBork
स्रोत
1

फैक्टर, 85 बाइट्स

किसी कारण से मैं अपने सिर को कुछ मिनट पहले तक लपेट नहीं सका, जब मैंने कोड को सरलीकृत किया (और शायद छोटा कर दिया?)।

[ "e" = [ even? ] [ odd? ] ? [ [ >bin ] { } map-as concat [ 49 = ] count ] dip call ]

?एक टर्नरी ऑपरेटर की तरह है: यह तीसरे स्टैक आइटम की सत्यता का परीक्षण करता है, और या तो trueमूल्य या मूल्य का चयन करता है false।

यह लगभग सी-सी Pseduocode के बराबर है:

void* parity_tester_function = strcmp(p, "e") ? (void *) even?  // it's a function pointer (I think)
                                              : (void *) odd? ;

कोड के बाकी बहुत सरल है: 

[                       ! to count a string's set bits:
    [ >bin ] { } map-as ! get the binary of each character, and map as an array, because you can't have stringy data nested in another string (that's called a type error)
    concat              ! { "a" "B" } concat -> "aB"
    [ 49 = ] count      ! count items in the resulting string which match this condition (in this case, the condition we're testing is whether the character has the same code point as "1")
] dip                   ! take the above function pointer off the stack, apply this anonymous function to the now-top of the stack, then restore the value after the quotation finishes.
                        ! in other words, apply this quotation to the second-to-top item on the stack
call                    ! remember that conditionally chosen function pointer? it's on the top of the stack, and the number of sets bits is second.
                        ! we're gonna call either odd? or even? on the number of set bits, and return the same thing it does.
— बिल्ली
स्रोत
1

IA-32 मशीन कोड, 15 बाइट्स

Hexdump:

0f b6 c2 40 32 01 0f 9b c0 3a 21 41 72 f6 c3

विधानसभा कोड:

    movzx eax, dl;
    inc eax;
repeat:
    xor al, [ecx];
    setpo al;
    cmp ah, [ecx];
    inc ecx;
    jb repeat;
    ret;

यह एक ऐसा फंक्शन है जो अपना पहला तर्क (स्ट्रिंग) ecxऔर दूसरा तर्क (चार) में प्राप्त करता है dl। यह परिणाम को अंदर लौटाता है eax, इसलिए यह fastcallकॉलिंग कन्वेंशन के अनुकूल है ।

जब यह setpoनिर्देश का उपयोग करता है तो यह कोड नियमों को मोड़ देता है:

किसी स्ट्रिंग या वर्ण में "ऑन" बिट्स की संख्या गिनने वाले बिल्डरों को अनुमति नहीं है

यह निर्देश alपिछले निर्देश द्वारा गणना की गई समता बिट के लिए सेट है - इसलिए मेरे पास नियमों पर ये दो नाइटपिक्स हैं:

  • यह "ऑन" बिट्स की संख्या की गणना नहीं करता है - यह सीधे समता बिट की गणना करता है!
  • तकनीकी रूप से, यह पिछले निर्देश ( xor) है जो समता बिट की गणना करता है। setpoअनुदेश केवल करने के लिए इसे ले जाता है alरजिस्टर।

ये शब्दार्थ विवरण इस तरह से है, यहाँ कोड क्या करता है पर स्पष्टीकरण दिया गया है।

पात्रों के प्रतिनिधित्व हैं:

'e' = 01100101
'o' = 01101111

यदि हम उनके साथ 1 जोड़ते हैं, तो वे सही समानता रखते हैं:

'e' + 1 = 01100110 (odd parity)
'o' + 1 = 01110000 (even parity)

तो हम XORस्ट्रिंग के सभी पात्रों, alइन मूल्यों के लिए प्रारंभिक , जो जवाब देता है।

पहला निर्देश movzx eax, dlअधिक स्पष्ट (और कम) के बजाय है mov al, dl, क्योंकि मैं एक रजिस्टर में 0 नंबर ( ahइस मामले में) चाहता हूं ताकि वह सही क्रम में ( 0, [ecx]तुलना में [ecx], 0) तुलना करने में सक्षम हो सके ।

— anatolyg
स्रोत
1

जूलिया, 58 47 45 40 बाइट्स

f(s,p)=(p>'e')$endof(prod(bin,s)∩49)&1

यह एक फ़ंक्शन है जो एक स्ट्रिंग और एक चरित्र को स्वीकार करता है और एक पूर्णांक देता है।

बाइनरी प्रतिनिधित्व में लोगों की संख्या प्राप्त करने के लिए, हम पहले binस्ट्रिंग में प्रत्येक वर्ण पर फ़ंक्शन को लागू करते हैं , जो हमें बाइनरी स्ट्रिंग्स की एक सरणी देता है। फिर उन्हें एक का उपयोग करके कम करें prod(चूंकि *जूलिया में स्ट्रिंग कॉन्फैनेटेशन है) और उस स्ट्रिंग के सेट चौराहे और उसके लिए वर्ण कोड लें 1, जो हमें एक स्ट्रिंग प्रदान करता है। उस तार का अंतिम सूचकांक लोगों की संख्या है। हम इसे 1 के साथ XOR करते हैं यदि प्रदान किया गया चरित्र ओ और 0 है अन्यथा, तो बिटवाइज़ और 1 का उपयोग करके समता प्राप्त करें।

इसे ऑनलाइन आज़माएं! (सभी परीक्षण मामले शामिल हैं)

डेनिस की बदौलत बचाए गए 18 बाइट!

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

05AB1E , 15 , 13 बाइट्स

कोड:

€ÇbSOÈ„oe²k<^

उदाहरण इनपुट:

Programming Puzzles and Code-Golf
o

उदाहरण आउटपुट:

1

स्पष्टीकरण:

€                 # for each char in string
 Ç                # get ascii value
  b               # convert to binary
   S              # split to single chars (ex: '1101' to '1','1','0','1')
    O             # sum
     È            # check if even
      „oe         # push string "oe"
         ²        # push 2nd input (p)
          k       # get 1-based index of p in "oe"
           <      # decrease (to get either 0-based index)
            ^     # xor with result of È

2 बाइट बचाने के लिए अदनान को धन्यवाद।

— Emigna
स्रोत
वाह बहुत अच्छा! आप ²कमांड का उपयोग करके दो बाइट्स को बंद कर सकते हैं । यह स्वचालित रूप से स्टैक के शीर्ष पर दूसरे इनपुट को धक्का देता है। इसके अलावा, दो-चार तार का उपयोग कर छोटा किया जा सकता है „। तो "oe"के बराबर है „। 13 बाइट्स के लिए: €ÇbSOÈ„oe²k<^:)
— अदनान
05AB1E CP-1252 एन्कोडिंग का भी उपयोग करता है , इसलिए यहां प्रत्येक वर्ण 1 बाइट :) है।
— अदनान
@ अदनान: धन्यवाद! बाइटकाउंट के लिए नोटपैड ++ का उपयोग किया गया और बस यह मान लिया गया कि इसने वर्णों की गिनती की: पी
— एमिग्ना
0

रूबी, 57 बाइट्स

अगर 0रूबी में फाल्सी थी, तो ==संभवत: बस को स्विच किया जा सकता है -, या अन्य अनुकूलन हो सकते हैं, लेकिन ऐसा नहीं है।

->s,b{s.gsub(/./){$&.ord.to_s 2}.count(?1)%2==(b>?i?0:1)}
— मूल्य स्याही
स्रोत
0

रेटिना , 102 बाइट्स

पहली पंक्ति पर स्ट्रिंग लेता है, और दूसरी पंक्ति पर अक्षर। आईएसओ 8859-1 एन्कोडिंग का उपयोग करता है।

[12478abdghkmnpsuvyzCEFIJLOQRTWX#%&)*,/;=>@[\]^| ](?=.*¶)
1
[^1](?=.*¶)
0
^(0|10*1)*¶o|^0*1(0|10*1)*¶e

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

पहली पंक्ति पर वर्ण वर्ग द्विआधारी प्रतिनिधित्व में विषम संख्या वाले किसी भी चरित्र से मेल खाता है।

रेगेक्स के साथ कैसे / भी अजीब पता लगाने का विवरण यहां काम करता है ।

— mbomb007
स्रोत
0

ऑक्टेव, 56 बाइट्स

f=@(s,p) mod(sum((i=bitunpack([s p]))(1:length(i)-5)),2)

bitunpackसमारोह, ASCII वर्ण के लिए, थोड़ा-endian क्रम में उन्हें देता है। तो हमारे स्ट्रिंग के अंत में समता ध्वज लगाकर, पूरी चीज़ को खोलना, और अंतिम 5 बिट्स को छोड़ देना, फिर हम अपने अंतिम उत्तर के लिए पूरी चीज़ मॉड 2 को जोड़ सकते हैं।

उपयोग:

octave:137> f('Hello World!', 'o')
ans = 0
octave:138> f('Hello World!', 'e')
ans =  1
— dcsohl
स्रोत
0

 आम लिस्प, 87

(lambda(s p)(=(mod(reduce'+(mapcar'logcount(map'list'char-code s)))2)(position p"oe")))
  • के चार-कोड का लॉगऑन योग s।
  • इसमें से शेष, जब 2 से विभाजित किया जाता है, तो pस्ट्रिंग में समता तर्क की स्थिति की तुलना की जाती है "oe"(या तो 0 या 1)। उदाहरण के लिए, यदि 4 हैं, तो शेष शून्य है। यदि पी है o, तो कोई अतिरिक्त बिट नहीं जोड़ा जाना चाहिए, और परीक्षण गलत है।

सुंदर मुद्रित

(lambda (s p)
  (= (mod (reduce '+ (mapcar 'logcount (map 'list 'char-code s))) 2)
     (position p "oe")))
— कोर निपात
स्रोत
0

जावा, 91 बाइट्स

(s,c)->{s+=c%8;int e=1;for(int i:s.getBytes())while(i>0){if(i%2==1)e^=1;i/=2;}return e==0;}

मैंने @ CAT97 के समान ही किया, लेकिन मॉडुलो 8 का उपयोग करके कुछ पात्रों को छीन लिया और @Luis मेंडो के कॉन्सेप्ट और बूलियन के बजाय इंट का उपयोग किया।

यह एक लंबोदर है a BiFunction<String, Character, Boolean>।

— miselico
स्रोत
0

मतलाब, 49 बाइट्स

f=@(x,p)mod(sum(sum(dec2bin(x)-'0'))+(p-'e'>0),2)

कहाँ पे:

  • x इनपुट स्ट्रिंग है;
  • p समता के लिए 'e' और विषम के लिए 'o' है।

उदाहरण के लिए:

>> f('Programming Puzzles and Code-Golf','e')

ans =

     0
— PieCot
स्रोत
0

बैश और यूनिक्स टूल (72 बाइट्स)

f(){ bc<<<"$(xxd -b<<<"$2$1"|cut -b9-64|tail -c +7|tr -dc 1|wc -c)%2" }

sपहले और pदूसरे तर्क के रूप में स्वीकार करता है। सौभाग्य से पिछले 3 बिट्स oऔर eक्रमशः विषम और समता है।

xxd -b        print the concatenation of `p` and `s` in binary
cut -b9-64    parse xxd output
tail -c +7    keep only the last 3 bits of `p`
tr -dc 1      keep only the `1`s
wc -c         count them
bc ...%2      modulo two

इनपुट के माध्यम से आपूर्ति करना <<<एक पंक्ति फ़ीड वर्ण जोड़ता है, लेकिन समता सम्‍मिलित \nहै, इसलिए यह कोई समस्‍या नहीं है।

— PGY
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.