Ce défi est fortement inspiré par ce que @Mego a créé avec ses numéros Holy et Holier , beaucoup de remerciements à lui et à ses jeux de mots.

Les nombres sacrés sont des nombres composés uniquement des chiffres avec des trous , qui sont:

04689

Les nombres avec au moins un chiffre impie sont considérés comme impies. Les chiffres impurs sont mauvais par définition, mais être proches des chiffres saints les aident à devenir neutres. Par conséquent, plus ils sont proches, moins ils sont impurs (1 lorsqu'ils sont adjacents).

L'impiété d'un nombre est la somme de l'impie de ses chiffres, un nombre composé uniquement d'un nombre impie a une impie infinie.

Number            :8 5 5 8 7
Digital Unholiness:0+1+1+0+1
Total Unholiness  :3

Number            :0 1 7 5 5 2 8 5 7 
Digital Unholiness:0+1+2+3+2+1+0+1+2
Total Unholiness  :12

Number            :1 5 7 3 2 1
Digital Unholiness:∞+∞+∞+∞+∞+∞
Total Unholiness  :∞

Number            :0 4 6 8 9
Digital Unholiness:0+0+0+0+0
Total Unholiness  :0

Ta tâche

Vous devez écrire un programme ou une fonction qui prend un entier positif ou une chaîne composée uniquement de chiffres en entrée, et sortir son caractère impur. Si vous avez choisi d'utiliser un entier comme entrée, vous pouvez supposer qu'il n'aura jamais de début 0car votre langue peut le supprimer.

En cas d'impiété infinie, vous pouvez choisir entre trois sorties

• Le caractère ∞(3 octets)
• Sortie infinie contenant au moins 1 chiffre différent de zéro, mais uniquement des chiffres.
• Une Infinityvaleur intégrée .

C'est le code-golf, donc le code le plus court en octets gagne, bonne chance!

MATL , 25 24 octets

7Zq1hVmt~f!wf-|X<st~?xYY

Essayez-le en ligne!

L'entrée est une chaîne. Dans la sortie, l'infini est affiché nativement sous la forme Inf.

Explication

7         % number literal                                 
Zq        % prime numbers up to a 7: [2 3 5 7]
1         % number literal                        
h         % horizontal concatenation                       
V         % convert numbers to string: '2  3  5  7  1'
m         % take input implicitly. Determine which digits are 1,2,3,5,7
t         % duplicate
~         % element-wise negate: which digits are 4,6,8,9,0
f         % indices of occurrences of digits 4,6,8,9,0
!         % transpose into column array
w         % swap elements in stack           
f         % indices of occurrences of digits 1,2,3,5,7  
-         % element-wise subtraction with broadcast. Gives 2D array
|         % element-wise absolute value                          
X<        % minimum of each column
s         % sum of elements of array
t         % duplicate                       
~         % element-wise negate
?         % if all elements are true                            
  x       %   delete                                         
  YY      %   push infinity                                       
          % (implicit) end if
          % (implicit) convert to string and display  

Python (3), 137 131 octets

def f(s):
 l=range(len(s))
 r=[min(i)for i in zip(*[[abs(j-i)for j in l]for i in l if s[i]in'46890'])]
 return sum(r)if r else'∞'

Résultats

>>> [f(i) for i in ['85587', '012321857', '157321', '04689']]
[3, 12, '∞', 0]

Pyth, 31 29 27 25 octets

smhS.e?}b"04689"akd.n4zUz

Essayez-le en ligne: démonstration ou suite de tests

Pour chaque chiffre, je calcule les distances à chaque nombre. Une distance est infinty, si le deuxième chiffre n'est pas saint. De ces listes, je prends la distance minimale et je la résume.

Explication:

smhS.e?}b"04689"akd.n4zUz  implicit: z = input string of numbers
 m                     Uz  map each d in [0, 1, ..., len(z)-1] to:
    .e                z      map each k (index), b (value) of b to:
                akd            absolute difference between k and d

      ?}b"04689"               if b in "04689" else
                   .n4         infinity
   S                           sort
  h                            take the first element (=minimum)
s                              print the sum

JavaScript (ES6), 93 octets

s=>[...s].map(n=>/[12357]/.test(n)?++u:u=0,u=1/0).reverse().map(n=>r+=n?n<++u?n:u:u=0,r=0)&&r

Si ce Infinityn'est pas un infini légal, ajoutez 13 octets pour ==1/0?'∞':r.