Vous connaissez probablement tous l' affichage à 7 segments qui peut afficher entre autres tous les chiffres de :$0\dots 9$

Défi

Nous considérons uniquement les segments , votre tâche consiste à décoder un seul chiffre en fonction des segments activés.$\texttt{A}\dots\texttt{G}$

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:

$$\begin{array}{c|c|rr|rr} \text{Digit} & \texttt{.ABCDEFG} & \text{Little-endian} && \text{Big-endian} & \\ \hline 0 & \texttt{01111110} & 126 & \texttt{0x7E} & 126 & \texttt{0x7E} \\ 1 & \texttt{00110000} & 48 & \texttt{0x30} & 12 & \texttt{0x0C} \\ 2 & \texttt{01101101} & 109 & \texttt{0x6D} & 182 & \texttt{0xB6} \\ 3 & \texttt{01111001} & 121 & \texttt{0x79} & 158 & \texttt{0x9E} \\ 4 & \texttt{00110011} & 51 & \texttt{0x33} & 204 & \texttt{0xCC} \\ 5 & \texttt{01011011} & 91 & \texttt{0x5B} & 218 & \texttt{0xDA} \\ 6 & \texttt{01011111} & 95 & \texttt{0x5F} & 250 & \texttt{0xFA} \\ 7 & \texttt{01110000} & 112 & \texttt{0x70} & 14 & \texttt{0x0E} \\ 8 & \texttt{01111111} & 127 & \texttt{0x7F} & 254 & \texttt{0xFE} \\ 9 & \texttt{01111011} & 123 & \texttt{0x7B} & 222 & \texttt{0xDE} \end{array}$$

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)$7$
• 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.

JavaScript (ES6), 26 octets

Prend entrée en petit Endian.

n=>'0958634172'[n*3%77%10]

Essayez-le en ligne!

Python 3 , 18 octets

b'~0my3[_p{'.find

Essayez-le en ligne!

Utilise des entrées peu endiennes. Contient un \x7Foctet brut .

Python 2 , 27 octets

map(ord,'~0my3[_p{').index

Essayez-le en ligne!

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.

Gelée , 12 octets

“0my3[_p¶{‘i

Accepte un entier petit-boutien.

Essayez-le en ligne!

Ceci est l'implémentation naïve, il pourrait y avoir un moyen d'obtenir un code terser.

Python 2 , 31 octets

lambda n:'99608231754'[n%41%11]

Essayez-le en ligne! prend l'entrée en petit-boutien.

Java (JDK) , 32 octets

n->"99608231754".charAt(n%41%11)

Essayez-le en ligne!

Crédits

• Port de Arnauld de JavaScript réponse , beaucoup plus courte que tentative précédente dans l'histoire post.
• -1 octet grâce à Jonathan Allan , à l' aide de Misha Lavrov de Wolfram Langue (Mathematica) réponse .

JavaScript (Node.js) , 25 octets

n=>'1498620537'[384%n%13]

Accepte un entier petit-boutien.

Essayez-le en ligne!

---

Ports pour 31 octets en Python avec lambda n:'1498620537'[384%n%13]

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

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.

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

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

Perl 5 -pl, 24 octets

$_=index'~0my3[_p{',chr

Essayez-le en ligne!

Prend des entiers petit-boutiens.

Rubis , 29 octets

->n{"0083416243795"[n%23-10]}

Essayez-le en ligne!

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.

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!

Stax , 12 octets

å╬JÄk☺é[£¿⌐→

Exécuter et déboguer

L'entrée est un petit entier endien.

Il utilise la même constante de chaîne que la solution MATL de Luis.

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

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.

Fusain, 17 octets

Ｉ⌕”y~¶ÌÚúþÞ”℅Ｎ

Essayez!

Port de la réponse Japt .