Dado um display de 7 segmentos com alguns segmentos ativados e desativados, encontre uma sequência de dígitos (0-9), de modo que, após alternar os segmentos correspondentes para cada dígito, todos os segmentos sejam desativados.

Exemplo

  _
  _    [3] =>     |   [1] =>    [OFF]
  _               |

Números e seus segmentos correspondentes:

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

Regras

Codegolf - menor entrada ganha.

Entrada

Uma lista não vazia de segmentos ativados, fornecida como

1. Uma sequência de números. Os segmentos são numerados de cima para baixo, da esquerda para a direita; a partir de 0 ou 1. Os números não precisam estar em ordem.

2. Um único dígito de 7 bits. MSB / LSB não especificado (portanto, você pode escolher).

Caracteres não numéricos entre números são permitidos (mas não precisam ser suportados).

Por exemplo. para número 7: 136ou 1010010ou0100101

Resultado

Uma sequência de números a serem "aplicados" ao visor. Não é restrito de forma alguma, como a ordem dos dígitos. Por exemplo. para o estado inicial correspondente ao número 1, saídas válidas seria 1, 111, 010, etc.

Uma saída alternativa é um dígito de 10 bits (novamente, MSB / LSB é sua escolha). Por exemplo. para 1como entrada, a saída seria 1000000000ou 0000000001.

Algumas combinações têm várias soluções não repetitivas, por exemplo. os segmentos correspondentes à letra maiúscula Hpodem ser desativados por 013, mas também 489e 0258.

Se não existir uma solução (que eu acredito que não seja possível), a saída está vazia.

Geléia , 26 25 bytes

2ṗ⁵’µ×“wØ][:koR¶{‘^/=µÐfḢ

Experimente online!

Recebe a entrada como um número inteiro de 7 bits. Retorna a forma binária de um número inteiro de 10 bits.

Este bruto apenas força todas as possibilidades. Remova o Ḣpara obter todas as saídas possíveis ou substitua-o por um Xpara obter uma saída possível aleatória.

Programa de Visualização Mágica!

Como funciona

2ṗ⁵’µ×“wØ][:koR¶{‘^/=µÐfḢ  - main link, takes one integer
2ṗ⁵’                       - generate all length-10 binary arrays
    µ                µÐf   - now we find those arrays which correspond to digit-
                              sequences which work to switch off all segments:
                              Filter (keep) those arrays which:
     ×                      - multiplied by 
      “wØ][:koR¶{‘          - [119, 18, 93, 91, 58, 107, 111, 82, 127, 123] 
                               (encoding for turned-on segments given number)
                  ^/        - reduced by XOR
                    =      - are equal to (implicit) the program's input
                        Ḣ  - output the first of these valid arrays

JavaScript (ES6), 60 bytes

n=>[65,35,55,42,48,54,110].reduce((r,v,i)=>r^=n>>i&1&&v+v,0)

Isso funciona porque:

• Alternar 1 e 7 alterna apenas o segmento superior
• Alternar 1, 2 e 6 alterna apenas o segmento superior esquerdo
• Alternar 1, 2, 3, 5 e 6 alterna apenas o segmento superior direito
• Alternar 2, 4 e 6 alterna apenas o segmento central
• Alternar 5 e 6 alterna apenas o segmento inferior esquerdo
• Alternar 2, 3, 5 e 6 alterna apenas o segmento inferior direito
• Alternar 2, 3, 4, 6 e 7 alterna apenas o segmento inferior

JavaScript (ES6), 117 107 101 86 84 bytes

Economizou 15 bytes graças a Neil

Recebe a entrada como um número inteiro de 7 bits, onde o LSB é o segmento superior. Retorna um número inteiro de 10 bits em que o LSB é um dígito 0.

f=(n,k)=>[83,0,57,73,10,71,87,1,91,75].reduce((n,v,i)=>n^=k>>i&1&&v+36,n)?f(n,-~k):k

Demo

f=(n,k)=>[83,0,57,73,10,71,87,1,91,75].reduce((n,v,i)=>n^=k>>i&1&&v+36,n)?f(n,-~k):k

console.log("'1' shape", "-->", f(0b0100100).toString(2))
console.log("'7' shape", "-->", f(0b0100101).toString(2))
console.log("'H' shape", "-->", f(0b0111110).toString(2))

Mathematica, 40 bytes

BitXor@@{260,802,10,514,3,266,293}[[#]]&

(Pode-se jogar mais escolhendo a saída para cada segmento com cuidado e alternando entre LSB e MSB.)

Tome entrada como uma lista de posições, por exemplo, {2,4,5,7}e envie um número de 10 bits ( 384=0110000000 em binário) na ordem MSB (0, ..., 9).

No exemplo, corresponde a

  |_
  |_

e a saída corresponde a {7,8} .

Explicação:

Os números mágicos (lista codificada) são a saída retornada para cada segmento. (codificado em binário) E, se um número aparecer na lista duas vezes, o efeito é o mesmo de não aparecer, portanto, o XOR bit a bit é usado. Nós apenas precisamos XOR a saída do valor possível dos segmentos ativados.

Gelatina , 12 bytes

ị“A#7*06n‘^/

Experimente online!

Isso não força bruta e é notavelmente mais curto que minha outra solução. Recebe a entrada como uma lista de segmentos ativados e as saídas como LSB é o segmento superior.

Saída como lista de movimentos de dígitos.

Como funciona

Isso vai ser rápido

ị“A#7*06n‘^/ - main link, takes input as a list of turned-on segments (eg. [1,3,6])
 “A#7*06n‘   - list literal [65,35,55,42,48,54,110] where each element is a 7-bit
                 integer, where each integer corresponds to how to turn off
                 a segment (eg. turn off the first segment with 7 and 1 =>2^7+2^1=>64)
ị            - get the elements in the list corresponding to the input indices
          ^/ - XOR reduce these elements to get a single 7-bit integer