Nehmen Sie eine positive ganze Zahl als Eingabe. Beginnen Sie mit und erhöhen Sie wiederholt um die größte ganzzahlige Potenz von zehn so dass und .$k$$n := 1$$n$$i$$i \le n$$i + n \le k$

Wiederholen Sie diesen Vorgang, bis und geben Sie eine Liste aller Zwischenwerte von , einschließlich der ersten und der letzten .$n = k$$n$$1$$k$

Während dieses Prozesses wird das Wachstum zunächst durch die erstere Ungleichung und erst danach durch die letztere begrenzt; Das Wachstum wird in Form einer anfänglichen "Expansions" -Periode erfolgen, in der durch immer größere Potenzen erhöht wird, gefolgt von einer "Kontrakt" -Periode, in der durch immer kleinere Potenzen erhöht wird, um zu "zoomen". auf die richtige Nummer.$n$$n$

Testfälle

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]

Das ist Code-Golf , also gewinnt die kürzeste Antwort (in Bytes).

Haskell , 72 68 64 63 Bytes

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

Probieren Sie es online!

Vielen Dank an Sriotchilism O'Zaic für -4 Bytes!

Verwendung

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]

Erläuterung

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]:[]

Probieren Sie es online!

Wie?

Theorie

Die folgenden Schritte werden wiederholt, bis $n=0$ :

• Suchen Sie nach der Anzahl $k$ der nachgestellten Nullen in der Dezimaldarstellung von $n$
• Dekrementiere $k$ wenn $n$ eine exakte Potenz von $10$
• subtrahiere $x=10^k$ von $n$

Implementierung

Der Wert von $x$ wird direkt als Zeichenfolge mit dem folgenden Ausdruck berechnet:

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

Hinweis : Ohne Berücksichtigung der führenden '10'wirkt sich nur auf genaue Potenzen von $10$ (zB $n=\color{red}{10}\color{green}{00}$ ) , aber die Anzahl der erfassten Nullen für Werte nicht wie ändern $n=\color{red}{10}23\color{green}{00}$ (wegen der zusätzlichen nicht-Null mittleren Ziffern, '10'eigentlich ist in solchen Fällen überhaupt nicht übereinstimmen).

Python 2 , 61 Bytes

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

Probieren Sie es online!

Perl 6 , 48 41 Bytes

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

Probieren Sie es online!

Erläuterung:

->\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

Anonyme implizite Präfixfunktion. Druckt Zahlen in separaten Zeilen auf Standardausgabe.

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

Probieren Sie es online!

{}∘1$n$

 ⍺=⍵$k$$n$

  ⍺$k$

 ⋄ sonst:

  ⎕←⍵$n$

  ⍺-$k$

  ⍵,$n$

  10⍟ $\log_{10}$

  ⌊ Boden diejenigen

  ⌊/ Minimum davon

  10* zehn, die dazu erzogen wurden

  ⍵+ $n$

  ⍺∇$k$$n$

05AB1E , 15 Bytes

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

Port von @PaulMutsers (erster) Haskell-Antwort , also stelle sicher, dass du ihn positiv bewertest !!

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Gibt die durch Zeilenumbrüche getrennten Zahlen aus.
Wenn es eine Liste sein muss, müsste ich 3 Bytes hinzufügen:

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

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Jelly , 19 Bytes

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

Probieren Sie es online!

Wolfram Language (Mathematica) , 51 Byte

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

Probieren Sie es online!

Batch, 131 Bytes

@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

Übernimmt die Eingabe als Befehlszeilenparameter und gibt die Liste der Zahlen an STDOUT aus. Erläuterung:

@set/an=i=1

Beginnen Sie mit n=1und i=1repräsentieren Sie die Potenz von 10.

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

Mit i10 multiplizieren, wenn ndie nächste Zehnerpotenz erreicht ist.

@echo %n%

Den aktuellen Wert von ausgeben n.

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

Das Wiederholen von while ikann hinzugefügt werden, nohne dass die Eingabe überschritten wird.

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

Stellen Sie den vorherigen Wert von wieder her nund dividieren Sie idurch 10.

@if %i% neq 0 goto c

Wenn inicht dann Null versuchen Sie izu nwieder.

R , 67 65 Bytes

-2 Bytes dank 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

Ziemlich einfach. Es werden Potenzen von 10 benötigt, die über die in umgekehrter Reihenfolge erforderliche Menge hinausgehen i.

(Ich würde es vorziehen, i=10^rev(0:log10(k))anstatt zu verwenden, i=10^(k:0)da letzteres rechnerisch ineffizient ist, aber Golf ist Golf!).

Wendet dann in einer while-Schleife die Bedingungen auf idie erste (dh die größte) an und nimmt sie an. wird aktualisiert nund an die Ausgabe angehängt

Probieren Sie es online!

Gelee , 12 Bytes

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

Probieren Sie es online!

Pip , 27 Bytes

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

Probieren Sie es online!

Im Pseudocode:

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
}

Ich bin ziemlich zufrieden mit den Golf-Tricks, die ich anwenden konnte, um diesen Algorithmus zu verkürzen. Durch Initialisieren, Aktualisieren und Drucken von Inhalten im Schleifenkopf konnte ich geschweifte Klammern für den Schleifenkörper vermeiden. Es gibt jedoch wahrscheinlich einen golferischeren Algorithmus.

Japt , 18 Bytes

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

Versuch es

Æ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 # Interactive Compiler) , 123 bis 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;}

Probieren Sie es online!

Prolog (SWI) , 142 Bytes

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.

Probieren Sie es online!

Erklärung kommt morgen oder so