과업 설명

정수가 주어지면 모든 정수 k> 0에 대해 (2k–1) 번째와 2k 번째 최하위 비트를 교체하십시오 . OEIS의 시퀀스 A057300 입니다.

숫자는 "무한한"선행 0을 갖는 것으로 가정합니다. 실제로 이것은 단순히 단일 0 비트를 홀수 길이의 숫자 앞에 추가하는 것을 의미합니다.

이것은 code-golf 이므로 가장 짧은 코드 (바이트)가 이깁니다.

테스트 사례

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.

파이썬 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

그런 다음 비트 전환 결과 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)/2xsot에서 최적화에 바이트 감사를 절약 할 수.

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

C 함수, 38

비트 트위들 링 :

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

이데온

또는 그것의 재미를 위해 :

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;}

이데온

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 Compiler 에서 사용해보십시오 .

작동 원리

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

자바 스크립트 (ES6), 32 30 바이트

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

JavaScript 정수의 제한으로 인해 최대 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)

x86 asm 기능 : 14 바이트의 기계 코드

uint64_t 버전 : 24 바이트

x86-64 SysV 호출 규칙 ( xin 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 링크 참조). movabs rax, 0x55...레지스터에서 마스크를 생성하는 데 10 바이트보다 짧은 방법은 없습니다 . (x86의 div지시는 어리석기 때문에 서명하지 않은 모든 사람을 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 바이트입니다.

이 답변의 이전 버전에는 loopinsn을 사용하여 10 바이트 루프가 있었지만 0xFFFFFFFFFFFFFF08설정 만했기 때문에 최악의 반복 런타임이있었습니다 cl.

오아시스 , 17 바이트 (비경쟁)

n4÷axxn4÷xxe+3120

온라인으로 사용해보십시오!

Oasis는 Adnan 이 디자인 한 언어 로 시퀀스에 특화되어 있습니다.

현재이 언어는 재귀 및 닫힌 양식을 수행 할 수 있습니다.

우리는이 공식을 사용합니다 : 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.

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에 출력합니다.

zsh 특정 기본 변환 구문을 사용하기 때문에 Bash와 호환되지 않습니다.

                       $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
^
엑스
r` (.) (.)
$ 2 $ 1
1
엑스@
+`@ x
엑스@@
엑스*(@*)
$ .1
0 $

테스트 스위트. (약간 수정되었습니다.)

글쎄, 재미를 위해 : 7 바이트

T`12`21

base-4를 입력으로 취하고 base-4로 출력을 취합니다.

온라인으로 사용해보십시오!

05AB1E, 8 바이트

4B12‡4ö

-5 바이트의 @Adnan에게 감사합니다!

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 +

xnor의 Python answer에 대한 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

파이썬 버전에는이 문제가 없습니다. 파이썬은 고정 된 상한으로 잘리는 대신 필요할 때 임의의 정밀도 정수 유형을 사용 하기 때문 입니다.

자바 스크립트 (ES6), (113) 109 바이트

Upgoat 덕분에 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
)

J, 20 바이트

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

용법

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

>>STDIN은 어디에 있고 <<STDOUT입니다.

언 골프

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

세 포크.

사이드 노트

공식 인터프리터에서는 1 바이트를 절약 ^:_1하여로 대체 할 수 있습니다 inv.

그러나 온라인 통역사는이를 구현하지 않습니다.

C #, 44 바이트

C 구현을 기반으로

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

여기에서 시도하십시오 : C # 패드

INTERCAL , 60 바이트

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

온라인으로 사용해보십시오!

INTERCAL에 대해 가장 자연스러운 형식으로 I / O를 수행하는 16 비트 정수에 대해 작동합니다. 입력은 여러 자연어 또는 생성 된 언어 중 하나로 철자 된 일련의 10 진수이며 출력은 "도달 된 로마 숫자"입니다.

이것은 비트 재배치가 전부이기 때문에 INTERCAL의 이진 연산자를 실제로 직관적으로 사용할 수있는 드문 과제 중 하나입니다. Select ( ~)는 두 번째 인수의 1에 해당하는 첫 번째 인수에서 비트를 가져와 오른쪽으로 0으로 채 웁니다. mingle ( $)은 인수에서 비트를 인터리브하여 첫 번째 인수의 비트가 더 중요합니다. 따라서 간단한 해결책은 덜 중요한 대체 비트 ( .1~#21845)를 선택하고 더 중요한 대체 비트 (.1~#43690), 반대 순서로 다시 삽입합니다. 운 좋게도 바이트 수는 INTERCAL의 연산자가 정의 된 우선 순위를 갖지 않지만 (언어의 목표는 선례가 없기 때문에) TIO의 C-INTERCAL 은이 특정 표현식에 대해 많은 그룹화가 필요하지 않기 때문에 1 바이트 만 필요합니다 '.축약 될 수 있습니다 !.

32 비트 정수 지원 :

INTERCAL , 67 바이트

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

온라인으로 사용해보십시오!

INTERCAL은 32 비트 리터럴을 허용하지 않습니다. 실제로이 비트 를 읽기가 더 쉬워집니다. 교대로 비트를 선택하기위한 마술 상수는 두 개의 16 비트 리터럴을 함께 조합하여 구성해야합니다. 모든 것. (실제로 32 비트 리터럴이 있어도이 길이 #0$#65535는 더 짧을 것입니다. 2 바이트는 떨어져 #1431655765있고 다른 바이트도 마찬가지입니다.) 이것은 전체 프로세스를 부 자연스럽게 잘 전달합니다.

피연산자 오버로드 를 서투르게 사용하는 대체 접근법 :

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덜 중요한 교번 비트들을 포함한다. 이 경우 4 바이트로 두 개의 32 비트 솔루션의 짧은 것이다 PLEASE WRITE IN :1대체 할 수있는 PLEASE WRITE IN :2 DO :1 <- :2과부하로 :1하지만,CALCULATING과부하를 사용하는 데 필요한 것으로 밝혀졌습니다. 또한 프로그램을 시작하는 것보다 과부하 자체를 수행하는 더 짧은 방법이있을 것이라고 생각 DO:1<-:1/.2$.3하지만 이것이 INTERCAL이기 때문에 나는 또한 할 수없는 것처럼 느낍니다.

매스 매 티카, 44 바이트

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

내 CJam 답변과 동일한 접근 방식 : 기본 4로 변환, 1과 2를 바꾸고 다시 변환하십시오. 또한 alephalpha의 트릭을 사용 하여 1 바이트를 저장 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))