以正整数作为输入。从开始，并反复将增加10的最大整数幂，以使和。$k$$n := 1$$n$$i$$i \le n$$i + n \le k$

重复直到并返回所有中间值的列表，包括初始和最终。$n = k$$n$$1$$k$

在这一过程中，增长最初将受到前者的不平等的限制，然后才受到后者的限制。增长将采取初始“扩张”时期的形式，在此期间，会以更大的幂增加，随后是“契约”时期，在此期间，会以越来越小的幂增加以“放大”在正确的数字上。$n$$n$

测试用例

1 => [1]
10 => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
321 => [1,  2,  3,  4,  5,  6,  7,  8,  9,
        10, 20, 30, 40, 50, 60, 70, 80, 90,
        100, 200, 300, 310, 320, 321]
1002 => [1,   2,   3,   4,   5,   6,   7,   8,   9,
         10,  20,  30,  40,  50,  60,  70,  80,  90,
         100, 200, 300, 400, 500, 600, 700, 800, 900,
         1000, 1001, 1002]

这是代码高尔夫球，因此最短的答案（以字节为单位）获胜。

Haskell，72 68 64 63字节

f=(1!)
c!t|t==c=[c]|t>c=c:(c+10^(pred.length.show.min c$t-c))!t

在线尝试！

感谢Sriotchilism O'Zaic的-4个字节！

用法

f 321
[1,2,3,4,5,6,7,8,9,10,20,30,40,50,60,70,80,90,100,200,300,310,320,321]

说明

c!t         -- c=current number, t=target number
 |t==c=[c]  -- Target is reached, return last number
 |t>c=c:(c+10^(pred.length.show.min c$t-c))!t
      c:                                        -- Add current number to list
                                min c$t-c       -- The minimum of the current number, and the difference between the current number and the target
                    length.show.                -- The length of this number
               pred.                            -- Minus 1
           10^(                          )      -- Raise 10 to this power
         c+                                     -- Add that to the current number
        (                                 )!t   -- Recursion

JavaScript（ES6），50个字节

f=n=>n?[...f(n-(1+/(^10)?(0*$)/.exec(n)[2])),n]:[]

在线尝试！

怎么样？

理论

重复以下步骤，直到$n=0$为止：

• 在n的十进制表示中寻找尾随零的数字$k$$n$
• 如果n是10的精确幂，则将$k$减1$n$$10$
• 从n减去$x=10^k$$n$

实作

$x$的值直接使用以下表达式作为字符串计算：

+---- leading '1'
|
1 + /(^10)?(0*$)/.exec(n)[2]
     \____/\___/
        |    |
        |    +---- trailing zeros (the capturing group that is appended to the leading '1')
        +--------- discard one zero if n starts with '10'

注意：排除前导'10'仅会影响$10$精确乘方（例如$n=\color{red}{10}\color{green}{00}$），但不会更改$n=\color{red}{10}23\color{green}{00}$值所捕获的尾随零的数量（因为多余的非零中间数字'10'实际上是在这种情况下根本不匹配）。

Python 2，61个字节

f=lambda k,n=1:n<k and[n]+f(k,n+10**~-len(`min(n,k-n)`))or[n]

在线尝试！

Perl 6的，48 41个字节

->\k{1,{$_+10**min($_,k-$_).comb/10}...k}

在线尝试！

说明：

->\k{                                   }  # Anonymous code block taking k
     1,                             ...k   # Start a sequence from 1 to k
       {                           }       # Where each element is
        $_+          # The previous element plus
           10**      # 10 to the power of
                           .comb     # The length of
               min($_,k-$_)          # The min of the current count and the remainder
                                /10  # Minus one

APL（Dyalog Unicode），30 字节^SBCS

匿名默认前缀功能。在单独的行上将数字打印到标准输出。

{⍺=⍵:⍺⋄⍺∇⍵+10*⌊/⌊10⍟⍵,⍺-⎕←⍵}∘1

在线尝试！

{… }∘1 匿名中缀lambda，其中以1开头的$n$咖喱：

 ⍺=⍵ 如果$k$和$n$相等：

  ⍺ 返回（并隐式打印）$k$

 ⋄ 其他：

  ⎕←⍵ 打印$n$

  ⍺- 从k减去$k$

  ⍵, 前置$n$

  10⍟ $\log_{10}$

  ⌊ 那些那些

  ⌊/ 最少的

  10* 十倍的力量

  ⍵+ $n$

  ⍺∇ 使用相同的递归$k$$n$

05AB1E，15 个字节

1[=ÐIαD_#‚ßg<°+

@PaulMutser（第一个）Haskell答案的端口，所以请确保支持他！！

在线尝试或验证所有测试用例。

输出以换行符分隔的数字。
如果它必须是列表，则必须添加3个字节：

X[DˆÐIαD_#‚ßg<°+}¯

在线尝试 或验证所有测试用例。

说明：

1             # Push a 1 to the stack
 [            # Start an infinite loop
  =           #  Print the current number with trailing newline (without popping it)
  Ð           #  Triplicate the current number
   Iα         #  Get the absolute difference with the input
     D        #  Duplicate that absolute difference
      _       #  If this difference is 0:
       #      #   Stop the infinite loop
      ‚ß      #  Pair it with the current number, and pop and push the minimum
        g<°   #  Calculate 10 to the power of the length of the minimum minus 1
           +  #  And add it to the current number

果冻，19字节

1µ«³_$DL’⁵*$+µ<³$п

在线尝试！

Wolfram语言（Mathematica），51个字节

Union@NestList[#+10^Floor@Log10@Min[s-#,#]&,1,s=#]&

在线尝试！

批处理，131个字节

@set/an=i=1
:e
@if %n%==%i%0 set i=%i%0
@echo %n%
:c
@set/an+=i
@if %n% leq %1 goto e
@set/an-=i,i/=10
@if %i% neq 0 goto c

将输入作为命令行参数，并将数字列表输出到STDOUT。说明：

@set/an=i=1

开始n=1并i=1代表10的幂。

:e
@if %n%==%i%0 set i=%i%0

i如果n达到下一个10的幂，则乘以10。

@echo %n%

输出的当前值n。

:c
@set/an+=i
@if %n% leq %1 goto e

i可以重复添加while n而不超出输入范围。

@set/an-=i,i/=10

恢复以前的值n并除以i10。

@if %i% neq 0 goto c

如果i不为零，则尝试添加i到n一次。

R，67 65字节

-2个字节，感谢Giuseppe

k=scan();o=1;i=10^(k:0);while(T<k)o=c(o,T<-T+i[i<=T&i+T<=k][1]);o

很简单 它需要一组10的幂，超过相反顺序所需的幂i。

（我宁愿使用i=10^rev(0:log10(k))而不是，i=10^(k:0)因为后者在计算上效率低下，但是高尔夫就是高尔夫！）。

然后在while循环中，将条件应用于第一个条件i（即最大条件）；更新n，并追加到输出

在线尝试！

果冻，12字节

1+«ạæḟ⁵«Ɗɗ¥Ƭ

在线尝试！

点，27字节

Wa>Po+:y/t*Y1Ty>o|o+y>ay*:t

在线尝试！

用伪代码：

a = args[0]
o = 1
print o
while a > o {
  y = 1
  till y > o || o + y > a
    y *= 10
  o += y / 10
  print o
}

我对能够缩短此算法的高尔夫技巧感到非常满意。通过初始化，更新和打印循环头中的内容，我可以避免在循环主体中使用花括号。不过，可能有一个高尔夫球手算法。

Japt，18个字节

ÆT±ApTmTnU)sÊÉÃf§U

尝试一下

ÆT±ApTmTnU)sÊÉÃf§U     :Implicit input of integer U
Æ                      :Map the range [0,U)
 T±                    :  Increment T (initially 0) by
   A                   :  10
    p                  :  Raised to the power of
     Tm                :    The minimum of T and
       TnU             :      T subtracted from U
          )            :    End minimum
           s           :    Convert to string
            Ê          :    Length
             É         :    Subtract 1
              Ã        :End map
               f       :Filter
                §U     :  Less than or equal to U

C＃（Visual C＃交互式编译器），123122字节

m=>{var a=new[]{1}.ToList();int s;for(;(s=a.Last())<m;)a.Add(s+(int)Math.Pow(10,(int)Math.Log(s<m-s?s:m-s,10)));return a;}

在线尝试！

Prolog（SWI），142字节

L-D-M:-append(L,[D],M).
N-L-C-X-R-I:-I=1,C is X*10,N-L-C-C-R-1;D is C+X,(D<N,L-D-M,N-M-D-X-R-I;D>N,N-L-C-(X/10)-R-0;L-D-R).
N-R:-N-[]-0-1-R-1.

在线尝试！

明天有什么解释