이 도전은 내가 자주 쓰는 프로그래밍 블로그에서 영감을 얻었습니다. 원래 게시물을 참조하십시오 : 프로그래밍 퍼즐

도전

함수 정의 f:Q->Q같은 것을 f(f(n)) = -n'0'이 아닌 정수에 대해 n, 그리고 Q유리수의 집합입니다.

세부

당신이 선호하는 어떤 언어로 정의하십시오 하나 개의 기능이나 프로그램을 f매개 변수로 받아 하나의 수를 n반환 또는 출력 한 수를 f(n).

함수 인수, STDIN에서 읽기, 명령 행 인수, 스택 위치, 음성 입력, 갱 사인 등 언어에 가장 자연스러운 메커니즘을 통해 입력이 제공 될 수 있습니다.

출력은 기능 / 프로그램에서 리턴 값이거나 STDOUT으로 인쇄되어야합니다.

프로그램 상태 나 함수 외부에서 볼 수있는 전역 메모리 / 데이터를 활용하지 않는 함수에 대한 답변을 제한하고 싶습니다 f. 예를 들어, 카운터를 f그 외부에 유지하는 것은 몇 번의 f호출을 했는지 계산 하고이 카운트를 기반으로 부정을하는 것은 누구에게나 어렵거나 흥미롭지 않습니다. 결정 f은 f어휘 범위 내의 데이터에만 의존해야합니다 .

그러나 이러한 제한은 일부 스택 지향 언어 또는 이러한 유형의 데이터 또는 범위를 구분하지 않는 다른 유형의 언어에는 적합하지 않을 수 있습니다. 이 도전의 정신을 지키기 위해 최선의 판단을하십시오.

채점

공통 코드 골프 규칙이 적용됩니다. 점수는 소스 코드 의 바이트 수입니다 .

최소 답변을 위해서는 도메인과 공동 도메인 f이 합리적 부분 집합이어야합니다 Q. 도메인과 코 도메인을 fintegers로 제한하면 Z점수는 소스 코드 바이트 수의 90 %의 상한입니다 .

타이 브레이크

동점 일 경우 다음이 순서대로 사용됩니다.

1. 소스 코드에서 인쇄 가능한 비 공백 기호의 수가 가장 적음
2. 가장 빠른 답변 제출 날짜 및 시간

편집하다

임의 크기의 숫자를 지원할 필요는 없습니다. 선택한 언어 (일반적으로 정수 및 부동 소수점)로 세트 Z및 Q데이터 유형을 해석하십시오 .

솔루션이 데이터 유형의 기본 구조 또는 비트 패턴에 전적으로 의존하는 경우 해당 제한 사항과 사용 방법을 설명하십시오.

J, 9 점 (10 자)

stackoverflow 답변을 기반으로 :

   (*-[*_1&^)

첫 번째 아이디어 (13 문자) :

   ((-*)-2&|*+:)

   ((-*)-2&|*+:) _10 _9 _8 _7 _6 _5 _4 _3 _2 _1 0 1 2 3 4 5 6 7 8 9 10
_9 10 _7 8 _5 6 _3 4 _1 2 0 _2 1 _4 3 _6 5 _8 7 _10 9

   ((-*)-2&|*+:) _9 10 _7 8 _5 6 _3 4 _1 2 0 _2 1 _4 3 _6 5 _8 7 _10 9
10 9 8 7 6 5 4 3 2 1 0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _10

파이썬 : 61 34 30 29 27 포인트

f : Q-> Q

수학에서 :

       | 0.5-x   if x is in Q \ Z
f(x) = |
       | x+0.5   if x is in Z

파이썬에서 :

f=lambda x:.5+[x,-x][x%1>0]

테스트

filter(lambda n: n[0] != -n[1], map(lambda n:(n,f(f(n))),range(0,50)))

이 뒤에 논리 :

정수를 가져 와서 n넣으면 f얻을 수 x+0.5있습니다. 이것은 더 이상 정수가 아니므로 다음 응용 프로그램은 0.5-(x+0.5)입니다 -x.

크레딧

덕분에

• 61 자에서 34 자로 줄이려고하는 Bakuriu
• 코드 크기를 30 자로 줄이려는 변동성
• 코드 크기를 29 자로 줄이기 위해 복사 하고 잠재적 부동 소수점 문제를 수정하십시오.
• 위의 변경 사항과 함께 제공되는 불일치를 언급 해 주셔서 감사 합니다.

노트

처음에는 이것이 괜찮을 것이라고 생각했습니다.

f = lambda n: 1j*n

그러나 그것의 f : N-> C 그리고 그것은 허용되지 않습니다 :-/

C, 41 포인트 (41 또는 45 자)

32 비트와 64 비트를 모두 사용합니다.

f : Z -> Z(제외 INT_MAX) :

f(n){return (abs(n)%2*2-1)*n+n?(-n<n)*2-1:0;}

포함 할 필요가없는 경우 0일부 문자 (41 자)를 제거 할 수 있습니다.

f : Z -> Z( 0& 제외 INT_MAX) :

f(n){return (abs(n)%2*2-1)*n+(-n<n)*2-1;}

이 함수는 부호와 패리티에 따라 모든 정수를 4 개의 그룹으로 나누는 방식으로 작동합니다.

따라서 4 가지 조합이 있습니다 :

+ even, + odd, - even, - odd

우리는 숫자의 부호를 전환해야하지만 두 번의 통과 후 패리티는 전환하지 않기 때문에 가능한 두 가지 시퀀스가 ​​있습니다.

  + even -> - odd -> - even -> + odd -\
^-------------------------------------/

  + even -> + odd -> - even -> - odd -\
^-------------------------------------/

이 예에서는 첫 번째를 선택했습니다.

먼저 모든 양의 정수를 홀수 음의 정수에 매핑해야합니다. 우리는 부호를 변경하고 숫자를 증가 시켜서이를 수행합니다 (대신 숫자를 줄 이도록 선택할 수도 있습니다).

f1(n) = -n + 1

그런 다음 모든 홀수 음수를 짝수 음수로 매핑해야합니다. 다음을 확인해야합니다 f2(f1(n)) = -n.

f2(f1(n)) = -n
f2(-n + 1) = -n
f2(-n) = -n - 1
f2(n) = n - 1

우리가 찾을 같은 방법을 사용 f3하고 f4:

f3(n) = -n - 1
f4(n) =  n + 1

이러한 함수를 하나의 단일 함수로 결합하기 위해 매번 n부호를 바꾸고 n매번 n양수로 증가하면 1 씩 증가하고 그렇지 않으면 1 씩 감소합니다.

f1(n) = -n + 1 (+ even)
f2(n) =  n - 1 (- odd)
f2(n) = -n - 1 (- even)
f4(n) =  n + 1 (+ odd)

따라서 다음과 같이 다시 작성할 수 있습니다.

f(n) = odd(n) * n + sign(n)

여기서 odd(n)반환 1홀수 및 -1짝수합니다.

총 4 가지 솔루션이 있습니다.

f(n) = odd(n) * n + sign(n)  (edge cases: f(f(0))  -> -2, f(f(INT_MAX))   -> -8)
f(n) = even(n) * n - sign(n) (edge cases: f(f(0))  -> -2, f(f(INT_MIN+1)) -> -6)
f(n) = odd(n) * n - sign(n)  (edge cases: f(f(1))  -> -3, f(f(INT_MIN))   -> -5)
f(n) = even(n) * n + sign(n) (edge cases: f(f(-1)) -> -1, f(f(INT_MIN))   -> -5)

INT_MIN-INT_MIN == INT_MIN=> 로 4 가지 함수 모두에서 항상 대소 문자로 간주 될 수 있습니다 f(f(INT_MIN)) = INT_MIN.

여기 내가 간다.

long f(int i){return i;}
int f(long i){return -i;}

라이브 예 :

int main()
{
  for(int i=-10; i<10; i=i+3)
    std::cout << f(f(i)) << "\n";
}

입력 유형은 필요에 맞게 임의로 조정할 수 있습니다. 이 버전은 2 ^ 32-1보다 작은 크기의 정수 리터럴에 작동합니다.

자바 스크립트, 18

f=n=>n%1?.5-n:n+.5

새로운 지방 화살표 표기법 사용 (Firefox 22).

다른 버전 (18) :

f=n=>n%1?-.5/n:.5/n

이전 버전 (20) :

f=n=>n-~~n?.5-n:n+.5

예:

> [-3,-2,-1,1,2,3].map(f).map(f)
[3, 2, 1, -1, -2, -3]

매스 매 티카 18

f=#+1/2-4#(#-⌊#⌋)&

⌊...⌋바닥 기능은 다음과 같습니다 . 합리적인 숫자 만 사용합니다 (목록, 복소수 등은 아님).

f[10]
f[f[10]]

21/2

-10

f[-5]
f[f[-5]]

-9/2

5

x86 어셈블리 언어 (FASM). 인수와 결과는 eax 레지스터에 있습니다.

-2 ^ 30 <N <+ 2 ^ 30-1에 대해 올바르게 작동합니다

16 바이트 실행 코드

        use32

f_n:
        lea     edx, [2*eax]
        xor     edx, eax
        btc     eax, 30
        shl     edx, 1
        jnc     .end
        neg     eax
.end:
        retn

일반적인 Lisp : 35 바이트

(defun f(x)(/(if(> 1 x)-1/2 1/2)x))

구성표 (및 라켓) : 36 바이트

(define(f x)(/(if(> 1 x)-1/2 1/2)x))

의견과 설명이 담긴 골퍼

(define (f x)
  (/             ;; divide
     (if (> 1 x) ;; if x is below 1 
         -1/2    ;; then -1/2 (the fraction)
         1/2)    ;; else 1/2 (the fraction)
      x))        ;; gets divided with x

어떤 수의 경우 x에 [1,->]는 if분수로 바뀝니다 1/2두 언어의 실제 정확한 숫자입니다.

그런 다음 나누기 부분이 (/ 1/2 x)되어 분수는 1/(x*2)항상 아래에있게됩니다 1. 위해 1가 될 것입니다 1/2위해 2그것의 1/4등

1보다 작은 숫자의 if경우 분수로 바뀌어 -1/2함수가 수행 (/ -1/2 x)하게 -1/(2*x)되지만 이전 실행의 결과 값을 기대할 수 있으므로 x를 1 / (x * 2) 대신 x를 대체하여 이중 응용 프로그램을 만들 수 있습니다-1/((1/(x*2))*2) = -x

예 1를 1/2들어 두 번째 응용 프로그램 으로 바뀌면(/ -1/2 1/2) ==> -1

C, 60 (⌈66 * .9⌉)

int f(int x){if(!x&1||!~x)return ~x;if(x<0)return x-1;return x+1;}

압축되지 않은 버전은 다음과 같습니다.

int f(int x){
    if(!x&1 || !~x) return ~x;
    if(x<0) return x-1;
    return x+1;
}

이 방법은 정수만 사용하므로 90 %의 점수 보너스를받습니다. 원래 Java로 작성했지만이 프로그램은 특히 C 스타일 논리 연산자의 이점을 누릴 수 있음을 깨달았습니다.

에 해당하는 정수가 없기 때문에 -INT_MIN, f(f(INT_MIN))반환 INT_MIN대신.

기본 매핑은 대수적으로 다소 간단합니다. 명령문을 실행하면 x=f(x)x가 다음으로 대체됩니다.

• x+1x긍정적이고 홀수 인 경우
• -x+1, 경우는 x도 긍정적이다
• x-1(IF)는 x네거티브 및 홀수
• -x-1x음수 이면

다음에 함수가 x에 적용될 때 각 경우의 결과는 다음 경우에 해당합니다.

보시다시피, 다음과 같이 사례를 작성하면 결과가됩니다 -x.

이 코드는 2의 보수 정수의 비트 구조를 활용하기 위해 함수를 영리하게 단순화 한 결과입니다.

> <> , 21 + 3 = 24 바이트, 22 포인트

:0)$:0($:1$2%2*-*+-n;

사용 공식 파이썬 인터프리터를 하고 사용하는 -v3 바이트의 비용으로, 입력을 입력 명령 줄 옵션을.

나는 이것이 더 나을 수 있다고 생각한다. 나는 그것을 계속 보면서 골프를 치기 위해 노력할 것이다.

주어진 입력 n, 프로그램 출력

(n>0) - ((n<0) + n * (1 - 2*(n%2)))

경우 (n>0)와는 (n<0)논리 값입니다. 이것은 젤라틴의 파이썬 답변 과 같습니다.

(n>0) - (n<0) - n * (-1)**n

하지만 ><>내장 지수 연산자가 없으므로 (1 - 2*(n%2))대신에 사용 (-1)**n합니다.

다음은 수학 이론입니다. 관심이있는 경우 (만 해당되는 경우에만) 읽으십시오.

어떤 기능을 감안할 f: Z -> Z있도록 f(f(n)) = -n모두 n에서 Z, 우리는 그 즉시 볼 f(f(f(f(n)))) = n, 또는 다른 말로, f^4신원 기능입니다. 특히, f뒤집을 수 없으며 그 역함수는 f^3입니다. 따라서 f의 순열이며 Z, 이후 f^4 = Id모든 궤도 (또는주기)가 다음 것을 f크기 하나 갖고 1, 2, 또는 4.

다음으로, 우리는 그것을 본다 f(0) = 0. 증명 : f(0) = f(-0) = f(f(f(0))) = -f(0)그래서 f(0) = 0, 같은 원했다. 반대로, 가정하자는 x길이의주기에 1또는 2그렇게 f(f(x)) = x. 그런 다음 -x = x이렇게 x = 0.

따라서 f의 고정 점 (1 사이클)을 제외하고는 전체적으로 4 사이클로 구성됩니다 0.

또한, 매 4 사이클의 형식을 가지고 있어야 (x, y, -x, -y)하고, 우리가 그것을 가정 할 수 주변의주기를 돌려 x하고 y모두 긍정적이다. 반대로, 0이 아닌 정수를 분할하는 4주기의 모든 곱은 선택을 결정합니다 f.

따라서, 각각의 선택은 f정점이 양의 정수인 유향 그래프에 유일하게 대응하여, 모든 정점이 정확히 하나의 화살표에 들어 오거나 나가도록한다. 보다 정확하게, 기본 무 방향 그래프에서 모든 정점의 정도는 정확히 1입니다. (각 4 사이클 (x y -x -y)과 x및 y화살표 긍정적 대응 x --> y).

이 응답 (여기 몇몇 다른 응답)의 함수는 그래프에 대응하고 1 --> 2, 3 --> 4그리고 일반적 2k-1 --> 2k.

이러한 그래프 순서쌍 무한 시퀀스 전단 사 함수에 (a_n, p_n)각각, a_n양의 정수이며, 각각은 p_n하나 인 0또는 1시퀀스 주어진 : (a_1, p_1), (a_2, p_2), (a_3, p_3), ...우리 첫번째 쌍 1과 1 + a_1, 그리고, 우리는 화살표 어느 형태 1 --> 1 + a_1또는 화살표 1 + a_1 --> 1여부에 따라 p_1인 0이상 1. 기본적으로 화살표는 의 패리티에 따라 <부호 또는 >부호입니다 p_1.

다음으로, 작은 짝 양의 정수을 k하고부터 카운트 k정확하게, a_2이미 뭔가 짝을 이루는 숫자를 건너 뛰고 단계. k결과와 쌍 을 이루어 p_2위와 같이 화살표의 방향을 설정하십시오 . 그런 다음 (a_3, p_3)등으로 반복하십시오 .

각 화살표는 결국 이런 식으로 결정되므로 프로세스가 잘 정의됩니다. 이 대답의 함수는 (1,0), (1,0), (1,0), ...단계 n에서 가장 작은 짝을 이루지 않은 정수가 무엇 2n-1보다 2n-1짝을 이루는 것보다 큰 정수가 아니기 때문에 sequence에 해당합니다. 따라서 우리 2n-1 --> 2n는 각각에 대해 얻 습니다 n(화살표는 각각 p_n이 같기 때문에이 방향으로 향합니다 0).

이 집합의 카디널리티는이며 (N*2)^N = N^N, 이 답변 의 마지막 단락 2^N에서 실수의 카디널리티 와 같습니다 .

이전 J 답변을 수정하려면 (원본에 의견을 말할만큼 충분한 평판이 없습니다) :

(*+[*1-~2*2|])

그것은 단지를 대체 _1&^와 1-~2*2|]반대의 기호를 준다. 그래서를로 변경 -했습니다 +( 1및 입력에만 중요합니다 _1).

테스트는 다음과 같습니다.

   (*+[*1-~2*2|])6 3 _9 _8 1r2 _4.6 0 1 _1
7 _2 8 _9 1 7.28 0 2 _2
   (*+[*1-~2*2|])7 _2 8 _9 1 7.28 0 2 _2
_6 _3 9 8 0 _10.3568 0 _1 1

   NB. f^:2 = f@:f
   (*+[*1-~2*2|])^:(2)6 3 _9 _8 1r2 _4.6 0 1 _1
_6 _3 9 8 2 _5.0832 0 _1 1

보시다시피 도메인과 범위는 모두 실수이지만 정수 (0 포함)에서만 작동합니다.

설명:

(   *     + [ *  1-~    2*     2|]    )
 signum n + n * pred (twice (n mod 2))

GolfScript ceiling(26*.9)=24

Golfscript는 정수만 처리하므로 Z총 24 포인트 의 보너스를 적용하십시오 .

.{..0>2*(\)2%!2*(@*+}{ }if

특수한 0의 경우 8자를 나타냅니다. 0을 무시하면 17 포인트 답변을 얻을 수 있습니다.

..0>2*(\)2%!2*(@*+

이 코드는 x스택 맨 위의 정수 에 대해 다음을 수행합니다 .

• 경우 x0, 휴가입니다 0스택에 더 이상 규칙을 적용하지 않는다.
• 경우는 x부정도있다 x.
• 경우 x긍정적, 추가 1.
• 경우 x음수, 빼기 1.

이것은 사이클에서 4 개의 숫자 세트를 논리적으로 연결하는데, 사이클의 f요소를 가로 지르며 사이클의 반대쪽 모서리는 서로 음입니다. 모든 정수는 특수한 경우 0을 제외하고 정확히 1주기의 일부입니다. 예를 들면 다음과 {-8, -7, 7, 8}같습니다.

• 7 f -> 8
• 8 f -> -7
• -7 f -> -8
• -8 f -> 7

나는 이상한 부정, 부정도 긍정 홀수, 긍정적 심지어이었다 생각할 수있는 유일한 관련 테스트 케이스 0, 그리고 그때 던졌다 -1과 1의 근접 때문에 0발생했을 수 있습니다 문제 :

[-10 -5 -1 0 1 5 10]
{.{..0>2*(\)2%!2*(@*+}{ }if}:f;
{f f}%
-> [10,5,1,0,-1,-5,-10]

실제 GolfScript가 다소 향상 될 수 있다고 확신합니다. 26자를 차지할 것 같지 않습니다! 몇 가지 제안을 듣고 싶습니다.

그냥 재미로 자바

다음은 odd 와 ℤ² 사이의 실제 bijection을 수행하는 구현입니다. 이는 동시에 홀수 함수입니다 (g (-x) == -g (x)). 해당 ℤ² 요소를 복소수로 취급하고 "i"를 곱한 다음 다시 ℤ로 변환합니다.

f (x) = g⁻¹ (ig (x))
f (f (x)) = g⁻¹ (-g (x)) =-x

이 함수는 O (1)에서 실행됩니다.

public class Ffn {
    public static int f(int n) {
        if (n == 0) {
            return 0;
        }
        // adjust sign
        int s = n > 0 ? 1 : -1;
        int m = n * s;
        // calculate square "radius"
        int r = (int) (Math.sqrt(2 * m - 1) + 1) / 2;
        int q = r * 2;
        // starting point
        int x = r, y = r;
        int k = q * (r - 1) + 1;

        if (m - k < q) {
            // go left
            x -= m - k;
        }
        else {
            // go left
            x -= q;
            // go down
            y -= m - k - q;
        }

        // multiply by i
        int x2 = -y * s, y2 = x * s;
        // adjust sign
        s = y2 < x2 || y2 == x2 && x2 < 0 ? -1 : 1;
        x2 *= s;
        y2 *= s;

        if (y2 == r) {
            // go left
            k += r - x2;
        }
        else {
            // go left and down
            k += q + r - y2;
        }
        return k * s;
    }

    public static void main(final String... args) {
        for (int i = 0; i < 1000000; ++i) {
            if (f(f(i)) != -i || f(f(-i)) != i) {
                System.out.println(i);
            }
        }
    }
}

PS 새해 복 많이 받으세요!

파이썬 3-38

@moose의 답변과 비슷하지만 f(n) == n. 모든 정수 값에 적용됩니다.

f=lambda x:x*(isinstance(x,int)*2.0-1)

Perl, 33 (비 공백)

sub f{($=)=@_;$=-$_[0]?-$=:"$=.1"}

편집하다:

• $=.".1"단축 "$=.1"(ardnew 덕분에).

수학 :

언 골프 드 :

# script.pl
sub f {
  ($=) = @_;   # short for $= = int($_[0]); 
               # "int" is implicit in assignments to $=;
               # ($=) can be prepended by "local" to get
               # the function free of side effects.

  $= - $_[0] ? # short for $= != $_[0], check if input is integer
    -$=        # input is not an integer  
  : $= . ".1"  # input is integer
}  

# Testing
chomp;
$_ = sprintf "f(f($_)) = f(%s) = %s\n", f($_), f(f($_));

예 :

perl -p script.pl
7
f(f(7)) = f(7.1) = -7
2
f(f(2)) = f(2.1) = -2
0
f(f(0)) = f(0.1) = 0
-1
f(f(-1)) = f(-1.1) = 1
-10
f(f(-10)) = f(-10.1) = 10
-1.23
f(f(-1.23)) = f(1) = 1.1
3.4
f(f(3.4)) = f(-3) = -3.1
1.0
f(f(1.0)) = f(1.1) = -1

줄리아, 26

julia> f(n::Int)=n//1
f (generic function with 1 method)
julia> f(n)=int(-n)
f (generic function with 2 methods)
julia> f(f(4))
-4

슈퍼 경쟁은 아니지만 다중 파견에 의존하기 때문에 Julian은 매우 경쟁적입니다. Int 인 경우 Rational을 만들거나 다른 경우 인 경우 빼기 기호가있는 int를 만듭니다. 하나는 이것이 2 개의 함수라고 반대 할 수도 있지만 Julia는이 함수를 두 가지 방법으로 하나의 함수로 간주하며의 유형에 대해 if 문을 사용하여 하나의 함수를 정의하는 것과 같습니다 n.

캔디 , 20 18 바이트

3-> 4-> -3-> -4-> 3 트릭을 사용합니다.

~A2%{|m}1A0>{+|-}.

호출하려면 인터프리터에서 -i 스위치를 사용하십시오.

이중 호출의 예 :

$ candy -i 7 -e '~A2%{|m}1A0>{+|-}.'
program length: 18
>>> 8
$ candy -i 8 -e '~A2%{|m}1A0>{+|-}.'
program length: 18
>>> -7
$ candy -i -7 -e '~A2%{|m}1A0>{+|-}.'
program length: 18
>>> -8
$ candy -i -8 -e '~A2%{|m}1A0>{+|-}.'
program length: 18
>>> 7

긴 형태 :

peekA
pushA
digit2
mod          # even/odd
if
else
  negate     # negate even numbers
endif
digit1
pushA
digit0
greater      # positive/negative
if
  add        # add two numbers from stack (original stack value, and delta)
else
  sub        # diff two numbers from stack (original stack value, and delta)
endif
retSub

Dyalog APL, 9 포인트

×-⍨⊢ׯ1*⊢

소스는 9 바이트 길이이며 보너스를받을 자격이 있습니다 (아무 도움이되지 않음). 또한 상단 SO 답변의 수식을 사용합니다.

파이썬 : 32 바이트 (29 포인트)

f : Z-> Z

f=lambda n:(n>0)-(n<0)-n*(-1)**n

Ben Reich의 방법을 사용합니다.

GTB , 22

@S;N,"--$x?N)→N~N#~-N&

자바, 113 바이트

접근 방식은 매우 간단합니다. 예상보다 많은 바이트가 생겼지 만 약간 다운 될 수 있습니다.

public class F{public static int f(int x){if(x<0)x+=-2147483647-++x;x+=1073741824;return x<0?-2147483647-++x:x;}

기본적으로 자바는 변수를 감쌀 수 있다는 사실을 이용하여 x의 4 가지 "영역"을 만듭니다. 음수에 대한 까다로운 변환을 수행해야했기 때문에 예상보다 큰 결과를 냈습니다.

-2147483648 이외의 모든 x에서 작동합니다.

골프 스크립트 답변과 동일한 일련의 숫자 (3, 4, -3, -4, 3 ...)이지만 perl (공백 제거 후 42 문자)로 구현됩니다.

sub f{($_[0]%2?1:-1)*$_[0]+($_[0]<0?-1:1)}

더 읽기 :

sub f { ($_[0] % 2 ? $_[0] : -$_[0] ) + ( $_[0] < 0 ? -1 : 1 ) }

또는 훨씬 더 명확하게 :

sub f {
  my $n = shift;
  my $sign = $n >= 0 ? 1 : -1;
  # note that in perl $n % 2 is the same as int($n) % 2
  if( $n % 2 ) {
    # odd: add one to magnitude
    return $n + $sign
  } else {
    # even: subtract one from magnitude then invert
    return -($n - $sign)
  }
}

산출:

ski@anito:~/mysrc/.../acme$ echo 3 | perl -e 'sub f{($_[0]%2?1:-1)*$_[0] + ($_[0]<0?-1:1)}; my $x = <>; for(0..10) { print "$_: $x\n"; $x = f($x); }'
0: 3
1: 4
2: -3
3: -4
4: 3
5: 4
6: -3
7: -4
8: 3
9: 4
10: -3

Sed, 25 바이트

|sed s/0+/0-/|sed s/^/0+/

용법:

$ echo 1.23 |sed s/0+/0-/|sed s/^/0+/
0+1.23
$ echo 0+1.23 |sed s/0+/0-/|sed s/^/0+/
0+0-1.23

Matlab, 26 자

f=@(n) (n<0)-(n<0)-n*(-1)^n

C ++- 63 55.8

코드는 다음과 같습니다.

int f(int n){return (n&45056?n^45056:n|45056)*(n&45056?-1:1);}

패스를 추적하기 위해 해당 값을 사용하기 때문에 네 번째 바이트가 0xB와 같은 정수에서는 작동하지 않습니다. 그렇지 않으면 0을 포함하여 Z의 모든 멤버에서 작동합니다.

Synthetica에서 제공하는 기능으로 업데이트 됨

언어 : 파이썬

문자 수 : 공백을 포함하여 41

f=lambda x:-float(x) if str(x)==x else`x`

프롤로그, 36 바이트

암호:

X*Y:-X//1=:=X,Y is 0.5+X;Y is 0.5-X.

설명 :

Dyadic predicate which converts integers to floats and floats back to negated integers.

예:

10*X.
X = 10.5

10*Y,Y*X.
X = -10,
Y = 10.5

자바 스크립트 ES6, 27 26 바이트

a=>a%1?-Math.floor(a):a+.2

Mouse-2002 , 21 19 12 바이트

$A1%[1%_|1%]

함수를 정의합니다 A. 다음과 같이 호출하십시오 #A,#A,?;;(사용자가 숫자를 입력 할 때까지 기다립니다). 또는 숫자가있는 #A,#A,n;;곳 처럼 호출하십시오 n.

줄리아, 21

f(x)=(1-2(1>x>-1))/2x

그때

julia> f(f(12//1))
-12//1

p // q는 julia의 합리적인 숫자 표기법입니다.