Étant donné un affichage à 7 segments avec certains segments activés et d'autres désactivés, recherchez une séquence de chiffres (0-9), de sorte qu'après avoir basculé les segments correspondants pour chaque chiffre, tous les segments sont désactivés.

Exemple

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

Numéros et leurs segments correspondants:

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

Règles

Codegolf ⊨ remporte la plus courte entrée.

Contribution

Une liste non vide de segments activés, donnée comme

1. Une séquence de nombres. Les segments sont numérotés de haut en bas, de gauche à droite; à partir de 0 ou 1. Il n'est pas nécessaire que les nombres soient en ordre.

2. Un seul chiffre de 7 bits. MSB / LSB non spécifié (vous pouvez donc choisir).

Les caractères non numériques entre les nombres sont autorisés (mais ne doivent pas nécessairement être pris en charge).

Par exemple. pour numéro 7: 136ou 1010010ou0100101

Production

Une séquence de nombres à «appliquer» à l'affichage. Pas de restriction en aucune façon, comme l'ordre des chiffres. Par exemple. pour l' état initial correspondant au nombre 1, sorties valides serait 1, 111, 010, etc.

Une sortie alternative est un chiffre de 10 bits (encore une fois, MSB / LSB est votre choix). Par exemple. car 1en entrée, la sortie serait 1000000000ou 0000000001.

Certaines combinaisons ont plusieurs solutions non répétitives, par exemple. les segments correspondant à la lettre majuscule Hpeuvent être désactivés par 013, mais aussi 489et 0258.

Si aucune solution n'existe (ce qui, je pense, n'est pas possible), la sortie est vide.

Gelée , 26 25 octets

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

Essayez-le en ligne!

Prend l'entrée comme un entier de 7 bits. Renvoie la forme binaire d'un entier de 10 bits.

Cette brute force toutes les possibilités. Retirer leḢ pour obtenir toutes les sorties possibles ou remplacez-le par un Xpour obtenir une sortie possible aléatoire.

Programme de visualisation magique!

Comment ça fonctionne

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 octets

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

Cela fonctionne parce que:

• Basculer entre 1 et 7 bascule uniquement le segment supérieur
• Basculer 1, 2 et 6 bascule uniquement le segment supérieur gauche
• Basculer entre 1, 2, 3, 5 et 6 bascule uniquement le segment supérieur droit
• Basculer entre 2, 4 et 6 bascule le segment central uniquement
• Basculer entre 5 et 6 bascule uniquement le segment inférieur gauche
• Basculer entre 2, 3, 5 et 6 bascule uniquement le segment inférieur droit
• Basculer entre 2, 3, 4, 6 et 7 bascule uniquement le segment inférieur

JavaScript (ES6), 117 107 101 86 84 octets

15 octets enregistrés grâce à Neil

Prend l'entrée comme un entier de 7 bits, où le LSB est le segment supérieur. Renvoie un entier de 10 bits où le LSB est un chiffre 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

Démo

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 octets

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

(Il peut être plus joué en choisissant la sortie pour chaque segment avec soin et en basculant entre LSB et MSB.)

Prenez l'entrée comme une liste de positions par exemple {2,4,5,7}et sortez un nombre de 10 bits ( 384= 0110000000en binaire) dans l'ordre MSB (0, ..., 9).

Dans l'exemple, il correspond à

  |_
  |_

et la sortie correspond à {7,8} .

Explication:

Les nombres magiques (liste codée en dur) est la sortie qui est retournée pour chaque segment. (codé en binaire) Et, si un nombre apparaît deux fois dans la liste, l'effet est le même s'il n'apparaît pas, donc XOR au niveau du bit est utilisé. Nous avons juste besoin de XOR la ​​sortie de la valeur possible des segments activés.

Gelée , 12 octets

ị“A#7*06n‘^/

Essayez-le en ligne!

Ce n'est pas de la force brute, et c'est remarquablement plus court que mon autre solution. Prend l'entrée comme une liste de segments activés et les sorties comme LSB est le segment supérieur.

Sortie sous forme de liste de mouvements de chiffres.

Comment ça fonctionne

Ça va être rapide

ị“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