รูทดิจิทัล (ผลรวมดิจิตอลซ้ำ) ของจำนวนเต็มบวกคือค่า (หลักเดียว) ที่ได้รับจากกระบวนการวนซ้ำของตัวเลขในแต่ละการวนซ้ำโดยใช้ผลลัพธ์จากการคำนวณซ้ำก่อนหน้านี้เพื่อคำนวณผลรวมหลัก กระบวนการดำเนินการต่อไปจนกว่าจะถึงตัวเลขหลักเดียว

ยกตัวอย่างเช่นรากดิจิตอล65536เป็น7เพราะ6 + 5 + 5 + 3 + 6 = 25และ2 + 5 = 7

การเรียงลำดับรากดิจิตอลทั้งหมดไม่สมเหตุสมผลเนื่องจากมันจะเริ่มต้นด้วย1วินาทีมากมาย

แต่เราจะสร้างรายการของจำนวนเต็มหลักเดียวพร้อมกับรูทดิจิทัลของพวกเขาจากนั้นก็เป็นตัวเลขสองหลักทั้งหมดพร้อมกับรูทดิจิทัลของพวกเขาจากนั้นจะเป็นสามเท่าสี่เท่าและอื่น ๆ

ตอนนี้สำหรับแต่ละรายการเราจะจัดเรียงเพื่อให้จำนวนเต็มทั้งหมดที่มีรากดิจิตอล1ปรากฏก่อนจากนั้นจำนวนเต็มทั้งหมดที่มีรากดิจิตอล2และต่อไป การเรียงลำดับจะมีความเสถียรดังนั้นรายการจำนวนเต็มที่มีรากดิจิตอลที่แน่นอนควรอยู่ในลำดับจากน้อยไปหามากหลังจากการเรียงลำดับ

ในที่สุดเราจะต่อเรียงรายการเหล่านี้เป็นลำดับเดียว ลำดับนี้จะเริ่มต้นด้วยตัวเลขหลักเดียวทั้งหมดแล้วตัวเลขสองหลักทั้งหมด (เรียงตามรากดิจิตอลของพวกเขา) จากนั้นตัวเลขสามหลักและอื่น ๆ

ท้าทาย:

รับจำนวนเต็มบวกnเป็นอินพุตและส่งออกตัวเลขn 'ตามลำดับที่อธิบายไว้ข้างต้น คุณสามารถเลือกได้ว่าจะทำรายการ0 -indexed จาก1 -exexed

ลำดับจะเป็นดังนี้:

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

กรณีทดสอบ:

กรณีทดสอบมีการจัดทำดัชนี 1

   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

ง่ายต่อการคัดลอก:

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

ชี้แจง:

• คุณไม่สามารถส่งออกองค์ประกอบแรกทั้งหมดn คุณจะต้องส่งออกเพียงn 'TH
• รหัสต้องในทางทฤษฎีการทำงานสำหรับจำนวนเต็มทั้งหมดถึง10 ^ 9แต่ก็ ok ถ้ามันออกมาในครั้ง TIO (หรือล่ามอื่น ๆ ที่มีข้อ จำกัด เวลา) สำหรับปัจจัยการผลิตที่มีขนาดใหญ่กว่า999
• คำอธิบายได้รับการสนับสนุน

มันเป็นรหัส - กอล์ฟดังนั้นรหัสที่สั้นที่สุดในแต่ละภาษาชนะ! อย่าท้อใจกับโซลูชันอื่น ๆ ในภาษาที่คุณต้องการตีกอล์ฟแม้ว่ามันจะสั้นกว่าสิ่งที่คุณสามารถจัดการได้!

Python 2 , _{78 60 52 46} 45 ไบต์

-6 ไบต์ต้องขอบคุณGB
-1 ขอบคุณไบต์จาคอบ

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

ลองออนไลน์!

ในที่สุดก็มาถึงรูปแบบปิดการจัดทำดัชนี 1

Python 2 , 78 ไบต์

0 การจัดทำดัชนี

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

ลองออนไลน์!

Python 3 , 80 ไบต์

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)

ลองออนไลน์!

1 การจัดทำดัชนี นี่เป็นสิ่งที่ดีที่สุดที่ฉันสามารถจัดการได้ใน Python 3 (ดียกเว้น78 byterซึ่งเป็นพอร์ตของโซลูชัน Python 2 ของฉันด้านล่าง แต่ฉันคิดว่าอันนี้เย็นกว่ามาก) โปรแกรมเต็มรูปแบบ Python 2 เป็นข้อได้เปรียบสำหรับความท้าทายนี้โดยเฉพาะเนื่องจากinput()ต้องการการแปลงเป็นintPython 3 (+5 ไบต์) execเป็นฟังก์ชันแทนที่จะเป็นคำสั่ง (+2 ไบต์) และ/ดำเนินการหารจำนวนเต็มตามค่าเริ่มต้นหากอาร์กิวเมนต์เป็นจำนวนเต็ม py 2 (1 ไบต์) ดังนั้นนี้เป็นแน่นอนสั้นกว่า porting คำตอบ OVS'

มันทำงานอย่างไร

ติดตั้ง

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

นี้กำหนดฟังก์ชัน recursive ฉว่าจะใช้เวลาหนึ่งอาร์กิวเมนต์จำนวนเต็มผมและอีกคนหนึ่ง, kซึ่งเริ่มต้นที่1 ในขณะที่k ≤ฉัน , ฟังก์ชั่นฉผลตอบแทนf (i, 10k)คูณkโดย10ในแต่ละครั้งจนกระทั่งมันกลายเป็นมากกว่าฉัน

ช่วงเป้าหมายและการจัดทำดัชนีที่ถูกต้อง

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

หลังจากที่ชุดของการดำเนินการนี้เรากำลังทิ้งให้อยู่กับฉัน , การป้อนข้อมูลเริ่มต้นและตัวแปรkซึ่งหมายถึงอำนาจที่เล็กที่สุดของ10มากกว่าฉัน ด้วยวิธีนี้เราสามารถสร้างช่วง (จำนวนเต็ม) [floor (k / 10), k)ซึ่งโดยทั่วไปจะมีจำนวนเต็มทั้งหมดที่:

• มากกว่าหรือเท่ากับพลังสูงสุด10น้อยกว่าหรือเท่ากับi
• น้อยกว่าk , พลังที่เล็กที่สุดของ10มากกว่าฉัน

เนื่องจากเราไม่สนใจจำนวนเต็มที่น้อยกว่าx = floor (k / 10)เราจะต้องเลื่อนการจัดทำดัชนีเพื่อให้เราพิจารณาตัวเลขที่ขาดหายไป วิธีที่ชัดเจนคือการลบนับของพวกเขาxจากฉันเพื่อให้เราดัชนีลงในรายการ (หลังจากการเรียงลำดับซึ่งอธิบายไว้ด้านล่าง) จึงมีix อย่างไรก็ตามเนื่องจากรายการมี9k / 10รายการและการจัดทำดัชนีในรายการที่ดัชนี-yสำหรับค่าบวกyบางค่าให้องค์ประกอบy ^thจากจุดสิ้นสุดใน Python นี่เป็นเพียงการทำดัชนีเทียบเท่ากับikซึ่งช่วยประหยัด 4 ไบต์

เรียงลำดับแต่ละก้อนโดยรากดิจิตอล

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

สูตรสำหรับฟังก์ชันรูทดิจิทัลคือ1 + ((n-1) mod 9) (ดูที่ส่วนสูตรความสอดคล้องของบทความ Wikipedia นี้ ) ในฐานะที่เป็น1จะด้วยวิธีนี้จะเพิ่มไปยังแต่ละของพวกเขาก็เป็นฟุ่มเฟือยเมื่อเรียงลำดับดังนั้นเราจะเหลือ(n-1) mod 9 วิธี%การทำงานของ Python ทำงานเมื่อได้รับจำนวนลบบน RHS นั้นสะดวกมากเพราะเราสามารถใช้n pymod -9แทนเพื่อบันทึก byte anther

Python 2 , 72 ไบต์

แรงบันดาลใจจากการส่ง Chas ของบราวน์

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

ลองออนไลน์!

Python 2 , 73 71 70 ไบต์

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

ลองออนไลน์!

2 ไบต์ขอบคุณMr. XCoder ; และ 1 ไบต์ขอบคุณไปH.PWiz

นี่คือดัชนี 0

เยลลี่ ,  15 14 10  9 ไบต์

D,Ḣ$‘Ḍḅ9’

ลองออนไลน์!

อย่างไร?

ใช้วิธีแก้ปัญหาแบบปิดที่สร้างขึ้นโดยovs ในคำตอบของ Python ...

สูตรที่เปิดเผยโดย ovs คือ: 9 * (n% b) + (n / b) + b - 1โดยที่b = 10 ^{ชั้น (บันทึก (n, 10))}

ทีนี้ถ้าcคือจำนวนหลักทศนิยมของnดังนั้นb-1คือc-1เก้าในทศนิยม
นี่เหมือนกับเก้าครั้งของค่าของc-1ในหน่วยทศนิยม (เช่น111*9=999)

นอกจากนี้n / bเป็นตัวเลขนำหน้าของnและn% bคือตัวเลขที่เหลือเป็นตัวเลขทศนิยม

สูตรเช่นb * x + yอาจนำไปใช้เป็นการแปลง[x,y]จากฐานb
(เช่นb ^ 1 * x + b ^ 0 * y = b * x + y )

ด้วยเหตุนี้เราจึงสามารถใช้ตัวเลขn (ตัวอย่าง7045) แบ่งออกเป็นตัวเลขนำหน้าและต่อท้ายวางตัวเลขนำหน้าไว้ที่ท้าย ( [[0,4,5],7]) เพิ่มหนึ่งหลักของรายการแรกทั้งหมดเพื่อรองรับการเพิ่มb-1 ( [[1,5,6],7]) แปลงจากรายการทศนิยมเป็นจำนวนเต็ม ( [156,7]) และแปลงจากฐานเก้า ( 1411)

ในการนำไปใช้ด้านล่างเราจะเพิ่มหนึ่งหลักของทั้งสองรายการเมื่อรองรับb-1 ( [[0,4,5],8]), แปลงจากรายการเลข[156,8]ฐานสิบเป็นจำนวนเต็ม ( ), แปลงจากฐานเก้า ( 1412) จากนั้นลบหนึ่งขั้นตอนที่เพิ่มนี้ ( 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

ก่อนหน้า 14 byter:

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

ลองออนไลน์!

อันนี้สร้างรายการขึ้นสู่กำลังงานถัดไปของ10เหนืออินพุตโดยเรียงลำดับตัวเลขธรรมชาติเหล่านี้จาก[digitalRoot, digitCount]นั้นค้นหาค่าที่ดัชนีอินพุต

Haskell , 94 88 ไบต์

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

ลองออนไลน์! 0 การจัดทำดัชนี

คำอธิบาย:

รายการความเข้าใจสร้างลำดับเป็นรายการที่ไม่มีที่สิ้นสุดที่เราจัดทำดัชนีด้วย!!:

• x น้อยกว่าจำนวนหลักหนึ่งในปัจจุบันและดึงมาจากรายการที่ไม่มีที่สิ้นสุด [0,1,2,3, ...]
• iวนซ้ำในช่วงจาก1ถึง9และใช้สำหรับการจัดเรียงตามรากดิจิตอล
• nวนซ้ำทุกตัวเลขด้วยx+1ตัวเลข
• until(<10)(sum.map(read.pure).show)คำนวณรากดิจิตอล ( ดูที่นี่สำหรับคำอธิบาย )
• niจะถูกเพิ่มลงในรายการถ้ารากดิจิตอลเท่ากับ

เรติน่า 65 ไบต์

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

ลองออนไลน์! 1 การจัดทำดัชนี คำอธิบาย:

.
9
.+
*
L$`
$`

สร้างรายการของบรรทัด_จาก 0 จนกระทั่งกำลังต่อไปของ 10 (พิเศษ)

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

จัดเรียงทั้งหมดตามลำดับรูทดิจิทัล

_+
$.&

แปลงจาก unary เป็นทศนิยม

N$`
$.&

เรียงลำดับตามความยาว

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

แยกnองค์ประกอบที่

Pyth ,  36 31 25 24 23  22 ไบต์

1 การจัดทำดัชนี

@o%tN9rFK^LThBlt`Q-QhK

ชุดทดสอบ!

มันทำงานอย่างไร (ล้าสมัย)

@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 ไบต์

ท่าเรือคำตอบหลามของฉัน

-6 ไบต์ (!) ต้องขอบคุณเควิน Cruijssen

g<°©‰`9*®O<

ลองออนไลน์!

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 ไบต์

@o%tN9rF_mJ^TsdtBl`Q-QJ

ลองที่นี่

-3 ขอบคุณMr. Xcoder

1 การจัดทำดัชนี

Perl 6 ,  68  58 ไบต์

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

ทดสอบตาม 0

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

ทดสอบ 1-based

ขยาย:

{  # 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 ไบต์

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

ลองออนไลน์!

เดิมทีพอร์ตของคำตอบ Python ที่ยอดเยี่ยมโดย ovs จากนั้นทำให้ง่ายขึ้นอีกเล็กน้อย

Java 8, 68 ไบต์

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

น่าเบื่อพอร์ตของ@ovs 'Python 2 คำตอบดังนั้นอย่าลืม upvote เขาด้วย!
-1 ไบต์ขอบคุณ@Jakob

ลองออนไลน์

K4 , 38 ไบต์

วิธีการแก้:

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

ตัวอย่าง:

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

คำอธิบาย:

ทางออกของโจนาธานอัลลันเมื่อฉันใช้หน่วยความจำไม่เพียงพอที่จะสร้างรากดิจิตอลจาก 1 ถึง 1e9

-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

โบนัส:

การแปลโซลูชันของ ovs นั้นง่ายขึ้น แต่นานขึ้น:

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

เยลลี่ขนาด 19 ไบต์

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

ลองออนไลน์!

-1 ขอบคุณMr. XcoderXcoder

1 การจัดทำดัชนี

J, 24 ไบต์

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

โดยปริยายนี้การแสดงออกถูกห่อหุ้มไว้เพื่อแสดงว่าควรได้รับการปฏิบัติด้วยตนเองแทนที่จะเป็นส่วนหนึ่งของการแสดงออกต่อไปนี้ (เช่นข้อโต้แย้ง)

วลี '] /:' คำสั่งซื้อ (จากน้อยไปมาก '/:') อาร์เรย์ดั้งเดิม ']' โดยรวม '+ /' ของตัวเลขนิพจน์

". &> ":

แปลงตัวเลขให้เป็นเวกเตอร์อักขระด้วย '":' จากนั้นจึงใช้ค่าอินเวอร์สของมันกับ" "' - ตัวอักษรเป็นตัวเลข - ใช้กับรายการ '&>' แต่ละรายการ ดังนั้น 65536 -> '65536' -> 6 5 5 3 6

การรวมพลัง '^:' ใกล้ถึงจุดสิ้นสุดของนิพจน์จะใช้รหัสที่เราเพิ่งอธิบาย (ด้านซ้าย) ตามจำนวนครั้งที่ระบุ ในกรณีนี้จำนวนครั้งที่ระบุคืออนันต์ '_' ซึ่งหมายถึงการใช้ต่อไปจนกว่าผลลัพธ์จะหยุดการเปลี่ยนแปลง

'' 0 'สุดท้ายหมายถึงการใช้นิพจน์ทั้งหมดทางซ้ายกับรายการสเกลาร์ (0 มิติ) แต่ละรายการทางด้านขวาซึ่งจะเป็นอาร์เรย์ของตัวเลขที่เราต้องการนำไปใช้

Elixir , 239 ไบต์

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

ลองออนไลน์!

คำอธิบายขาเข้า (ช้า)! ฉันไม่คิดว่ามันจะสั้นกว่านี้มาก แต่ฉันเปิดรับข้อเสนอแนะเสมอ

Perl 5 -pF , 27 ไบต์

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

ลองออนไลน์!

ใช้สูตรของ @ ovs และคำอธิบายของ @ JonathanAllen เพื่อให้ได้โค้ดที่มีขนาดกะทัดรัด