ให้สร้างระบบของตัวเลขที่ตัวเลขที่ใหญ่ที่สุดในค่าที่ n (นับจากขวาไปซ้าย) ของความยาวหมายเลข m เท่ากับ m - n + 1 เสมอเพื่อให้ตัวอย่างตัวเลข 5 หลักที่ใหญ่ที่สุดในระบบนี้ ถูกเขียน 12345 นอกเหนือจากจำนวนหลักที่มีให้ใช้ในบางสถานที่ที่ถูก จำกัด การเพิ่มอื่น ๆ ทั้งหมดเป็นมาตรฐาน คือเมื่อหลักคือเกินขีด จำกัด หลักเราเพิ่มหนึ่งหลักถัดไป

นี่คือวิธีการนับจำนวนที่จะแสดงในระบบนี้:

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

งานของคุณคือการเขียนฟังก์ชั่นที่ใช้ตัวเลขฐาน 10 และแปลงเป็นระบบเลขของฉัน

รหัสที่สั้นกว่าจะดีกว่า Bonne Chance!

** หากคุณต้องการตัวเลขหลังจาก 9 (คุณควร) คุณสามารถเลือกที่จะใช้ตัวอักษรหรือคุณสามารถส่งคืนตัวเลข 2 หลักเป็นองค์ประกอบของรายการ

กรณีทดสอบ

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

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

Mathematica, 64 ไบต์

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

ฟังก์ชั่นที่ไม่มีชื่อการโต้แย้งอาร์กิวเมนต์จำนวนเต็มบวกและส่งกลับรายการจำนวนเต็ม

Join[{{1}},Array[Range,#-1,3]-1]{ {1}, {0,1,2}, {0,1,2,3}, ..., {0,1,...,#} }ส่งกลับรายการที่ซ้อนกัน จากนั้นTuplesส่งคืนชุด (เรียงลำดับ) ของ tuples ทั้งหมดที่มีองค์ประกอบแรกอยู่ใน{1}ซึ่งองค์ประกอบที่สองอยู่ใน{0,1,2}และอื่น ๆ ; นี่คือ#ตัวเลข -digit ในระบบการกำหนดหมายเลขนี้ Join@@Array[...,#]ส่งกลับอาร์เรย์ของตัวเลขทั้งหมดในระบบการกำหนดตัวเลขนี้ด้วย#ตัวเลขสูงสุดและPart[...,#]แยก#จำนวนดังกล่าวที่ th

นี่ช้าอย่างสิ้นหวัง! มันทำงานได้ดีสำหรับอินพุตสูงสุดถึง 9 สำหรับอินพุตที่ใหญ่ขึ้นให้ทดสอบโดยแทนที่ปลาย,#],#]&ด้วย,Ceiling[0.9Log[#]]],#]&; สิ่งนี้ทำให้จำนวนแคปที่เหมือนจริงมากขึ้นกับจำนวนตัวเลขที่จำเป็นในการไปไกลพอในระบบหมายเลขเพื่อค้นหาสิ่งที่เราต้องการ

Mathematica, 93 ไบต์

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},#]&

#ฟังก์ชั่นบริสุทธิ์ที่มีอาร์กิวเมนต์แรก หากได้รับจำนวนเต็มที่ไม่ใช่ค่าลบมันจะส่งออกรายการของตัวเลขที่ถูกต้อง (แม้จะจัดการ0อย่างถูกต้อง!)

คำอธิบาย

Nest[f,expr,n]ให้ผลลัพธ์ของการใช้fกับexpr nเวลา ในกรณีนี้exprเป็นรายการ{0}และเป็นจำนวนเต็มการป้อนข้อมูลn #ฟังก์ชั่นfซับซ้อน:

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

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

รับจำนวนเต็มบวกและแสดงรายการจำนวนเต็มแทนตัวเลข

คำอธิบาย:

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

เพียงส่งคืนnthค่าที่ตรงกับ "รูปแบบค่าที่น้อยกว่า"

e.f.A.eghkbjZT

Test Suite

Haskell, 65 ไบต์

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

iเพิ่มตัวเลขในระบบตัวเลขด้วยตัวเลขในลำดับที่กลับรายการ สร้างรายการที่ไม่มีที่สิ้นสุดของตัวเลขเหล่านี้ทั้งหมดที่เริ่มต้นด้วยศูนย์ซึ่งเป็นตัวแทนจากiterate []จากนั้นสิ่งที่เหลืออยู่ให้ทำคือรับ ( !!) จำนวนที่ต้องการและreverseมัน

บรรทัดสุดท้ายคือฟังก์ชั่นไม่ใช่คำจำกัดความของฟังก์ชั่นดังนั้นจึงไม่สามารถปรากฏได้เหมือนในไฟล์ซอร์สโค้ด แต่ให้ใส่บรรทัดอื่นในซอร์สโค้ดและใช้บรรทัดสุดท้ายที่ล่าม (หรือผูกฟังก์ชันกับชื่อโดยf=การต่อท้ายบรรทัดสุดท้าย)

ตัวอย่างการใช้:

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

(8 ไบต์สามารถบันทึกได้หาก[5,3,0,0,1]เป็นการแสดงผลลัพธ์ที่ได้รับอนุญาต)

Haskell, 49 ไบต์

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

บรรทัดแรกคือคำจำกัดความเสริมและข้อที่สองประเมินว่าเป็นฟังก์ชัน ใช้จำนวนเต็มและส่งคืนรายการจำนวนเต็ม ลองออนไลน์!

คำอธิบาย

ฉันกำหนดxเป็นรายการที่ไม่สิ้นสุดของการรับรองที่กล่าวถึงในข้อความท้าทาย หน้าที่หลักเพียง decrements xโต้แย้งและดัชนีของมันเข้าไป บรรทัดแรกทำงานดังนี้:

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.

คุณเห็นว่าxถูกกำหนดในแง่ของตัวเอง แต่ Haskell ขี้เกียจดังนั้นนี่ไม่ใช่ปัญหา