Bir m uzunluk uzunluğunun n. Basamak değerindeki (sağdan sola sayılan) en büyük basamağın daima m - n + 1'e eşit olduğu bir sayı sistemi oluşturalım. Belirli bir yerde kullanılabilecek basamak sayısının dışında, diğer tüm artışlar standarttır. Yani bir basamak, basamak sınırını aşacaksa, bir sonraki basamağa bir tane ekleriz.

Saymanın bu sistemde nasıl temsil edileceği aşağıda açıklanmıştır:

1; 10; 11; 12; 100; 101; 102; 103; 110; 111; 112; 113; 120; 121; 122; 123; 1000; 1001 ...

Senin görevin standart bir temel sayı 10 alır ve numaralandırma sistemime dönüştüren bir işlev yazmaktır.

Daha kısa kod tercih edilir. Bonne Şansı!

** 9'dan sonra rakamlara ihtiyacınız varsa (kullanmalısınız) harfleri kullanmayı seçebilirsiniz veya listenin bir öğesi olarak 2 basamaklı bir sayı döndürebilirsiniz.

Test Durumları

10 -> 111
20 -> 1003
30 -> 1023
50 -> 1123
100 -> 10035
23116 -> 1234567
21977356 -> 123456789A

Son durumun nasıl uyguladığınıza bağlı olarak çalışması son derece yavaş olabilir. Çok uzun sürerse veya çok fazla bellek kullanıyorsa, çalıştırmanız gerekmez. Ancak, hızlı çalışmasını ve çok az bellek kullanmasını sağlamanın yolları olduğunu unutmayın.

Mathematica, 64 bayt

Part[Join@@Array[Tuples@Join[{{1}},Array[Range,#-1,3]-1]&,#],#]&

Adsız işlev, pozitif bir tamsayı argümanı alarak ve tamsayıların bir listesini döndürür.

Join[{{1}},Array[Range,#-1,3]-1]yuvalanmış listeyi döndürür { {1}, {0,1,2}, {0,1,2,3}, ..., {0,1,...,#} }. Ardından Tuples, ilk öğesi içinde {1}bulunan, ikinci öğesi içinde {0,1,2}bulunan ve bu şekilde devam eden tüm grupların (sıralı) kümesini döndürür ; bunlar #bu numaralandırma sistemindeki-haneli rakamlardır. Join@@Array[...,#]bu numaralandırma sistemindeki tüm sayıların en fazla #hane içeren bir dizisini döndürür ve bu sayıyı Part[...,#]ayıklar #.

Bu umutsuzca yavaş! Daha büyük giriş 9'a kadar girdi kadar, son değiştirerek testi bunu daha iyi çalışır ,#],#]&ile ,Ceiling[0.9Log[#]]],#]&; bu, numaralandırma sisteminde istediğimiz rakamı bulmak için yeterince ileri gitmek için gereken basamak sayısına daha gerçekçi bir sınır koyar.

Mathematica, 93 bayt

Nest[#/.{x___,y_}:>{x,y+1}//.x:{y___,z_:0,w_,v___}/;w>Tr[1^x]-Tr[1^{v}]:>{y,z+1,0,v}&,{0},#]&

İlk argüman ile saf fonksiyon #. Negatif olmayan bir tamsayı verilirse, doğru rakam listesinin çıktısını alır ( 0doğru şekilde işler !).

açıklama

Nest[f,expr,n]uygulama sonucunu verir fetmek expr nzamanlarda. Bu durumda, exprliste {0}ve ngiriş tamsayısıdır #. İşlev fkarmaşıktır:

# (* Starting with the input # *)
 /. (* Apply the following rule *)
   {x___,y_} (* If you see a list of the form {x___,y} *)
            :> (* replace it with *)
              {x,y+1} (* this *)
                     //. (* Now apply the following rule repeatedly until nothing changes *)
                        x:{y___,z_:0,w_,v___} (* If you see a list x starting with a sequence y of 0 or more elements, 
                                                 followed by an optional element z (default value of 0),
                                                 followed by an element w,
                                                 followed by a sequence v of 0 or more elements *)
                                             /; (* such that *)
                                               w>Tr[1^x]-Tr[1^{v}] (* w is greater than the length of x minus the length of {v} *)
                                                                  :> (* replace it with *)
                                                                    {y,z+1,0,v}& (* this *)

Perl 6 , 38 bayt

{map({|[X] 1,|map ^*,3..$_},1..*)[$_]}

Pozitif bir tam sayı alır ve rakamları temsil eden tam sayıların bir listesini çıkarır.

Açıklama:

{                                    }  # a lambda

 map({                    },1..*)       # for each number length from 0 to infinity,
                                        # offset by 1 to avoid a +1 in next step...

           1,|map ^*,3..$_              # generate the digit ranges, e.g.:
                                        #     length 0  ->  (1)  # bogus, but irrelevant
                                        #     length 1  ->  (1)
                                        #     length 2  ->  (1, 0..2)
                                        #     length 3  ->  (1, 0..2, 0..3)
                                        #     length 4  ->  (1, 0..2, 0..3, 0..4)

       [X]                              # take the cartesian product

      |                                 # slip the results into the outer sequence

                                 [$_]   # Index the sequence generated this way

Pyth - 14 bayt

Sadece nth"yer değeri modelinden küçük" değere uyan değeri döndürür .

e.f.A.eghkbjZT

Test Takımı .

Haskell, 65 bayt

i(x:r)|x>length r=0:i r|1<2=1+x:r
i[]=[1]
reverse.(iterate i[]!!)

iRakam sistemindeki rakamları, rakamlar ters sırada olacak şekilde artırır. iterateile temsil edilen sıfır ile başlayan tüm bu sayıların sonsuz listesini oluşturur []. Sonra tek yapmanız !!gereken talep edilen numarayı almaktır ( ) reverse.

Son satır, bir işlev tanımı değil, bir işlevdir, bu nedenle kaynak kodu dosyasında olduğu gibi görünemez. Bunun yerine, diğer satırları yalnızca kaynak koduna koyun ve yorumlayıcıdaki son satırı kullanın (veya işlevi f=son satıra ekleyerek bir ada bağlayın ).

Örnek kullanım:

*Main> reverse.(iterate i[]!!) $ 100
[1,0,0,3,5]

( [5,3,0,0,1]Sonucun izin verilen bir sunumu olsaydı 8 bayt kaydedilebilir .)

Haskell, 49 bayt

x=[1]:[n++[d]|n<-x,d<-[0..length n+1]]
(x!!).pred

İlk satır yardımcı bir tanımdır ve ikincisi bir işlevi değerlendirir. Bir tamsayı alır ve bir tamsayı listesi döndürür. Çevrimiçi deneyin!

açıklama

xMeydan okuma metninde belirtilen sonsuz temsil listesi olarak tanımlarım ; ana işlev argümanını azaltır ve indeksler x. İlk satır şu şekilde çalışır:

x=                     -- The list of lists x contains
 [1]:                  -- the list [1], followed by
 [n++[d]|              -- integer d appended to list n, where
  n<-x,                -- n is drawn from x, and
  d<-[0..length n+1]]  -- the new "digit" d is drawn from this range.

Gördüğünüz gibi x, bu kendisi açısından tanımlanmıştır, ancak Haskell tembeldir, bu yüzden bu bir sorun değildir.