Você provavelmente todos sabem o display de 7 segmentos que pode exibir, entre outras coisas todos os dígitos de $0\dots 9$ :

Desafio

Consideramos apenas os segmentos $\texttt{A}\dots\texttt{G}$ , sua tarefa é decodificar um único dígito, considerando quais segmentos estão ativados.

Isso pode ser codificado como um número inteiro de 8 bits. Aqui está uma tabela de cada dígito com sua representação binária e os valores little-endian e big-endian correspondentes:

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

Regras e E / S

• A entrada será uma das
  • número inteiro único (como na tabela acima, uma das duas ordens fornecidas)
  • uma lista / matriz / .. de bits
  • uma sequência composta por caracteres ABCDEFG(você pode assumir que está classificada, como um exemplo ABCcodifica $7$ ), o caso deles é a sua escolha (não com maiúsculas e minúsculas)
• Saída será o dígito que codifica
• Você não pode assumir entradas inválidas (inválido significa que não há dígito correspondente)

Testes

Como esse desafio permite múltiplas representações, consulte a tabela.

JavaScript (ES6), 26 bytes

Recebe entrada em little Endian.

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

Experimente online!

Python 3 , 18 bytes

b'~0my3[_p{'.find

Experimente online!

Usa entradas little-endian. Contém um \x7Fbyte bruto .

Python 2 , 27 bytes

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

Experimente online!

Wolfram Language (Mathematica) , 41 bytes

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

Experimente online!

Usa a coluna little-endian de números inteiros como entrada. Ignore o aviso de sintaxe.

Para uma entrada X, primeiro pegamos o X mod 41 e depois o resultado 11. O resultado é o mod 11 distinto, para que possamos extraí-los de uma tabela. Por exemplo, 126 mod 41 mod 11 é 3, portanto, se tornarmos a posição 3 igual a 0, obteremos a resposta correta para uma entrada de 126.

A tabela é 9[,6,0,8,2,3,1,7,5,4]. Parte 0 é a cabeça, que é 9. Falta a parte 1, portanto, é Nullpara salvar um byte: nunca precisamos participar da parte 1. Então a parte 2 é6 , a parte 3 é 0, e assim por diante, como de costume.

---

Resposta de Jonathan Allan nos dá 1[4,9,8,6,2,0,5,3,7][[384~Mod~#~Mod~13]]&. Isso não é mais curto, mas evita o aviso de sintaxe!

---

Língua Wolfram (Mathematica) , 27 25 bytes

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

(Há algum personagem aqui que não aparece muito, desculpe. Clique no link abaixo e você verá.)

Experimente online!

Isso é tudo sobre forçar brutalmente uma string a ser inserida, Hashpara que os hashes acabem tendo os valores corretos, mod 11. Mais força bruta provavelmente pode nos levar a uma solução ainda mais curta.

Gelatina , 12 bytes

“0my3[_p¶{‘i

Aceita um número inteiro little-endian.

Experimente online!

Esta é a implementação ingênua, pode haver uma maneira de obter um código de terser.

Python 2 , 31 bytes

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

Experimente online! aceita entrada como little-endian.

Java (JDK) , 32 bytes

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

Experimente online!

Créditos

• Porto de Arnauld 's resposta JavaScript , muito menor do que a tentativa anterior na história pós.
• -1 byte graças a Jonathan Allan , utilizando Misha Lavrov 's Wolfram Idioma resposta (Mathematica) .

JavaScript (Node.js) , 25 bytes

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

Aceita um número inteiro little-endian.

Experimente online!

---

Portas para 31 bytes em Python com lambda n:'1498620537'[384%n%13]

Espaço em branco , 152 bytes

Obrigatório "os S, T e L não estão realmente lá, são apenas representações visíveis dos 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	

Experimente online!

Termina com um erro.

Sintaxe equivalente a montagem:

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

Toma uma sequência de oito 0 e 1inclui a primeira 0para o ponto decimal.

(como na segunda coluna da tabela na postagem)

Dígito de saída de 0 a 9.

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

Experimente online!

Algoritmo

Observando o estado de um segmento específico, podemos dividir um conjunto de dígitos possíveis em subconjuntos menores. Abaixo está a árvore de pesquisa binária estática usada no meu código. A subárvore esquerda corresponde ao estado ON do segmento, a direita corresponde ao estado OFF do segmento.

                                         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

Algumas observações úteis para jogar golfe

1. Os bits C e D são redundantes e podem ser ignorados.
2. O zero inicial (bit para ponto decimal) pode ser (ab) usado como valor 48, importante tanto para analisar a entrada quanto para preparar a saída.
3. Quando a folha é alcançada e o dígito é impresso, precisamos apenas pular todas as condições adicionais. Isso pode ser feito movendo o ponteiro de dados o suficiente para a área de zeros, para que não possa voltar.
4. Para a compatibilidade, é melhor usar zeros à direita, porque algumas implementações de BF não suportam ponteiros de dados negativos.
5. Portanto, é melhor armazenar o valor de saída na célula mais à direita, para que possamos alcançar facilmente a área de zeros à direita.
6. Por isso, é melhor verificar os bits da esquerda para a direita: A, B, E, F, G para que possamos alcançar a célula de saída mais facilmente.
7. Dígitos diferentes podem compartilhar o código de saída. Por exemplo, 5 e 6 estão na mesma subárvore. Podemos fazer +++++pelos dois valores e depois +apenas por seis.
8. Podemos diminuir o número de +comandos se adicionarmos 2 ao valor da saída com antecedência. Nesse caso, precisamos diminuí-lo para 0e 1somente e obter vantagem para outros 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

Experimente online! Pode não ser o melhor caminho, mas é uma maneira interessante de programar no Retina. Explicação:

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

Tenta capturar os casos interessantes. As capturas positivas simplesmente capturam a letra, se estiver presente. O comprimento da captura é, portanto, 1 se estiver presente e 0 se estiver ausente. Os casos especiais são capturas 4 e 6, que existem apenas se D ou E estão ausentes, respectivamente. Eles só podem ser expressos em decimal como $#4e $#6mas é tudo o que precisamos aqui. As capturas são então construídas em uma sequência cujo comprimento é o número desejado. Por exemplo, se escrevermos 6*$1, essa sequência terá comprimento 6 se A estiver presente e 0 se estiver ausente. Para escolher entre diferentes expressões, usamos $.(para as capturas positivas) ou $#(para as capturas negativas) que são avaliadas como 0 ou 1 e isso pode ser multiplicado pela cadeia até agora.

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

Fé repetido 6 vezes e Bduas vezes (por concatenação, pois é mais golfista). No entanto, o resultado é ignorado, a menos que ambos Ee Gestejam presentes. Isso lida com os casos de 2, 6e 8.

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

Fé repetido 5 vezes e, se Bestiver presente, é adicionado uma sexta vez mais um 3 extra (representado por uma sequência constante de comprimento 3). No entanto, o resultado é ignorado, a menos que Desteja presente e Eausente. Isso lida com os casos de 3, 5e 9.

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

Aé repetido 6 vezes, e Grepetido 3 vezes, e um acréscimo 1adicional (representado por um caractere constante entre os dois porque é mais golfista). No entanto, o resultado é ignorado, a menos que Desteja ausente. Isso lida com os casos de 1, 4e 7.

$.(

As strings acima são então concatenadas e o comprimento obtido. se nenhuma das opções acima se aplicar, nenhuma sequência será gerada e seu comprimento será, portanto 0.

As seqüências resultantes (antes que o comprimento seja obtido) são as seguintes:

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

MATL , 14 bytes

'/lx2Z^o~z'Q&m

Entrada é um número que representa os segmentos no formato little-endian.

Experimente online!

Explicação

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

Experimente online!

Toma inteiros little-endian.

Ruby , 29 bytes

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

Experimente online!

Japonês, 15 bytes

Pega o valor big-endian como entrada.

"~¶ÌÚúþÞ"bUd

Tente

---

Explicação

A cadeia contém os caracteres em cada um dos pontos de código dos valores big endian; Udobtém o caractere no ponto de código da entrada e bencontra o índice na string.

Neim , 15 bytes

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

Explicação:

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

Experimente online!

Stax , 12 bytes

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

Execute e depure

A entrada é um pequeno número inteiro endian.

Ele usa a mesma constante de string que a solução MATL de Luis.

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

int(10fPart(194909642ln(Ans

Usa entrada little-endian. Os hashes são bastante comuns no TI-BASIC, então eu escrevi uma função hash brute-forcer para casos como este.

Temos um pouco de sorte aqui, pois o multiplicador tem 9 dígitos e não os 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 graças a @ErikTheOutgolfer .
-1 byte, criando uma porta da resposta Mathematica de @MishaLavrov .
-3 bytes graças a @Grimy .

Experimente online ou verifique todos os casos de teste .

Explicação:

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

Veja este 05AB1E ponta do meu (seção Como comprimir grandes inteiros? ) Para entender por que •NŽyf¯•é 99608231754.

Carvão, 17 bytes

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

Tente!

Resposta do porto do Japão .