양의 정수의 디지털 근 (반복 된 디지털 합)은 숫자 합을 계산하기 위해 이전 반복의 결과를 사용하여 각 반복에서 합산 ​​숫자의 반복 프로세스에 의해 얻은 (한 자릿수) 값입니다. 한 자리 숫자에 도달 할 때까지 프로세스가 계속됩니다.

예를 들어, 루트의 디지털 65536 이다 7 때문에 6 + 5 + 5 + 3 + 6 = 25 및 2 + 5 = 7 .

모든 디지털 근을 정렬하는 것은 많은 수의 1 초로 시작하기 때문에별로 의미가 없습니다 .

대신, 모든 단일 자릿수 정수와 함께 디지털 뿌리, 그런 다음 모든 두 자리 수와 함께 디지털 뿌리, 삼중, 사중 등의 목록을 작성합니다.

이제 각 목록에 대해 디지털 뿌리가 1 인 모든 정수가 먼저 나타난 다음 디지털 뿌리가 2 인 모든 정수 등이 나타나 도록 정렬합니다 . 정렬은 안정적이므로 특정 디지털 뿌리를 가진 정수 목록은 정렬 후 오름차순이어야합니다.

마지막으로 이러한 목록을 하나의 단일 시퀀스로 연결합니다. 이 순서는 모든 한 자리 숫자, 모든 두 자리 숫자 (디지털 루트로 정렬), 모든 세 자리 숫자 등으로 시작합니다.

도전:

양의 정수 n 을 입력으로 취하여 위에서 설명한 순서로 n 번째 숫자를 출력하십시오 . 목록이 0- 인덱스 중 1- 인덱스 인지를 선택할 수 있습니다 .

순서는 다음과 같습니다.

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 19, 28, 37, 46, 55, 64, 73, 82, 91, 11, 20, 29 ... 
72, 81, 90, 99, 100, 109, 118, ... 
981, 990, 999, 1000, 1009, 1018, 1027, ...

테스트 사례 :

테스트 사례는 1- 색인입니다.

   n   f(n)  
   9      9
  10     10
  11     19
  40     13
  41     22
  42     31
  43     40
  44     49
  45     58
 600    105
 601    114
 602    123
 603    132
 604    141
 605    150
4050   1453
4051   1462
4052   1471
4053   1480
4054   1489
4055   1498

더 쉽게 복사 :

n =    9, 10, 11, 40, 41, 42, 43, 44, 45, 600, 601, 602, 603, 604, 605, 4050, 4051, 4052, 4053, 4054, 4055, 
f(n) = 9, 10, 19, 13, 22, 31, 40, 49, 58, 105, 114, 123, 132, 141, 150, 1453, 1462, 1471, 1480, 1489, 1498

설명 :

• n 개의 첫 번째 요소를 모두 출력하지 못할 수 있습니다 . n 번째 만 출력해야합니다 .
• 코드는 이론적으로 최대 10 ^ 9 까지의 모든 정수에 대해 작동해야 하지만 999 보다 큰 입력에 대해 TIO (또는 시간 제한이있는 다른 인터프리터)에서 시간 초과되면 괜찮습니다 .
• 설명이 권장됩니다.

그것은의 코드 골프 , 각 언어 승리의 짧은 코드 그래서! 당신이 관리 할 수있는 것보다 짧은 경우라도 골프를 치고 싶은 언어로 된 다른 솔루션에 낙심하지 마십시오!

파이썬 2 , _{78 60 52 46} 45 바이트

GB 덕분에 -6 바이트 . Jakob
덕분에 -1 바이트 .

n=input()
b=10**~-len(`n`)
print~-b+n/b+n%b*9

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

마지막으로 1- 인덱싱 된 닫힌 양식에 도달했습니다.

파이썬 2 , 78 바이트

인덱스가 0입니다.

d=10;k=1
exec'\nk+=9\nif k>d+7:k=d;d*=10\nif k>=d:k-=d/10*9-1'*input()
print k

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

파이썬 3 , 80 바이트

f=lambda i,k=1:k>i and sorted(range(k//10,k),key=lambda n:n%-9)[i-k]or f(i,k*10)

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

1- 색인. 이것은 Python 3에서 관리 할 수있는 최선입니다 ( 아래의 Python 2 솔루션 포트 인 78-byter 제외 ). 이것은 훨씬 더 시원하다고 생각합니다. 파이썬 2 풀 프로그램은 파이썬 3에서 input()변환이 필요하고 int(+5 바이트), exec명령문 (+2 바이트)이 아니라 함수이며 /인수가 정수인 경우 기본적으로 정수 나누기를 수행 하기 때문에이 특정 문제에 유리 합니다. Py 2 (+1 byte)이므로 ovs의 answer 포팅보다 확실히 짧 습니다 .

작동 원리

설정

f=lambda i,k=1:k>i and ... or f(i,k*10)

이것은 하나의 정수 인수 i 와 다른 하나의 인수 k 를 취하는 재귀 함수 f 를 정의하며 기본값은 1 입니다. 반면 k는 ≤ 나 함수 F 복귀 F (I, 10K)을 곱하고 K를 하여 10 마다하면 그 이상이 될 때까지 I .

대상 범위 및 올바른 색인 생성

...range(k//10,k)...[i-k]

이 동작 설정 한 후, 우리는 남아있는 I , 초기 입력 및 변수 K 의 최소 전력 나타내는 10 보다 큰 I를 . 이런 식으로, 우리는 (정수) 범위 [floor (k / 10), k) 를 생성 할 수 있으며 , 기본적으로

• 10 의 최대 거듭 제곱 보다 크거나 같음 i 보다 작거나 같음
• k 보다 작고 i 보다 10 의 가장 작은 거듭 제곱

x = floor (k / 10) 보다 작은 정수를 무시하기 때문에 누락 된 숫자를 설명하도록 인덱싱을 이동해야합니다. 명백한 방법은 i 에서 개수 x 를 빼서 목록에 색인화하여 (아래에 설명 된 정렬 후) ix가되도록하는 것 입니다. 리스트가 포함되어 있기 때문에, 9K / 10 인덱스의리스트에서 항목을 인덱싱 -y 긍정적 대한 예를 수율 (Y)을 ^제 파이썬 끝에서 요소를 이것과 인덱싱 단순히 동등 IK , 따라서, 4 바이트를 저장.

디지털 루트 별로 각 청크 정렬

sorted(...,key=lambda n:n%-9)

디지털 루트 함수의 공식은 1 + ((n-1) mod 9)입니다 ( 이 Wikipedia 기사 의 Congruence 공식 섹션 참조 ). 으로 1 이 방법은 그들 각각에 추가 될 것이다 정렬 할 때 우리가 남아있어, 그래서 그것이 불필요 (N-1) 9 모드 . %RHS에 음수가 주어지면 파이썬의 연산자가 작동 하는 방식 은 매우 편리합니다. 우리는 n pymod -9를 대신 사용하여 또 다른 바이트를 저장할 수 있습니다 .

파이썬 2 , 72 바이트

Chas Brown의 제출에서 영감을 얻었 습니다 .

lambda i:sorted(range(1,10**len(`i`)),key=lambda n:(len(`n`),n%-9))[i-1]

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

파이썬 2 , 73 71 70 바이트

lambda n:sorted(range(10**len(`n`)),key=lambda i:(len(`~i`),i%9))[n]+1

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

Mr. XCoder에 2 바이트 ; 그리고 1 바이트 THX H.PWiz .

이것은 0 인덱스입니다.

젤리 ,  15 14 10  9 바이트

D,Ḣ$‘Ḍḅ9’

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

방법?

파이썬 답변에서 ovs가 만든 폐쇄 형 솔루션의 골프 버전을 사용합니다 ...

ovs에 의해 노출되는 공식은 다음과 같습니다. 9 * (n % b) + (n / b) + b-1 여기서 b = 10 ^{floor (log (n, 10))}

이제 c 가 n 의 소수 자릿수 이면 b-1 은 c-1 십진수입니다.
이것은 c-1 값의 10 배 (예 : 9)의 9 배와 같습니다 111*9=999.

또한 N / B는 의 주요 자리 인 N 과 N % B는 십진수로 나머지 자리한다.

같은 화학식 (B)는 X + Y는 * 의 전환으로 구현 될 수있는 [x,y]베이스로부터 B
(즉, B ^ 1 * B + X ^ Y = 0 * B * X + Y )

따라서 숫자 n (예 7045:)을 선행 및 후행 숫자로 나누고 선행 숫자를 끝에 ( [[0,4,5],7]) 배치 하고 첫 번째 항목의 모든 숫자에 1을 추가하여 추가 할 수 있습니다. b-1 ( [[1,5,6],7])을 10 진수 목록에서 정수 ( [156,7])로 변환하고 밑을 9 ( 1411) 로 변환합니다 .

아래 구현에서는 b-1 ( [[0,4,5],8])을 제공 할 때 두 항목의 모든 숫자에 1을 더하고 10 진수 목록에서 정수 ( [156,8])로 변환하고 기본 9 ( 1412) 에서 변환 한 다음이 프로세스가 추가 한 것을 뺍니다 ( 1411).

D,Ḣ$‘Ḍḅ9’ - Link: positive integer, n    e.g. 4091
D         - to base ten                       [4, 0, 9, 1]
   $      - last two links as a monad:
  Ḣ       -   head (modifies the list too)    4
 ,        -   pair (the modified list) with   [[0, 9, 1], 4]
    ‘     - increment (vectorises)            [[1, 10, 2], 5]
     Ḍ    - from base ten (vectorises)        [202, 5] (since 1*10^2+10*10^1+2*10^0 = 100+100+2 = 202)  
      ḅ9  - convert from base 9               1823 (since 202*9^1 + 5*9^0 = 202*9 + 6*9 = 1818 + 5 = 1823)
        ’ - decrement                         1822

이전, 14 개월 :

æċ⁵DL,’%9ƊƲÞị@

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

이것은 자연수를 정렬하여 입력보다 10 의 다음 거듭 제곱까지 목록을 작성한 [digitalRoot, digitCount]다음 입력 된 색인에서 값을 찾습니다.

하스켈 , 94 88 바이트

([n|x<-[0..],i<-[1..9],n<-[10^x..10^(x+1)-1],until(<10)(sum.map(read.pure).show)n==i]!!)

온라인으로 사용해보십시오! 인덱스가 0입니다.

설명:

리스트 이해는 다음과 !!같이 색인을 생성하는 무한리스트로 시퀀스를 생성합니다 .

• x 현재 자릿수보다 1이 적고 무한 목록에서 가져옵니다. [0,1,2,3, ...]
• i의 범위에 걸쳐 반복 1에 9와 디지털 뿌리 정렬에 사용됩니다
• n모든 숫자을 반복 x+1자리
• until(<10)(sum.map(read.pure).show)디지털 루트를 계산합니다 ( 설명은 여기 참조 ).
• n디지털 루트가 같으면 목록에 추가됩니다 i.

레티 나 , 65 바이트

.
9
.+
*
L$`
$`
O$`_(_{9})*(_*)
$2
_+
$.&
N$`
$.&
"$+L`^|\d+"^~G`

온라인으로 사용해보십시오! 1- 색인. 설명:

.
9
.+
*
L$`
$`

_0에서 다음 10의 거듭 제곱 (제외)까지 의 행 목록을 작성하십시오 .

O$`_(_{9})*(_*)
$2

디지털 루트 순서대로 모두 정렬하십시오.

_+
$.&

단항에서 10 진수로 변환합니다.

N$`
$.&

길이 순서대로 정렬하십시오.

"$+L`^|\d+"^~G`

nth 요소를 추출하십시오 .

Pyth ,  36 31 25 24 23  22 바이트

1- 색인.

@o%tN9rFK^LThBlt`Q-QhK

테스트 스위트!

작동 방식 (오래된)

@smo%tN9dcU^TKhs.lQT^LTSK – Full program. Q = input.
             Khs.lQT      – Take floor(log10(Q))+1 and store it in K.
          U^T             – Generate [0 ... T^K).
         c                – Cut at locations...
                    ^LTSK – Of the powers of 10 less than K.
  m     d                 – Map over those.
   o  N                   – Sort them by...
    %t 9                  – Themselves decremented, modulo 9.
@s                        – Flatten the result and retrieve the Q'th entry.

05AB1E , 19 11 바이트

내 파이썬 답변 포트 .

Kevin Cruijssen 덕분에 -6 바이트 (!) .

g<°©‰`9*®O<

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

Code           Explanation            Stack
               implicit input         [n]
g              length                 [len(n)]
 <             decrement              [len(n)-1]
  °            10 ** a                [10**(len(n) - 1)]
   ©           store value            [10**(len(n) - 1)]
    ‰          divmod                 [[n // 10**(len(n) - 1), n % 10**(len(n) - 1)]]
     `         push items to stack    [n // 10**(len(n) - 1), n % 10**(len(n) - 1)]
      9*       multiply by 9          [n // 10**(len(n) - 1), n % 10**(len(n) - 1) * 9]
        ®      retrieve value         [n // 10**(len(n) - 1), n % 10**(len(n) - 1) * 9, 10**(len(n) - 1)]
         O     sum the stack          [n // 10**(len(n) - 1) + n % 10**(len(n) - 1) * 9 + 10**(len(n) - 1)]
          <    decrement              [n // 10**(len(n) - 1) + n % 10**(len(n) - 1) * 9 + 10**(len(n) - 1) - 1]
               implicit output

Pyth , 23 바이트

@o%tN9rF_mJ^TsdtBl`Q-QJ

여기에서 시도하십시오.

Xcoder 씨 에게 -3 감사합니다

1- 색인.

펄 6 ,  68  58 바이트

{({|(10**$++..^10**++$).sort({({.comb.sum}…*==*).tail})}…*)[$_]}

0 기반 테스트

{sort({.chars,({.comb.sum}…*==*).tail},^10**.chars)[$_]}

1 기반 테스트

넓히는:

{  # bare block lambda with implicit parameter $_

  sort(
    {
      .chars,         # sort by the length first

      (  # generate sequence to find digital sum

        { .comb.sum } # one round of digital sum
        … * == *      # stop when the digital sum matches itself (1..9)

      ).tail          # get the last value
    },

    ^                 # Range up to (and excluding)
      10 ** .chars    # the next power of 10

  )[ $_ ] # index into the sequence
}

루비 , 43 38 바이트

->x{9*(x%b=10**~-x.to_s.size)+x/b+b-1}

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

원래 ovs의 훌륭한 Python 답변 포트이며 더 단순화했습니다.

자바 8, 68 바이트

n->{int b=(int)Math.pow(10,(n+"").length()-1);return~-b+n/b+n%b*9;}

@ovs 의 Python 2 답변 의 지루한 포트이므로 그를 투표 해야합니다! @Jakob
덕분에 -1 바이트

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

K4 , 38 바이트

해결책:

-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\:

예 :

q)k)-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\:40
13
q)k)-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\:601
114
q)k)-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\:4051
1462

설명:

1에서 1e9까지 디지털 루트를 구축하는 메모리가 부족할 때 Jonathan Allan의 솔루션 포트.

-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\: / the solution
                                  10\: / convert to base 10
                                1+     / add 1
                              x:       / save as x
                             #         / take from x
                     (      )          / do together
                          #x           / count x
                        c:             / save as c
                      1+               / add 1
                   1_                  / drop the first
                  _                    / cut at these indices
           ( ;   )                     / 2-item list
              c-1                      / length - 1
            0                          / .. zero
      10/:'                            / convert each from base 10
   9/:                                 / convert from base 9
-1+                                    / subtract 1

보너스:

ovs 솔루션의 번역은 더 간단하지만 더 길다 :

-1+b+/1 9*(_%;.q.mod).\:x,b:10 xexp#1_$x:

젤리 , 19 바이트

æḟ©ræċɗ⁵Ṗ%Þ-9⁸‘_®¤ị

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

Xcoder 씨께 -1 감사합니다 .

1- 색인.

J, 24 바이트

(]/:([:+/[:".&>":)^:_"0)

이 암묵적인 표현은 괄호로 묶여 다음과 같은 표현의 일부가 아닌 자체적으로 처리되어야 함을 나타냅니다 (인수와 같은).

'] / :'문구는 원래 배열 ']'을 숫자의 합계 '+ /'로 정렬합니다 ( '/ :'오름차순).

". &> ":

' ":'를 사용하여 숫자를 문자형 벡터로 변환 한 다음 역 '"를 적용합니다. -문자 대 숫자-각 '&>'항목에 적용됩니다. 따라서 65536-> '65536'-> 6 5 5 3 6.

표현식 끝 근처의 힘 연결 '^ :'은 방금 설명한 코드 (왼쪽)를 지정된 횟수만큼 적용합니다. 이 경우 지정된 횟수는 무한대 '_'이므로 결과가 변경을 멈출 때까지 계속 적용됩니다.

마지막 ' "0'은 왼쪽의 전체 표현식을 오른쪽의 각 스칼라 (0 차원) 항목에 적용하는 것을 의미합니다. 이는 우리가 이것을 적용하려는 숫자의 배열입니다.

엘릭서 , 239 바이트

q=:math
e=Enum
r=fn x,f->cond do
x<10->x
1->f.(e.sum(Integer.digits x),f)end end
fn p->e.at(e.at(Stream.unfold({0,[0]},fn {a,c}->{c,{a+1,c++e.sort(trunc(q.pow 10,a)..trunc(q.pow 10,a+1)-1,&r.(&1,r)<=r.(&2,r))}}end),1+trunc q.log10 p),p)end

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

들어오는 설명 (느리게)! 나는 이것이 이것보다 훨씬 짧아 질 수는 없다고 생각하지만 항상 제안에 개방적입니다.

펄 5 -pF , 27 바이트

$_=9x$#F+$_%10**$#F*9+$F[0]

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

@ovs의 공식과 @JonathanAllen의 설명을 사용하여 멋진 소형 코드를 만들 수 있습니다.