Dans de nombreuses polices (en particulier dans la police Consolas ), 5 «chiffres décimaux» ont des «trous». Nous appellerons ces chiffres sacrés:
46890
Les 5 chiffres impies sont donc:
12357
Un entier peut donc être classé comme "sacré" s'il ne contient que des chiffres sacrés, et "impie" dans le cas contraire. Parce que -
c'est impie, aucun entier négatif ne peut être saint.
Les entiers sacrés peuvent être classés en fonction de leur nombre de trous. Par exemple, les chiffres suivants ont une sainteté de 1:
469
Et ces chiffres ont une sainteté de 2:
80
Nous disons que la sainteté globale d'un entier est la somme de la sainteté de ses doigts. Par conséquent, 80
aurait une sainteté de 4 et 99
aurait une sainteté de 2.
Le défi
Soit deux entiers n > 0
et h > 0
sort le n
entier saint dont la sainteté est au moins h
. Vous pouvez supposer que les entrées et les sorties ne seront pas supérieures au nombre entier représentable maximum dans votre langue ou 2^64 - 1
, selon la valeur la moins élevée.
Voici une liste des 25 premiers entiers sacrés avec la sainteté h >= 1
, pour référence:
0, 4, 6, 8, 9, 40, 44, 46, 48, 49, 60, 64, 66, 68, 69, 80, 84, 86, 88, 89, 90, 94, 96, 98, 99
Les 25 premiers entiers sacrés avec la sainteté h >= 2
sont:
0, 8, 40, 44, 46, 48, 49, 60, 64, 66, 68, 69, 80, 84, 86, 88, 89, 90, 94, 96, 98, 99, 400, 404, 406
0
a une sainteté de deux" avant de cliquer enfin sur le lien wikipedia vers ConsolasRéponses:
Pyth, 32 octets
Explication
Essayez ici
Prend la saisie sous la forme
h \n n
la source
Ruby,
1091059582 octetsC’est la terrible approche "calculer entre 0 et 99999999999 ..." qui a 13 octets de moins que son équivalent paresseux. Cependant, il est peu probable que cette version se termine avant la mort de l'univers par la chaleur. De toute façon, une valeur de 13 octets ¯ \ _ (ツ) _ / ¯
Vous pouvez tester des valeurs plus petites en changeant
?9*99
, disons,'99999'
.Voici l'ancienne version (95 octets, avec une évaluation paresseuse, qui tourne presque instantanément plutôt que presque jamais):
la source
take
au lieu defirst
?take
renvoieLazy
, qui ne peut pas être indexé.Python 3, 103
Voici une solution qui utilise une approche plus efficace en termes de mémoire, mais utilise le même algorithme si vous souhaitez le tester.
Cas de test:
la source
2**64-1
; voir stackoverflow.com/questions/34113609/…PowerShell,
1631501411019896 octetsPrend les entrées, puis boucle jusqu'à
$n
zéro. Nous réglons initialement$i=-1
en utilisant une astuce de pré-traitement, ce qui fonctionne car$i
, n'ayant pas encore été déclaré, is$null
. Ensuite, nous--
, ce qui amène PowerShell à l’évaluer$i = $null - 1
, ce qui est$i=-1
.Chaque boucle est incrémentée
$i
puis exécutée par une longueif
instruction. La première partie du conditionnel vérifie qu’il$i
n’y a aucun élément12357
en utilisant l’-notmatch
opérateur , pour filtrer les nombres impies.La deuxième partie du conditionnel vérifie la quantité de trous dans
$i
. Il utilise l'-replace
opérateur pour les remplacer8
ou0
par11
, puis compare si la longueur est> =$h
. Nous n'avons pas à nous soucier de supprimer les chiffres impies, car cela fait partie de la première partie du conditionnel, et les chiffres à trou unique ont la même longueur que de1
toute façon, nous n'avons donc pas besoin de les remplacer.Si cela reste vrai, nous décrémentons
$n
(car cela signifie que nous avons trouvé un autre nombre qui satisfait aux exigences d'entrée). Ainsi, lorsque lafor
condition est recalculée pour vérifier si$n
est égal à zéro, cela signifie que nous avons trouvé le nième , nous quittons donc lafor
boucle, la sortie$i
et nous terminons.Edit - sauvegardé 13 octets en utilisant un tableau au lieu de chaîne pour
$l
et en modifiant la façon dont$n
est décrémentée / vérifiéeEdit 2 - sauvegardé 9 octets supplémentaires en cochant
$n
lafor
condition et en déplaçant la sortie en dehors de la boucleEdit 3 - sauvé énormément 40 octets de plus en modifiant radicalement la manière dont nous calculons les trous
Edit 4 - économisé 3 octets supplémentaires en déplaçant le
++
pour être une pré-incrémentation sur la première partie du conditionnel Edit 5 - enregistré 2 octets supplémentairesgrâce à TessellatingHeckler
la source
for(--$i;$n)
et-replace"8|0"
?$i=-1
me rendait absolument dingue. J'essaie toujours de trouver un moyen d'éviter les initialisations$i
, mais les choses que j'ai essayées jusqu'à présent sont plus longues (et, étant donné cela, ce sera probablement encore plus long).CJam,
3634 octetsMerci à aditsu pour la sauvegarde de 2 octets.
Testez-le ici.
la source
Utilitaires Bash + GNU, 67
seq
génère simplement des entiers à partir de0
hautsed -r
:h
copier la ligne d'entrée dans l'espace d'attente/12357/d
effacer les chiffres impiess/8|0/&&/g
remplacez doublement les chiffres sacrés par deux fois eux-mêmes. Ainsi, les chiffres sacrés sont comptés une fois et les chiffres doublement sacrés sont comptés deux fois./^.{$1}/!d
Si les$1
trous ne correspondent pas , effacez et passez à la ligne suivante.x
ramener le numéro original dans l'espace du motifsed
$2!d
sur toutes les lignes avant ligne$2
, supprimez et passez à la ligne suivanteq
doit être à la ligne$2
- quitter (et impression implicite)Idéone.
la source
sed -r "h;/[12357]/d;s/8|0/&&/g;/^.{$1}/!d;x"
. Et un autre 4:sed $2!d\;q
. Et si vous êtes satisfait d'une limite haute de 4611686018427387904, vous pourriez vous en tirerseq 0 $[1<<62]
seq
accepteNaN
comme valeur: j'ai maintenant unseq 0 NaN|sed -r "h;/[12357]/d;s/8|0/&&/g;/^.{$1}/!d;x"|sed $2!d\;q
score de 67.-sh: !d\: event not found
` before
! ` N'est pas nécessaire dans un script . Cela n'est nécessaire que lorsque vous exécutez ceci directement sur la ligne de commande, ce qui, à mon avis, n'est pas une obligation.MATL , 39
40octetsLes envois sont
n
eth
dans cet ordre.Essayez-le en ligne!
Nous devons suivre deux nombres: le numéro actuel du candidat (pour vérifier sa sainteté) et le nombre de chiffres trouvés qui sont suffisamment sacrés. Le premier est le sommet de la pile et le dernier est conservé en nombre d'éléments dans la pile. Lorsque le programme est terminé, seul le haut doit être affiché.
la source
R,
109107 octetsAvec de nouvelles lignes et empreintes:
Usage:
la source
JavaScript (ES6), 110 octets
Queue solution récursive qui accumule des nombres sacrés dans un tableau.
Par intérêt, ne pas exiger que le nombre soit totalement (!) Saint rend la sainteté plus difficile à gérer, mais cela permet néanmoins d'économiser 10% au total:
la source
i
etr
à un moment donné et je n'ai pas pu modifier correctement la modification.JavaScript ES6, 191 octets
Bien sûr, ce n'est pas le moyen le plus efficace. Mais tu me connais, j'aime les générateurs <3
Légèrement non-golfé:
la source
C # 6, 168 octets
Ceci est une expression Lambda de type Func <int, int, int>. Ce code est optimisé pour une taille minimale (non performatique).
Ci-dessous, le code embelli dans la déclaration de méthode (avec plus de performances):
la source
JavaScript (ES6), 87
Moins golfé
Tester
la source
Lua, 169 octets
Ungolfed:
la source
Lua,
155141140 octetsPrend les deux entrées par un argument de ligne de commande (le premier argument est n, puis h)
Edit: Merci à @DavisDude, qui m'a aidé à éliminer 14 octets et m'a rappelé que je n'avais pas à imprimer tous les nombres sacrés jusqu'à n, mais seulement le nième.
Ungolfed et explications
la source
print(a[arg[1]])
n
. En fait,print(a[#a])
sauve encore plus d'octets. Merci pour le commentaire !x=0a={}
place dex,a=0,{}
.0a
serait interprété comme un nombre hexadécimal, mais je peux le fairea={}x=0while
sans problème :)Oracle SQL 11.2, 229 octets
Non-golfé
la source
Python 2, 96 octets
La condition d'holyness on
k
est vérifiée parsum(map(s.count,`k`))>=h
, qui compte le nombre de trous en additionnant les comptes de chaque personnage danss="0046889"
, où0
et8
apparaissent deux fois.set(str(k))<=set(s))
, qui vérifie que les nombres sont tous saints.str
est utilisé plutôt que des backticks pour éviter le suffixeL
pour les longs.Celles-ci sont chaînées en une seule égalité en utilisant le fait Python 2 que les nombres sont plus petits que les ensembles.
La fonction est définie de manière récursive pour compter les nombres
k
, en diminuant le compteur àn
chaque fois qu'un nombre sacré de touches est atteint, à moins qu'il ne frappe0
. Il pourrait alors renvoyer l'k
élément qui a déclenché cette opération, mais il est plus court de conserver le nombre récursivement en ajoutant1
chaque fois, même si une analyse décalée nécessite un nombre de base-1
à corriger.la source
Haskell, 94 octets
c
est la sainteté d'un chiffre,v
la sainteté d'un nombre,n!h
fait le reste.Note: Je pense que c'est la seule réponse sans les caractères
4,6,8
.la source
Rapide
la source