Decodifica una pantalla de 7 segmentos

17

Probablemente todos conozcan la pantalla de 7 segmentos que puede mostrar, entre otras cosas, todos los dígitos de :09

Pantalla de 7 segmentos (wikipedia.org)

Desafío

Solo consideramos los segmentos , su tarea es decodificar un solo dígito dados los segmentos que están activados.AG

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:

Dígito.ABCDEFGLittle endianBig-endian0 0011111101260x7E1260x7E100110000480x30120x0C2011011011090x6D1820xB63011110011210x791580x9E4 400110011510x33204 2040xCC5 50101101191 910x5B2180xDA6 601011111950x5F2500xFA7 7011100001120x70140x0E8011111111270x7F2540xFE9011110111230x7B2220xDE

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.

ბიმო
fuente
Relacionados .
ბიმო
¿Podemos aceptar un número entero (o matriz) en cualquier orden de bits especificado o solo en los dos que se muestran?
Jonathan Allan
@ JonathanAllan: aclararé, solo los que ya se muestran.
ბიმო
Ohhh mierda, no tienes que manejar todos los tipos de entrada? ¿Solo uno? Whoops ...
Magic Octopus Urn
@MagicOctopusUrn: Sí, de hecho :)
ბიმო

Respuestas:

7

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.

Misha Lavrov
fuente
¿Podría explicar un poco esta respuesta, para alguien que no conoce Mathematica?
jrook
Pensé que sería legible para cualquiera, pero está bien, editaré una explicación.
Misha Lavrov
Felicidades La solución de 41 bytes rompió mi compresor Mathematica.
lirtosiast
4

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.

Jonathan Allan
fuente
3

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
JosiahRyanW
fuente
Puede eliminar las tres nuevas líneas finales para guardar 3 bytes. Da un error en STDERR, pero el programa aún funciona y está permitido por las meta-reglas .
Kevin Cruijssen
3

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.
Daniil Tutubalin
fuente
2

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
Neil
fuente
2

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
Luis Mendo
fuente
1

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.

Lanudo
fuente
1

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!

Okx
fuente
1

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.

recursivo
fuente
1

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
lirtosiast
fuente
1

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.

Kevin Cruijssen
fuente
1
16 bytes .
Erik el Outgolfer
@EriktheOutgolfer Ah, por supuesto ... Casualmente es así 128в. Olvidé que hay un lugar para 128ser reducido a la mitad 256. ¡Gracias!
Kevin Cruijssen
Probé algunas cosas extrañas, tampoco pude tener menos de 15 años. Intento más extraño: ¦C•26¤æÈÛµÀš•2ô₂+sk(19).
Urna mágica del pulpo
1
@ Grimy Gracias! Ahora que lo veo es obvio, ya que el número entero comprimido es de tamaño 11 y patadas en envolventes.
Kevin Cruijssen