Định nghĩa

Đây là quá trình để mô tả một số:

• Đối với mỗi số từ đó 0đến 9hiện diện trong số:
• Viết tần số của chữ số đó và sau đó là chữ số.

Ví dụ: đối với số 10213223:

• Có 1sự xuất hiện của 0,
• 2sự xuất hiện của 1,
• 3sự xuất hiện của 2,
• 2sự xuất hiện của 3.

Do đó, số mô tả 10213223là 10213223( 10từ thuộc tính đầu tiên, 21từ thứ hai, v.v.).

Lưu ý rằng số lần xuất hiện của một chữ số có thể lớn hơn 9 .

Bài tập

Bạn phải in / xuất tất cả các số mô tả chính họ.

Thông số kỹ thuật

• Các lỗ hổng tiêu chuẩn được áp dụng, ngoại trừ việc bạn được phép mã hóa đầu ra hoặc lưu trữ thông tin liên quan đến đầu ra trong chương trình của bạn.
• Các số trong đầu ra có thể theo thứ tự bất kỳ .
• Các số trong đầu ra được phép có trùng lặp.
• Bạn có thể sử dụng bất kỳ dấu phân cách nào , nếu bạn chọn in thay vì đầu ra.
• Bạn được phép xuất tiền tố và / hoặc đầu ra hậu tố nếu bạn chọn in thay vì đầu ra.
• Dấu phân cách và tiền tố và hậu tố có thể không chứa bất kỳ chữ số nào (U + 0030 đến U + 0039).
• Các giải pháp phải tính toán trong một ngày .

Danh sách đầy đủ (109 bài)

22
10213223
10311233
10313314
10313315
10313316
10313317
10313318
10313319
21322314
21322315
21322316
21322317
21322318
21322319
31123314
31123315
31123316
31123317
31123318
31123319
31331415
31331416
31331417
31331418
31331419
31331516
31331517
31331518
31331519
31331617
31331618
31331619
31331718
31331719
31331819
1031223314
1031223315
1031223316
1031223317
1031223318
1031223319
3122331415
3122331416
3122331417
3122331418
3122331419
3122331516
3122331517
3122331518
3122331519
3122331617
3122331618
3122331619
3122331718
3122331719
3122331819
10413223241516
10413223241517
10413223241518
10413223241519
10413223241617
10413223241618
10413223241619
10413223241718
10413223241719
10413223241819
41322324151617
41322324151618
41322324151619
41322324151718
41322324151719
41322324151819
41322324161718
41322324161719
41322324161819
41322324171819
1051322314251617
1051322314251618
1051322314251619
1051322314251718
1051322314251719
1051322314251819
1051322325161718
1051322325161719
1051322325161819
1051322325171819
5132231425161718
5132231425161719
5132231425161819
5132231425171819
5132232516171819
106132231415261718
106132231415261719
106132231415261819
106132231426171819
106132231526171819
613223141526171819
1011112131415161718
1011112131415161719
1011112131415161819
1011112131415171819
1011112131416171819
1011112131516171819
1011112141516171819
1011113141516171819
1111213141516171819
10713223141516271819
101112213141516171819

Người giới thiệu

• Số tự động: OEIS A047841
• Số tiểu sử: OEIS A047842

gawk, 161 byte

BEGIN{
    for(split("0 10 2 2 1 1 1 1",a);c=c<11;n=o=_){
        while(++$c>a[c]+1)$(c++)=0;
        for(i in a)n=$i?n$i i-1:n;
        for(i=10;i--;)if(d=gsub(i,i,n))o=d i o;
        if(n==o)print n
    }
}

(ngắt dòng và tab cho rõ ràng)

Đó là một bộ đếm đơn giản sử dụng thực tế là mỗi số có một số lần xuất hiện hạn chế. Chẳng hạn, 0 không quá một lần trong bất kỳ số nào, 1 không quá 11 lần, 2 không quá 3 lần ... và cứ thế.

Cách này chỉ có 124415 số để kiểm tra.

Sau đó, nó tạo ra tất cả các số và kiểm tra tính hợp lệ của chúng.

Hoàn thành trong vài giây.

dc, 487 byte

Hardcoding giải pháp. Tôi bắt đầu với 22 và thêm các khác biệt để có được các số tiếp theo. Một số hoạt động trở lại như thêm 1 năm lần liên tiếp được lưu trữ trong sổ đăng ký.

Đây là chương trình đầu tiên của tôi từng được viết bằng dc nên có lẽ nó có thể chơi gôn nhiều hơn nữa.

[1+d1+d1+d1+d1+d]sa[1+d1+d1+d1+d97+d]sb[1+d1+d99+d1+d100+d]sc[1+d1+d1+d98+dlcx]sd[1+d100+d10000+d]se22d10213201+d98010+d2081+dlax11008995+dlax9800995+dlax208096+dlbxldx999891495+dlax2091108096+dlbxldx10410100909697+dldx30909100909798+dlcx9899+dlex1009999990079798+dlcx10909899+dlex4080909099989899+dlex1091000000+d100999998899089899+d1+d100+d10910000+d10 8^+d50709091 10 10^*+d397888989888989899+dlex10 6^+d10 8^+d10 10^+d10 12^+d1001 10 14^*+d9602010000000100000+d90398989999999900000+f

Bạn có thể thực thi chương trình bằng cách sử dụng dc -e "[solution]", trong đó [giải pháp] là chuỗi ở trên. Nó xuất các số theo thứ tự ngược lại. dc -e "[solution]" | sort -ncho đầu ra theo thứ tự như danh sách.

Ruby, 776 byte

Các quy tắc nói rằng "bạn được phép mã hóa đầu ra", vì vậy giải pháp này thực hiện điều đó.

x="m|62wkn|65075|651sy|651sz|651t0|651t1|651t2|651t3|cp0ei|cp0ej|cp0ek|cp0el|cp0em|cp0en|ij2wi|ij2wj|ij2wk|ij2wl|ij2wm|ij2wnAh3Ah4Ah5Ah6Ah7AjwAjxAjyAjzAmpAmqAmrApiApjAsb|h1yp02|h1yp03|h1yp04|h1yp05|h1yp06|h1yp07Bc7Bc8Bc9BcaBcbBf0Bf1Bf2Bf3BhtBhuBhvBkmBknBnfFh8Fh9FhaFhbFk1Fk2Fk3FmuFmvFpnC08xC08yC08zC0bqC0brC0ejC81iC81jC84bCfu3EsxkfohEsxkfoiEsxkfojEsxkfraEsxkfrbEsxkfu3Et429yuEt429yvEt42a1nEt42hrf|1ej82kg93hy|1ej82kg93hz|1ej82kg93kr|1ej82kg9baj|1ej832ht8a3|t10qi0rmwpi|t10qi0rmwpj|t10qi0rmwsb|t10qi0y4qzv|t10qi2lo3hn|4nq1gm5kd1grG4p2zeraG4p2zerbG4p2zeu3G4p2zmjvG4p3l25nG4qr4enfG9c4v417|7ojtp0qb1maz|8fxg6lw9mtyj|29e6onjxe94gb|lc7bc5zbz4je3";a="|inj,|1fmye,|enb7ow,|enb7,|acnu,|3ovro98,|7ojtc".split',';b="ABCDEFG";7.times{|i|x.gsub! b[i],a[i]};x.split('|').map{|x|p x.to_i 36}

Ruby, 116 byte

Một chương trình ngắn hơn nhiều, mất quá nhiều thời gian để chạy, nhưng được cung cấp đủ lâu để có thể thực hiện được. Tôi không biết nếu nó phù hợp với hạn chế thời gian.

f=->n{(?0..?9).map{|x|[n.to_s.chars.count{|c|c==x},x]}.select{|a|a[0]>0}.join.to_i}
(10**9).times{|i|p i if i==f[i]}

Python 2.7 - 684 byte

o=[22]
i=[[10213223,100096],[21322314,5],[31123314,5],[31331415,404],[1031223314,5],[3122331415,404],[10413223241516,303],[41322324151617,20202],[1051322314251617,202],[1051322325161718,10101],[5132231425161718,10101],[5132232516171819,0],[106132231415261718,101],[106132231426171819,0],[106132231526171819,0],[613223141526171819,0],[1011112131415161718,10101]]
l=[1011112131416171819,1011112131516171819,1011112141516171819,1011113141516171819,1111213141516171819,10713223141516271819,101112213141516171819]
for n in i:
 for x in range(n[0],n[0]+n[1]):
  m="";x=str(x)
  for v in range(10):
   v=str(v);c=x.count(v)
   if c!=0:
    m=m+str(c)+v
    if m==x:o.append(m)
o+=l
print o

Loại một nửa cứng mã hóa và một nửa tính toán. Nó sử dụng phương pháp chia các số thành các nhóm có kích thước có thể quản lý được với giới hạn trên và dưới. Danh sách i lưu trữ giới hạn dưới và chênh lệch giữa giới hạn trên và giới hạn trên dưới dạng danh sách lồng nhau, Tất cả các ứng viên tiềm năng sau đó được kiểm tra trong phạm vi được thêm vào danh sách đầu ra o. 7 số cuối cách xa nhau đến mức rẻ hơn khi lưu trữ chúng trong danh sách của riêng chúng và thêm vào cuối.

Nó hiện đang chạy trong vài giây và rõ ràng việc tăng kích thước nhóm sẽ làm giảm số lượng byte nhưng tăng thời gian chạy. Không chắc chắn những gì nó sẽ đi xuống và vẫn còn trong giới hạn một ngày.

/// , 542 byte

/:/\/\///^/13223:!/31:*/
10:#/!223!:&/4^241:$/1819:(/51617:)/
!3!:%/5^142:@/111:-/*@121!:_/51:+/
!123!:=/41:A/617:B/19:C/*!3!:D/18:E/6^1=52:F/
#:G/
2^:H/*5^2:I/1!=($:J/_6:K/
&:L/*&:M/_7/22*2^*!1233C4C5C6C7C8C9G14G15G16G17GDGB+4+5+6+7+8+9)=5)=6)=7)=8)=9)J)M)_8)_9)A)6D)6B)7D)7B)8B*#4*#5*#6*#7*#8*#9F=5F=6F=7F=8F=9FJF_7F_8F_9FAF6DF6BF7DF7BF8BLJLML_8L_9LAL6DL6BL7DL7BL8BK(KJDKJBKMDKMBK5$KADKABK6$K7$*%(*%JD*%JB*%MD*%MB*%5$H(DH(BHJ$HM$
%(D
%(B
%J$
%M$
5^2($*EAD*EAB*E6$*6^142A$*6^152A$
EA$-=(D-=(B-=J$-=_7$-=617$-($*@121=($*@I
@12I*7^1=_627$*@22I

Hãy thử trực tuyến!

Chắc chắn ít hơn 1440 byte cho chắc chắn !!! Sử dụng 28 hằng số cùng với nghĩa đen, một số tiền cao bất thường cho ///.