Giriş olarak pozitif bir tamsayısını alın . İle Başlat ve sürekli artırmak on büyük tamsayı gücüyle öyle ki ve .$k$$n := 1$$n$$i$$i \le n$$i + n \le k$

olana kadar tekrarlayın ve hem ilk hem de son dahil tüm ara değerlerinin bir listesini döndürün .$n = k$$n$$1$$k$

Bu süreçte büyüme başlangıçta eski eşitsizlikle ve daha sonra sadece ikincisi ile sınırlı olacaktır; büyüme, başlangıçta bir "genişleme" dönemi biçiminde olacaktır, bu sırada , daha büyük güçlerle artar ve bunu takiben, "yakınlaştırmak" için her zamankinden küçük güçlerle artar. doğru numarada.$n$$n$

Test Durumları

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]

Bu kod golf , bu yüzden en kısa cevap (bayt cinsinden) kazanır.

Haskell , 72 68 64 63 bayt

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

Çevrimiçi deneyin!

-4 bayt için Sriotchilism O'Zaic teşekkürler!

kullanım

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]

açıklama

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 bayt

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

Çevrimiçi deneyin!

Nasıl?

teori

Aşağıdaki adımlar $n=0$ olana kadar tekrarlanır :

• n ondalık gösteriminde sondaki sıfırların $k$ sayısını arayın$n$
• eksiltme $k$ ise $n$ tam bir gücüdür $10$
• çıkarma $x=10^k$ gelen $n$

uygulama

Değeri $x$ doğrudan aşağıdaki ifade ile, bir dizi olarak hesaplanır:

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

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

Çevrimiçi deneyin!

Perl 6 , 48 41 bayt

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

Çevrimiçi deneyin!

Açıklama:

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

Anonim zımni önek fonksiyonu. Numaraları ayrı satırlara stdout'a yazdırır.

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

Çevrimiçi deneyin!

{}∘1$n$

 ⍺=⍵$k$$n$

  ⍺$k$

 ⋄ Başka:

  ⎕←⍵$n$

  ⍺-$k$

  ⍵,$n$

  10⍟ $\log_{10}$

  ⌊ onları katla

  ⌊/ minimum

  10* onun gücü yükseltildi

  ⍵+ $n$

  ⍺∇ aynı kullanarak tekrarlama$k$$n$

05AB1E , 15 bayt

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

Port of @PaulMutser 's (ilk) Haskell cevap , bu yüzden onu upvote emin olun !!

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Yeni satırın sınırlandırılmış sayılarını çıkarır.
Bir liste olması gerekiyorsa, 3 bayt eklemem gerekir:

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

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

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

Jöle , 19 bayt

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

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 51 bayt

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

Çevrimiçi deneyin!

Toplu, 131 bayt

@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

Komut satırı parametresi olarak girişi alır ve sayı listesini STDOUT'a verir. Açıklama:

@set/an=i=1

10'un gücü ile başlayın n=1ve i=1temsil edin.

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

Bir sonraki 10 güce ulaşmışsa i10 ile çarpın n.

@echo %n%

Akım değerini girin n.

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

Tekrar girişi girişin iüzerine nçıkmadan eklenebilir .

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

Değerinin önceki değerini geri yükleyin ve 10'a nbölün i.

@if %i% neq 0 goto c

Eğer ideğil sıfır sonra eklemeyi deneyin iiçin ntekrar.

R , 67 65 bayt

Giuseppe sayesinde -2 bayt

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

Gayet basit. Ters sırada ihtiyaç duyulacak şeyin ötesinde 10'luk bir güç seti alır i.

( Ikincisi hesaplamalı olarak verimsiz, ama golf golf i=10^rev(0:log10(k))yerine kullanmayı tercih ederim i=10^(k:0)!).

Sonra bir while döngüsünde, koşulları ilkine uygular ive alır (yani en büyüğü); güncellenir nve çıktıya eklenir

Çevrimiçi deneyin!

Jöle , 12 bayt

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

Çevrimiçi deneyin!

Pip , 27 bayt

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

Çevrimiçi deneyin!

Sözde kodda:

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
}

Bu algoritmayı kısaltmak için uygulayabildiğim golf hilelerinden oldukça memnunum. Döngü başlığında bir şeyler başlatarak, güncelleyerek ve yazdırarak, döngü gövdesi için kıvırcık parantezlere ihtiyaç duymayı önleyebildim. Yine de muhtemelen daha golfçü bir algoritma var.

Japt , 18 bayt

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

Dene

Æ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 # Etkileşimli derleyicisi) , 123 122 bayt

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

Çevrimiçi deneyin!

Prolog (SWI) , 142 bayt

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.

Çevrimiçi deneyin!

Yarın gelecek bir açıklama