Probabilmente tutti sapete il display a 7 segmenti in grado di visualizzare, tra l'altro tutte le cifre da $0\dots 9$ :

Sfida

Consideriamo solo i segmenti $\texttt{A}\dots\texttt{G}$ , il tuo compito è decodificare una singola cifra dato quali segmenti sono attivi.

Questo può essere codificato come un numero intero a 8 bit, ecco una tabella di ogni cifra con la loro rappresentazione binaria e i corrispondenti valori little-endian e big-endian:

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

Regole e I / O

• L'input sarà uno di
  • intero singolo (come nella tabella sopra uno dei due ordini dati)
  • un elenco / array / .. di bit
  • una stringa composta da caratteri ABCDEFG(puoi presumere che sia ordinata, ad esempio ABCcodifica $7$ ), il loro caso è la tua scelta (non maiuscola)
• L'output sarà la cifra che codifica
• Non puoi assumere input non validi (non valido significa che non esiste una cifra corrispondente)

test

Poiché questa sfida consente rappresentazioni multiple, fare riferimento alla tabella.

JavaScript (ES6), 26 byte

Accetta input in little Endian.

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

Provalo online!

Python 3 , 18 byte

b'~0my3[_p{'.find

Provalo online!

Utilizza input little-endian. Contiene un \x7Fbyte non elaborato.

Python 2 , 27 byte

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

Provalo online!

Wolfram Language (Mathematica) , 41 byte

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

Provalo online!

Utilizza la colonna little-endian di numeri interi come input. Ignora l'avviso di sintassi.

Per un input X, prendiamo prima X mod 41 e poi prendiamo il risultato mod 11. I risultati sono distinti mod 11, quindi possiamo estrarli da una tabella. Ad esempio, 126 mod 41 mod 11 è 3, quindi se rendiamo la posizione 3 uguale a 0, otteniamo la risposta corretta per un input di 126.

Il tavolo è 9[,6,0,8,2,3,1,7,5,4]. La parte 0 è la testa, che è 9. Manca la parte 1, quindi è Nullper salvare un byte: non abbiamo mai bisogno di prendere la parte 1. Quindi la parte 2 è 6, la parte 3 è 0e così via, come al solito.

---

La risposta di Jonathan Allan ci dà 1[4,9,8,6,2,0,5,3,7][[384~Mod~#~Mod~13]]&. Questo non è più breve, ma evita l'avviso di sintassi!

---

Wolfram Language (Mathematica) , 27 25 byte

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

(C'è un personaggio qui che non si presenta, scusa. Fai clic sul link qui sotto e lo vedrai.)

Provalo online!

Si tratta solo di forzare una stringa all'interno del bruto in Hashmodo che gli hash finiscano per avere i giusti valori mod 11. Probabilmente più forza bruta può portarci a una soluzione ancora più breve.

Gelatina , 12 byte

“0my3[_p¶{‘i

Accetta un numero intero little-endian.

Provalo online!

Questa è l'implementazione ingenua, potrebbe esserci un modo per ottenere un codice terser.

Python 2 , 31 byte

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

Provalo online! accetta input come little-endian.

Java (JDK) , 32 byte

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

Provalo online!

Titoli di coda

• Porto di Arnauld 's risposta JavaScript , molto più breve rispetto alle precedenti tentativo nella storia post.
• -1 byte grazie a Jonathan Allan , utilizzando Misha Lavrov s' Wolfram Language (Mathematica) risposta .

JavaScript (Node.js) , 25 byte

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

Accetta un numero intero little-endian.

Provalo online!

---

Porte per 31 byte in Python con lambda n:'1498620537'[384%n%13]

Spazio bianco , 152 byte

"Le S, le T e le L obbligatorie non sono realmente presenti, sono solo rappresentazioni visibili dei comandi".

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	

Provalo online!

Termina con un errore.

Sintassi simile ad un assieme:

	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 byte

Accetta una stringa di input di otto 0 e 1incluso il primo0 per il punto decimale.

(come nella seconda colonna della tabella nel post)

Emette cifre da 0 a 9.

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

Provalo online!

Algoritmo

Osservando lo stato di un particolare segmento possiamo dividere un insieme di possibili cifre in sottoinsiemi più piccoli. Di seguito è riportato l'albero di ricerca binario statico utilizzato nel mio codice. La sottostruttura sinistra corrisponde allo stato del segmento ON, la destra corrisponde allo stato 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

Alcune osservazioni utili per il golf

1. I bit C e D sono ridondanti e possono essere ignorati.
2. Lo zero iniziale (bit per il punto decimale) può essere (ab) utilizzato come valore 48, importante sia per l'analisi dell'input che per la preparazione dell'output.
3. Quando viene raggiunta la foglia e viene stampata la cifra, dobbiamo solo saltare tutte le ulteriori condizioni. Può essere fatto spostando il puntatore dei dati abbastanza lontano nell'area degli zeri in modo che non possa tornare indietro.
4. Per la compatibilità è meglio usare zeri a destra, perché alcune implementazioni di BF non supportano puntatori di dati negativi.
5. Quindi è meglio memorizzare il valore di output nella cella più a destra, in modo da poter raggiungere facilmente l'area degli zeri a destra.
6. Quindi è meglio controllare i bit da sinistra a destra: A, B, E, F, G in modo da poter raggiungere più facilmente la cella di output.
7. Cifre diverse possono condividere il codice di output. Ad esempio, 5 e 6 sono nella stessa sottostruttura. Possiamo fare +++++per entrambi i valori e quindi +solo per sei.
8. È possibile ridurre il numero di +comandi se si aggiunge in anticipo 2 al valore di output. In tal caso, è necessario diminuirlo per 0e 1solo e ottenere vantaggio per altre cifre.

Retina , 96 byte

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

Provalo online! Potrebbe non essere il modo migliore, ma è un modo interessante di programmare in Retina. Spiegazione:

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

Cerca di catturare i casi interessanti. Le catture positive catturano semplicemente la lettera se è presente. La lunghezza della cattura è quindi 1 se è presente e 0 se è assente. I casi speciali sono catture 4 e 6 che esistono solo se D o E sono assenti rispettivamente. Questi possono essere espressi solo in decimali come $#4e $#6ma è tutto ciò di cui abbiamo bisogno qui. Le acquisizioni vengono quindi integrate in una stringa la cui lunghezza è il numero desiderato. Ad esempio, se scriviamo, 6*$1questa stringa ha lunghezza 6 se A è presente e 0 se è assente. Per scegliere tra espressioni diverse utilizziamo $.(per le catture positive) o $#(per le catture negative) che valutano a 0 o 1 e questo può quindi essere moltiplicato per la stringa finora.

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

Fviene ripetuto 6 volte e Bdue volte (per concatenazione poiché è più golfista). Tuttavia, il risultato viene ignorato a meno che entrambi Ee non Gsiano presenti. Questo gestisce i casi di 2, 6e 8.

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

Fviene ripetuto 5 volte e, se Bpresente, viene aggiunto una sesta volta più un extra 3 (rappresentato da una stringa costante di lunghezza 3). Tuttavia, il risultato viene ignorato se non Dè presente ed Eè assente. Questo gestisce i casi di 3, 5e 9.

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

Aviene ripetuto 6 volte e Gripetuto 3 volte e viene 1aggiunto un ulteriore (rappresentato da un carattere costante tra i due perché è più golfista). Tuttavia, il risultato viene ignorato a meno che non Dsia assente. Questo gestisce i casi di 1, 4e 7.

$.(

Le stringhe sopra vengono quindi concatenate e la lunghezza presa. se nessuna delle precedenti condizioni si applica, non viene generata alcuna stringa e pertanto la sua lunghezza è 0.

Le stringhe risultanti (prima che venga presa la lunghezza) sono le seguenti:

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

MATL , 14 byte

'/lx2Z^o~z'Q&m

L'input è un numero che rappresenta i segmenti in formato little-endian.

Provalo online!

Spiegazione

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

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

Provalo online!

Accetta numeri interi little-endian.

Rubino , 29 byte

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

Provalo online!

Japt, 15 byte

Prende il valore big-endian come input.

"~¶ÌÚúþÞ"bUd

Provalo

---

Spiegazione

La stringa contiene i caratteri in ciascuno dei punti di codice dei valori big-endian; Udottiene il carattere nel punto di codice dell'input e btrova l'indice di quello nella stringa.

Neim , 15 byte

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

Spiegazione:

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

Provalo online!

Stax , 12 byte

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

Esegui ed esegui il debug

L'input è un intero piccolo endian.

Utilizza la stessa costante di stringa della soluzione MATL di Luis.

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

int(10fPart(194909642ln(Ans

Utilizza input little-endian. Gli hash sono abbastanza comuni in TI-BASIC, quindi ho scritto una funzione hash brute-forcer per casi come questo.

Qui siamo un po 'fortunati, poiché il moltiplicatore è lungo 9 cifre anziché i 10 previsti.

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

05AB1E , 17 16 15 12 byte

•NŽyf¯•I41%è

-1 byte grazie a @ErikTheOutgolfer .
-1 byte creando una porta della risposta Mathematica di @MishaLavrov .
-3 byte grazie a @Grimy .

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Vedere questo 05AB1E punta del mio (sezione Come comprimere grandi numeri interi? ) Per capire il motivo per cui •NŽyf¯•è 99608231754.

Carbone, 17 byte

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

Provalo!

Risposta di Port of the Japt .