正の整数のデジタルルート（繰り返しデジタル合計）は、前の繰り返しの結果を使用して数字の合計を計算する各繰り返しで、数字を合計する反復プロセスによって取得された（1桁の）値です。このプロセスは、1桁の数字に達するまで続きます。

たとえば、65536のデジタルルートは7です。これは、6 + 5 + 5 + 3 + 6 = 25および2 + 5 = 7であるためです。

すべてのデジタルルートを並べ替えるのはあまり意味がありません。無限に1で始まるためです。

代わりに、すべての1桁の整数とそのデジタルルートのリストを作成し、次にすべての2桁の数字とそのデジタルルート、次にトリプル、4倍などのリストを作成します。

次に、これらのリストのそれぞれについて、デジタルルートが1のすべての整数が最初に表示され、次にデジタルルートが2のすべての整数が表示されるようにソートします。ソートは安定しているため、特定のデジタルルートを持つ整数のリストは、ソート後に昇順になります。

最後に、これらのリストを1つのシーケンスに連結します。このシーケンスは、すべて1桁の数字で始まり、次にすべての2桁の数字（デジタルルートでソート）、すべての3桁の数字などになります。

チャレンジ：

入力として正の整数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（または時間制限のある他のインタープリター）でタイムアウトしても問題ありません。
• 説明が奨励されます。

それはcode-golfなので、各言語で最も短いコードが勝ちます！あなたが管理したいものよりも短くても、あなたがゴルフをしたい言語の他の解決策に落胆しないでください！

パイソン2、_{78の 60 52 46} 45バイト

GBのおかげで-6バイト。Jakobの
おかげで-1バイト。

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

オンラインでお試しください！

最終的に、1インデックス付きの閉じたフォームに到達しました。

Python 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

オンラインでお試しください！

Python 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を除いて、これはもっとクールだと思います）。Python 2 （+5バイト）input()への変換が必要であり、ステートメント（+2バイト）ではなく関数であり、引数がPy 2（+1バイト）なので、これはovsの回答を移植するよりも確実に短くなります。intexec/

使い方

セットアップ

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

これは、1つの整数引数iとデフォルトの1である別の引数kを取る再帰関数fを定義します。一方、K≤I 、関数F戻る（I、10K）F、乗算Kをすることによって10がより大きくなるまで毎回I。

ターゲット範囲と正しいインデックス作成

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

この一連の操作の後、i、初期入力、およびiよりも大きい10の最小累乗を表す変数kが残ります。このようにして、（整数）範囲[floor（k / 10）、k）を生成できます。これには基本的に以下のすべての整数が含まれます。

• iに等しいかそれよりも小さい10の最大の累乗以上
• k未満、iより大きい10の最小のべき乗

x = floor（k / 10）より小さい整数を無視するため、欠落している数字を説明するためにインデックスをシフトする必要があります。明白な方法は、彼らの数、減算することであるXをから、私たち（以下で説明され、ソート後の）リストへのインデックスは、それゆえ持つように、IXを。ただし、リストには9k / 10のアイテムが含まれ、インデックスと-yのリストでの正のyのインデックス付けはPythonの末尾からy ^番目の要素を生成するため、これはikを使用したインデックス付けと同等であり、したがって4バイトを節約します。

デジタルルートで各チャンクを並べ替える

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

デジタルルート関数の式は1 +（（n-1）mod 9）です（このウィキペディアの記事の合同式のセクションを参照してください）。このように1をそれぞれに追加すると、ソート時に余分なものになるため、（n-1）mod 9が残ります。%RHSで負の数を指定した場合のPythonの演算子の動作は非常に便利です。これは、n pymod -9を使用してさらに別のバイトを保存できるためです。

Python 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バイトthx ; H.PWizへの1バイトthx 。

これは0インデックスです。

ゼリー、 15 14 10  9 バイト

D,Ḣ$‘Ḍḅ9’

オンラインでお試しください！

どうやって？

Pythonの回答でovsによって作成されたクローズドフォームソリューションのゴルフバージョンを使用します ...

ovsによって公開される式は、9 *（n％b）+（n / b）+ b-1です。ここで、b = 10 ^{floor（log（n、10））}

今ならcがあるの小数点以下の桁数nは、その後のB-1があるC-1小数で華やか。
これは、10進数のc-1の値の9倍（たとえば111*9=999）と同じです。

さらに、N / Bは、の先頭の数字であり、NとN％bは小数点数として数字の残りの部分です。

b * x + yのような式は[x,y]、ベースbからの変換として実装できます
（つまり、b ^ 1 * x + b ^ 0 * y = 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]し、入力されたインデックスで値を見つけます。

Haskell、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$`
$`

_s の行のリストを0から次の10のべき乗（排他的）まで作成します。

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

それらをすべてデジタルルートの順に並べ替えます。

_+
$.&

単項から小数に変換します。

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バイト

私のPython回答のポート。

-6バイト（！）Kevin Cruijssenに感謝します。

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

ここで試してみてください。

-3 Mr. Xcoderに感謝

1インデックス付き。

Perl 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の優れた回答の移植版でしたが、さらに簡略化されました。

Java 8、68バイト

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

@ovs 'Python 2 answerの退屈なポートなので、必ず彼に賛成してください！@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

説明：

Port of Jonathan Allanのソリューションで、1から1e9のデジタルルートを構築するためのメモリが不足しています。

-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⁸‘_®¤ị

オンラインでお試しください！

-1 氏Xcoderに感謝します。

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

オンラインでお試しください！

（ゆっくり）着信説明！これよりもずっと短くなるとは思わないが、私は常に提案を受け入れている

Perl 5、27 -pFバイト

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

オンラインでお試しください！

@ovsの式と@JonathanAllenの説明を使用して、コンパクトなコードを作成します。