Probablemente todos conozcan la pantalla de 7 segmentos que puede mostrar, entre otras cosas, todos los dígitos de :$0\dots 9$

Desafío

Solo consideramos los segmentos , su tarea es decodificar un solo dígito dados los segmentos que están activados.$\texttt{A}\dots\texttt{G}$

Esto se puede codificar como un entero de 8 bits, aquí hay una tabla de cada dígito con su representación binaria y los valores little-endian y big-endian correspondientes:

$$\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}$$

Reglas y E / S

• La entrada será una de
  • entero único (como en la tabla de arriba una de las dos órdenes dadas)
  • una lista / matriz / .. de bits
  • una cadena que consta de caracteres ABCDEFG(puede suponer que está ordenada, como un ejemplo ABCcodifica ), su caso es su elección (no caso mixto)$7$
• La salida será el dígito que codifica
• Puede suponer que no hay entradas inválidas (inválido significa que no hay un dígito correspondiente)

Pruebas

Como este desafío permite múltiples representaciones, consulte la tabla.

JavaScript (ES6), 26 bytes

Toma entrada en el pequeño Endian.

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

Pruébalo en línea!

Python 3 , 18 bytes

b'~0my3[_p{'.find

Pruébalo en línea!

Utiliza entradas little-endian. Contiene un \x7Fbyte sin procesar .

Python 2 , 27 bytes

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

Pruébalo en línea!

Wolfram Language (Mathematica) , 41 bytes

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

Pruébalo en línea!

Utiliza la columna de enteros little endian como entrada. Ignora la advertencia de sintaxis.

Para una entrada X, primero tomamos X mod 41 y luego tomamos el resultado mod 11. Los resultados son distintos del mod 11, por lo que podemos extraerlos de una tabla. Por ejemplo, 126 mod 41 mod 11 es 3, por lo que si hacemos que la posición 3 sea igual a 0, obtenemos la respuesta correcta para una entrada de 126.

La mesa es 9[,6,0,8,2,3,1,7,5,4]. La parte 0 es la cabeza, que es 9. Falta la parte 1, por lo que es Null, para guardar un byte: nunca necesitamos tomar la parte 1. Entonces la parte 2 es 6, la parte 3 es 0, y así sucesivamente, como de costumbre.

---

La respuesta de Jonathan Allan nos da 1[4,9,8,6,2,0,5,3,7][[384~Mod~#~Mod~13]]&. ¡Esto no es más corto, pero evita la advertencia de sintaxis!

---

Wolfram Language (Mathematica) , 27 25 bytes

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

(Aquí hay algún personaje que no aparece, lo siento. Haz clic en el enlace a continuación y lo verás).

Pruébalo en línea!

Esto se trata de forzar con fuerza alguna cadena para Hashque los hash terminen teniendo los valores correctos mod 11. Más fuerza bruta probablemente puede llevarnos a una solución aún más corta.

Jalea , 12 bytes

“0my3[_p¶{‘i

Acepta un entero little endian.

Pruébalo en línea!

Esta es la implementación ingenua, puede haber una manera de obtener un código terser.

Python 2 , 31 bytes

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

Pruébalo en línea! toma la entrada como little-endian.

Java (JDK) , 32 bytes

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

Pruébalo en línea!

Créditos

• La respuesta de JavaScript del Puerto de Arnauld , mucho más corta que el intento anterior en el historial de publicaciones.
• -1 bytes gracias a Jonathan Allan , utilizando Misha Lavrov 's Wolfram Idioma respuesta (Mathematica) .

JavaScript (Node.js) , 25 bytes

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

Acepta un entero little endian.

Pruébalo en línea!

---

Puertos para 31 bytes en Python con lambda n:'1498620537'[384%n%13]

Espacio en blanco , 152 bytes

Obligatorio "las S, T y L no están realmente allí, son solo representaciones visibles de los comandos".

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	

Pruébalo en línea!

Termina en un error.

Sintaxis equivalente tipo ensamblado:

	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 149 137 bytes

Toma una cadena de entrada de ocho 0 e 1incluye la primera 0para el punto decimal.

(como en la segunda columna de la tabla en la publicación)

Salida de dígitos de 0 a 9.

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

Pruébalo en línea!

Algoritmo

Al observar el estado de un segmento particular, podemos dividir un conjunto de posibles dígitos en subconjuntos más pequeños. A continuación se muestra el árbol de búsqueda binario estático utilizado en mi código. El subárbol izquierdo corresponde al estado del segmento ON, el derecho corresponde al estado del segmento OFF.

                                         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

Algunas observaciones útiles para el golf.

1. Los bits C y D son redundantes y pueden ignorarse.
2. El cero inicial (bit para el punto decimal) puede (ab) usarse como valor 48, importante tanto para analizar la entrada como para preparar la salida.
3. Cuando se alcanza la hoja y se imprime el dígito, solo necesitamos omitir todas las demás condiciones. Se puede hacer moviendo el puntero de datos lo suficientemente lejos del área de ceros para que no pueda volver.
4. Para la compatibilidad, es mejor usar ceros a la derecha, porque algunas implementaciones de BF no admiten punteros de datos negativos.
5. Por lo tanto, es mejor almacenar el valor de salida en la celda más a la derecha, para que podamos alcanzar fácilmente el área de ceros a la derecha.
6. Por lo tanto, es mejor verificar los bits de izquierda a derecha: A, B, E, F, G para que podamos alcanzar la celda de salida más fácilmente.
7. Diferentes dígitos pueden compartir el código de salida. Por ejemplo, 5 y 6 están en el mismo subárbol. Podemos hacer +++++ambos valores y luego +solo seis.
8. Podemos disminuir el número de +comandos si agregamos 2 al valor de salida por adelantado. En ese caso hay que disminuirlo para 0y 1única y obtener ventaja para los otros dígitos.

Retina , 96 bytes

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

Pruébalo en línea! Puede que no sea la mejor manera, pero es una forma interesante de programar en Retina. Explicación:

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

Intenta capturar los casos interesantes. Las capturas positivas simplemente capturan la letra si está presente. La longitud de la captura es, por lo tanto, 1 si está presente y 0 si está ausente. Los casos especiales son capturas 4 y 6 que existen solo si D o E están ausentes respectivamente. Estos solo se pueden expresar en decimal como $#4y, $#6pero eso es todo lo que necesitamos aquí. Las capturas se construyen en una cadena cuya longitud es el número deseado. Por ejemplo, si escribimos 6*$1, esta cadena tiene una longitud 6 si A está presente y 0 si está ausente. Para elegir entre diferentes expresiones, usamos $.(para las capturas positivas) o $#(para las capturas negativas) que se evalúan como 0 o 1 y esto puede multiplicarse por la cadena hasta el momento.

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

Fse repite 6 veces y Bdos veces (por concatenación ya que es más golfista). Sin embargo, el resultado se ignora a menos que ambos Ey Gestán presentes. Esto maneja los casos de 2, 6y 8.

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

Fse repite 5 veces, y si Bestá presente, se agrega una sexta vez más un extra 3 (representado por una cadena constante de longitud 3). Sin embargo, el resultado se ignora a menos que Desté presente y Eesté ausente. Esto maneja los casos de 3, 5y 9.

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

Ase repite 6 veces, y Gse repite 3 veces, y se 1agrega un extra (representado por un carácter constante entre los dos porque es más golfista). Sin embargo, el resultado se ignora a menos que Desté ausente. Esto maneja los casos de 1, 4y 7.

$.(

Las cadenas anteriores se concatenan y se toma la longitud. si no se aplica ninguno de los anteriores, no se genera una cadena y, por lo tanto, su longitud es 0.

Las cadenas resultantes (antes de tomar la longitud) son las siguientes:

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

MATL , 14 bytes

'/lx2Z^o~z'Q&m

La entrada es un número que representa los segmentos en formato little-endian.

Pruébalo en línea!

Explicación

'/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 bytes

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

Pruébalo en línea!

Toma enteros poco endianos.

Ruby , 29 bytes

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

Pruébalo en línea!

Japt, 15 bytes

Toma el valor big-endian como entrada.

"~¶ÌÚúþÞ"bUd

Intentalo

---

Explicación

La cadena contiene los caracteres en cada uno de los puntos de código de los valores big-endian; Udobtiene el carácter en el punto de código de la entrada y bencuentra su índice en la cadena.

Neim , 15 bytes

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

Explicación:

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

Pruébalo en línea!

Stax , 12 bytes

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

Ejecutar y depurarlo

La entrada es un pequeño entero endian.

Utiliza la misma constante de cadena que la solución MATL de Luis.

TI-BASIC (serie TI-83 + / 84 +), 15 bytes

int(10fPart(194909642ln(Ans

Utiliza entrada little-endian. Los hashes son bastante comunes en TI-BASIC, por lo que escribí una función hash brute-forcer para casos como este.

Tenemos un poco de suerte aquí, ya que el multiplicador tiene 9 dígitos en lugar de los 10 esperados.

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

05AB1E , 17 16 15 12 bytes

•NŽyf¯•I41%è

-1 byte gracias a @ErikTheOutgolfer .
-1 byte creando un puerto de la respuesta de Mathematica de @MishaLavrov .
-3 bytes gracias a @Grimy .

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

Ver este consejo 05AB1E mío (sección Cómo comprimir grandes números enteros? ) Para entender por qué •NŽyf¯•es 99608231754.

Carbón de leña, 17 bytes

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

¡Intentalo!

Puerto de la respuesta de Japt .