Il existe de nombreux casse-tête avec des correspondances qui impliquent l'ajout, la suppression ou le déplacement d'un certain nombre de correspondances pour créer de nouveaux nombres ou formes. C'est comme ça avec une horloge numérique.

Étant donné une heure valide sur une horloge numérique de 12 heures, émettez le chiffre qui nécessite de déplacer le moins de lignes pour que chaque chiffre visible de l'horloge devienne ce chiffre. Si plus d'un chiffre est le minimum, sortez-les tous. S'il est impossible de faire en sorte que chaque chiffre soit le même, une sortie -1ou une valeur falsifiée autre que 0 (vous en obtiendrez beaucoup).

Les chiffres de l'horloge ressemblent à ceci:

  |
  |
 _
 _|
|_
 _
 _|
 _|

|_|
  |
 _
|_
 _|
 _
|_
|_|
 _
  |
  |    
 _ 
|_|
|_|
 _
|_|
 _|
 _
| |
|_|

Cas de test:

Contribution: 123

Affichage de l'horloge:

       _   _
  | :  _|  _|
  | : |_   _|

Production: 4

Explication: L'affichage de 1:23nécessite un total de 12 lignes à tracer. Par conséquent, pour que chaque chiffre soit le même, chaque chiffre devrait avoir 4 lignes. Le seul chiffre qui a 4 lignes est 4. Par conséquent, la réponse doit être 4.

Contribution: 1212

Affichage de l'horloge:

     _        _
  |  _| :  |  _|
  | |_  :  | |_

Production: -1

Explication: L'affichage de 12:12nécessite 14 lignes. 14 divisé par 4 n'est pas un entier, il est donc impossible que chaque chiffre soit le même.

Contribution: 654

Affichage de l'horloge:

 _     _  
|_  : |_  |_|
|_| :  _|   |

Production: 5

Explication: Le nombre total de lignes est de 15. 15 divisé par 3 est 5, donc chaque chiffre doit avoir 5 lignes. Les chiffres qui ont seulement 5 lignes sont 2, 3et 5. La réponse est 5parce qu'il ne faut que 2 coups pour faire chaque chiffre 5. Déplacez simplement la ligne en bas à gauche du 6 vers le bas du 4, alors vous avez:

 _     _  
|_  : |_  |_|
 _| :  _|  _|

Ensuite, comme vous pouvez le voir, tout ce que vous avez à faire est de déplacer la ligne en haut à droite du chiffre qui était à l'origine 4 vers le haut, et vous obtenez 5:55. Pour faire de chaque chiffre un 2ou 3nécessiterait plus de 2 mouvements.

Contribution: 609

Affichage de l'horloge:

 _     _   _
|_  : | | |_|
|_| : |_|  _|

Sortie: 609( 6,0,9ou [6,0,9]aussi ok).

Explication: 6, 0et 9sont les seuls chiffres qui ont 6 lignes. En tant que tels, ils sont également les seules solutions possibles. Il n'est pas difficile de voir qu'il faudrait deux mouvements pour que l'un d'eux soit le seul chiffre. Par conséquent, vous sortez les trois chiffres.

Remarques:

• Bien que le temps d'entrée doit être valide, le temps de sortie ne l'est pas (par exemple, 999comme une sortie est OK.)
• Je suis très flexible avec entrée. Vous pouvez exiger un 0 en tête. Vous pouvez utiliser un nombre avec un point décimal. Vous pouvez utiliser une chaîne. Vous pouvez utiliser un tableau. Vous pouvez avoir un paramètre pour chaque chiffre.

Julia, 160 157 154

x->(c=count_ones;l=[119;36;93;109;46;107;123;37;127;111];m=l[x+1];n=map(a->c(a)==mean(map(c,m))?sum(map(b->c(a$b),m)):1/0,l);find(n.==minimum(n).!=1/0)-1)

Il s'agit d'une fonction lambda. Affectez-le à une variable pour l'appeler. Accepte un vecteur d'entiers dans une plage 0-9de n'importe quelle longueur et renvoie un vecteur de résultats (éventuellement vide).

Cas de test

julia> clock = x->(c=co...        # assign function to variable
(anonymous function)

julia> clock([1 2 3])
1-element Array{Int64,1}:
 4

julia> clock([1 2 1 2])
0-element Array{Int64,1}

julia> clock([6 5 4])
1-element Array{Int64,1}:
 5

clock([6 0 9])
3-element Array{Int64,1}:
 0
 6
 9

Explication

Énumérer les sept segments et les représenter comme un vecteur de bits.

+---+                     +-0-+
|   |      Enumerate      1   2
+---+   >  the seven  >   +-3-+
|   |      segments       4   5
+---+                     +-6-+

Exemple: 1 (segments 2 + 5 activés) devient 36(bits 2 + 5 définis).
Voici les représentations des chiffres 0-9.

l=[119;36;93;109;46;107;123;37;127;111];
m=l[x+1];

Nous pouvons utiliser le chiffre comme index pour obtenir sa représentation vectorielle binaire. +1en raison de l'indexation basée sur 1 en julia.

La fonction c=count_ones;compte le nombre de 1 bits dans un entier. Nous attribuons un alias car nous en avons besoin plus souvent.

Le programme complet, quelque peu non golfé:

x->(
  c=count_ones;
  l=[119;36;93;109;46;107;123;37;127;111];
  m=l[x+1];
  n=map(a->c(a)==mean(map(c,m))?sum(map(b->c(a$b),m)):1/0,l);
  find(n.==minimum(n).!=1/0)-1
)

Maintenant, les deux dernières lignes en détail:

mean(map(c,m)) calcule le nombre moyen de lignes par chiffre d'entrée.

n=map(a->...,l) boucle sur la représentation vectorielle de tous les chiffres.

Si le nombre de lignes de notre chiffre actuel aest différent du nombre de lignes moyen de l'entrée, retournez inf.

c(a)==mean(map(c,m))?...:1/0

Sinon, renvoyez la somme des distances de Hamming entre notre courant et tous les chiffres d'entrée.

sum(map(b->c(a$b),m))

Nous avons maintenant un vecteur nde longueur 10représentant les nombres 0-9qui nous donne le nombre total d'ajouts / suppressions que nous devons effectuer pour transformer tous les chiffres d'entrée en ce nombre, ou inf, si une telle transformation est impossible sans changer le nombre de lignes.

find(n.==minimum(n).!=1/0)-1

Enfin, affichez les emplacements (basés sur 0) de tous les minima qui ne le sont pas inf.