Définition

Voici le processus pour décrire un nombre:

• Pour chaque nombre de 0à 9qui est présent dans le nombre:
• Notez la fréquence de ce chiffre, puis le chiffre.

Par exemple, pour le nombre 10213223:

• Il y a 1occurrence de 0,
• 2occurrences de 1,
• 3occurrences de 2,
• 2occurrences de 3.

Par conséquent, le nombre qui décrit 10213223est 10213223( 10de la première propriété, 21de la seconde, etc.).

Notez que le nombre d'occurrences d'un chiffre peut être supérieur à 9 .

Tâche

Vous devez imprimer / sortir tous les nombres qui se décrivent.

Spécifications

• Les failles standard s'appliquent, sauf que vous êtes autorisé à coder en dur la sortie ou à stocker des informations relatives à la sortie dans votre programme.
• Les nombres dans la sortie peuvent être dans n'importe quel ordre .
• Les chiffres de la production sont autorisés à avoir des doublons.
• Vous pouvez utiliser n'importe quel séparateur , si vous choisissez d'imprimer au lieu de la sortie.
• Vous êtes autorisé à préfixer et / ou à postfixer la sortie si vous choisissez d'imprimer au lieu de la sortie.
• Le séparateur et le préfixe et le suffixe ne peuvent contenir aucun chiffre (U + 0030 à U + 0039).
• La solution doit calculer en une journée .

Liste complète (109 objets)

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

Les références

• Numéros autobiographiques: OEIS A047841
• Numéro biographique: OEIS A047842

gawk, 161 octets

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
    }
}

(sauts de ligne et tabulations pour plus de clarté)

C'est un simple compteur qui utilise le fait que chaque numéro a une occurrence limitée. Par exemple, 0 n'est pas plus d'une fois dans n'importe quel nombre, 1 pas plus de 11 fois, 2 pas plus de 3 fois ... et ainsi de suite.

De cette façon, il n'y a que 124415 numéros à vérifier.

Il crée ensuite tous les numéros et vérifie leur validité.

Se termine en quelques secondes.

dc, 487 octets

Codé en dur la solution. Je commence par 22 et j'ajoute les différences pour obtenir les prochains chiffres. Certaines opérations de retour comme l'ajout de 1 cinq fois de suite sont stockées dans des registres.

C'est mon premier programme jamais écrit en DC donc il peut probablement jouer beaucoup plus.

[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

Vous pouvez exécuter le programme en utilisant dc -e "[solution]", où [solution] est la chaîne ci-dessus. Il sort les nombres dans l'ordre inverse. dc -e "[solution]" | sort -npour la sortie dans le même ordre que la liste.

Rubis, 776 octets

Les règles disent que "vous êtes autorisé à coder en dur la sortie", donc cette solution fait exactement cela.

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}

Rubis, 116 octets

Un programme beaucoup plus court qui prend beaucoup trop de temps à exécuter, mais qui est suffisamment long devrait pouvoir le faire. Je ne sais pas si cela correspond à la contrainte de temps.

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 octets

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

Type à moitié codé en dur et à moitié calculé. Il adopte l'approche de diviser les nombres en groupes d'une taille gérable avec une limite supérieure et inférieure. La liste i stocke la limite inférieure et la différence entre elle et la limite supérieure sous forme de liste imbriquée. Tous les candidats potentiels sont ensuite vérifiés dans la plage ajoutée à la liste de sortie o. Les 7 derniers numéros sont si éloignés qu'il est moins cher de les stocker dans leur propre liste et de les ajouter à la fin.

Il s'exécute actuellement en quelques secondes et, de toute évidence, l'augmentation de la taille du groupe réduirait le nombre d'octets mais augmenterait le temps d'exécution. Je ne sais pas à quoi cela reviendrait et resterait dans la limite d'un jour.

/// , 542 octets

/:/\/\///^/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

Essayez-le en ligne!

Certainement moins de 1440 octets à coup sûr !!! Utilise 28 constantes avec le littéral, un montant inhabituellement élevé pour ///.