คำอธิบายงาน

ได้รับจำนวนเต็มสลับมัน(2k-1) -th และ2k -th น้อยบิตที่สำคัญสำหรับจำนวนเต็มทั้งหมดk> 0 นี่คือลำดับA057300ใน OEIS

(ตัวเลขจะถือว่ามีเลขศูนย์นำหน้าเป็น "จำนวนอนันต์" ในทางปฏิบัตินี่หมายถึงการเตรียมตัวเลขบิตความยาวคี่ 0 บิตหนึ่งครั้ง)

นี่คือโค้ดกอล์ฟดังนั้นรหัสที่สั้นที่สุด (เป็นไบต์) ชนะ

กรณีทดสอบ

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

เยลลี่ , 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.

Python 2, 26 ไบต์

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

เคล็ดลับบิต!

Say nมีรูปแบบเป็น...ghfedcbaเลขฐานสอง จากนั้นเราสามารถแบ่งมันออกเป็นบิตอื่น ๆ ได้เช่นกัน

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

จากนั้นผลบิต-switched สามารถแสดงเป็นss=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ซึ่งบันทึกไบต์แทนการเพิ่มประสิทธิภาพจาก xsot

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

ฟังก์ชั่น C, 38

บิต twiddling:

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

Ideone

หรือเพื่อความสนุกของมัน

ฟังก์ชันแบบเรียกซ้ำ C 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

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.

Pyth, 9 ไบต์

iXjQ4S2)4

ลองมันในPyth คอมไพเลอร์

มันทำงานอย่างไร

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

JavaScript (ES6), 32 30 ไบต์

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

ทำงานได้มากถึง 1073741823 เนื่องจากข้อ จำกัด ของจำนวนเต็มของ JavaScript 38 36 ไบต์ทำงานได้มากถึง 4294967295:

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

แก้ไข: บันทึก 2 ไบต์ด้วย @ user81655

51 ไบต์ทำงานได้ถึง 4503599627370495:

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

ฟังก์ชัน asm x86: 14 ไบต์ของรหัสเครื่อง

รุ่น uint64_t: 24 ไบต์

x86-64 SysV เรียกแบบแผน ( xในedi), แต่รหัสเครื่องเดียวกันนี้จะทำงานในโหมด 32 บิต (ในกรณีที่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 ไบต์

นี่คือเอาท์พุทคอมไพเลอร์จากการใช้หน้ากากที่ยอดเยี่ยมของ xnor เมื่อคิดในทางตรงกันข้าม (และคำศัพท์ตรงข้าม: บิตต่ำคือบิต 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 ไบต์ (ดูลิงค์ godbolt) ฉันไม่เห็นวิธีที่สั้นกว่า 10 ไบต์movabs rax, 0x55...ในการสร้างรูปแบบในการลงทะเบียน ( divคำสั่งของ x86 นั้น clunky ดังนั้นการหารที่ไม่ได้รับการลงนามของทุกคนด้วย 3 จึงไม่ได้ช่วย)

ฉันขึ้นมาพร้อมกับวนรอบเพื่อสร้างมาสก์ใน rax แต่มันมีขนาด 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 ไบต์

รุ่นก่อนหน้าของคำตอบนี้มีห่วง 10 ไบต์ใช้loopinsn แต่มันมีความเลวร้ายที่สุดกรณีระยะเวลาของการทำซ้ำเพราะผมตั้งเท่านั้น0xFFFFFFFFFFFFFF08cl

โอเอซิส 17 ไบต์ (ไม่ใช่การแข่งขัน)

n4÷axxn4÷xxe+3120

ลองออนไลน์!

Oasis เป็นภาษาที่ออกแบบโดยAdnanซึ่งมีความเชี่ยวชาญในการเรียงลำดับ

ขณะนี้ภาษานี้สามารถทำการสอบถามซ้ำและแบบฟอร์มปิด

เราใช้สูตรนี้: a(4n+k) = 4a(n) + a(k), 0 <= k <= 3

เพื่อระบุกรณีฐานเป็นง่าย: ในตอนท้ายก็หมายความว่า3120a(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.

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

zsh, 28 ไบต์

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

รับอินพุตเป็นอาร์กิวเมนต์บรรทัดคำสั่งเอาต์พุตบน STDOUT

ไม่เข้ากันได้กับ Bash เพราะใช้ไวยากรณ์การแปลงพื้นฐานเฉพาะ 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

เรติน่า 70 ไบต์

. +
$ *
+ `(1 +) \ 1
$ 1x
x1
1
^
x
r` (.) (.)
$ 2 $ 1
1
x @
+ `@ x
x @@
* x (@ *)
$ 0.1
0 $

ชุดทดสอบ (แก้ไขเล็กน้อย)

เพื่อความสนุก: 7 ไบต์

T`12`21

ใช้ base-4 เป็นอินพุตและเอาต์พุตเป็น base-4

ลองออนไลน์!

05AB1E, 8 ไบต์

4B12‡4ö

ขอบคุณ @Adnan สำหรับ -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.

C, 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 +

ขั้นตอนวิธีการคัดลอกมาจากความคิดเห็น xsot บน XNOR คำตอบของงูหลาม แทนที่จะปิดบังทั้งสองวิธีให้ปกปิดทางเดียวและรวมกัน

คอมไพล์นี้เป็น asm เดียวกับเวอร์ชั่นสุดท้ายที่ฉันทดสอบและใช้งานได้ (สำหรับ x สูงถึง0x3FFFFFFFและสำหรับ x สูงกว่านั้นตราบใดที่บิต 30 ไม่ได้ถูกตั้งค่าดูด้านล่าง) ในรหัสเครื่องความยาวเท่ากับคำตอบ asm ที่ฉันมีอยู่

เวอร์ชันด้านบนจะล้างผลลัพธ์ในระดับสูงเสมอ รุ่นที่ปลอดภัยที่สุดคือ 32 ไบต์:

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

เวอร์ชัน Python ไม่มีปัญหานี้เนื่องจากpython ใช้ชนิดจำนวนเต็มที่มีความแม่นยำตามอำเภอใจเมื่อต้องการแทนที่จะตัดทอนให้เป็นขีด จำกัด สูงสุดคงที่

Javascript (ES6), 113 109 ไบต์

บันทึกแล้ว 4 ไบต์ขอบคุณUpgoat

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
)

J, 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

สามส้อม

sidenote

ในล่ามอย่างเป็นทางการ^:_1สามารถถูกแทนที่ด้วยinvประหยัด 1 ไบต์

อย่างไรก็ตามไม่มีล่ามออนไลน์ที่ใช้สิ่งนี้

C #, 44 ไบต์

ขึ้นอยู่กับการใช้งาน C

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

ลองที่นี่: C # pad

INTERCAL 60 ไบต์

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

ลองออนไลน์!

ใช้งานได้กับจำนวนเต็ม 16 บิตโดยที่ I / O ทำในรูปแบบที่เป็นธรรมชาติที่สุดสำหรับ INTERCAL: อินพุตคือชุดของตัวเลขทศนิยมที่สะกดออกมาเป็นหนึ่งในภาษาธรรมชาติหรือภาษาที่สร้างขึ้นจำนวนหนึ่งและเอาต์พุตจะอยู่ใน "ตัวเลขโรมัน

นี่เป็นหนึ่งในความท้าทายที่หาได้ยากซึ่งผู้ให้บริการไบนารีของ INTERCAL สามารถใช้งานได้จริงโดยสังเขปเนื่องจากการวางตำแหน่งบิตเป็นสิ่งที่พวกเขากำลังทำ Select ( ~) ใช้บิตจากการโต้แย้งครั้งแรกที่สอดคล้องกับที่อยู่ในการโต้แย้งที่สองและแผ่นพวกเขาไปทางขวาด้วยศูนย์และ mingle ( $) interleaves บิตจากการขัดแย้งของมันเช่นที่บิตจากการโต้แย้งครั้งแรกมีความสำคัญมากขึ้น ดังนั้นทางออกที่ตรงไปตรงมาคือการเลือกบิตสลับที่มีนัยสำคัญน้อยกว่า ( .1~#21845) เลือกบิตสลับที่มีความสำคัญมากขึ้น (.1~#43690) และสอดแทรกกลับเข้าด้วยกันในลำดับที่ตรงกันข้าม โชคดีสำหรับการนับจำนวนไบต์ถึงแม้ว่าตัวดำเนินการของ INTERCAL จะไม่มีการกำหนดมาก่อน (เนื่องจากเป้าหมายของภาษานั้นไม่มีการอ้างถึง) แต่ปรากฎว่า C-INTERCAL บน TIO ไม่ต้องการการจัดกลุ่มสำหรับนิพจน์นี้โดยเฉพาะสามารถย่อ'.!

ด้วยการรองรับจำนวนเต็ม 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การป้อนข้อมูลแล้วแสดงผลผสมกับ.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 ฉันก็รู้สึกเหมือนไม่สามารถทำได้

Mathematica ขนาด 44 ไบต์

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

เช่นเดียวกับคำตอบ CJam ของฉัน: แปลงเป็น base-4, สลับ 1s และ 2s, แปลงกลับ นอกจากนี้ยังใช้เคล็ดลับของ alephalpha เพื่อแทนที่FromDigitsด้วยการFoldดำเนินการเพื่อบันทึกหนึ่งไบต์

จริงแล้ว 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

J, 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

REXX, 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))