Prendi un intero positivo $k$ come input. Inizia con $n := 1$ e aumenta ripetutamente $n$ della potenza intera più grande di dieci $i$ tale che $i \le n$ e $i + n \le k$ .

Ripetere fino a $n = k$ e restituire un elenco di tutti i valori intermedi di $n$ , inclusi sia $1$ iniziale che $k$ finale .

Durante questo processo, la crescita sarà inizialmente limitata dalla prima disuguaglianza e solo successivamente dalla seconda; la crescita assumerà la forma di un periodo iniziale di "espansione", durante il quale $n$ viene aumentato da potenze sempre più grandi, seguito da un periodo di "contratto", durante il quale $n$ viene aumentato da poteri sempre più piccoli al fine di "ingrandire" sul numero corretto.

Casi test

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]

Questo è code-golf , quindi vince la risposta più breve (in byte).

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

Provalo online!

Grazie Sriotchilism O'Zaic per -4 byte!

uso

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]

Spiegazione

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

Provalo online!

Come?

Teoria

I seguenti passaggi si ripetono fino a $n=0$ :

• cerca il numero $k$ di zeri finali nella rappresentazione decimale di $n$
• decrementa $k$ se $n$ è una potenza esatta di $10$
• sottrai $x=10^k$ da $n$

Implementazione

Il valore di $x$ viene calcolato direttamente come una stringa con la seguente espressione:

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

Nota : l'esclusione del comando principale '10'influisce solo sui poteri esatti di $10$ (ad es. $n=\color{red}{10}\color{green}{00}$ ) ma non modifica il numero di zeri finali catturati per valori come $n=\color{red}{10}23\color{green}{00}$ (a causa delle cifre intermedie aggiuntive diverse da zero, '10'è in realtà non corrisponde affatto in tali casi).

Python 2 , 61 byte

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

Provalo online!

Perl 6 , 48 41 byte

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

Provalo online!

Spiegazione:

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

Funzione prefisso tacito anonimo. Stampa numeri su righe separate su stdout.

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

Provalo online!

{}∘1$n$ :

 ⍺=⍵$k$$n$ sono uguali:

  ⍺$k$

 ⋄ altro:

  ⎕←⍵$n$

  ⍺-$k$

  ⍵,$n$

  10⍟ $\log_{10}$ di quelli

  ⌊ piano quelli

  ⌊/ minimo di quelli

  10* dieci elevato al potere di quello

  ⍵+ $n$ più quello

  ⍺∇$k$$n$

05AB1E , 15 byte

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

La risposta di Haskell a Port of @PaulMutser , quindi assicurati di votarlo !!

Provalo online o verifica tutti i casi di test .

Emette i numeri di nuova riga delimitati.
Se deve essere un elenco, dovrei aggiungere 3 byte:

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

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Gelatina , 19 byte

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

Provalo online!

Wolfram Language (Mathematica) , 51 byte

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

Provalo online!

Lotto, 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

Accetta l'input come parametro della riga di comando e restituisce l'elenco di numeri a STDOUT. Spiegazione:

@set/an=i=1

Inizia con n=1e i=1rappresenta la potenza di 10.

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

Moltiplicare iper 10 se nha raggiunto la potenza successiva di 10.

@echo %n%

Emette il valore corrente di n.

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

Ripeti finché ipuò essere aggiunto nsenza superare l'input.

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

Ripristina il valore precedente di ne dividi iper 10.

@if %i% neq 0 goto c

Se inon è zero, prova ad aggiungere idi nnuovo.

R , 67 65 byte

-2 byte grazie a 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

Abbastanza semplice. Prende un insieme di poteri di 10 oltre a quello che sarebbe necessario in ordine inverso i.

(Preferirei usare i=10^rev(0:log10(k))invece dii=10^(k:0) dal momento che quest'ultimo è inefficiente dal punto di vista computazionale, ma il golf è golf!).

Quindi, in un ciclo while, applica le condizioni ie prende il primo (ovvero il più grande); si aggiorna ne aggiunge all'output

Provalo online!

Gelatina , 12 byte

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

Provalo online!

Pip , 27 byte

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

Provalo online!

In pseudocodice:

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
}

Sono abbastanza soddisfatto dei trucchi del golf che sono stato in grado di applicare per abbreviare questo algoritmo. Inizializzando, aggiornando e stampando le cose nell'intestazione del loop, sono stato in grado di evitare di aver bisogno di parentesi graffe per il corpo del loop. Tuttavia, probabilmente esiste un algoritmo più golfista.

Japt , 18 byte

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

Provalo

Æ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 # (compilatore interattivo 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;}

Provalo online!

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.

Provalo online!

Spiegazione in arrivo domani o qualcosa del genere