0. 정의

순서 번호의 목록입니다. 일련 번호 목록의 합계입니다. 자연수 세트 에는 "0보다 큰 음이 아닌 정수"가 모두 포함됩니다. 제수 자연수의 (이 상황에서) j는 자연수 I ,되도록 J ÷ 전 또한 자연수이다.

1. 머리말

이 사이트의 다른 몇 가지 질문은 일정량의 개념, 또는 자연수의 약수의 순서 언급 미만이다 을 . 우호적 인 숫자 를 결정 하는 데는 분주 합계 또는 분취 시리즈라고하는 이러한 제수의 합계를 계산해야합니다. 모든 자연수에는 고유 한 분취 액이 있지만 숫자의 분취 액의 값이 반드시 해당 숫자에 고유하지는 않습니다. ( 예시 gratia , 모든 소수는 1의 몫의 합 을가집니다 .)

2. 도전

자연수가 주어지면, 분취 량의 시퀀스의 자리수를 n돌려줍니다 n. 1의 시리즈부터 시작하여 시퀀스의 처음 몇 시리즈는 다음과 같습니다.

{0, 1, 1, 3, 1, 6, 1, 7, 4, 8, 1, 16, 1, 10, 9, 15, 1, 21, 1, 22, 11, 14, 1, 36, 6, 16, 13}

연결하면 다음과 같습니다.

0113161748116110915121122111413661613

선호도에 따라 입력 값이 0 또는 1 색인 일 수 있습니다. 솔루션은 10,000 번째 숫자 ( 9999또는 최대 입력)를 반환 할 수있는 프로그램 또는 기능이어야합니다 10000. 가장 짧은 작업 솔루션이 승리합니다.

3. 테스트 사례

올바른 입출력 쌍에는 다음이 포함 되나 이에 국한되지 않습니다.

   0 or     1    ->    0
   4 or     5    ->    1
  12 or    13    ->    6
9999 or 10000    ->    7

"또는"앞의 숫자는 0 색인입니다. 다음 숫자는 1 색인입니다.
요청에 따라 추가 테스트 사례가 제공 될 수 있습니다.

4. 참조

OEIS에는 숫자 목록 과 그에 따른 분취 액이 있습니다.

05AB1E , 14 11 10 바이트

약 15 초 안에 n = 9999를 계산합니다. 암호:

ÌL€Ñ€¨OJ¹è

설명:

Ì           # Increment implicit input by 2
 L          # Generate the list [1 .. input + 2]
  ۄ        # For each, get the divisors
    ۬      # For each, pop the last one out
      O     # Sum all the arrays in the array
       J    # Join them all together
        ¹è  # Get the nth element

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오! .

수학, 51 바이트

Array[##&@@IntegerDigits[Tr@Divisors@#-#]&,#][[#]]&

정수를 가져 와서 반환하고 1 기반 색인을 사용하는 명명되지 않은 함수입니다. 입력을 10000즉시 처리합니다 .

설명

이것은 첫 번째 n제수 합이 항상 n숫자 를 결정하기에 충분 하다는 사실을 이용하여 정의를 매우 간단하게 구현합니다 . 평소와 같이 골프 Mathematica의 읽기 순서는 약간 재미 있습니다.

Array[...&,#]...&

이것은 모든 왼쪽의 값을 명명 함수를 적용한 결과 모두와리스트 생성 i에서 1에 n포함한다.

...Tr@Divisors@#-#...

우리는의 제수를 계산하고 i그것들을 Tr더하고 빼서 i제수보다 작은 제수의 합으로 시작 i합니다.

...IntegerDigits[...]...

결과가 10 진수 목록으로 바뀝니다.

##&@@...

이렇게하면 "목록"헤드가 제거되어 모든 숫자 목록이 자동으로 결과로 연결됩니다 Array. ##작동 방식 에 대한 자세한 내용 은이 게시물의 "인수 순서"섹션 을 참조하십시오 .

...[[#]]

마지막으로 n결과에서 숫자를 선택합니다 .

Brachylog , 40 바이트

:2-I,?:?:1yrc:Im.;0.
:1e:2f+.
>.>0,?:.%0

이 인덱스는 1- 인덱스이며 약 0.15 초 N = 100,에 15 초가 걸립니다 N = 1000. 현재에 대해 실행 중입니다 N = 10000. 실행이 끝나면 한 번보고합니다 (추정이 정확하면 약 8 시간이 소요됨)

편집 : Brachylog에서 조기 제약 조건 전파를 수정하면 코드가 3 바이트 이상 걸리는 데 2.5몇 분이 걸리지 10000만 out of global stack오류가 반환 됩니다.

설명

• 주요 술어 : Input = N

  :2-I,                 I = N - 2
       ?:?:1y           Find the N first valid outputs of predicate 1 with input N
             rc         Reverse and concatenate into a single number
               :Im.     Output is the Ith digit of that number
                   ;    Or (I strictly less than 0)
                    0.  Output is 0
  

• 술어 1 : 제수의 합을 계산합니다.

  :1e                   Get a number between N and 1
     :2f                Find all valid outputs of predicate 2 with that number as input
        +.              Output is the sum of those outputs
  

• 술어 2 : 입력의 제수로 출력을 통합합니다.

  >.>0,                 Output is a number between Input and 0
       ?:.%0            Input is divisible by Output
  

Pyth, 26 21 20 15 바이트

@sm`sf!%dTtUdSh

온라인으로 사용해보십시오. 테스트 스위트.

0 기반 인덱싱을 사용합니다. 이 프로그램은 O (n²)이며 2008 년 컴퓨터에서 약 14 분 동안 n = 9999 동안 완료됩니다 .

젤리, 13 11 10 바이트

@Adnan 덕분에 2 바이트, @Dennis 덕분에 1 바이트 더.

ÆDṖSDµ€Fị@

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

1 기반 인덱싱을 사용합니다. 대한을 완료 N 온라인 이초 아래에서 = 10000.

PHP, 90 바이트

0 인덱스

<?php for(;strlen($s)<=$a=$argv[1];$s.=$n)for($n=0,$j=++$i;--$j;)$i%$j||$n+=$j;echo$s[$a];

절대적으로 미묘하거나 전혀 접근하지 않는 영리한 방법은 아닙니다.
또한 평소와 같이 무시되는 세 가지 알림이 생성됩니다.

J , 34 바이트

{[:;1<@":@(-~>:@#.~/.~&.q:)@+i.@>:

이것은 인덱스가 0이며 아래 수식을 사용하여 제수 합을 계산합니다.

설명

{[:;1<@":@(-~>:@#.~/.~&.q:)@+i.@>:  Input: n
                                >:  Increment n
                             i.@    Create the range [0, 1, ..., n]
    1                       +       Add one to each to get [1, 2, ..., n+1]
          (               )@        For each value
                        q:            Get the prime factors
                   /.~&.              For each group of equal prime factors
                #.~                     Raise the first to the first power, the second
                                        squared and so on, and sum them
             >:@                        Increment that sum
                      &.q:            Reduce the groups using multiplication
           -~                         Subtract the initial value from that sum
       ":@                            Convert each to a string
     <@                               Box each
 [:;                                Unbox each and concatenate the strings
{                                   Select the character from that string at index n
                                    and return it

MATL , 16 15 바이트

:"@@q:\~fsV]vG)

인덱싱은 1 기반입니다.

마지막 테스트 사례는 온라인 컴파일러에서 시간 초과되지만 약 15 초 안에 오프라인 컴파일러에서 올바른 결과를 제공합니다.

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

:         % Take input n. Push [1 2 ... n]
"         % For each k in [1 2 ... n]
  @       %   Push k
  @q:     %   Push [1 2 ... k-1]
  \       %   Modulo. Zero values correspond to divisors
  ~f      %   Indices of zeros. These are the divisors
  s       %   Sum
  V       %   Convert to string
]         % End for each
v         % Concatenate all stack contents vertically
G)        % Take n-th digit. Implicitly display

하스켈, 52 바이트

(([1..]>>= \n->show$sum[m|m<-[1..n-1],mod n m<1])!!)

사용 예 : (([1..]>>= \n->show$sum[m|m<-[1..n-1],mod n m<1])!!) 12->6 .

그것은 정의의 직접적인 구현입니다 : foreach n합계는 제수이며 문자열로 변환합니다. 이러한 모든 문자열을 연결하고 요청 된 인덱스에서 요소를 선택하십시오. Haskell의 게으름은 필요한만큼 n무한 목록에서 가져옵니다 [1..].

파이썬 3.5, 103 93 92 바이트 :

R=range;A=lambda f:''.join([str(sum([j for j in R(1,i)if i/j%1==0]))for i in R(1,f+1)])[f-1]

포스트에 설명 된 방법의 매우 간단한 구현.

온라인으로 사용해보십시오! (아이디어)

온라인 컴파일러에서 할당 된 5 초 이내에 input을 10000끝내지 않지만 약 8.5 초 내에 동일한 입력을 위해 내 컴퓨터에서 완료됩니다.

옥타브, 71 바이트

이것은 옥타브 전용입니다. MATLAB에서는 작동하지 않습니다. 1- 인덱싱 된 숫자에서 작동하는 가상 함수가 생성됩니다. 아마도 조금 더 단순화 될 수 있습니다. 오늘 저녁 좀 봐

@(x)c((c=num2str(arrayfun(@(n)sum(b(~rem(n,b=(1:n-1)))),1:x)))~=' ')(x)

여기서 온라인으로 시도 할 수 있습니다 .

접두사 a=또는 무엇이든 (여러 번 사용할 수 있도록) 위의 명령을 실행 한 다음 수행하십시오 a(10000). 10000 번째 자릿수가 7이라고 계산하는 데 약 7 초가 걸립니다.

자바 8, 220 바이트

import java.util.stream.IntStream;
char a(int n){return IntStream.range(1,n+2).map(i->IntStream.range(1,i).filter(k->i%k==0).sum()).mapToObj(Integer::toString).collect(java.util.stream.Collectors.joining("")).charAt(n);}

글쎄, 적어도 빠릅니다. 내 컴퓨터에서 9999/10000 번째 요소를 얻는 데 평균 0.3 초가 걸립니다. 지정한 인덱스 수만큼 분취 량 합계 만 생성합니다. 이는 일부 aliquots 합계가 2 자리 이상의 숫자를 갖기 때문에 대부분의 경우 문자열이 색인보다 약간 길다는 것을 의미하지만 대부분의 경우 필요한만큼 긴 문자열 만 생성합니다.

용법:

public static void main(String[] args) {
    System.out.println(a(0));
    System.out.println(a(4));
    System.out.println(a(12));
    System.out.println(a(9999));
}

언 골프 드 :

public static void main(String[] args) {
    System.out.println(all(0));
    System.out.println(all(4));
    System.out.println(all(12));
    System.out.println(all(9999));
}

static int aliquotSum(int n) {
    return IntStream.range(1, n).filter(k -> n % k == 0).sum();
}

static IntStream sums(int n) {
    return IntStream.range(1, n + 2).map(i -> aliquotSum(i));
}

static String arraycat(IntStream a) {
    return a.mapToObj(Integer::toString).collect(java.util.stream.Collectors.joining(""));
}

static char all(int index) {
    return arraycat(sums(index)).charAt(index);
}