태스크

양수 주어 n출력 n+1하면 n홀수 및 출력 n-1경우 n에도있다.

입력

양의 정수 정수가 언어의 처리 능력 내에 있다고 가정 할 수 있습니다.

산출

위에서 지정한 양의 정수입니다.

테스트 케이스

input output
    1      2
    2      1
    3      4
    4      3
    5      6
    6      5
    7      8
    8      7
  313    314
  314    313

채점

이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.

표준 허점이 적용됩니다.

참고 문헌

• OEIS A103889

C, 20 바이트

f(x){return-(-x^1);}

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

스택 고양이 , 3 + 3 ( -n) = 6 바이트

-*-

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

-n숫자 입력 및 출력과 함께 작동 하려면 플래그가 필요합니다 .

설명

Stack Cats는 일반적으로 제한된 명령 세트 (모두 인젝션, 대부분은 인볼 루션)와 모든 프로그램에 미러 대칭이 필요하기 때문에 경쟁력이 없습니다. 그러나 그 중 하나는 숫자의 최하위 비트를 토글하는 것이며, 단항 부정으로 값을 상쇄 할 수도 있습니다. 운 좋게도 그것은 대칭 프로그램을 제공하므로 다른 것에 대해 걱정할 필요가 없습니다.

-   Multiply the input by -1.
*   Toggle the least significant bit of the value (i.e. take it XOR 1).
-   Multiply the result by -1.

입력과 출력은 프로그램의 시작과 끝에서 암시 적입니다. 입력을 수행하고 출력을 생성하는 것은 되돌릴 수있는 작업이 아니므로 명령이 될 수 없습니다.

x86 어셈블리, 9 바이트 (경쟁 참가 용)

높은 수준의 언어에서이 도전을 시도하는 모든 사람은 놓치고있다 실제 원시 비트를 조작하는 재미. 이 작업을 수행하는 방법에는 미묘한 변형이 많으며 미쳤으며 생각하는 것도 즐겁습니다. 다음은 32 비트 x86 어셈블리 언어로 고안 한 몇 가지 솔루션입니다.

이것이 일반적인 코드 골프 답변이 아니라는 점을 미리 사과드립니다. 반복 최적화 (생각에 대한)의 사고 과정에 대해 많은 것을 논할 것입니다. 바라건대 그것은 많은 사람들에게 흥미롭고 교육적이지만, TL; DR 유형이라면 끝까지 건너 뛰더라도 기분 나빠하지 않을 것입니다.

명확하고 효율적인 해결책은 값이 홀수인지 짝수인지 (최소 비트를보고 효율적으로 수행 할 수 있는지) 테스트 한 다음 그에 따라 n + 1 또는 n-1 중에서 선택하는 것 입니다. 입력이 ECX레지스터에 매개 변수로 전달되고 결과가 EAX레지스터에 리턴 된다고 가정하면 다음 함수를 얻게됩니다.

F6 C1 01  |  test  cl, 1                      ; test last bit to see if odd or even
8D 41 01  |  lea   eax, DWORD PTR [ecx + 1]   ; set EAX to n+1 (without clobbering flags)
8D 49 FF  |  lea   ecx, DWORD PTR [ecx - 1]   ; set ECX to n-1 (without clobbering flags)
0F 44 C1  |  cmovz eax, ecx                   ; move in different result if input was even
C3        |  ret

^{(13 바이트)}

그러나 코드 골프 목적을 위해 이러한 LEA명령은 인코딩하는 데 3 바이트가 걸리기 때문에 좋지 않습니다. 간단한 DECrement는 ECX훨씬 짧아 지지만 (1 바이트 만) 이것은 플래그에 영향을 미치므로 코드를 정렬하는 방법에있어 약간 영리해야합니다. 먼저 감소를 , 홀수 / 짝수 테스트를 두 번째 로 수행 할 수 있지만 홀수 / 짝수 테스트 의 결과를 반전시켜야합니다.

또한 조건부 이동 명령을 분기로 변경하면 분기가 얼마나 예측 가능한지에 따라 코드 실행 속도가 느려질 수 있습니다. 입력이 홀수와 짝수 사이에서 일관성없이 번갈아 가면 분기가 느려집니다. 패턴이 더 빠를 것입니다) 다른 바이트를 절약 할 수 있습니다.

실제로이 개정판을 사용하면 단일 레지스터 만 사용하여 전체 작업을 제자리에서 수행 할 수 있습니다. 이 코드를 어딘가에 인라인하는 경우 유용합니다 (너무 짧기 때문에 가능성이 있습니다).

    48     |  dec  eax          ; decrement first
    A8 01  |  test al, 1        ; test last bit to see if odd or even
    75 02  |  jnz  InputWasEven ; (decrement means test result is inverted)
    40     |  inc  eax          ; undo the decrement...
    40     |  inc  eax          ; ...and add 1
  InputWasEven:                 ; (two 1-byte INCs are shorter than one 3-byte ADD with 2)

^{(인라인 : 7 바이트; 함수 : 10 바이트)}

그러나 기능으로 만들고 싶다면 어떻게해야할까요? 표준 호출 규칙은 반환 값에 대한 것과 동일한 레지스터를 사용하여 매개 변수를 전달하지 않으므로 MOV함수의 시작 또는 끝에 레지스터 레지스터 명령어를 추가해야 합니다. 이것은 사실상 비용이 들지 않지만 2 바이트를 추가합니다. ( RET명령은 바이트를 추가하고 함수 호출에서 만들고 반환해야 할 때 발생하는 약간의 오버 헤드가 있습니다. 즉 , 고전적인 속도가 아니라 인라인으로 속도 와 크기 이점을 모두 생성하는 한 가지 예입니다 -공백 절충) 함수로 작성된이 코드는 10 바이트로 증가합니다.

우리는 10 바이트로 무엇을 할 수 있습니까? 성능 (적어도 예측 가능한 성능) 에 관심이있는 경우 해당 지점을 제거하는 것이 좋습니다. 다음은 바이트 단위의 동일한 크기의 분기없는 비트 트위들 링 솔루션입니다. 기본 전제는 간단합니다. 비트 XOR을 사용하여 마지막 비트를 뒤집어 홀수 값을 짝수로 변환하거나 그 반대로 변환합니다. 그러나 홀수 입력의 경우 n-1 을 제공 하고 입력도 짝수의 경우 n + 1을 제공합니다 . 정확히 원하는 것과 반대입니다. 따라서 문제를 해결하기 위해 음수 값으로 연산을 수행하여 부호를 효과적으로 뒤집습니다.

8B C1     |  mov eax, ecx   ; copy parameter (ECX) to return register (EAX)
          |
F7 D8     |  neg eax        ; two's-complement negation
83 F0 01  |  xor eax, 1     ; XOR last bit to invert odd/even
F7 D8     |  neg eax        ; two's-complement negation
          |
C3        |  ret            ; return from function

^{(인라인 : 7 바이트; 함수 : 10 바이트)}

꽤 매끄러운; 그것이 어떻게 개선 될 수 있는지 알기가 어렵습니다. 한 가지가 내 눈길을 사로 잡습니다. 두 개의 2 바이트 NEG명령입니다. 솔직히 말해서, 2 바이트는 간단한 부정을 인코딩하기에는 1 바이트가 너무 많은 것처럼 보이지만, 이것이 우리가 작업해야 할 명령어 세트입니다. 해결 방법이 있습니까? 확실한! 우리 XOR가 -2이면 두 번째 NEGation을 INCrement로 바꿀 수 있습니다 .

8B C1     |  mov eax, ecx
          |
F7 D8     |  neg eax
83 F0 FE  |  xor eax, -2
40        |  inc eax
          |
C3        |  ret

^{(인라인 : 6 바이트; 기능 : 9 바이트)}

x86 명령어 세트의 또 다른 단점 중 하나는 다목적 LEA명령어 이며 레지스터 레지스터 이동, 레지스터 레지스터 추가, 상수로 오프셋 및 단일 명령어로 모두 스케일링 할 수 있습니다!

8B C1        |  mov eax, ecx
83 E0 01     |  and eax, 1        ; set EAX to 1 if even, or 0 if odd
8D 44 41 FF  |  lea eax, DWORD PTR [ecx + eax*2 - 1]
C3           |  ret

^{(10 바이트)}

AND명령은 같다 TEST모두 것을 따라 비트 단위-AND 및 설정 플래그을, 우리는 이전에 사용 된 명령하지만, AND실제로는 피연산자 대상을 업데이트합니다. LEA명령어는이 감산 1, 2에 의해 스케일링이 입력 값이 홀수 인 경우 (1)에 의해 원래의 입력 값 및 감소 추가 - 그 행을 (2 × 1 = 0 -1); 입력 값이 짝수이면 1 (2 × 1-1 = 1)이 추가됩니다.

이것은 프런트 엔드에서 많은 실행을 수행 할 수 있기 때문에 코드를 작성하는 매우 빠르고 효율적인 방법이지만, 복잡한 인코딩에 많은 시간이 걸리기 때문에 바이트 방식으로 많이 사지 않습니다. LEA교수. 이 버전은 원래 입력 값을 LEA명령 의 입력으로 유지해야하기 때문에 인라인 목적으로도 잘 작동하지 않습니다 . 따라서이 마지막 최적화 시도로 인해 실제로 이전으로 되돌아 가서 중지해야 할 시점이 될 수 있습니다.

따라서, 최종 경쟁 항목에 대해, 우리는 입력 상기의 값을 취하는 9 바이트 함수가 ECX레지스터 (세미 표준 레지스터 기반 호출 규약 32 비트 86 페이지) 및 복귀의 결과 EAX와 마찬가지로, 레지스터 ( 모든 x86 호출 규칙) :

           SwapParity PROC
8B C1         mov eax, ecx
F7 D8         neg eax
83 F0 FE      xor eax, -2
40            inc eax
C3            ret
           SwapParity ENDP

MASM으로 조립할 준비가되었습니다. C에서 다음과 같이 전화하십시오.

extern int __fastcall SwapParity(int value);                 // MSVC
extern int __attribute__((fastcall)) SwapParity(int value);  // GNU   

젤리 , 3 바이트

-*ạ

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

의사 코드 : abs((-1)**n - n)

Python3, 20 18 바이트

lambda n:n-1+n%2*2

꽤 간단합니다. 먼저 n-1 을 계산 하고 2를 더할 것인지 아닌지를 결정합니다.

n이 짝수 경우 -> N 모드 (2) 따라서 우리가 추가 할 것입니다, 0이됩니다 2 * 0 으로 N-1 의 결과로, N-1 .

n이 홀수 인 경우 -> N 모드 (2) 따라서 우리가 추가 할 것입니다, 1이됩니다 2 * 1 로 N-1 의 결과로, N + 1 .

나는 MS paint & laptop touchpad로 만든 설명을 선호합니다 ...

파이썬, 16 바이트

lambda x:-(-x^1)

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

MATL , 7 바이트

Q:HePG)

이것은 산술 연산을 피합니다. 온라인으로 사용해보십시오!

설명

4예를 들어 입력 을 고려하십시오 .

Q    % Implicit input. Add 1
     % STACK: 5
:    % Range
     % STACK: [1 2 3 4 5]
He   % Reshape with 2 rows in column-major order. Pads with a zero if needed
     % STACK: [1 3 5;
               2 4 0]
P    % Flip vertically
     % STACK: [2 4 0;
               1 3 5]
G    % Push input again
     % STACK: [2 4 0;
               1 3 5], 4
)    % Index, 1-based, in column major order. Implicitly display
     % STACK: 3

Braingolf v0.1 , 11 10 바이트

.1>2,%?+:-

온라인으로 사용해보십시오! (두 번째 인수는 Braingolf 코드이고 세 번째 인수는 입력입니다)

Neil 덕분에 바이트를 절약했습니다.

처음으로 경쟁하는 braingolf 답변 : D

설명:

.            Duplicate the top of the stack
 1>          Push 1 to the bottom of the stack
   2         Push 2 to stack
    ,%       Pop last 2 items, mod them and push result
      ?      If last item > 0
       +     Add the 1 to the input
        :    Else
         -   Subtract the 1 from the input

             No semicolon in code so print last item

Braingolf v0.2 , 9 바이트 [비경쟁]

.2%?1+:1-

온라인으로 사용해보십시오! (두 번째 인수는 Braingolf 코드이고 세 번째 인수는 입력입니다)

설명은 위를 참조하십시오. 차이점은 Braingolf v0.2에만 있으며, 이항 연산자의 기본 동작과 ,수정 자의 기능 이 반대로되어 v0.1 답변의 2 개의 쉼표가 더 이상 필요하지 않습니다.

그러나 챌린지 후 v0.2가 릴리스되었으므로 경쟁이 아닙니다.

Cubix , 10 9 바이트

cO1)I(//@

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

설명

넷 버전

    c O
    1 )
I ( / / @ . . .
. . . . . . . .
    . .
    . .

실행 된 문자는

I(1c)O@
I          Input
 (         Decrement
  1c       XOR with 1
    )      Increment
     O@    Output and exit

파이썬, 68 바이트

lambda x:[m.floor(x-m.cos(m.pi*x)) for m in [__import__('math')]][0]

독특한 접근 방식의 정신. 다음 그래프는 기능을 보여줍니다 (처음 10 가지 경우를 나타내는 자주색 점). 이론적으로는 대부분의 모든 주기적 기능 (예 : sin, tan, sec)을 기반으로이 질문에 대한 솔루션을 구성 할 수 있어야합니다. 실제로 코드에서 cos를 sec로 대체하면 작동합니다.

PHP, 15 바이트

<?=-(-$argn^1);

자바 스크립트, 17 12 바이트

x=>x-(-1)**x

f=x=>x-(-1)**x;

<input id=i oninput=o.innerText=f(this.value) type=number><pre id=o>

또 다른 접근법 _{은 C 답변에서} 10 바이트를 _{도난당했습니다 (sssshhh).}

x=>-(-x^1)

f=x=>-(-x^1)

<input id=i oninput=o.innerText=f(this.value) type=number><pre id=o>

자바 스크립트 (ES6), 14 13 12 10 바이트

n=>-(-n^1)

• Luke 덕분에 1 바이트가 절약되었습니다 .
• feersum의 C 솔루션 을 이식하여 2 바이트 절약 . (이것이 싫은 경우 알려 주시기 바랍니다 아래의 이전 솔루션으로 롤백합니다)

시도 해봐

f=
n=>-(-n^1)
i.addEventListener("input",_=>o.innerText=f(+i.value))

<input id=i type=number><pre id=o>

원본, 12 바이트

n=>n-1+n%2*2

파이썬, 20 바이트

lambda n:n+(n%2or-1)

n%2or-1 홀수이면 1을 반환하지만 짝수이면 n%2 "false"(0)이므로 대신 -1을 반환합니다. 그런 다음에 간단히 추가합니다 n.

이전 솔루션, 23 바이트

lambda n:[n-1,n+1][n%2]

n%2n2로 나눈 나머지를 계산합니다. 짝수이면 0을 반환하고이 목록의 요소 0은 n-1입니다. 홀수이면 1을 반환하고이 목록의 요소 1은 n+1입니다.

망막 , 21 바이트

.+
$*
^11(?=(11)*$)

온라인으로 사용해보십시오! 첫 번째 Retina는 두 개의 줄 바꿈 문자로 답변합니다! 설명 : 처음 두 줄은 10 진수에서 단항으로 변환됩니다. 세 번째와 네 번째 줄은 짝수에서 2를 뺍니다. 마지막 줄은 십진수로 다시 변환되지만 한 줄도 추가합니다.

05AB1E , 4 바이트

(1^(

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

Cubix , 11 바이트

u%2!I(/+@O<

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

설명

넷 버전 :

    u %
    2 !
I ( / + @ O < .
. . . . . . . .
    . .
    . .

문자는 다음 순서로 실행됩니다.

I(2%!+O@
I        # Take a number as input
 (       # Decrement it
  2%     # Take the parity of the decremented number
         # (0 if the input is odd, 1 if it's even)
    !    # If that number is zero:
     +   #   Add 2
      O  # Output the number
       @ # Terminate the program

Brain-Flak , 36 바이트

(({})(())){({}[()]<([{}])>)}{}({}{})

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

나는이 대답에 대해 개인적으로 정말로 행복합니다. 왜냐하면이 문제를 해결하는 전통적인 방법으로 생각되는 것보다 훨씬 짧기 때문입니다.

설명

코드의 첫 번째 비트

(({})(()))

스택을 그냥 n에서

n + 1
  1
  n

그런 다음 스택의 상단이 0이 아닌 동안 우리는 그것을 줄이고 그 아래 숫자의 부호를 뒤집습니다.

{({}[()]<([{}])>)}

우리는 0을 제거하고 나머지 두 숫자를 더합니다

{}({}{})

수학, 22 19 바이트

Greg Martin 덕분에 3 바이트를 절약했습니다!

#-1[-1][[#~Mod~2]]&

이전 답변, 22 바이트

#+{-1,1}[[#~Mod~2+1]]&

설명 (이전 답변)

Mathematica는 산술과 같은 연산이 목록을 자동으로 스레드하는 멋진 기능을 가지고 있습니다.

이 경우 Mod[#,2]0 또는 1을 반환하지만 Mathematica 목록은 1- 인덱스이므로 1을 추가해야합니다. 그것의 경우 에도 ,이 일에 나오는, 그래서 #-1반환됩니다. 그것의 경우 홀수 ,이 2에 나오는, 그래서 #+1반환됩니다.

와이즈 , 8 바이트

-::^~-^-

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

설명

이것이 다른 방법이라면 (홀수이면 감소하고, 짝수이면 증가),이 작업을 수행하는 것은 매우 쉽습니다.

우리는 마지막 비트를 뒤집을 것입니다.

::^~-^

여기서 수정은 마지막 비트를 음수로 뒤집는 것입니다. 음수는 숫자의 부정에서 1입니다~ 문제를 해결하는 오프셋을 만듭니다.

그래서 우리는 단지 프로그램을 꺼내서 포장합니다 -.

-::^~-^-

자바 8, 16 10 바이트

n->-(-n^1)

자바 7, 34 28 바이트

int c(int n){return-(-n^1);}

@feersum 의 놀라운 C 답변의 지루한 포트 .
여기에서 시도하십시오.

오래된 답변 :

자바 8, 16 바이트

n->n%2<1?n-1:n+1

자바 7, 34 바이트

int c(int n){return--n%2>0?n:n+2;}

설명 (구 Java 7 답변) :

여기에서 시도하십시오.

위의 대답 int c(int n){return n%2<1?n-1:n+1;}은 공간을 없애는 것 보다 짧은 변형입니다 .

int c(int n){     // Method with integer parameter and integer return-type
  return--n%2>0?  //  If n-1 mod-2 is 1:
    n             //   Return n-1
   :              //  Else:
    n+2;          //   Return n+1
}                 // End of method

Japt , 6 바이트

n ^1 n

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

파이썬, 20 바이트

lambda n:n+(n&1)*2-1

Befunge 93 , 18 바이트

&:2%#v_1+.@
@.-1 <

나는 아직 골프를하지 않았다 (나는 희망한다).

Ruby, 12 bytes

->n{-(-n^1)}

R, 17 bytes

(n=scan())-(-1)^n

where n=scan() takes the digit value.

Casio-Basic, 27 bytes

piecewise(mod(n,2),1,-1)+n

26 bytes for the function, +1 to enter n in the parameters box.

C, 29 bytes

a(int b){return b%2?b+1:b-1;}

Jelly, 4 bytes

‘’Ḃ?

Try it online!

Batch, 20 bytes

@cmd/cset/a"-(1^-%1)

Independently rediscovered @feersum's algorithm, honest!