Hay muchos acertijos con coincidencias que implican agregar, eliminar o mover un cierto número de coincidencias para crear nuevos números o formas. Esto es así con un reloj digital.

Dada una hora válida en un reloj digital de 12 horas, genera el dígito que requiere mover la menor cantidad de líneas para que cada dígito visible en el reloj se convierta en ese dígito. Si más de un dígito es el mínimo, imprímalos todos. Si es imposible hacer que cada dígito sea igual, salida -1o un valor falso distinto de 0 (obtendrá muchos de estos).

Los dígitos del reloj se ven así:

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

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

Casos de prueba:

Entrada: 123

Pantalla del reloj:

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

Salida: 4

Explicación: La visualización de 1:23requiere un total de 12 líneas para dibujar. Por lo tanto, para que cada dígito sea el mismo, cada dígito tendría que tener 4 líneas. El único dígito que tiene 4 líneas es 4. Por lo tanto, la respuesta tiene que ser 4.

Entrada: 1212

Pantalla del reloj:

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

Salida: -1

Explicación: La visualización de 12:12requiere 14 líneas. 14 dividido entre 4 no es un entero, por lo tanto, es imposible que cada dígito sea el mismo.

Entrada: 654

Pantalla del reloj:

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

Salida: 5

Explicación: El número total de líneas es 15. 15 dividido entre 3 es 5, por lo que cada dígito debe tener 5 líneas. Las únicas cifras que tienen 5 líneas son 2, 3y 5. La respuesta es 5porque solo requiere 2 movimientos para hacer cada dígito 5. Simplemente mueva la línea en la parte inferior izquierda del 6 hacia la parte inferior del 4, entonces usted tiene:

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

Luego, como puede ver, todo lo que necesita hacer es mover la línea en la parte superior derecha del dígito que originalmente era 4 hacia la parte superior, y obtendrá 5:55. Hacer cada dígito a 2o 3requeriría más de 2 movimientos.

Entrada: 609

Pantalla del reloj:

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

Salida: 609( 6,0,9o [6,0,9]también está bien).

Explicación: 6, 0, y 9son los únicos dígitos que tienen 6 líneas. Como tales, también son las únicas soluciones posibles. No es difícil ver que se necesitarían dos movimientos para hacer que cualquiera de estos sea el único dígito. Por lo tanto, genera los tres dígitos.

Notas:

• Aunque el tiempo de entrada debe ser válido, el tiempo de salida no (p. Ej., 999Como una salida está bien).
• Soy muy flexible con la entrada. Puede requerir un 0 inicial. Puede usar un número con un punto decimal. Puedes usar una cuerda. Puedes usar una matriz. Puede tener un parámetro para cada dígito.

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)

Esta es una función lambda. Asignarlo a una variable para llamarlo. Acepta un vector de enteros en el rango 0-9de cualquier longitud y devuelve un vector de resultados (posiblemente vacío).

Casos de prueba

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

Explicación

Enumerar los siete segmentos y representarlos como un vector de bits.

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

Ejemplo: 1 (segmentos 2 + 5 habilitados) se convierte 36(conjunto de bits 2 + 5).
Aquí están las representaciones para los dígitos 0-9.

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

Podemos usar el dígito como índice para obtener su representación vectorial de bits. +1debido a la indexación basada en 1 en julia.

La función c=count_ones;cuenta el número de 1 bits en un entero. Asignamos un alias porque lo necesitamos con más frecuencia.

El programa completo, de alguna manera no golfista:

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
)

Ahora, las dos últimas líneas en detalle:

mean(map(c,m)) calcula el número promedio de líneas por dígito de entrada.

n=map(a->...,l) recorre la representación vectorial de todos los dígitos.

Si el número de líneas de nuestro dígito actual no aes igual al recuento de líneas promedio de la entrada, regrese inf.

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

De lo contrario, devuelva la suma de las distancias de Hamming entre nuestros dígitos de entrada actuales y todos.

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

Ahora tenemos un vector nde longitud que 10representa los números 0-9que nos dan el número total de adiciones / eliminaciones que tenemos que realizar para transformar todos los dígitos de entrada a ese número o inf, si tal transformación es imposible sin cambiar el número de líneas.

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

Finalmente, muestre las ubicaciones (basadas en 0) de todos los mínimos que no lo son inf.