Existem muitos quebra-cabeças com correspondências que envolvem adicionar, remover ou mover um certo número de correspondências para criar novos números ou formas. É assim com um relógio digital.

Dado um tempo válido em um relógio digital de 12 horas, imprima o dígito que requer mover o menor número de linhas para que todos os dígitos visíveis no relógio se tornem esse dígito. Se mais de um dígito for o mínimo, imprima todos eles. Se for impossível tornar todos os dígitos iguais, -1gerar um valor falso ou diferente de 0 (você obterá muitos deles).

Os dígitos do relógio são assim:

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

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

Casos de teste:

Entrada: 123

Exibição do relógio:

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

Resultado: 4

Explicação: A exibição para 1:23requer um total de 12 linhas a serem desenhadas. Portanto, para cada dígito ser o mesmo, cada dígito teria que ter 4 linhas. O único dígito que tem 4 linhas é 4. Portanto, a resposta tem que ser 4.

Entrada: 1212

Exibição do relógio:

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

Resultado: -1

Explicação: A exibição para 12:12requer 14 linhas. 14 dividido por 4 não é um número inteiro; portanto, é impossível que cada dígito seja o mesmo.

Entrada: 654

Exibição do relógio:

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

Resultado: 5

Explicação: O número total de linhas é 15. 15 dividido por 3 é 5, portanto, cada dígito deve ter 5 linhas. Os únicos dígitos que têm 5 linhas são 2, 3e 5. A resposta é 5que são necessários apenas dois movimentos para fazer todos os dígitos 5. Mova a linha na parte inferior esquerda do 6 para a parte inferior do 4, e você terá:

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

Então, como você pode ver, tudo o que você precisa fazer é mover a linha no canto superior direito do dígito que originalmente era 4 para o topo e você consegue 5:55. Para tornar cada dígito um 2ou 3exigiria mais de 2 movimentos.

Entrada: 609

Exibição do relógio:

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

Saída: 609( 6,0,9ou [6,0,9]também ok).

Explicação: 6, 0, e 9são os únicos dígitos que têm 6 linhas. Como tal, elas também são as únicas soluções possíveis. Não é difícil ver que seriam necessários dois movimentos para tornar qualquer um deles o único dígito. Portanto, você produz os três dígitos.

Notas:

• Embora o tempo de entrada deva ser válido, o tempo de saída não (por exemplo, 999como uma saída está correta).
• Eu sou muito flexível com a entrada. Você pode exigir um 0. inicial. Você pode usar um número com um ponto decimal. Você pode usar uma string. Você pode usar uma matriz. Você pode ter um 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 é uma função lambda. Atribua a uma variável para chamá-lo. Aceita um vetor de números inteiros no intervalo 0-9de qualquer comprimento e retorna um vetor de resultados (possivelmente vazio).

Casos de teste

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

Explicação

Enumere os sete segmentos e os represente como um vetor de bits.

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

Exemplo: 1 (segmentos 2 + 5 ativados) se torna 36(bits 2 + 5 configurados).
Aqui estão as representações para dígitos 0-9.

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

Podemos usar o dígito como índice para obter sua representação vetorial de bits. +1por causa da indexação baseada em 1 em julia.

A função c=count_ones;conta o número de 1 bits em um número inteiro. Atribuímos um alias porque precisamos com mais frequência.

O programa completo, de certa forma não destruído:

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
)

Agora, as duas últimas linhas em detalhes:

mean(map(c,m)) calcula o número médio de linhas por dígito de entrada.

n=map(a->...,l) circula a representação vetorial de todos os dígitos.

Se o número de linhas do nosso dígito atual afor desigual à contagem de linha média da entrada, retorne inf.

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

Caso contrário, retorne a soma das distâncias de Hamming entre nossos dígitos atuais e todos os dígitos de entrada.

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

Agora temos um vetor nde comprimento 10representando os números 0-9que nos fornece o número total de adições / exclusões que precisamos executar para transformar todos os dígitos de entrada nesse número ou inf, se essa transformação for impossível sem alterar o número de linhas.

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

Finalmente, produza os locais (com base em 0) de todos os mínimos que não são inf.