Décoder un affichage à 7 segments


17

Vous connaissez probablement tous l' affichage à 7 segments qui peut afficher entre autres tous les chiffres de :09

Affichage à 7 segments (wikipedia.org)

Défi

Nous considérons uniquement les segments , votre tâche consiste à décoder un seul chiffre en fonction des segments activés.UNEg

Cela peut être codé comme un entier de 8 bits, voici un tableau de chaque chiffre avec leur représentation binaire et les valeurs correspondantes petit-bout et grand-bout:

Chiffre.ABCDEFGPetit endianBig-endian0011111101260x7E1260x7E100110000480x30120x0C2011011011090x6D1820xB63011110011210x791580x9E400110011510x332040xCC501011011910x5B2180xDA601011111950x5F2500xFAsept011100001120x70140x0E8011111111270x7F2540xFE9011110111230x7B2220xDE

Règles et E / S

  • L'entrée sera l'une des
    • entier unique (comme dans le tableau ci-dessus l'un des deux ordres donnés)
    • une liste / tableau / .. de bits
    • une chaîne composée de caractères ABCDEFG(vous pouvez supposer qu'elle est triée, comme un exemple ABCcode ), leur cas est votre choix (pas de casse mixte)sept
  • La sortie sera le chiffre qu'il code
  • Vous ne pouvez supposer aucune entrée invalide (invalide signifie qu'il n'y a pas de chiffre correspondant)

Les tests

Étant donné que ce défi permet plusieurs représentations, veuillez vous référer au tableau.



Pouvons-nous accepter un entier (ou un tableau) dans n'importe quel ordre de bits spécifié ou juste les deux affichés?
Jonathan Allan

@JonathanAllan: Je vais clarifier, seulement ceux déjà montrés.
ბიმო

Ohhh merde, vous n'avez pas à gérer tous les types d'entrée? Seulement un? Oups ...
Urne de poulpe magique

@MagicOctopusUrn: Oui en effet :)
ბიმო

Réponses:




7

Wolfram Language (Mathematica) , 41 octets

9[,6,0,8,2,3,1,7,5,4][[#~Mod~41~Mod~11]]&

Essayez-le en ligne!

Utilise la colonne de petits nombres entiers comme entrée. Ignorez l'avertissement de syntaxe.

Pour une entrée X, nous prenons d'abord X mod 41 puis prenons le résultat mod 11. Les résultats sont distincts mod 11, nous pouvons donc les extraire d'une table. Par exemple, 126 mod 41 mod 11 est 3, donc si nous faisons la position 3 égale à 0, alors nous obtenons la bonne réponse pour une entrée de 126.

Le tableau est 9[,6,0,8,2,3,1,7,5,4]. La partie 0 est la tête, ce qui est 9. La partie 1 est manquante, donc c'est Nullpour sauver un octet: nous n'avons jamais besoin de prendre la partie 1. Ensuite, la partie 2 est 6, la partie 3 est 0, et ainsi de suite, comme d'habitude.


La réponse de Jonathan Allan nous donne 1[4,9,8,6,2,0,5,3,7][[384~Mod~#~Mod~13]]&. Ce n'est pas plus court, mais cela évite l'avertissement de syntaxe!


Wolfram Language (Mathematica) , 27 25 octets

Mod[Hash[")dD}"#]+2,11]&

(Il y a un personnage ici qui n'apparaît pas tout à fait, désolé. Cliquez sur le lien ci-dessous et vous le verrez.)

Essayez-le en ligne!

Il s'agit de forcer brutalement une chaîne à l'intérieur Hashafin que les hachages finissent par avoir les bonnes valeurs mod 11. Plus le forçage brutal peut probablement nous amener à une solution encore plus courte.


Pourriez-vous expliquer un peu cette réponse, pour quelqu'un qui ne connaît pas Mathematica?
jrook

Je pensais que ce serait lisible pour n'importe qui, mais d'accord, je vais éditer une explication.
Misha Lavrov

Félicitations; la solution de 41 octets a cassé mon compresseur Mathematica.
lirtosiast





3

Espace , 152 octets

Obligatoire "les S, T et L ne sont pas vraiment là, ce ne sont que des représentations visibles des commandes".

S S S T	S S L
S S S T	S T	L
S S S T	T	T	L
S S S T	L
S S S T	T	L
S S S T	S L
S S S T	S S S L
S S S L
S S S T	T	S L
S S S L
S S S T	S S T	L
S S S L
S L
S T	L
T	T	T	T	T	S S S T	S T	S S T	L
T	S T	T	S S S T	S T	T	L
T	S T	T	L
S S L
S L
S L
T	S S L
S T	L
S T	L
S S S T	L
T	S S T	L
S L
L
L
S S S L
S L
L
T	L
S T	

Essayez-le en ligne!

Se termine par une erreur.

Syntaxe assimilable à un assemblage:

	push 4
	push 5
	push 7
	push 1
	push 3
	push 2
	push 8
	push 0
	push 6
	push 0
	push 9
	push 0
	dup
	readi
	retrieve
	push 41
	mod
	push 11
	mod
slideLoop:
	dup
	jz .slideLoop
	slide 1
	push 1
	sub
	jmp slideLoop
.slideLoop:
	drop
	printi

Vous pouvez supprimer les trois sauts de ligne de fin pour économiser 3 octets. Cela donne une erreur dans STDERR, mais le programme fonctionne toujours, et il est autorisé par les méta-règles .
Kevin Cruijssen du

3

brainfuck , 474 176 154 151 151 149 137 octets

Prend une chaîne d'entrée de huit 0 et 1incluant la première 0pour le point décimal.

(comme dans la deuxième colonne du tableau dans le post)

Sorties chiffre de 0 à 9.

,>,>,>,,,>,>,>+[[->]<++<<<<<<]>[>[>[>[->[>++++++<-<]>[--<]<]>>.>>]<[>
>[>->++<<-]>-[+>++++<]>+.>]]>[>>>+<<<-]>[>>+++.>]]>[>>>[>+++<-]>-.>]

Essayez-le en ligne!

Algorithme

En observant l'état d'un segment particulier, nous pouvons diviser un ensemble de chiffres possibles en sous-ensembles plus petits. Voici l'arborescence de recherche binaire statique utilisée dans mon code. La sous-arborescence gauche correspond à l'état ON du segment, la droite correspond à l'état OFF du segment.

                                         0,1,2,3,4,5,6,7,8,9
                                                  |    
                                         /-------[A]-------------------------\
                                 0,2,3,5,6,7,8,9                             1,4
                                        |                                     |
                         /-------------[B]----------------\             /----[G]----\
                   0,2,3,7,8,9                            5,6          4             1   
                        |                                  |
              /--------[E]--------\                  /----[E]----\    
            0,2,8                3,7,9              6             5
              |                    |
        /----[F]----\        /----[F]----\
      0,8            2      9            3,7   
       |                                  |
 /----[G]----\                      /----[G]----\
8             0                    3             7

Quelques observations utiles pour le golf

  1. Les bits C et D sont redondants et peuvent être ignorés.
  2. Le zéro initial (bit pour le point décimal) peut être (ab) utilisé comme valeur 48, important à la fois pour l'analyse de l'entrée et la préparation de la sortie.
  3. Lorsque la feuille est atteinte et que le chiffre est imprimé, nous devons simplement ignorer toutes les autres conditions. Cela peut être fait en déplaçant le pointeur de données suffisamment loin vers la zone des zéros pour qu'il ne puisse pas revenir.
  4. Pour la compatibilité, il est préférable d'utiliser des zéros à droite, car certaines implémentations BF ne prennent pas en charge les pointeurs de données négatifs.
  5. Par conséquent, il est préférable de stocker la valeur de sortie dans la cellule la plus à droite, afin que nous puissions facilement atteindre la zone de zéros vers la droite.
  6. Par conséquent, il est préférable de vérifier les bits de gauche à droite: A, B, E, F, G afin que nous puissions atteindre plus facilement la cellule de sortie.
  7. Différents chiffres peuvent partager le code de sortie. Par exemple, 5 et 6 sont dans le même sous-arbre. Nous pouvons faire +++++pour les deux valeurs, puis +pour six seulement.
  8. Nous pouvons diminuer le nombre de +commandes si nous ajoutons 2 à la valeur de sortie à l'avance. Dans ce cas, nous devons le diminuer pour 0et 1seulement et obtenir un avantage pour les autres chiffres.

2

Rétine , 96 octets

^(A)?(B)?C?(D|())(E|())(F)?(G)?
$.($.5*$.8*$(6*$7$2$2)$#6*$.3*$($.2*$(___$7)5*$7)$#4*$(6*$1_3*$8

Essayez-le en ligne! Ce n'est peut-être pas la meilleure façon, mais c'est une façon intéressante de programmer dans Retina. Explication:

^(A)?(B)?C?(D|())(E|())(F)?(G)?

Tente de saisir les cas intéressants. Les captures positives capturent simplement la lettre si elle est présente. La longueur de la capture est donc 1 si elle est présente et 0 si elle est absente. Les cas particuliers sont les captures 4 et 6 qui n'existent que si D ou E sont respectivement absents. Celles-ci ne peuvent être exprimées qu'en décimales $#4et, $#6mais c'est tout ce dont nous avons besoin ici. Les captures sont ensuite intégrées dans une chaîne dont la longueur est le nombre souhaité. Par exemple, si nous écrivons, 6*$1cette chaîne a une longueur de 6 si A est présent et de 0 s'il est absent. Afin de choisir entre différentes expressions, nous utilisons soit $.(pour les captures positives) ou $#(pour les captures négatives) qui évaluent à 0 ou 1 et cela peut ensuite être multiplié par la chaîne jusqu'à présent.

$.5*$.8*$(6*$7$2$2)

Fest répété 6 fois et Bdeux fois (par concaténation car c'est golfier). Cependant, le résultat est ignoré sauf si les deux Eet Gsont présents. Cela gère les cas de 2, 6et 8.

$#6*$.3*$($.2*$(___$7)5*$7)

Fest répété 5 fois, et s'il Best présent, il est ajouté une sixième fois plus un 3 supplémentaire (représenté par une chaîne constante de longueur 3). Cependant, le résultat est ignoré sauf s'il Dest présent et Eabsent. Cela gère les cas de 3, 5et 9.

$#4*$(6*$1_3*$8

Aest répété 6 fois, et Gest répété 3 fois, et un supplément 1ajouté (représenté par un caractère constant entre les deux parce qu'il est golfeur). Cependant, le résultat est ignoré sauf s'il Dest absent. Cela gère les cas de 1, 4et 7.

$.(

Les chaînes ci-dessus sont ensuite concaténées et la longueur prise. si rien de ce qui précède ne s'applique, aucune chaîne n'est générée et sa longueur est donc 0.

Les chaînes résultantes (avant que la longueur ne soit prise) sont les suivantes:

1   _
2   BB
3   ___
4   _GGG
5   FFFFF
6   FFFFFF
7   AAAAAA_
8   FFFFFFBB
9   ___FFFFFF

2

MATL , 14 octets

'/lx2Z^o~z'Q&m

L'entrée est un nombre représentant les segments au format little-endian.

Essayez-le en ligne!

Explication

'/lx2Z^o~z'  % Push this string
Q            % Add 1 to the codepoint of each char. This gives the array
             % [48 109 ... 123], corresponding to numbers 1 2 ... 9. Note that
             % 0 is missing
&m           % Implicit input. Call ismember function with second output. This
             % gives the 1-based index in the array for the input, or 0 if the
             % input is not present in the array.
             % Implicit display



1

Japt, 15 octets

Prend la valeur big-endian en entrée.

"~¶ÌÚúþÞ"bUd

Essayez-le


Explication

La chaîne contient les caractères à chacun des points de code des valeurs big-endian; Udrécupère le caractère au point de code de l'entrée et btrouve l'index de celui-ci dans la chaîne.


1

Neim , 15 octets

&bᚫJ𝕂𝕨O𝐖𝐞ℤ£ᛖ𝕪)𝕀

Explication:

&bᚫJ𝕂𝕨O𝐖𝐞ℤ£ᛖ𝕪)      create list [126 48 109 121 51 91 95 112 127 123]
                 𝕀     index of

Essayez-le en ligne!



1

TI-BASIC (série TI-83 + / 84 +), 15 octets

int(10fPart(194909642ln(Ans

Utilise une entrée peu endienne. Les hachages sont assez courants dans TI-BASIC, j'ai donc écrit une fonction de hachage brute-forcer pour des cas comme celui-ci.

Nous avons un peu de chance ici, car le multiplicateur comporte 9 chiffres plutôt que les 10 attendus.

      fPart(194909642ln(Ans   hash function mapping onto [0,1)
int(10                        take first digit after decimal point

1

05AB1E , 17 16 15 12 octets

•NŽyf¯•I41%è

-1 octet grâce à @ErikTheOutgolfer .
-1 octet en créant un port de la réponse Mathematica de @MishaLavrov .
-3 octets grâce à @Grimy .

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

NŽyf¯•       # Push compressed integer 99608231754
       I41%   # Push the input modulo-41
           è  # Index this into the integer (with automatic wraparound)
              # (and output the result implicitly)

Voir cette astuce de mes 05AB1E (section Comment compresser les grands entiers? ) Pour comprendre pourquoi •NŽyf¯•est 99608231754.



@EriktheOutgolfer Ah, bien sûr .. Par coïncidence, c'est 128в. J'ai oublié qu'il y a une fonction intégrée pour 128être divisé par deux 256. Merci!
Kevin Cruijssen

J'ai essayé des trucs bizarres aussi, je n'ai pas pu avoir moins de 15 ans. Tentative la plus bizarre: ¦C•26¤æÈÛµÀš•2ô₂+sk(19).
Urne de poulpe magique

1
@Grimy Merci! Maintenant que je le vois, c'est évident, car l'entier compressé est de taille 11 et le bouclage entre en jeu.
Kevin Cruijssen

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.