Pozitif bir tamsayıdaki dijital kök (aynı zamanda tekrarlanan dijital toplam), bir rakam toplamını hesaplamak için önceki yinelemenin sonucunu kullanarak her bir yinelemede yinelemeli toplama rakamları ile elde edilen (tek basamaklı) değerdir. İşlem, tek basamaklı bir sayı elde edilene kadar devam eder.

Örneğin, dijital kök 65536 olan 7 , çünkü 6 + 5 + 5 + 3 + 6 = 25 ve 2 + 5 = 7 .

Tüm dijital kökleri sıralamak pek bir anlam ifade etmiyor, çünkü sonsuz sayıda 1 saniye ile başlayacak .

Bunun yerine, dijital kökleriyle birlikte tüm tek basamaklı tam sayıların, ardından dijital kökleriyle birlikte tüm çift basamaklı sayıların, ardından üçlü, dörtlü vb. Listelerini oluşturacağız.

Şimdi, bu listelerin her biri için, 1'in dijital kökleri olan tüm tam sayıların önce görünmesini, sonra da 2'nin dijital kökleri olan tüm tam sayıların görünmesini sağlayacak şekilde sıralayacağız . Sıralama sabit olacaktır, böylece belirli bir dijital köklü tamsayıların listesi sıralamadan sonra artan sırada olmalıdır.

Sonunda bu listeleri tek bir dizide birleştireceğiz. Bu sıra, tüm tek basamaklı sayılarla, ardından tüm çift basamaklı sayılarla (dijital köklerine göre sıralanır), sonra tüm üçlü basamaklı sayılarla başlar.

Meydan okuma:

Bir al pozitif tam sayı n girdi olarak alır ve çıkışı , n sırayla inci yukarıda tanımlanan'. Listenin 0 -tekslenmiş olup 1 -dekslenmiş olmasını seçebilirsiniz.

Dizi şöyle gider:

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 19, 28, 37, 46, 55, 64, 73, 82, 91, 11, 20, 29 ... 
72, 81, 90, 99, 100, 109, 118, ... 
981, 990, 999, 1000, 1009, 1018, 1027, ...

Test durumları:

Test vakaları 1 indekslidir.

   n   f(n)  
   9      9
  10     10
  11     19
  40     13
  41     22
  42     31
  43     40
  44     49
  45     58
 600    105
 601    114
 602    123
 603    132
 604    141
 605    150
4050   1453
4051   1462
4052   1471
4053   1480
4054   1489
4055   1498

Kopyalamak daha kolay:

n =    9, 10, 11, 40, 41, 42, 43, 44, 45, 600, 601, 602, 603, 604, 605, 4050, 4051, 4052, 4053, 4054, 4055, 
f(n) = 9, 10, 19, 13, 22, 31, 40, 49, 58, 105, 114, 123, 132, 141, 150, 1453, 1462, 1471, 1480, 1489, 1498

Açıklamalar:

• N ilk öğenin tümünü çıkartamayabilirsiniz. Yalnızca çıkış -acak n 'inci.
• Kodun teorik olarak 10 ^ 9'a kadar olan tüm tamsayılar için çalışması gerekir , ancak 999'dan daha büyük girişler için TIO'da (veya zaman kısıtlamalı diğer tercümanlarda) zaman aşımına uğrarsa sorun olmaz .
• Açıklamalar teşvik edilir.

Bu kod golf , yani her dilde en kısa kod kazanıyor! Yönetmek istediklerinizden daha kısa olsalar bile, golf oynamak istediğiniz dilde başka çözümler tarafından cesaretlenmeyin!

Python 2 , _{78 60 52 46} 45 bayt

GB sayesinde -6 bayt . Jakob
sayesinde -1 bayt .

n=input()
b=10**~-len(`n`)
print~-b+n/b+n%b*9

Çevrimiçi deneyin!

Sonunda 1 indeksli kapalı bir forma ulaştı.

Python 2,78 bayt

0 endeksli.

d=10;k=1
exec'\nk+=9\nif k>d+7:k=d;d*=10\nif k>=d:k-=d/10*9-1'*input()
print k

Çevrimiçi deneyin!

Python 3 , 80 bayt

f=lambda i,k=1:k>i and sorted(range(k//10,k),key=lambda n:n%-9)[i-k]or f(i,k*10)

Çevrimiçi deneyin!

1 endeksli. Python 3'te yönetebileceğim en iyisi bu (peki, aşağıdaki Python 2 çözümümün bir limanı olan 78 bayt hariç ; bunun daha serin olduğunu düşünüyorum). Python 2'nin tam programları bu özel zorluk için avantajlıdır, çünkü Python 3'te (+5 bytes) input()dönüştürülmeye ihtiyaç duyar , bir ifade (+2 bytes) yerine bir fonksiyondur ve bağımsız değişkenleri tamsayı ise varsayılan olarak tamsayı bölme işlemini gerçekleştirir. Py 2 (1 bayt), bu da öyle kesinlikle kısa taşıma daha Ovs' cevabını .intexec/

Nasıl çalışır

Kurmak

f=lambda i,k=1:k>i and ... or f(i,k*10)

Bu tanımlar, bir özyinelemeli fonksiyon f bu bir tamsayı değeri alır i ve bir tane, k , varsayılan 1 . İken k ≤ i , fonksiyon f getiri f (i, 10k) , çarparak k ile 10 her kıyasla daha büyük bir hale gelinceye kadar i .

Hedef aralığı ve doğru indeksleme

...range(k//10,k)...[i-k]

Bu operasyon kümesi sonra biz kalacaksın i , ilk giriş ve değişken k en küçük gücünü temsil 10 Büyüktür i . Bu yolla, temel olarak aşağıdaki tüm tam sayıları içeren (tam sayı) aralığını [kat (k / 10), k) oluşturabiliriz:

• i'nin 10 veya en yüksek gücüne eşit veya daha büyük
• den az k , en küçük güç 10 den büyük i

X = floor (k / 10) değerinden küçük olan tamsayıları göz ardı ettiğimizden, indekslemeyi, eksik sayıları hesaba katacak şekilde değiştirmeliyiz. Belirgin yolu onların sayısı, çıkarmak olduğunu x dan, i (aşağıda açıklanmıştır sıraladıktan sonra,) listeye dizine, bu nedenle sahip böylece, ix . Liste, çünkü Ancak, 9k / 10 endeksi de bir listede, öğeleri ve indeksleme -y bazı olumlu için y verir y ^inci Python ucundan elemanı, bununla endeksleme basitçe eşdeğerdir ik , dolayısıyla 4 bayt tasarrufu.

Her öbeği dijital kök dizinine göre sıralama

sorted(...,key=lambda n:n%-9)

Dijital kök fonksiyonu için formül 1 + ((n-1) 9 mod) (bakınız Eşlik formül bölümü bu Ara maddesi ). As 1 bu şekilde her birine eklenebilir sıralarken biz kalacaksın nedenle, bu gereksiz olduğu (n-1) 9 mod . Python %operatörünün RHS'de negatif sayılar verildiğinde çalışma şekli çok uygundur, çünkü henüz anter baytı kaydetmek için n podod -9 kullanabiliriz .

Python 2,72 bayt

Chas Brown'un gönderisinden esinlenerek .

lambda i:sorted(range(1,10**len(`i`)),key=lambda n:(len(`n`),n%-9))[i-1]

Çevrimiçi deneyin!

Python 2 , 73 71 70 bayt

lambda n:sorted(range(10**len(`n`)),key=lambda i:(len(`~i`),i%9))[n]+1

Çevrimiçi deneyin!

Bay XCoder'a 2 bayt thx ; ve H.PWiz'e 1 byte thx .

Bu 0 indeksli.

Jöle ,  15 14 10  9 bayt

D,Ḣ$‘Ḍḅ9’

Çevrimiçi deneyin!

Nasıl?

Tarafından oluşturulan kapalı form çözümün bir golfed versiyonunu kullanır kendi Python cevap OVS ...

Ovs tarafından maruz bırakılan formül: 9 * (n% b) + (n / b) + b - 1, burada b = 10 ^{kat (log (n, 10))}

Şimdi eğer c ondalık basamak sayısıdır ait n sonra b-1 olan c-1 ondalık Dokuzlar.
Bu, ondalık sayıdaki c-1 değerinin dokuz katı ile aynıdır (örn. 111*9=999).

Bundan başka , n / b lider haneli n ve n,% b bir sayısal değer olarak basamak geri kalanı ise.

Gibi bir formül b, x + y * bir dönüşüm olarak uygulanabilir [x,y]taban dan b
(yani b ^ 1 * x + B ^ 0 * y = b * x + y )

Bu nedenle, n (örneğin 7045) bir sayı alabiliriz , onu baştaki ve sondaki hanelere böleriz, baştaki haneyi sonuna ( [[0,4,5],7]) yerleştiririz , ilk öğenin tüm hanelerine bir tane ekleriz. b-1 ( [[1,5,6],7]) bunları ondalık listelerden tamsayılara ( [156,7]), onu da dokuzuncu tabancaya ( ) dönüştürür 1411.

Aşağıdaki uygulamada, b-1 ( [[0,4,5],8]) için ikram yaparken her iki öğenin rakamlarının tümüne bir tane ekler , ondalık listelerden tamsayılara ( [156,8]) dönüştürür, dokuzuncu tabandan ( 1412) dönüştürür ve sonra bu işlemi ekleriz ( 1411).

D,Ḣ$‘Ḍḅ9’ - Link: positive integer, n    e.g. 4091
D         - to base ten                       [4, 0, 9, 1]
   $      - last two links as a monad:
  Ḣ       -   head (modifies the list too)    4
 ,        -   pair (the modified list) with   [[0, 9, 1], 4]
    ‘     - increment (vectorises)            [[1, 10, 2], 5]
     Ḍ    - from base ten (vectorises)        [202, 5] (since 1*10^2+10*10^1+2*10^0 = 100+100+2 = 202)  
      ḅ9  - convert from base 9               1823 (since 202*9^1 + 5*9^0 = 202*9 + 6*9 = 1818 + 5 = 1823)
        ’ - decrement                         1822

Önceki, 14 bayt:

æċ⁵DL,’%9ƊƲÞị@

Çevrimiçi deneyin!

Bu liste, bu doğal sayıları daha sonra sıralanan değeri girerek sıraya sokarak girişin üzerindeki bir sonraki gücün 10'a kadar oluşturur [digitalRoot, digitCount].

Haskell , 94 88 bayt

([n|x<-[0..],i<-[1..9],n<-[10^x..10^(x+1)-1],until(<10)(sum.map(read.pure).show)n==i]!!)

Çevrimiçi deneyin! 0 endeksli.

Açıklama:

Liste anlayışı, dizini içinde bulunduğumuz sonsuz liste olarak oluşturur !!:

• x şuanki basamak sayısından bir sayıdır ve sınırsız listeden çizilir. [0,1,2,3, ...]
• iila boyunca dolaşır 1için 9dijital köklerinin sınıflandırmak için kullanılır
• nTüm sayılar üzerinde dolaşır x+1basamak
• until(<10)(sum.map(read.pure).show)Dijital kökü hesaplar ( bir açıklama için buraya bakınız )
• nDijital kök eşittir ise listeye eklenir i.

Retina , 65 bayt

.
9
.+
*
L$`
$`
O$`_(_{9})*(_*)
$2
_+
$.&
N$`
$.&
"$+L`^|\d+"^~G`

Çevrimiçi deneyin! 1 endeksli. Açıklama:

.
9
.+
*
L$`
$`

_0'dan 10'a (özel) sonraki güce kadar bir s çizgisinin bir listesini oluşturun .

O$`_(_{9})*(_*)
$2

Hepsini dijital kök sırasına göre sıralayın.

_+
$.&

Unary'den ondalık karaktere dönüştür.

N$`
$.&

Bunları uzunluk sırasına göre sıralayın.

"$+L`^|\d+"^~G`

Özü ninci elemanı.

Pyth ,  36 31 25 24 23  22 bayt

1 endeksli.

@o%tN9rFK^LThBlt`Q-QhK

Test odası!

Nasıl çalışır (eski)

@smo%tN9dcU^TKhs.lQT^LTSK – Full program. Q = input.
             Khs.lQT      – Take floor(log10(Q))+1 and store it in K.
          U^T             – Generate [0 ... T^K).
         c                – Cut at locations...
                    ^LTSK – Of the powers of 10 less than K.
  m     d                 – Map over those.
   o  N                   – Sort them by...
    %t 9                  – Themselves decremented, modulo 9.
@s                        – Flatten the result and retrieve the Q'th entry.

05AB1E , 19 11 bayt

Python cevabımın limanı .

-6 byte (!), Kevin Cruijssen'e teşekkürler .

g<°©‰`9*®O<

Çevrimiçi deneyin!

Code           Explanation            Stack
               implicit input         [n]
g              length                 [len(n)]
 <             decrement              [len(n)-1]
  °            10 ** a                [10**(len(n) - 1)]
   ©           store value            [10**(len(n) - 1)]
    ‰          divmod                 [[n // 10**(len(n) - 1), n % 10**(len(n) - 1)]]
     `         push items to stack    [n // 10**(len(n) - 1), n % 10**(len(n) - 1)]
      9*       multiply by 9          [n // 10**(len(n) - 1), n % 10**(len(n) - 1) * 9]
        ®      retrieve value         [n // 10**(len(n) - 1), n % 10**(len(n) - 1) * 9, 10**(len(n) - 1)]
         O     sum the stack          [n // 10**(len(n) - 1) + n % 10**(len(n) - 1) * 9 + 10**(len(n) - 1)]
          <    decrement              [n // 10**(len(n) - 1) + n % 10**(len(n) - 1) * 9 + 10**(len(n) - 1) - 1]
               implicit output

Pyth , 23 bayt

@o%tN9rF_mJ^TsdtBl`Q-QJ

Burada dene.

-3, Bay Xcoder'a teşekkürler

1 endeksli.

Perl 6 ,  68  58 bayt

{({|(10**$++..^10**++$).sort({({.comb.sum}…*==*).tail})}…*)[$_]}

0 tabanlı test et

{sort({.chars,({.comb.sum}…*==*).tail},^10**.chars)[$_]}

1 tabanlı test et

Expanded:

{  # bare block lambda with implicit parameter $_

  sort(
    {
      .chars,         # sort by the length first

      (  # generate sequence to find digital sum

        { .comb.sum } # one round of digital sum
        … * == *      # stop when the digital sum matches itself (1..9)

      ).tail          # get the last value
    },

    ^                 # Range up to (and excluding)
      10 ** .chars    # the next power of 10

  )[ $_ ] # index into the sequence
}

Ruby , 43 38 bayt

->x{9*(x%b=10**~-x.to_s.size)+x/b+b-1}

Çevrimiçi deneyin!

Başlangıçta mükemmel Python'un limanı ovs tarafından cevaplandı, ardından biraz daha basitleştirildi.

Java 8, 68 bayt

n->{int b=(int)Math.pow(10,(n+"").length()-1);return~-b+n/b+n%b*9;}

@Ovs 'Python 2 cevabının sıkıcı limanı , bu yüzden onu yendiğinizden emin olun!
-1 bayt sayesinde@ Jakob

Çevrimiçi deneyin.

K4 , 38 bayt

Çözüm:

-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\:

Örnekler:

q)k)-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\:40
13
q)k)-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\:601
114
q)k)-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\:4051
1462

Açıklama:

Jonathan Allan Limanı’nın çözümü, dijital kökleri 1’den 1e9’a çıkaracak kadar hafızam kalmadı.

-1+9/:10/:'(0;c-1)_1_(1+c:#x)#x:1+10\: / the solution
                                  10\: / convert to base 10
                                1+     / add 1
                              x:       / save as x
                             #         / take from x
                     (      )          / do together
                          #x           / count x
                        c:             / save as c
                      1+               / add 1
                   1_                  / drop the first
                  _                    / cut at these indices
           ( ;   )                     / 2-item list
              c-1                      / length - 1
            0                          / .. zero
      10/:'                            / convert each from base 10
   9/:                                 / convert from base 9
-1+                                    / subtract 1

Bonus:

Ovs'nin çözümünün çevirisi daha basit ama daha uzun:

-1+b+/1 9*(_%;.q.mod).\:x,b:10 xexp#1_$x:

Jöle , 19 bayt

æḟ©ræċɗ⁵Ṗ%Þ-9⁸‘_®¤ị

Çevrimiçi deneyin!

-1, Bay Xcoder'a teşekkürler .

1 endeksli.

J, 24 bayt

(]/:([:+/[:".&>":)^:_"0)

Bu taktik ifade, takip eden ifadelerin bir parçası olarak (bağımsız değişkenler gibi) değil, kendi başına ele alınması gerektiğini belirtmek için parelere sarılır.

'] /:' İbaresi ('/:' artan) '' 'orijinal dizisini rakamların' + / 'toplamına göre sıralar.

". &> ":

Bir sayıyı '":' ile karakter vektörüne dönüştürür, sonra tersini" "uygular. - sayıya karakter - her '&>' öğeye uygulanır. Öyleyse, 65536 -> '65536' -> 6 5 5 3 6.

İfadenin sonuna yakın olan '^:' güç bağlantısı az önce açıkladığımız kodu (solda) belirtilen sayıda uygular. Bu durumda, belirtilen sayıda sonsuzluk '_' olur, bu sonuç değişmeyi durdurana kadar uygulamaya devam etmek anlamına gelir.

Son "" 0 "ifadesi, soldaki ifadenin tamamını sağdaki her skaler (0 boyutlu) öğeye uygulamak anlamına gelir; bu, bunu uygulamak istediğimiz sayı dizisi olacaktır.

İksir , 239 bayt

q=:math
e=Enum
r=fn x,f->cond do
x<10->x
1->f.(e.sum(Integer.digits x),f)end end
fn p->e.at(e.at(Stream.unfold({0,[0]},fn {a,c}->{c,{a+1,c++e.sort(trunc(q.pow 10,a)..trunc(q.pow 10,a+1)-1,&r.(&1,r)<=r.(&2,r))}}end),1+trunc q.log10 p),p)end

Çevrimiçi deneyin!

Açıklama gelen (yavaş)! Bundan daha kısa olabileceğini sanmıyorum ama önerilere her zaman açığım

Perl 5 -pF , 27 bayt

$_=9x$#F+$_%10**$#F*9+$F[0]

Çevrimiçi deneyin!

@ Ovs'un formülünü ve @ JonathanAllen'in güzel bir kompakt kod parçasını bulmak için açıklamalarını kullanır.