Lấy một số nguyên dương $k$ làm đầu vào. Bắt đầu với $n := 1$ và liên tục tăng $n$ theo công suất nguyên lớn nhất của mười sao cho và .$i$$i \le n$$i + n \le k$

Lặp lại cho đến khi và trả về danh sách tất cả các giá trị trung gian của , bao gồm cả ban đầu và cuối cùng .$n = k$$n$$1$$k$

Trong quá trình này, ban đầu sự tăng trưởng sẽ bị giới hạn bởi sự bất bình đẳng trước đây và chỉ sau đó bởi sự bất bình đẳng trước đó; sự tăng trưởng sẽ ở dạng thời kỳ "mở rộng" ban đầu, trong đó được tăng thêm bởi các cường quốc ngày càng lớn hơn, sau đó là giai đoạn "hợp đồng", trong đó được tăng lên bởi các quyền lực nhỏ hơn để "phóng to" vào đúng số$n$$n$

Các trường hợp thử nghiệm

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]

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

Haskell , 72 68 64 63 byte

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

Hãy thử trực tuyến!

Cảm ơn Sriotchilism O'Z cổ cho -4 byte!

Sử dụng

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]

Giải trình

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 byte

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

Hãy thử trực tuyến!

Làm sao?

Học thuyết

Các bước sau được lặp lại cho đến khi $n=0$ :

• tìm số $k$ của các số 0 ở cuối biểu thị thập phân của $n$
• giảm $k$ nếu $n$ là lũy thừa chính xác $10$
• trừ $x=10^k$ từ $n$

Thực hiện

Giá trị của $x$ được tính trực tiếp dưới dạng một chuỗi với biểu thức sau:

+---- 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'

Lưu ý : Loại trừ hàng đầu '10'chỉ ảnh hưởng đến quyền hạn chính xác là $10$ (ví dụ $n=\color{red}{10}\color{green}{00}$ ) nhưng không thay đổi số lượng các số 0 ở cuối được ghi cho các giá trị như $n=\color{red}{10}23\color{green}{00}$ ( '10'thực tế là có thêm các chữ số khác không hoàn toàn không phù hợp trong những trường hợp như vậy).

Python 2 , 61 byte

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

Hãy thử trực tuyến!

Perl 6 , 48 41 byte

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

Hãy thử trực tuyến!

Giải trình:

->\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 byte ^SBCS

Chức năng tiền tố ẩn danh. In số trên các dòng riêng biệt để xuất bản.

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

Hãy thử trực tuyến!

{}∘1$n$

 ⍺=⍵$k$$n$

  ⍺$k$

 ⋄ khác:

  ⎕←⍵$n$

  ⍺-$k$

  ⍵,$n$

  10⍟ $\log_{10}$

  ⌊ sàn những

  ⌊/ tối thiểu trong số đó

  10* mười tăng lên sức mạnh của điều đó

  ⍵+ $n$

  ⍺∇$k$$n$

05AB1E , 15 byte

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

Câu trả lời của Haskell của @PaulMutser (đầu tiên) , vì vậy hãy đảm bảo nâng cao anh ấy !!

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Xuất ra các dòng số giới hạn.
Nếu nó phải là một danh sách, tôi phải thêm 3 byte:

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

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

Thạch , 19 byte

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 51 byte

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

Hãy thử trực tuyến!

Mẻ, 131 byte

@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

Đưa đầu vào dưới dạng tham số dòng lệnh và xuất danh sách các số thành STDOUT. Giải trình:

@set/an=i=1

Bắt đầu với n=1và i=1đại diện cho sức mạnh của 10.

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

Nhân ivới 10 nếu nđã đạt đến sức mạnh tiếp theo là 10.

@echo %n%

Xuất giá trị hiện tại của n.

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

Lặp lại trong khi icó thể được thêm vào nmà không vượt quá đầu vào.

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

Khôi phục giá trị trước đó nvà chia icho 10.

@if %i% neq 0 goto c

Nếu ikhông bằng 0 thì thử thêm ivào nmột lần nữa.

R , 67 65 byte

-2 byte nhờ 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

Khá đơn giản. Nó cần một bộ sức mạnh 10 vượt quá những gì cần thiết theo thứ tự ngược lại i.

(Tôi thích sử dụng i=10^rev(0:log10(k)) thay vì i=10^(k:0)sau này là không hiệu quả về mặt tính toán, nhưng golf là golf!).

Sau đó, trong một vòng lặp while, áp dụng các điều kiện cho ivà lấy đầu tiên (nghĩa là lớn nhất); cập nhậtn và thêm vào đầu ra

Hãy thử trực tuyến!

Thạch , 12 byte

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

Hãy thử trực tuyến!

Pip , 27 byte

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

Hãy thử trực tuyến!

Trong mã giả:

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
}

Tôi khá hài lòng với các thủ thuật chơi gôn mà tôi có thể áp dụng để rút ngắn thuật toán này. Bằng cách khởi tạo, cập nhật và in các thứ trong tiêu đề vòng lặp, tôi có thể tránh được việc cần niềng răng xoăn cho thân vòng lặp. Có lẽ có một thuật toán golfier.

Japt , 18 byte

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

Thử nó

Æ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 # (Trình biên dịch tương tác Visual C #) , 123 122 byte

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;}

Hãy thử trực tuyến!

Prolog (SWI) , 142 byte

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.

Hãy thử trực tuyến!

Giải thích vào ngày mai hoặc một cái gì đó