J'ai besoin de préparer des chiffres en carton pour afficher un certain nombre ( exemple ). Je ne sais pas à l'avance quel numéro je dois afficher - la seule chose que je sais, c'est qu'il n'est pas supérieur à n.

Combien de chiffres en carton dois-je préparer?

Exemple: n = 50

Pour afficher un nombre compris entre 0 et 50, j'ai besoin des chiffres suivants:

1. Un zéro pour afficher le chiffre 0 ou tout autre chiffre rond
2. Deux copies des chiffres 1, 2, 3 et 4 pour afficher les numéros correspondants
3. Une copie des chiffres 5, 6, 7 et 8, dans le cas où ils apparaissent comme chiffre le moins significatif dans le nombre
4. Le chiffre 9 n'est jamais nécessaire, car je peux utiliser le chiffre inversé 6 à la place

Total: 13 chiffres

Cas de test (chaque ligne est un cas de test au format "entrée; sortie")

0 1
1 2
9 9
11 10
50 13
99 17
100 18
135 19
531 22
1000 27
8192 34
32767 38

Gelée , 9 octets

‘ḶDœ|/ḟ9L

Essayez-le en ligne!

Comment ça marche

‘ḶDœ|/ḟ9L
‘Ḷ         [0,1,...,n]
  D        convert each to list of its digits
   œ|/     fold by multiset union
      ḟ9   remove 9
        L  length

Python 2 , 49 octets

lambda n:9*len(`n`)-9+(n*9+8)/10**len(`n`)+(n<10)

Essayez-le en ligne!

Une formule arithmétique maladroite. Supposons que cela nrentre dans un intafin que Lne soit pas ajouté.

Merci à Neil d'avoir économisé 5 octets en soulignant que les 9 inutilisés peuvent être gérés en faisant à la n*9+8place de n*9+9, de sorte que, par exemple, 999*9+8=8999ne passe pas à 9000.

Haskell , 117 114 108 95 89 88 87 84 82 63 octets

6 octets économisés grâce à Laikoni

1 4 6 octets économisés grâce à nimi

g x=sum[maximum[sum[1|u<-show y,d==u]|y<-[0..x]]|d<-['0'..'8']]

Essayez-le en ligne!

Mathematica, 49 octets

Tr@Delete[Max~MapThread~DigitCount@Range[0,#],9]&

JavaScript (ES6), 60 53 octets

f=(n,i=9)=>n>(i%9+1+"e"+(i/9|0))/9-1?1+f(n,-~i):n>9^1

Une sorte de solution récursive hacky. Cela génère les nombres qui nécessitent l'ajout d'un chiffre:

1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 22, 33, 44, 55, 66, 77, 88, 100, 111, 222, ...

puis compte combien sont inférieurs à l'entrée. Par un miracle heureux, la suppression du chiffre supprime en9 fait plusieurs octets de la fonction, car la séquence peut alors être générée comme telle (en supposant une division entière):

1e1 / 9 = 1, 2e1 / 9 = 2, ..., 8e1 / 9 = 8, 9e1 / 9 = 10, 1e2 / 9 = 11, 2e2 / 9 = 22, ...

Nous devons prendre en compte le fait que les nombres inférieurs à 10 nécessitent toujours le zéro, mais c'est aussi simple que d'ajouter n > 9 ? 0 : 1au résultat.

Cas de test

let f=(n,i=9)=>n>(i%9+1+"e"+(i/9|0))/9-1?1+f(n,i+1):n>9^1;

[0, 1, 9, 11, 50, 99, 100, 135, 531, 1000, 8192, 32767].map(n => console.log(f(n)));

Lot, 67 octets

@if %1 geq 10%2 %0 %1 0%2 -~%3
@cmd/cset/a(%1*9+8)/10%2+9*%30+!%30

Dans la formulation standard de ce problème, vous devez séparer 6et 9chiffres, mais vous n'êtes pas obligé d'afficher 0. À mesure que la valeur maximale nrequise augmente, le nombre de chiffres requis augmente chaque fois que vous atteignez un chiffre (car vous n'en avez pas assez) et chaque fois que vous atteignez une puissance de 10(lorsque vous avez besoin d'un zéro supplémentaire). Au total, chaque puissance de 10nécessite 10plus de chiffres que la précédente, ce qui peut être calculé comme floor(log10(n))*10. Pour des valeurs ncomprises entre 10 puissances, le nombre de chiffres intermédiaires peut alors être calculé comme floor(n/((10**floor(log10(n))*10-1)/9))ou alternativement floor(n*9/(10**floor(log10(n))*10-1)).

Je calcule floor(log10(n))au moyen de la boucle sur la première ligne. Chaque fois, %2gagne un extra 0et %3gagne un extra -~. Cela signifie que 10%2c'est 10*10**floor(log10(n))et %30est floor(log10(n)).

La duplication de 6et 9a deux effets: d'une part, il n'y a que des 9chiffres requis pour chaque puissance de 10, et d'autre part la détection de repdigit doit ignorer les 9repdigits. Heureusement, comme ils sont inférieurs à une puissance de 10, cela peut être obtenu en ajustant la formule pour aboutir floor((n*9+8)/(10**floor(log10(n))*10)).

Gérer le zéro est assez simple: cela nécessite juste un chiffre supplémentaire quand n<10, c.-à-d floor(log10(n))==0.

Mathematica, 83 octets

v=DigitCount;s=v@0;(Table[s[[i]]=v[j][[i]]~Max~s[[i]],{i,10},{j,#}];s[[9]]=0;Tr@s)&

Python 3 , 75 octets

lambda n:sum(max(str(j).count(str(i))for j in range(n+1))for i in range(9))

Essayez-le en ligne!

PHP , 60 octets

<?=count(preg_grep('#^100+$|^([0-8])\1*$#',range(0,$argn)));

Essayez-le en ligne!