정의

• a(0) = 0
• a(n) = n-a(a(a(n-1))) 정수 n > 0

직무

음이 아닌 정수가 주어지면 noutput a(n).

테스트 케이스

n     a(n)
0     0
1     1
2     1
3     2
4     3
5     4
6     4
7     5
8     5
9     6
10    7
11    7
12    8
13    9
14    10
15    10
16    11
17    12
18    13
19    13
20    14
10000 6823

참고 문헌

• WolframMathWorld
• OEIS A005374

하스켈, 23 22 바이트

f 0=0
f n=n-f(f$f$n-1)

단순히 시퀀스의 정의를 사용합니다. f(f$f$n-1)와 같습니다 f (f (f (n-1))).

테스트:

main = putStrLn . show $ map f [0..20]
-- => [0,1,1,2,3,4,4,5,5,6,7,7,8,9,10,10,11,12,13,13,14]

덕분에 바이트에 대한 Anders Kaseorg 에게 !

젤리 , 8 바이트

’ßßßạµṠ¡

온라인으로 사용해보십시오!또는 더 작은 테스트 사례를 확인하십시오 .

작동 원리

’ßßßạµṠ¡  Main link. Argument: n

     µṠ¡  Execute the preceding chain sign(n) times.
’         Decrement n, yielding n - 1.
 ßßß      Recursively call the main link thrice.
    ạ     Take the absolute difference of n and the result.

Mathematica, 20 바이트

바이트 수는 ISO 8859-1 (또는 호환) 인코딩을 가정 $CharacterEncoding하고 Windows 기본값과 같이 일치하는 값으로 설정 WindowsANSI됩니다.

±0=0
±n_:=n-±±±(n-1)

단항 연산자를 정의합니다 ±.

J, 14 12 바이트

-$:^:3@<:^:*

@ Leaky Nun 덕분에 2 바이트 절약 .

재귀 때 자신을 호출하여 그 결과를 계산 N 에> 0 세번 N -1으로부터 감산 결과 N을 . n = 0 일 때 기본 경우에 대해 다른 상황 이 있습니다 . 0과 동일한 n - n 을 계산합니다 .

a(n) = n - n = 0           if n = 0
       n - a(a(a(n-1)))    if n > 0

여기에서 시도하십시오.

설명

-$:^:3@<:^:*  Input: n
           *  Get the sign of n (n = 0 => 0, n > 0 => 1)
         ^:   Execute that many times
                (0 times means it will just be an identity function)
       <:       Decrement n
 $:             Call itself recursively
   ^:3          three times
      @         on n-1
-             Subtract that result from n and return

줄리아, 16 바이트

!n=n>0&&n-!!!~-n

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

작동 원리

우리는 !목적에 맞게 단항 연산자 를 재정의합니다 .

경우 N = 0 , 비교 n>0반환 거짓 과 그렇게 !.

그렇지 않으면 이후 코드 &&가 실행됩니다. ~-n는 (n-1)2의 보수 와 같 으며 n-1 에서 !!!재귀 적으로 !3을 호출 하고 결과 값은 n 에서 뺍니다 .

파이썬, 31 바이트

a=lambda n:n and n-a(a(a(n-1)))

재귀 제한과 시간 제약으로 인해 위의 기능은 비실용적이지만 이론적으로는 작동해야합니다 (작은 n에서는 작동합니다).

자바 스크립트 (ES6), 52 바이트

n=>[0,...Array(n)].reduce((p,_,i,a)=>a[i]=i-a[a[p]])

나는 지루하고 재귀 버전을 작성할 수 있었지만이 버전은 훨씬 빠릅니다 (마지막 테스트 사례에 쉽게 대처할 reduce수 있음).

망막 , 49 43 바이트

.+
$*1:
{`^1(1*):
$1:::-1$1
}`^:*(1*)-\1

1

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

CJam, 13 12 바이트

1 바이트를 절약 해 준 Dennis에게 감사합니다.

ri0{_(jjj-}j

여기에서 테스트하십시오.

R, 42 41 바이트

a=function(n)ifelse(n<1,0,n-a(a(a(n-1))))

용법:

> a(1)
1
> a(10)
7

이 재귀 적 접근 방식은 더 큰 값에 n대해서는 잘 확장되지 않습니다 .

오아시스 , 6 바이트

암호:

nbaa-0

확장 버전 :

a(n) = nbaa-
a(0) = 0

암호:

n      # Push n
 b     # Calculate a(n - 1)
  a    # Calculate a(a(n - 1))
   a   # Calculate a(a(a(n - 1)))
    -  # Subtract a(a(a(n - 1))) from n

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

Sesos , 58 55 바이트

0000000: 16e0d7 bdcdf8 8cdf1b e6cfbb 840d3f bf659b 38e187  ..............?.e.8..
0000015: f8639b 39dc37 fc893f 666c05 7e7ed9 b88b3f ae0d3f  .c.9.7..?fl.~~...?..?
000002a: 676ed8 bd9940 7fdc3b 36619e f1                    gn...@..;6a..

최대 400 개의 입력을 합리적으로 잘 처리 하지만이 시점 이후에는 런타임이 크게 증가합니다.

온라인으로 사용해보십시오! 확인 디버그를 생성 sbin에 코드를 볼 수 있습니다.

Sesos 어셈블리

위의 바이너리 파일은 다음 SASM 코드를 조합하여 생성되었습니다.

set numin, set numout

get
jmp
    jmp
        rwd 3, add 1, rwd 1, add 1, fwd 4, sub 1
    jnz
    rwd 3, sub 1
jnz
rwd 3, add 1, fwd 2
jmp
    rwd 1, sub 1, fwd 3, sub 1, fwd 2, add 3
    jmp
        rwd 2
        jmp
            rwd 3
        jnz
        fwd 6, get, rwd 4, sub 1
        jmp
            fwd 1, sub 1
            jmp
                rwd 3
            jnz
            sub 1
            jmp
                fwd 3
            jnz
            rwd 4, sub 1
        jnz
        fwd 1
        jmp
            rwd 1, add 1, fwd 1, add 1
        jnz
        sub 1, fwd 3, sub 1
        jmp
            fwd 3
        jnz
        rwd 1, sub 1
    jnz
    rwd 2, get
    nop
        rwd 3
    jnz
    fwd 3, get, rwd 2
    jmp
        fwd 2, add 1
        jmp
            fwd 3
        jnz
        rwd 1, add 1, rwd 2
        jmp
            rwd 3
        jnz
        fwd 1, sub 1
    jnz
    fwd 2
    jmp
        rwd 2, add 1, fwd 2, sub 1
    jnz
    nop
        get, fwd 3
    jnz
    rwd 1, add 1, fwd 2
jnz
rwd 2, sub 1
jmp
    rwd 1, sub 1, fwd 1, sub 1
jnz
rwd 1, put

LISP, 61 바이트

(defun H(N)(if(= N 0)(return-from H 0)(- N(H(H(H(- N 1)))))))

아마도 최적의 솔루션은 아니지만 작동합니다.

자바 7, 42 바이트

int c(int n){return n>0?n-c(c(c(n-1))):0;}

언 골프 및 테스트 사례 :

여기에서 시도하십시오.

class Main{
  static int c(int n){
    return n > 0
              ? n - c(c(c(n-1)))
              : 0;
  }

  public static void main(String[] a){
    for(int i = 0; i < 21; i++){
      System.out.println(i + ": " + c(i));
    }
    System.out.println("1000: " + c(1000));
  }
}

산출:

0: 0
1: 1
2: 1
3: 2
4: 3
5: 4
6: 4
7: 5
8: 5
9: 6
10: 7
11: 7
12: 8
13: 9
14: 10
15: 10
16: 11
17: 12
18: 13
19: 13
20: 14
 (last case takes too long..)

루비, 27 바이트

명백한 구현.

a=->n{n<1?0:n-a[a[a[n-1]]]}

이것은 순서에서 이전 항목을 캐시하는 더 길고 빠른 답변입니다. 두 가지 답변 모두 1.9 이후 버전에서만 작동합니다 ->.

->n{r=[0];i=0;(i+=1;r<<i-r[r[r[i-1]]])while i<n;r[n]}

C #, 35 바이트

int a(int n)=>n>0?n-a(a(a(n-1))):0;

골프 스크립트, 26 25 바이트

~ [0] {...., (=== \., @-+} @ *) \;
~ [0] {...) \; == \., @-+} @ *) \;

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

로컬로 100000.5 초 미만이 소요됩니다.

씨, 35 32 바이트

@PeterTaylor 덕분에 3 바이트가 절약되었습니다!

a(n){return n?n-a(a(a(n-1))):0;}

Ideone에서 사용해보십시오!

자바 스크립트 ES6, 22 바이트

a=n=>n&&n-a(a(a(n-1)))

나는 지루하고 재귀 버전을 할 것이다 : P

VBA, 69 바이트

Function H(N):ReDim G(N):For j=1To N:G(j)=j-G(G(G(j-1))):Next:H=G(N)

테스트 세트에서 눈을 깜박이게하고 n = 1000000보다 약간 느리게하고 n = 2 천 5 백만보다 약간 작은 메모리 월로 들어갑니다.

Pyth, 10 바이트

L-WbbyFtb3

함수를 정의합니다 y. 온라인으로 사용해보십시오 : 데모

이것은 Pyth의 상대적으로 새로운 기능을 사용합니다. fold-syntax를 사용하여 함수를 여러 번 적용 할 수 있습니다. 실제로 바이트를 저장하지는 않고 데모 목적으로 만 사용했습니다.

설명:

L-WbbyFtb3
L            define function y(b), that returns:
    b           b
 -Wb            and subtract the following if b>0
     yF  3      y applied three times to
       tb       b - 1

메이플, 28 26 바이트

`if`(n=0,0,n-a(a(a(n-1))))

용법:

> a:=n->ifelse(n=0,0,n-a(a(a(n-1))));
> seq(a(i),i=0..10);
0, 1, 1, 2, 3, 4, 4, 5, 5, 6, 7

dc, 34 바이트

dsn[zdddd1-;a;a;a-r:aln!=L]dsLx;ap

스택 맨 위에서 입력을 가져옵니다. 스택 깊이는 카운터로 사용되므로 스택에서 유일한 항목이어야합니다. 사용 예 :

$ dc
10000dsn[zdddd1-;a;a;a-r:aln!=L]dsLx;ap

이것은 시퀀스 정의를 상당히 간단하게 구현 한 것입니다.

dsn               # Store n as `n', and keep a copy as a depth buffer (see below)
[                 # Open loop definition
 z                # Push stack depth i for i-th term
 dddd             # Duplicate stack depth four times, for a total of five copies
 1-               # Get i-1 for use as index to previous term
                  #   Note that if we hadn't duplicated n above, or left something else
                  #   on the stack, 0-1 would be -1, which is not a valid array index
 ;a;a;a           # Fetch a(a(a(i-1)))
 -                # Calculate i-a(a(a(i-1)))
 r                # Arrange stack to store i-th term: TOS |  i  (i-a(a(a(i-1))))
 :a               # Store i-th term in array `a'
 ln!=L            # Load n. If n!=i, we're not done calculating terms yet, so execute loop
]                 # Close loop definition. Note that we started with five copies of i:
                  #   i-1 was used to get last term
                  #   i-a(...) was used to calculate current term
                  #   ... i :a was used to store current term
                  #   i ln !=L was used to check loop exit condition
                  # One copy of i is left on the stack to increment counter
dsLx              # Duplicate loop macro, store it, and execute copy
;a                # Last i stored on stack from loop will equal n, so use this to get a(n)
p                 # Print a(n)

어쨌든, 그것은 간단하게 시작되었습니다 ... 그런 다음 골프가 발생했습니다.

공통 리스프 , 44 바이트

(defun f(x)(if(= x 0)0(- x(f(f(f(1- x)))))))

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

C ++ (주로 MSVC)

일반 버전 : 40 바이트

int a(int n){return n?n-a(a(a(n-1))):0;}

템플릿 메타 프로그래밍 버전 : 130 바이트

#define C {constexpr static int a(){return
template<int N>struct H C N-H<H<H<N-1>::a()>::a()>::a();}};template<>struct H<0>C 0;}};

사용법 :

std::cout << a(20) << '\n';       // Normal version
std::cout << H<20>::a() << '\n';  // Template version

템플릿 버전은 가장 빠른 코드입니다. 최적화로 값을 레지스터 =>로 옮기는 것보다 빠르지 않기 때문에 다음과 H<20>::a()같이 컴파일하십시오.

mov esi, 14

10000의 경우 스택 오버플로 오류로 인해 재귀 버전이 충돌하고 템플릿 인스턴스화 깊이로 인해 컴파일시 템플릿 버전이 충돌합니다. GCC는 900으로 간다 (614)

D , 36 바이트

T a(T)(T n){return n?n---n.a.a.a:0;}

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

APL (Dyalog Unicode) , 18 17 바이트

{⍵=0:0⋄⍵-∇⍣3⊢⍵-1}

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

놀랍게도이 도전에 대한 APL 답변은 없습니다. 이것은 OP에서 함수의 리터럴 구현입니다.

에 대한 TIO 시간 초과 $n>90$.

@ Zacharý 덕분에 바이트를 저장했습니다.

파이썬 3, 72 바이트

def f(n):
    a=[0];i=0
    while n:i+=1;a+=[i-a[a[a[i-i]]]];n-=1
    return a[i]

무시 했어!

PowerShell v2 +, 56 바이트

$a={$n=$args[0];if($n){$n-(&$a(&$a(&$a($n-1))))}else{0}}

재귀 정의를 형성하기위한 람다에 해당하는 PowerShell입니다. &호출 연산자 를 통해 실행하십시오 ( 예 :) &$a(5). 오래 걸린다실행 시간50 내 컴퓨터에 (기가 바이트 RAM과 최근 I5) 약 90 초 정도 걸립니다.

더 빠른 반복 솔루션, 59 바이트

param($n)$o=,0;1..$n|%{$o+=$_-$o[$o[$o[$_-1]]]};$o[-1]*!!$n

입력을 고려해야하기 때문에 더 길어집니다 0( *!!$n끝에 있습니다). 그렇지 않으면 우리는 반복적으로 배열을 구성하여 $n매번 새로운 요소를 추가하고 마지막에 마지막 요소를 출력합니다 $o[-1]. 초고속- 10000내 컴퓨터에서 계산 하는 데 약 5 초가 걸립니다.

> <> , 55 + 2 = 57 바이트

^~n;
.~-]{:0$
v>1-}32[
v/  /:1-32[
>$:?/$~]{:0$.
/30@2[

프로그램 시작시 입력이 스택에있을 것으로 예상되므로 -v플래그의 경우 +2 바이트입니다 . 온라인으로 사용해보십시오!

재귀를 사용하여 결과를 계산하므로 이는 매우 느립니다. TIO를 사용하면 h(50)1 분 이상 걸립니다. 올바른 결과 <= 30을 반환하므로 작동 할 것이라고 확신합니다. h(10000)실행하기 위해 실행하지 않았습니다!