Dada una pantalla de 7 segmentos con algunos segmentos encendidos y otros apagados, encuentre una secuencia de dígitos (0-9), de modo que después de alternar los segmentos correspondientes para cada dígito, todos los segmentos se apaguen.

Ejemplo

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

Números y sus segmentos correspondientes:

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

Reglas

Codegolf ⊨ gana la entrada más corta.

Entrada

Una lista no vacía de segmentos que están activados, dada como

1. Una secuencia de números. Los segmentos están numerados de arriba a abajo, de izquierda a derecha; a partir de 0 o 1. Los números no necesitan estar en orden.

2. Un solo dígito de 7 bits. MSB / LSB no especificado (por lo tanto, puede elegir).

Se permiten caracteres no numéricos entre números (pero no es necesario que sean compatibles).

P.ej. para número 7: 136o 1010010o0100101

Salida

Una secuencia de números que se "aplicarán" a la pantalla. No está restringido de ninguna manera, como el orden de los dígitos. P.ej. para el estado inicial correspondiente a número 1, salidas válidas sería 1, 111, 010, etc.

Una salida alternativa es un dígito de 10 bits (nuevamente, MSB / LSB es su elección). P.ej. para 1como entrada, la salida sería 1000000000o 0000000001.

Algunas combinaciones tienen varias soluciones no repetitivas, por ejemplo. Los segmentos correspondientes a la letra mayúscula Hse pueden desactivar mediante 013, pero también 489y 0258.

Si no existe una solución (que creo que no es posible), la salida está vacía.

Jalea , 26 25 bytes

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

Pruébalo en línea!

Toma la entrada como un entero de 7 bits. Devuelve la forma binaria de un entero de 10 bits.

Este bruto simplemente obliga a todas las posibilidades. Elimine el Ḣpara obtener todas las salidas posibles o reemplácelo con un Xpara obtener una salida posible aleatoria.

Programa de visualización mágica!

Cómo 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)

Esto funciona porque:

• Alternar 1 y 7 alterna solo el segmento superior
• Alternar 1, 2 y 6 alterna solo el segmento superior izquierdo
• Alternar 1, 2, 3, 5 y 6 solo alterna el segmento superior derecho
• Alternar 2, 4 y 6 alterna solo el segmento central
• Alternar 5 y 6 alterna solo el segmento inferior izquierdo
• Alternar 2, 3, 5 y 6 alterna solo el segmento inferior derecho
• Alternar 2, 3, 4, 6 y 7 solo alterna el segmento inferior

JavaScript (ES6), 117 107 101 86 84 bytes

Guardado 15 bytes gracias a Neil

Toma la entrada como un entero de 7 bits, donde el LSB es el segmento superior. Devuelve un entero de 10 bits donde el LSB es un 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

Manifestación

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}[[#]]&

(Se puede jugar más al elegir cuidadosamente la salida para cada segmento y cambiar entre LSB y MSB).

Tome la entrada como una lista de posiciones, por ejemplo, {2,4,5,7}y envíe un número de 10 bits ( 384= 0110000000en binario) en orden MSB (0, ..., 9).

En el ejemplo corresponde a

  |_
  |_

y la salida corresponde a {7,8}.

Explicación:

Los números mágicos (lista codificada) es la salida que se devuelve para cada segmento. (codificado en binario) Y, si un número aparece en la lista dos veces, el efecto es el mismo de no aparecer, por lo que se utiliza XOR a nivel de bits. Solo necesitamos XOR la ​​salida del posible valor de los segmentos activados.

Jalea , 12 bytes

ị“A#7*06n‘^/

Pruébalo en línea!

Esto no tiene fuerza bruta, y es notablemente más corto que mi otra solución. Toma la entrada como una lista de segmentos activados, y las salidas como LSB es el segmento superior.

Salida como lista de movimientos de dígitos.

Cómo funciona

Esto va a 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