पोलारिटी को उलट दें

Question

इस चुनौती का उद्देश्य एक प्रोग्राम लिखना है जो निम्नलिखित स्थितियों को संतुष्ट करता है:

• कार्यक्रम पैलिंड्रोमिक या अनिवार्य रूप से पैलिंड्रोमिक नहीं है (इसका अर्थ है कि प्रोग्राम के प्रभाव को बदलने के बिना इसे एक पैलिंड्रोम बनाने के लिए वर्णों को निकालना संभव है)।

• कार्यक्रम एक इंवोल्यूशन नहीं है (इसका अर्थ है कि यह अपने आउटपुट पर चलने पर अपने मूल इनपुट का उत्पादन नहीं करता है)

• उलट-polarity कार्यक्रम सामान्य कार्यक्रम का उल्टा होता है; इसलिए जब प्रत्यावर्तित कार्यक्रम सामान्य प्रोग्राम के आउटपुट पर चलाया जाता है, तो यह मूल इनपुट लौटाता है।

उलट-ध्रुवीयता का क्या अर्थ है? खैर, यह भाषाओं के बीच भिन्न है।

• अधिकांश गैर-esolangs के लिए, इसका मतलब है कि एक ही ऑपरेशन में उप-संचालन के क्रम को उलट देना, तर्कों के क्रम को उलटना, और हार्ड-कोडित सूचियों / सरणियों / ट्यूपल्स / शब्दकोशों / स्टैक्स / कतार / आदि की सामग्री को उलट देना, साथ ही साथ कोड-ब्लॉक और स्टैंड-अलोन लाइनों के क्रम को उलट करने के रूप में (लेकिन ब्लॉकों के भीतर लाइनें नहीं)

उदाहरण:

हास्केल : x`mod`y-> y`mod`x; zipWith ((*3).(+)) [1,2,3] [4,5,6]->zipWith ((+).(*3)) [6,5,4] [3,2,1]

अजगर : 2**3-> 3**2; for x,y in [(1,2),(3,4),(5,6)]->for y,x in [(6,5),(4,3),(2,1)]

• उन भाषाओं के लिए जिनके पास 1-वर्ण फ़ंक्शन (जैसे पाइथ, एपीएल) हैं, बस निर्देशों के स्ट्रिंग को उल्टा करें

• बीएफ जैसे 1-आयामी एसोलैंग्स के लिए, निर्देशों को उल्टा करें या ध्रुवता को स्वैप करें; ध्रुवीयता स्वैप हैं []-> {}, +-> -, --> +, >-> <, <-> >, .-> ,और ,-> .(लेकिन दोनों नहीं)

• Befunge जैसे 2-आयामी एसोलैंग्स के लिए, आप या तो x- या y- एक्सिस या एक तिरछे पर प्रतिबिंब का प्रदर्शन कर सकते हैं, 180 डिग्री घुमा सकते हैं, या एक प्रतिबिंब और एक रोटेशन का संयोजन कर सकते हैं

कम्यूटेटिव ऑपरेशंस की अनुमति है, लेकिन पलिंड्रोमिक नहीं हैं: 2*xठीक है, लेकिन x+xखराब है। एक ध्रुवीयता-उलट की परिभाषा बहुत ढीली है, लेकिन अपने निर्णय का उपयोग करें जो समझ में आता है; ऑब्जेक्ट सबसे चतुर लूपोल खोजने के लिए नहीं है, लेकिन सबसे चतुर समाधान खोजने के लिए।

यह एक लोकप्रियता प्रतियोगिता है, इसलिए एक बहुत ही चतुर लूपोल लोकप्रिय हो सकता है, लेकिन इस चुनौती की भावना के भीतर रखने की कोशिश करें। एक बार कम से कम 1 उत्थान के साथ कम से कम 10 समाधान होने पर विजेता की घोषणा की जाएगी, और कम से कम 1 उत्थान के साथ प्रस्तुतियाँ होने की तुलना में अधिक उत्थान के साथ कम से कम एक समाधान है; या 1 महीने में, जो भी पहले आता है। यह मेरी पहली चुनौती है, इसलिए निष्पक्ष रहने की कोशिश करें और मुझे रचनात्मक प्रतिक्रिया दें, लेकिन मुझे यह भी बताएं कि क्या यह अनुचित चुनौती है या यह किसी भी तरह से गलत या अस्पष्ट है। यदि आपके पास उस भाषा के बारे में कोई प्रश्न है जो मेरे द्वारा यहां निर्धारित किए गए किसी भी कबूतर में फिट नहीं है, तो टिप्पणी करें, और मैं समुदाय की इच्छा पर झुकूंगा यदि किसी विशेष स्पष्टीकरण या नियम-परिवर्तन के लिए एक मजबूत आक्रोश है।

अपडेट करें

इस प्रतियोगिता को शुरू हुए ठीक 1 महीना हो चुका है (मैं संयोग से इस पर जाँच करने के लिए हुआ था, यह जानते हुए नहीं कि मैं वास्तव में समय पर था)। जैसा कि यह एक लोकप्रियता प्रतियोगिता है, विजेता (एक भूस्खलन द्वारा) Pietu1998-Befunge है । भले ही नीचे के घटक (टेक्स्ट रिवर्सल और बैकवर्ड-अल्फाबेट) दोनों इन्वॉल्व हैं, एनकोडर / डिकोडर नहीं हैं, इसलिए वहां कोई समस्या नहीं है। बीच में "BEFUNGE" लिखने के प्रबंधन के लिए बोनस अंक (मेरे दिमाग में)। मुझे व्यक्तिगत रूप से ज़र्गेब के थिसस समाधान की नवीनता पसंद है , क्योंकि भाषा शांत दिखती है (यदि प्रतिबंधित है)। भाग लेने के लिए सभी का धन्यवाद, और विजेता चुने जाने के दौरान, मैं इस प्रतियोगिता को पूरी तरह से खुला छोड़ रहा हूं, और भविष्य की प्रस्तुतियां स्वागत करता हूं।

Comments

उलट-ध्रुवीयता कार्यक्रम से आपका क्या तात्पर्य है सामान्य कार्यक्रम का उलटा ? क्या आउटपुट किसी तरह से अलग है?

— 233 बजे Sp3000

यह उलटा ऑपरेशन करता है; जब प्रत्यावर्तित कार्यक्रम सामान्य प्रोग्राम के आउटपुट पर चलाया जाता है, तो यह मूल इनपुट लौटाता है।

— 23

त्रुटि के लिए क्षमा करें; मैंने इसके बारे में पहले नहीं सुना था, और यह मुझे थोड़ा सा अट्रैक्टिव लग रहा था, इसलिए मैंने यह मान लिया होगा कि यह एक एसोलंग था; मैं उसे बदल दूंगा।

— अर्चिफेरीक्स

बस कुछ है जो शायद निर्दिष्ट किया जाना चाहिए - ()पैलिंड्रोमिक है? तकनीकी रूप से, रिवर्स है )(।

— Sp3000

हास्केल उदाहरण में फ़ंक्शन तर्क को अंत तक फेरबदल क्यों नहीं किया जाता है? क्या उल्टे को इस तरह से चुना जाता है जो प्रकार की सुरक्षा को बरकरार रखता है? क्या हमें पोलरिटी रिवर्सल ऑपरेशन के कुछ विवरण चुनने की अनुमति है?

— जॉन ड्वोरक

Answer 1

Befunge

वाह, यह एक काम था, यहां तक ​​कि संपादक के साथ मैंने इस चुनौती के लिए बनाया था । यहाँ मुझे क्या मिला, एक अच्छा 11x12 ब्लॉक:

v$,g6<6g,$v
v,$ _^_ $,v
1W>v\B\v>L1
~T+:1E1:-O~
+F00-F-02L+
>:|6gUg6|:>
{a@>^N^>@z`
>1+|@G$| +>
:^9< E<  ^1
~>7^@_,#:>:
 xD>65 ^=P~
v,-\+**<  v

यह कुछ बातें करता है, दुख की बात है कि केवल लोअरकेस अक्षरों के लिए।

यह क्या करता है

जब सामान्य रूप से चलाया जाता है, तो यह इनपुट पर सीज़र सिफर करता है ।

abcxyz      -> bcdyza
exampletext -> fybnqmfufyu

जब क्षैतिज रूप से फ़्लिप किया जाता है, तो यह कहा जाता है कि सिफर। यह चुनौती की आवश्यकता है, लेकिन यह यहीं समाप्त नहीं होती है।

bcdyza      -> abcxyz
fybnqmfufyu -> exampletext

जब लंबवत रूप से फ़्लिप किया जाता है , तो यह एक रिवर्स वर्णमाला के साथ इनपुट को सिफर करता है। इसे सीज़र सिफर के विपरीत दृष्टिकोण माना जा सकता है।

abcxyz      -> zyxcba
exampletext -> vcznkovgvcg

अंत में, जब 180 डिग्री घुमाया जाता है, तो यह इनपुट को उलट देता है। मुझे लगता है कि यह किसी चीज का उल्टा होना है (संकेत: इनपुट)।

abcxyz      -> zyxcba
exampletext -> txetelpmaxe

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

ब्लॉक में मूल रूप से चार अर्ध-अतिव्यापी एल्गोरिदम शामिल हैं।

सीज़र सिफर एनकोडर

v$,g6<
v,$ _^
1 >v\
~ +:1
+ 00-
>:|6g
{a@>^

सीज़र सिफर डिकोडर (क्षैतिज रूप से फ़्लिप)

v$,g6<
v,$ _^
1 >v\
~ -:1
+ 20-
>:|6g
`z@>^

उल्टा वर्णमाला सिफर (लंबवत फ़्लिप)

v,-\+**<
   >65 ^
~>7^
:^9<
>1+|@
   >^

टेक्स्ट रिवर्सल (घुमाया गया 180 डिग्री)

v  <
~      
:>:#,_@
1^  <
>+ |$
   >^

Comments

मुझे लगता है कि Befunge यहाँ एक मामूली लाभ में है, क्योंकि आप हमेशा ऊपरी बाएँ वृत्त का चतुर्थ भाग का उपयोग कर सकते हैं और बाकी के कोड में पूरी तरह से अनदेखा कर सकते हैं। हालांकि अच्छा काम!

— मार्टिन एंडर

वाह! मुझे इसका उत्थान करना है, भले ही इसका मतलब है कि मैं नीचे तीसरे स्थान पर हूं।

— लेवल रिवर सेंट

Answer 2

ब्रेनफक, ५

,+.-,

संभवतः पहली बार, ब्रेनफ़क एक उत्तर का उत्पादन करता है जो कोड लंबाई पर प्रतिस्पर्धी है। शर्म की बात है कि यह एक कोड-गोल्फ सवाल नहीं है।

एक बाइट (वर्ण) इनपुट करता है, इसे बढ़ाता है, और परिणाम को आउटपुट करता है। अंत में अल्पविराम एक और इनपुट की प्रतीक्षा कर रहा है, जिसे यदि दिया गया है तो उसे नजरअंदाज कर दिया जाएगा। उचित समाप्ति के बारे में कल्पना में कुछ भी नहीं है: -) *

* (या दोनों दिशाओं में सभी कोड के साथ कुछ उपयोगी करने के बारे में)

विशिष्ट परिणाम (यदि दिया गया दूसरा वर्ण अनदेखा है)।

आगे: B->C

रिवर्स: B-> Aया C->B

Answer 3

Marbelous

यहाँ हमें शुरू करने के लिए एक सरल है। यह STDIN के एक चरित्र को पढ़ता है, वेतन वृद्धि करता है और उसे प्रिंट करता है।

--
]]
00
]]
++

यदि हम इसे 180 ° (बिना स्वैपिंग ब्रैकेट) के घुमाते हैं, या इसे एक्स-एक्सिस में मिरर करते हैं, तो हम प्राप्त करते हैं

++
]]
00
]]
--

जो STDIN से एक बाइट पढ़ता है और इसे घटाता है।

आप इसे यहाँ परीक्षण कर सकते हैं ।

मैं कुछ और अधिक जटिल मारबेलस कार्यक्रमों में देख सकता हूं, लेकिन मुझे यकीन है कि es1024 मुझे इसे हरा देगा। ;)

व्याख्या

00मान 0 (जो मनमाना है) के साथ एक संगमरमर है। ]]उपकरणों stdin से एक बाइट पढ़ा - जो है, एक संगमरमर उन के माध्यम से गिर जाता है, संगमरमर के मूल्य पढ़ने बाइट में बदल जाता है। ++और --उपकरणों बस वेतन वृद्धि या (आधुनिक 256) एक संगमरमर का मूल्य घटती और जाने के माध्यम से यह गिर जाते हैं। जब एक संगमरमर बोर्ड से गिर जाता है, तो बाइट को STDOUT लिखा जाता है।

इसलिए, शीर्ष पर स्थित दो उपकरण केवल इसलिए नजरअंदाज कर देते हैं क्योंकि नियंत्रण प्रवाह कभी उन तक नहीं पहुंचता है।

Comments

वैकल्पिक रूप से, आप अपनी तीन मध्य पंक्तियों को एकल इनपुट डिवाइस द्वारा बदल सकते हैं।

— रात

@overactor या क्या आप इसका मतलब है }0और इसे एक सबबोर्ड के रूप में उपयोग करते हैं?

— मार्टिन एंडर

}0सटीक होने के लिए कमांड लाइन इनपुट के रूप में।

— ओवरएक्टर 12

Answer 4

Marbelous

यह बोर्ड एक तर्क ( x) लेता है और वापस लौटता है (101 * x) mod 256।

.. @5 .. }0 }0 @1 .. @0 .. @2 .. 
.. /\ Dp << \\ .. &0 >0 &1 .. .. 
!! @3 .. << }0 .. \/ -- \/ .. }0 
@4 .. .. &0 @1 /\ &0 65 &1 /\ @2 
/\ Dp .. @4 .. .. @3 @0 @5 !! \\

वाई-अक्ष के साथ कोशिकाओं को मिरर करने के परिणामस्वरूप एक बोर्ड होगा जो एक तर्क ( y) और रिटर्न लेता है (101 * y + 8 * y) mod 256, जो पहले बोर्ड का व्युत्क्रम है।

.. @2 .. @0 .. @1 }0 }0 .. @5 ..
.. .. &1 >0 &0 .. \\ << Dp /\ ..
}0 .. \/ -- \/ .. }0 << .. @3 !!
@2 /\ &1 65 &0 /\ @1 &0 .. .. @4
\\ !! @5 @0 @3 .. .. @4 .. Dp /\

यहाँ यह परीक्षण करें । बेलनाकार बोर्ड और पुस्तकालयों को शामिल करना दोनों की जाँच होनी चाहिए।

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

Original Board:      Mirrored Board:
Input   Output       Input    Output
025     221          221      025
042     146          146      042
226     042          042      226

कृपया ध्यान दें कि मारबेलस केवल सकारात्मक पूर्णांकों को तर्क के रूप में पारित करने की अनुमति देता है, और इन पूर्णांकों को दुभाषिया द्वारा कार्यक्रम मोडुलो 256 में पारित किया जाता है।

101दो कारणों से चुना गया था: यह एक प्रमुख है (और इस कार्यक्रम के लिए हर संभव इनपुट का परिणाम एक अनूठा आउटपुट है), और उलटा ऑपरेशन शामिल है 109, जो कि 8 से दूर की सुविधाजनक दूरी है 101।

संक्षिप्त विवरण

सेल वाले स्तंभ (ऊपर से नीचे तक) @0 >0 -- 65 @0दोनों बोर्डों में समान होते हैं, और 101दाईं ओर जाने से पहले लूप को बार-बार चलाते हैं । >0शाखा के दोनों ओर एक अलग सिंक्रोनाइज़र है; जिसे चुना जाता है, वह इस बात पर निर्भर करता है कि बोर्ड को प्रतिबिंबित किया गया है या नहीं।

प्रत्येक तरफ, केंद्र लूप के साथ सिंक में, इनपुट को बार-बार अभिव्यक्त किया जाता है, इस प्रकार प्राप्त होता है 101*x mod 256। उलट बोर्ड पर, इनपुट की दो प्रतियों को भी दो बार बाईं ओर स्थानांतरित किया जाता है ( input * 4), फिर संक्षेपित और एक सिंक्रोनाइज़र में छोड़ दिया जाता है।

एक बार जब केंद्र लूप खत्म हो जाता है, तो सारांशित मार्बल को छपाई के लिए भेजा जाता है, जो बोर्ड की तरफ होता है (मूल बोर्ड के लिए छोड़ दिया जाता है, दर्पण के लिए सही)। छपाई के बाद, एक !!सेल पहुँच जाता है, बोर्ड को समाप्त करता है। ध्यान दें कि जो लूप दिया 101 * xगया है वह तब तक अपने आप चलता रहता है जब तक बोर्ड समाप्त नहीं हो जाता।

Dp बस परिणाम को दशमलव संख्या के रूप में प्रिंट करता है।

Answer 5

Theseus

यह एक खामियों के रूप में माना जा सकता है, लेकिन मुझे भाषा पसंद है, इसलिए यहां जाता है। इस कार्यक्रम के एक समारोह को परिभाषित करता है fप्राकृतिक संख्या पर कि नक्शे 3n को 3n + 1 , 3n + 1 के लिए 3n + 2 , और 3n + 2 करने के लिए 3n हर के लिए, एन ।

data Num = Zero | Succ Num

iso f :: Num <-> Num
  | n                          <-> iter $ Zero, n
  | iter $ m, Succ Succ Succ n <-> iter $ Succ m, n
  | iter $ m, Succ Succ Zero   <-> back $ m, Zero
  | iter $ m, Succ Zero        <-> back $ m, Succ Succ Zero
  | iter $ m, Zero             <-> back $ m, Succ Zero
  | back $ Succ m, n           <-> back $ m, Succ Succ Succ n
  | back $ Zero, n             <-> n
  where iter :: Num * Num
        back :: Num * Num

येस एक हास्केल जैसी वाक्य रचना के साथ एक प्रतिवर्ती भाषा है, जहां हर फ़ंक्शन उलटा है (गैर-समाप्ति के साथ छूट वाले मुद्दे)। यह अत्यधिक प्रयोगात्मक है, और अनुसंधान उद्देश्यों के लिए डिज़ाइन किया गया है। उपरोक्त कोड प्राकृतिक संख्या और फ़ंक्शन के लिए डेटाटाइप को परिभाषित करता है f। एक इनपुट नंबर को देखते हुए, आप इसे बायीं ओर स्थित पैटर्न-मैच करते हैं (यह हमेशा मेल खाता है n)। फिर आप दाईं ओर के पैटर्न को देखें। यदि उस पैटर्न में एक लेबल है (यहाँ)iter), आप इसे बायीं ओर के पैटर्न-मैच के लिए आगे बढ़ाते हैं, और फिर से दायें-बायें हाथ से संबंधित मान लेते हैं। यह तब तक दोहराता है जब तक आपके पास दाईं ओर एक अयोग्य मूल्य नहीं है, और यह आपका आउटपुट है। बाईं ओर पैटर्न, और दाईं ओर, संपूर्ण और गैर-अतिव्यापी (प्रत्येक लेबल के लिए अलग-अलग) होना चाहिए। अब, "ध्रुवीयता को उल्टा करने के लिए" f, मैं निम्नलिखित कार्य करता हूं।

• हर लेबल के दो मूल्यों को स्वैप करें। इससे शब्दार्थ में परिवर्तन नहीं होता है f।
• फंक्शन बॉडी में राइट- और लेफ्ट-हैंड-साइड स्वैप करें। यह f डिजाइन के व्युत्क्रम फ़ंक्शन को परिभाषित करता है ।

परिणाम:

iso f :: Num <-> Num
  | iter $ n, Zero             <-> n
  | iter $ n, Succ m           <-> iter $ Succ Succ Succ n, m
  | back $ Zero, m             <-> iter $ Succ Succ Zero, m
  | back $ Succ Succ Zero, m   <-> iter $ Succ Zero, m
  | back $ Succ Zero, m        <-> iter $ Zero, m
  | back $ Succ Succ Succ n, m <-> back $ n, Succ m
  | n                          <-> back $ n, Zero
  where iter :: Num * Num
        back :: Num * Num

Answer 6

टीआर

a b

उदाहरण:

$ echo "apple" | tr a b
bpple
$ echo "bpple" | tr b a
apple

स्ट्रिंग्स के डोमेन पर केवल एक सही उलटा जिसमें 'ए' और 'बी' दोनों शामिल नहीं हैं।

Comments

आपको वास्तव में डोमेन को उससे थोड़ा अधिक प्रतिबंधित करना होगा। उदाहरण के लिए, यदि आप "दलदल" से शुरू करते हैं, तो आपका कार्यक्रम और इसका उल्टा "दलदल" -> "दलदल" -> "अंग" है। तो कोई भी स्ट्रिंग जिसमें 'बी' एक समस्या है (या 'ए' युक्त है, यदि आप पहले रिवर्स प्रोग्राम लागू करते हैं)।

— user19057

आप tr abc bcaउलटे ध्रुवीयता संस्करण के साथ उपयोग कर सकते हैं tr acb cba।

— क्रिश्चियन सेवर्स

Answer 7

एक और मारबुलस जवाब

मूल राइट कमांड लाइन इनपुट (एक 8 बिट वैल्यू) को शिफ्ट करता है, अगर एक शिफ्टिंग से 1 खो जाता है, तो एक अग्रणी जोड़ देता है। ( 0000 0001 -> 1000 0000)

{0 ..
~~ ..
>> {0
-2 =0
.. ^0
\/ }0
}0 Sb
<< ..
\\ ..
:Sb
// ..
Sb >>
}0 ..
^7 }0
{0 \/

इस बोर्ड को 180 ° घुमाते हुए (लेकिन प्रत्येक कोशिका की सामग्री को समान छोड़ते हुए) कार्यक्रम में परिवर्तन करता है ताकि यह बदलाव छोड़ दे ( 1000 0000 -> 0000 0001)

\/ {0
}0 ^7
.. }0
>> Sb
.. //
:Sb
.. \\
.. <<
Sb }0
}0 \/
^0 ..
=0 -2
{0 >>
.. ~~
.. {0

आप इसे यहाँ परीक्षण कर सकते हैं । (आपको 'प्रदर्शन आउटपुट को दशमलव संख्या के रूप में' चालू करना होगा)

व्याख्या

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

original:      flipped:
   }0          }0
}0 Sb          .. }0
<< ..          >> Sb
\\ ..          .. //

वे बहुत सरल बोर्ड हैं, दोनों इनपुट की दो प्रतियाँ लेते हैं (जो }0कोशिकाओं का स्थान लेते हैं। मूल एक संस्करण को बाईं पारी डिवाइस में फीड करता है <<, फ़्लिप किया गया संस्करण इसे एक सही शिफ्ट डिवाइस में डालता है। >>ये एक बिटशिफ्ट करते हैं, लेकिन दुर्भाग्य से किसी को भी नहीं छोड़ते हैं। खोए हुए बिट्स। वह जगह जहां Sbबोर्ड आते हैं, वे जाँचते हैं कि क्या उनके द्वारा खिलाए गए मूल्य को बिटशिफ्ट करने के परिणामस्वरूप थोड़ा सा खो जाएगा और खोए हुए बिट को काउंटर करने के लिए परिणाम में जोड़े जाने वाले मूल्य को वापस कर देगा।

यहाँ Sbमूल कार्यक्रम के लिए मूल बोर्ड का प्रासंगिक हिस्सा है :

}0
^7
{0

यह एक अविश्वसनीय रूप से आसान है, `^ 7 'सबसे महत्वपूर्ण बिट के मूल्य की जांच करता है। यदि यह 1 है, तो बाईं पारी में प्रदर्शन करने से यह बिट खो जाएगा। तो यह बोर्ड इस बिट के मूल्य को बिटशिफ्ट के परिणाम में जोड़े जाने वाले 8 बिट मूल्य के रूप में आउटपुट करता है।

फ़्लिप किए गए संस्करण के लिए, Sbकम से कम महत्वपूर्ण बिट को देखना होगा और वापस लौटना होगा 128या 0, यह थोड़ा अधिक जटिल है:

}0
^0 ..
=0 -2
{0 >>
.. ~~
.. {0

यदि कम से कम महत्वपूर्ण बिट (जैसा कि परीक्षण किया गया है ^0) 0 है, यह सिर्फ 0. लौटाता है। यदि यह एक है, ^0तो आउटपुट होगा 1। इससे समानता परीक्षण विफल हो जाएगा 0 =0और इस प्रकार दाईं ओर धकेल दिया जाएगा। हम तब 2 -2को 255 प्राप्त करने के लिए घटाते हैं , >>127 को पाने के लिए बाएं बदलाव करते हैं और ~~128 पाने के लिए एक बाइनरी नहीं करते हैं (हम बस एक ++को 128 पाने के लिए जोड़ सकते हैं , लेकिन इसमें मज़ा कहाँ है?)