कार्य विवरण

एक पूर्णांक को देखते हुए इसकी स्वैप (2k-1) मई और 2k सभी पूर्णांकों के लिए मई के कम से कम महत्वपूर्ण बिट कश्मीर> 0 । यह OEIS में अनुक्रम A057300 है।

(संख्या को "असीम रूप से कई" अग्रणी शून्य माना जाता है। व्यवहार में, इसका अर्थ है कि एक 0 बिट को विषम-लंबाई संख्या में प्रस्तुत करना।)

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड (बाइट्स में) जीतता है।

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

0 -> 0
1 -> 2
9 -> 6
85 -> 170
220 -> 236
1827 -> 2835
47525 -> 30298

— लिन
स्रोत

5

क्या हम बिट शिफ्ट जैसी चीजों के लिए एक संख्या के रूप में फिट होने की संख्या मान सकते हैं?

— xnor

1

@ xnor: मुझे लगता है कि यह डिफ़ॉल्ट / सामुदायिक सहमति है (अन्यथा C आदि में उत्तर हमेशा गलत होंगे)? बिलकुल पक्का! :)

— लिन

@ लियन: सी को unsigned char array_of_bytes[1024]आपकी अपेक्षा के अनुरूप काम करने की आवश्यकता है (अर्थात 1024 * CHAR_BITप्रविष्टियों के साथ एक बिटफील्ड होना चाहिए )। मुझे लगता है कि मनमाने ढंग से लंबाई के इनपुट का समर्थन करने वाले अधिकांश उत्तर मानेंगे CHAR_BIT, हालांकि, बाइट्स के बीच बिट्स को स्थानांतरित करने के बाद से बोझिल है। तो आप बिल्कुल kकुछ स्थिर आकार का समर्थन करने की आवश्यकता कर सकते हैं , जैसे 256 या ऐसा कुछ जो एईएस के लिए उचित है, और 256 बिट पूर्णांक प्रकारों के बिना भाषाओं को लूप का उपयोग करना होगा। यह एक x86 asm उत्तर के लिए विचार करने के लिए SIMD वैक्टर बना सकता है: P

— पीटर कॉर्ड्स

2

मैं Minibits के साथ @Geobits स्वैप

— अनुकूलक

9

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

b4d2UFḄ

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

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

b4d2UFḄ  Main link. Argument: n (integer)

b4       Convert n to base 4.
  d2     Divmod each quaternary digit x by 2, yielding [x : 2, x % 2].
    U    Upend; reverse each pair, yielding [x % 2, x : 2].
     F   Flatten the 2D list of binary digits.
      Ḅ  Convert from binary to integer.

— डेनिस
स्रोत

20

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

lambda n:2*n-3*(4**n/3&n/2)

बिट ट्रिक्स!

कहना बाइनरी में nरूप ...ghfedcbaहै। फिर, हम इसे हर दूसरे बिट में विभाजित कर सकते हैं

n   = o + 2*e
n   = ...hgfedcba
o   = ...0g0e0c0a
2*e = ...h0f0d0b0

फिर, बिट-स्विच्ड परिणाम sको व्यक्त किया जा सकता है s=2*o+e।

s   = 2*o + e
s   = ...ghefcdab
2*o = ...g0e0c0a0
e   = ...0h0f0d0b

हम केवल एक की गणना करते हैं eऔर oइसलिए, हम व्यक्त करते हैं o=n-2*eऔर स्थानापन्न करते हैं

s=2*(n-2*e)+e = 2*n-3*e

तो, अब यह व्यक्त करने के लिए बनी हुई है eके संदर्भ में n। संख्या M=4**n/3का ...10101010101द्विआधारी में रूप है, जो विषम अंकों के लिए एक मुखौटा के रूप में कार्य करता है। घातांक nसुनिश्चित करता है कि Mकाफी लंबा है। बिटवाइज़ ले रहा है andकी n/2और इस मूल्य देता है eके रूप में वांछित।

n/2     = ...hgfedcb
M       = ...1010101
n/2 & M = ...h0f0d0b = e

हम इसके बदले में व्यक्त कर सकते eहैं o e=(n-o)/2, जो देता है s=(n+o*3)/2, जो बाइट को एक्सॉट से ऑप्टिमाइज़ेशन के लिए धन्यवाद देता है।

lambda n:n+(n&4**n/3)*3>>1

— XNOR
स्रोत

महान व्याख्या, और केवल एक बार से घटाकर मुखौटा का उपयोग करने की अच्छी चाल n। हालांकि, मैं विपरीत "विषम" बनाम "यहां तक कि" बिट नामकरण सम्मेलन पसंद करता हूं। LSB बिट 0 है, जो कि (भले ही यह पहला बिट है)। SIMD प्रोग्रामिंग में, जहां फेरबदल अक्सर एक सूचकांक के साथ तत्वों का चयन करते हैं, सूचकांक 0 से गिने जाते हैं, इसलिए निम्न तत्व को एक समान तत्व पर विचार करना सामान्य है। जैसे[ 3 2 1 0 ]

— पीटर कॉर्ड्स

मैंने आपकी अभिव्यक्ति का उपयोग करते हुए एक सी उत्तर जोड़ा। बाइट बचत बनाम डिजिटल ट्रॉमा के सी उत्तर के लिए सभी क्रेडिट इसके कारण हैं।

— पीटर कॉर्ड्स

2

26:lambda n:n+(n&4**n/3)*3>>1

— xsot

@PeterCordes आपका सी कोड मेरे लिए gcc 4.8.3 और डिफ़ॉल्ट सेटिंग्स के साथ काम करता है। इनपुट 2 के लिए 1f(x){return x+((x&~0U/3)*3)>>1;} रिटर्न ।

— डेनिस

@ डेनिस: हाँ, मेरे लिए सी में काम करता है, मेरा बुरा। मैं वास्तव में calc(aka apcalc) में अभिव्यक्ति का परीक्षण कर रहा था , वास्तव में C. नहीं। मैंने सोचा कि मैं ठीक हो जाऊंगा क्योंकि मुझे 32 बिट या दो के पूरक के लिए ट्रंकेशन की आवश्यकता नहीं थी। मुझे नहीं लगा कि अभिव्यक्ति सही लग रही थी, इसलिए मैं अपने गलत परीक्षणों पर विश्वास करने को तैयार था। लेकिन वैसे भी, मुझे बिटहॉक विकसित करने के लिए बेहतर REPL की आवश्यकता है। कोई सुझाव? (आदर्श रूप से लिनक्स कमांड लाइन, जैसे bc -lया calc, लेकिन वास्तव में उजागर int32_t/ uint32_tया कुछ, विस्तारित परिशुद्धता नहीं।)

— पीटर कॉर्ड्स

10

सी फ़ंक्शन, 38

बिट-twiddling:

f(x){return(x&~0U/3*2)/2+(x&~0U/3)*2;}

Ideone।

या इसके मज़े के लिए:

सी पुनरावर्ती कार्य, 43

OEIS सूत्र के अनुसार ,a(4n+k) = 4a(n) + a(k), 0 <= k <= 3

f(x){return x>3?4*f(x/4)+f(x%4):x%3?3-x:x;}

या

f(x){return x>3?4*f(x/4)+f(x%4):x%2*2+x/2;}

Ideone।

— डिजिटल आघात
स्रोत

1

एक्सनोर के अभिव्यक्ति के चतुर परिवर्तन को 32 बाइट्स में नीचे सी में मिलता है। मैंने इसे एक अलग उत्तर के रूप में पोस्ट किया, क्योंकि यह एक अलग दृष्टिकोण है।

— पीटर कॉर्ड्स

8

CJam, 16 14 13 बाइट्स

ri4b4e!2=f=4b

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

व्याख्या

ri  e# Read input and convert to integer.
4b  e# Get base-4 digits.
4e! e# Push all permutations of [0 1 2 3].
2=  e# Select the third one which happens to be [0 2 1 3].
f=  e# For each base-4 digit select the value at that position in the previous
    e# list, which swaps 1s and 2s.
4b  e# Convert back from base 4.

— मार्टिन एंडर
स्रोत

क्रमपरिवर्तन के साथ यह चाल बहुत अच्छी है!

— लुइस मेंडो

7

अजगर, 9 बाइट्स

iXjQ4S2)4

इसे पायथ कंपाइलर में आज़माएँ ।

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

  jQ4      Convert the input (Q) to base 4.
 X   S2)   Translate [1, 2] to [2, 1].
i       4  COnvert from base 4 to integer.

— डेनिस
स्रोत

5

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

(n,m=0x55555555)=>n*2&~m|n/2&m

केवल जावास्क्रिप्ट के पूर्णांक की सीमाओं के कारण 1073741823 तक काम करता है। 38 36 बाइट्स 4294967295 तक काम करती हैं:

(n,m=0x55555555)=>(n*2&~m|n/2&m)>>>0

संपादित करें: @ user81655 के लिए 2 बाइट्स धन्यवाद सहेजा गया।

51 बाइट्स 4503599627370495 तक काम करता है:

n=>parseInt(n.toString(4).replace(/1|2/g,n=>3-n),4)

— नील
स्रोत

हो n<<1सकता है n*2?

— 14:81 पर user81655

@ user81655 और मैं भी उपयोग कर सकते हैं n/2! मुझे नहीं पता कि मैंने पहले उन लोगों के बारे में क्यों नहीं सोचा।

— नील

मैंने कभी नहीं देखा >>>... वह क्या है?

— टाइटस

@ बिट्स यह पसंद है >>>लेकिन यह एक अहस्ताक्षरित बदलाव करता है। >>>0मूल रूप से एक 32-बिट अहस्ताक्षरित पूर्णांक में कनवर्ट करता है।

— नील

5

x86 asm फ़ंक्शन: मशीन कोड के 14 बाइट्स

uint64_t संस्करण: 24 बाइट्स

x86-64 SysV कॉलिंग कन्वेंशन ( xइन edi), लेकिन यह वही मशीन कोड 32bit मोड में भी काम करेगा। (जहां leaजैसा समझोगे lea eax, [edi + eax*2], वैसा ही परिणाम दूंगा )।

0000000000000040 <onemask_even>:
  40:   89 f8                   mov    eax,edi
  42:   25 55 55 55 55          and    eax,0x55555555
  47:   29 c7                   sub    edi,eax
  49:   d1 ef                   shr    edi,1
  4b:   8d 04 47                lea    eax,[rdi+rax*2]
  4e:   c3                      ret    
4f: <end>

0x4f - 0x40 = 14 बाइट्स

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

unsigned onemask_even(unsigned x) {
  unsigned emask = ~0U/3;
  unsigned e = (x & emask);
  return e*2 + ((x - e) >> 1);
}

कंपाइलर क्या करता है, इस पर मुझे कोई सुधार नहीं मिला। मैंने इसे mov eax, 0x555.../ के रूप में लिखा हो सकता है and eax, edi, लेकिन यह समान लंबाई है।

64 बिट पूर्णांक के लिए एक ही कार्य 24 बाइट्स लेता है (गॉडबोल्ट लिंक देखें)। मुझे movabs rax, 0x55...रजिस्टर में मास्क उत्पन्न करने के लिए 10-बाइट से कम कोई रास्ता नहीं दिखाई देता है। (x86 का divनिर्देश क्लिंक है, इसलिए 3 से सभी का अहस्ताक्षरित विभाजन मदद नहीं करता है।)

मैं एक लूप के साथ रक्स में मुखौटा उत्पन्न करने के लिए आया था, लेकिन यह 10 बाइट्स (बिल्कुल उसी लंबाई है mov imm64)।

# since 0x55 has its low bit set, shifting it out the top of RAX will set CF
0000000000000000 <swap_bitpairs64>:
   0:   31 c0                   xor    eax,eax      ; old garbage in rax could end the loop early
0000000000000002 <swap_bitpairs64.loop>:
   2:   48 c1 e0 08             shl    rax,0x8
   6:   b0 55                   mov    al,0x55      ; set the low byte
   8:   73 f8                   jnc    2 <swap_bitpairs64.loop>  ; loop until CF is set
000000000000000a <swap_bitpairs64.rest_of_function_as_normal>:
 # 10 bytes, same as   mov  rax, 0x5555555555555555
 # rax = 0x5555...
   a:   48 21 f8                and    rax,rdi
   ...

अगर हमें पता था कि मौजूदा बाइट्स में से कोई भी raxअपना कम बिट सेट नहीं है, तो हम इसे छोड़ सकते हैं xor, और यह 8 बाइट्स लंबा होगा।

इस उत्तर के पिछले संस्करण में loopइंस का उपयोग करके 10 बाइट लूप था, लेकिन इसमें 0xFFFFFFFFFFFFFF08पुनरावृत्तियों का सबसे खराब मामला था , क्योंकि मैंने केवल सेट किया था cl।

— पीटर कॉर्डेस
स्रोत

5

ओएसिस , 17 बाइट्स (गैर-प्रतिस्पर्धात्मक)

n4÷axxn4÷xxe+3120

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

ओएसिस अदनान द्वारा डिज़ाइन की गई भाषा है जो दृश्यों में विशिष्ट है।

वर्तमान में, यह भाषा पुनरावृत्ति और बंद रूप में कर सकती है।

हम इस सूत्र का उपयोग करते हैं: a(4n+k) = 4a(n) + a(k), 0 <= k <= 3

आधार मामला निर्दिष्ट करने के लिए सरल है: 3120अंत में बस इसका मतलब है कि a(0)=0, a(1)=2, a(2)=1, a(3)=3।

n4÷axxn4÷xxe+3120
                0  a(0) = 0
               2   a(1) = 2
              1    a(2) = 1
             3     a(3) = 3

n                  push n (input)
 4÷                integer-divide by 4
   a               a(n/4)
    xx             double twice; multiply by 4
                   now we have 4a(n/4)
      n            push n (input)
       4÷xx        integer-divide by 4 and then multiply by 4
                   since there is no modulo currently, n%4
                   is built as n-(n/4*4)
           e       we should have done a(n-(n/4*4)), but this
                   is a shortcut for a(n-x) where x is the top
                   of stack. Therefore, we now have a(n-n/4*4)
                   which is a(n%4).
            +      add.

— लीक नन
स्रोत

4

MATL , 10 बाइट्स

BP2eP1ePXB

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

अनुक्रम का पहला शब्द ( OEIS A057300 ) उत्पन्न करने के लिए संशोधित संस्करण ।

व्याख्या

B     % Take input implicitly. Convert to binary array
P     % Flip
2e    % Convert to two-row 2D array, padding with a trailing zero if needed. 
      % Because of the previous flip, this really corresponds to a leading zero
P     % Flip each column. This corresponds to swapping the bits
1e    % Reshape into a row
P     % Flip, to undo the initial flipping
XB    % Convert from binary array to number. Display implicitly

— लुइस मेंडो
स्रोत

3

zsh, 28 बाइट्स

<<<$[`tr 12 21<<<$[[#4]$1]`]

कमांड लाइन तर्क के रूप में इनपुट लेता है, STDOUT पर आउटपुट।

यह बैश-संगत नहीं है क्योंकि यह zsh- विशिष्ट आधार रूपांतरण सिंटैक्स का उपयोग करता है।

                       $1     input (first command line argument)
                 $[      ]    arithmetic expansion
                   [#4]       output in base 4
              <<<             pass the result of this to...
      tr                      the `tr' command
         12 21                and replace 1s with 2s, 2s with 1s
     `                    `   evaluate the result...
   $[                      ]  in another arithmetic expansion, to convert back
                                to base 10
<<<                           output the result on STDOUT

— Doorknob
स्रोत

3

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

। +
$ *
+ `(1 +) \ 1
$ 1x
x1
1
^
एक्स
r` (।) (।)
$ 2 $ 1
1
एक्स@
+ `@ X
एक्स@@
एक्स*(@*)
$ .1
0 $

परीक्षण सूट। (ज़रा - सा संशोधित।)

खैर, सिर्फ मनोरंजन के लिए: 7 बाइट्स

T`12`21

बेस -4 को इनपुट के रूप में लेता है, और बेस -4 के रूप में आउटपुट देता है।

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

— लीक नन
स्रोत

4

मैं विवादित हूं। मैं आपके उत्तर के निचले आधे हिस्से को उभारना चाहता हूं, लेकिन ऊपरी आधे हिस्से को नीचा दिखाना चाहता हूं।

— डेनिस

1

@ डेनिस अब मेरे पास उन बिट्स की अदला-बदली है।

— लीक नून

3

05AB1E, 8 बाइट्स

4B12Â‡4ö

-5 बाइट्स के लिए @ अदनान को धन्यवाद!

CP-1252 एन्कोडिंग का उपयोग करता है।

यह ऑनलाइन की कोशिश करो!

स्पष्टीकरण:

4B       - Take input and convert to base 4.
  12Â    - Push 12 bifurcated.
     ‡   - Transliterate [1, 2] to [2, 1].
      4ö - Convert to base 10.

— जॉर्ज गिब्सन
स्रोत

2

अच्छा है, लेकिन आप 8 बाइट्स के 1 2‚2 1‚साथ बदल सकते हैं 12Â।

— अदनान

अच्छा जवाब! यहाँ एक 8-बाइट विकल्प:4в2‰íJJC

— केविन क्रूज़सेन

3

सी, 32 30 29 बाइट्स

f(x){return(x&~0U/3)*3+x>>1;}                // 30 bit version, see below

// less golfed:
f(x){return ((x & 0x55555555)*3 + x) >>1;}   //  >> is lower precedence than +

एल्गोरिथ्म xnot के पायथन जवाब पर xsot की टिप्पणी से कॉपी किया गया । दोनों तरीकों को मास्क करने के बजाय, एक तरह से मास्क करें और गठबंधन करें।

यह उसी asm को संकलित करता है जिसे मैंने अंतिम संस्करण के रूप में परीक्षण किया था , और यह काम करता है (ऊपर x के लिए 0x3FFFFFFF, और ऊपर x के लिए जब तक बिट 30 सेट नहीं किया जाता है, नीचे देखें)। मशीन कोड में, यह मेरे मौजूदा asm उत्तर के समान लंबाई है।

उपरोक्त संस्करण हमेशा परिणाम के उच्च बिट को साफ करता है । सबसे सुरक्षित संस्करण 32 बाइट्स है:

g(x){return 2*x-3*(x/2U&~0U/3);}   // safe 32bit version, works for all x

पायथन संस्करण में यह समस्या नहीं है, क्योंकि अजगर एक निश्चित ऊपरी सीमा तक छंटनी करने के बजाय, जब आवश्यकता होती है , तो मनमाना-सटीक पूर्णांक प्रकारों का उपयोग करता है।

— पीटर कॉर्डेस
स्रोत

@ डेनिस: अर्घ, हां, धन्यवाद। मैंने परीक्षण के बाद अंतिम परिवर्तन किया, और asm आउटपुट में अंतर को याद किया। कोई आश्चर्य नहीं कि मैं सोच रहा था कि यह गलत लग रहा था; मैं भूल >>गया था कि ऐसी कम मिसाल थी। मैं अक्सर यह याद रखने के लिए पर्याप्त नहीं हूं कि नियम क्या हैं, क्योंकि खतरनाक मामलों में संकलक का सुझाव देने वाले कंपाइलर चेतावनी मुझे वास्तविक कोड में बचाते हैं। : पी

— पीटर कॉर्ड्स

2

आप अभिव्यक्ति में शर्तों को पुन: व्यवस्थित करके उस स्थान को छोड़ सकते हैं।

— Xsot

2

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

4 बाइट्स अपवेट के लिए धन्यवाद बचा

n=>+('0b'+/(..)+$/.exec('0'+n.toString`2`)[0].split``.reduce((p,c)=>p.length-1?[p.join(c)]:[p[0],c],[''])[0],2)

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

n=>+('0b'+                              //parse as binary literal
    /(..)+$/.exec('0'+n.toString`2`)[0] //convert to binary string with an even number of digits
        .split``                        //convert to array
        .reduce((p,c)=>p.length-1?[p.join(c)]:[p[0],c],[''])
                                        //swap all numbers
)

— ASCII-केवल
स्रोत

+('0b"+binary_string_here)'parseInt (..., 2) के बजाय का उपयोग करें

— डाउनगोट

1

जे, 20 बाइट्स

4#.0 2 1 3{~4#.^:_1]

प्रयोग

>> f =: 4#.0 2 1 3{~4#.^:_1]
>> f 85
<< 170

जहाँ >>STDIN है और <<STDOUT है।

Ungolfed

to_base   =: 4 #.^:_1 ]
transpose =: 0 2 1 3 {~ to_base
from_base =: 4 #. transpose

तीन कांटे।

पक्षीय लेख

आधिकारिक दुभाषिया में, 1 बाइट की बचत ^:_1करके प्रतिस्थापित किया जा सकता है inv।

हालांकि, ऑनलाइन दुभाषियों में से कोई भी इसे लागू नहीं करता है।

— लीक नन
स्रोत

1

सी #, 44 बाइट्स

सी कार्यान्वयन के आधार पर

int f(int n)=>n>3?4*f(n/4)+f(n%4):n%2*2+n/2;

इसे यहाँ आज़माएँ: C # पैड

— Cheesebaron
स्रोत

1

INTERCAL , 60 बाइट्स

DOWRITEIN.1PLEASE.1<-!1~#21845'$.1~#43690DOREADOUT.1DOGIVEUP

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

16-बिट पूर्णांक के लिए काम करता है, I / O ने INTERCAL के लिए सबसे प्राकृतिक प्रारूप में किया है: इनपुट कई प्राकृतिक या निर्मित भाषाओं में से एक में वर्तनी अंकों की एक श्रृंखला है, और आउटपुट "ब्यूटेड रोमन अंकों" में है।

यह उन दुर्लभ चुनौतियों में से एक है जहां INTERCAL के बाइनरी ऑपरेटरों को वास्तव में सभी सहज ज्ञान युक्त तरीकों से इस्तेमाल किया जा सकता है, क्योंकि बिट्स को रिप्रेजेंट करने के लिए वे क्या कर रहे हैं। चयन करें ( ~) बिट्स को इसके पहले तर्क से संबंधित दूसरे तर्क में से लेता है और उन्हें शून्य के साथ दाईं ओर पैड करता है, और मिंगल ( $) बिट्स को इसके तर्कों से इंटरलेव करता है, जैसे कि पहले तर्क से बिट्स अधिक महत्वपूर्ण हैं। तो सीधा समाधान कम महत्वपूर्ण वैकल्पिक बिट्स ( .1~#21845) का चयन करना है, अधिक महत्वपूर्ण वैकल्पिक बिट्स का चयन करें (.1~#43690), और उन्हें विपरीत क्रम में एक साथ वापस करना। सौभाग्य से बाइट की गिनती के लिए, हालांकि INTERCAL के संचालकों की कोई पूर्ववर्तीता नहीं है (जैसे कि भाषा का लक्ष्य कोई मिसाल नहीं है), यह पता चलता है कि TIO पर C-INTERCAL को इस विशेष अभिव्यक्ति के लिए बहुत समूहन की आवश्यकता नहीं है, केवल एक बाइट की लागत '.संक्षिप्त किया जा सकता है !।

32-बिट पूर्णांक के लिए समर्थन के साथ:

INTERCAL , 67 बाइट्स

DOWRITEIN:1PLEASE:1<-':1~#0$#65535'$:1~#65535$#0DOREADOUT:1DOGIVEUP

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

INTERCAL 32-बिट शाब्दिक की अनुमति नहीं देता है, जो वास्तव में इसे पढ़ने के लिए थोड़ा आसान बनाता है , क्योंकि इसका मतलब है कि वैकल्पिक बिट्स के चयन के लिए जादू की स्थिरांक का निर्माण दो 16-बिट शाब्दिक रूप से एक साथ करना होता है, जहां एक के सभी शून्य और दूसरे के सभी लोग। (वास्तव में, भले ही 32-बिट शाब्दिक थे, यह अभी भी छोटा होगा। #0$#65535दो बाइट्स बंद है #1431655765, और एक ही दूसरे के लिए चला जाता है।) यह पूरी प्रक्रिया को अस्वाभाविक रूप से INTERCAL के लिए अच्छी तरह से बताता है।

ऑपरेंड ओवरलोडिंग के अनाड़ी उपयोग के साथ एक वैकल्पिक दृष्टिकोण :

INTERCAL , 71 बाइट्स

DO:1<-:1/.2$.3PLEASEWRITEIN:2DO:1<-:2PLEASE:2<-.3$.2DOREADOUT:2DOGIVEUP

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

यह घोषणा की कि से पूरी तरह चयन करने के साथ दूर करता :1है .2के साथ मिश्रित .3की स्थापना, :1, इनपुट करने के लिए तो outputting .3के साथ मिश्रित .2। चूंकि :1अतिभारित था .2$.3, इसलिए DO :1 <- :2मानों को निर्दिष्ट करता है .2और .3इस तरह :1के मूल्य को प्राप्त करता है :2, जिसके परिणामस्वरूप .2अधिक महत्वपूर्ण बारी-बारी से बिट्स :2और .3कम महत्वपूर्ण वैकल्पिक बिट्स को समाहित करने में परिणाम होता है । यह चार बाइट्स द्वारा दो 32-बिट समाधानों से छोटा होगा यदि ओवरलोड के साथ PLEASE WRITE IN :1प्रतिस्थापित PLEASE WRITE IN :2 DO :1 <- :2किया जा सकता है :1, लेकिनCALCULATINGओवरलोडिंग का उपयोग करने के लिए आवश्यक हो जाता है। मुझे यह भी लगता है कि कार्यक्रम शुरू करने की तुलना में ओवरलोडिंग को अंजाम देने के लिए कुछ छोटे रास्ते हो सकते हैं DO:1<-:1/.2$.3, लेकिन चूंकि यह INTERCAL है इसलिए मुझे भी लगता है कि ऐसा नहीं हो सकता।

— असंबंधित स्ट्रिंग
स्रोत

0

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

Fold[3#+##&,#~IntegerDigits~4/.{1->2,2->1}]&

मेरे सीजेएम उत्तर के रूप में समान दृष्टिकोण: बेस -4 में कनवर्ट करें, 1 एस और 2 एस स्वैप करें, वापस कन्वर्ट करें। यह भी एक बाइट को बचाने के लिए FromDigitsएक Foldऑपरेशन के साथ बदलने के लिए alephalpha की चाल का उपयोग करता है ।

— मार्टिन एंडर
स्रोत

0

दरअसल, 16 बाइट्स

4@¡"21""12"(t4@¿

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

स्पष्टीकरण:

4@¡"21""12"(t4@¿
4@¡               base 4 representation of n
   "21""12"(t     translate (swap 1s and 2s)
             4@¿  base 4 to decimal

— मै जाऊं
स्रोत

0

जे, 22 बाइट्स

([:,_2|.\,&0)&.(|.@#:)

आधार 4 चाल के बजाय सरणी हेरफेर के आधार पर वैकल्पिक दृष्टिकोण।

प्रयोग

   f =: ([:,_2|.\,&0)&.(|.@#:)
   (,.f"0) 0 1 9 85 220 1827 47525
    0     0
    1     2
    9     6
   85   170
  220   236
 1827  2835
47525 30298

व्याख्या

([:,_2|.\,&0)&.(|.@#:)  Input: n
                   #:   Get the value as a list of base 2 digits
                |.@     Reverse it
(           )&.         Apply to the list of base 2 digits
         ,&0            Append a zero to the end of the list
    _2  \               Split the list into nonoverlapping sublists of size 2
      |.                Reverse each sublist
 [:,                    Flatten the list of sublists into a list
             &.(    )   Apply the inverse of (reversed base 2 digits)
                        to convert back to a number and return it

— मील की दूरी पर
स्रोत

0

आरईएक्सएक्स, 88 बाइट्स

n=x2b(d2x(arg(1)))
o=0
do while n>''
  parse var n a+1 b+1 n
  o=o||b||a
  end
say x2d(b2x(o))

— idrougge
स्रोत

अपने पड़ोसियों के साथ स्वैप बिट्स

कार्य विवरण

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

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

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

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

सी फ़ंक्शन, 38

सी पुनरावर्ती कार्य, 43

CJam, 16 14 13 बाइट्स

व्याख्या

अजगर, 9 बाइट्स

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

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

x86 asm फ़ंक्शन: मशीन कोड के 14 बाइट्स

uint64_t संस्करण: 24 बाइट्स

ओएसिस , 17 बाइट्स (गैर-प्रतिस्पर्धात्मक)

MATL , 10 बाइट्स

व्याख्या

zsh, 28 बाइट्स

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

खैर, सिर्फ मनोरंजन के लिए: 7 बाइट्स

05AB1E, 8 बाइट्स

सी, 32 30 29 बाइट्स

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

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

जे, 20 बाइट्स

प्रयोग

Ungolfed

पक्षीय लेख

सी #, 44 बाइट्स

INTERCAL , 60 बाइट्स

INTERCAL , 67 बाइट्स

INTERCAL , 71 बाइट्स

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

दरअसल, 16 बाइट्स

जे, 22 बाइट्स

प्रयोग

व्याख्या

आरईएक्सएक्स, 88 बाइट्स