Sie kennen wahrscheinlich alle die 7-Segment-Anzeige, die unter anderem alle Ziffern von anzeigen kann :$0\dots 9$

Herausforderung

Wir betrachten nur die Segmente . Ihre Aufgabe ist es, eine einzelne Ziffer zu decodieren, , welche Segmente sind.$\texttt{A}\dots\texttt{G}$

Dies kann als 8-Bit-Ganzzahl codiert werden. Hier ist eine Tabelle jeder Ziffer mit ihrer binären Darstellung und den entsprechenden Little-Endian- und Big-Endian-Werten:

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

Regeln & I / O

• Eingang wird einer von
  • einzelne ganze Zahl (wie in der Tabelle oben angegeben)
  • eine Liste / Array / .. von Bits
  • eine Zeichenfolge , die aus Zeichen ABCDEFG(Sie davon ausgehen , kann es sortiert, als ein Beispiel ABCkodiert ), deren Fall Ihrer Wahl (nicht gemischt-Fall)$7$
• Die Ausgabe ist die Ziffer, die kodiert wird
• Sie dürfen keine ungültigen Eingaben annehmen (ungültig bedeutet, dass es keine entsprechende Ziffer gibt)

Tests

Da diese Herausforderung mehrere Darstellungen zulässt, beziehen Sie sich bitte auf die Tabelle.

JavaScript (ES6), 26 Byte

Nimmt Eingaben in Little Endian auf.

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

Probieren Sie es online!

Python 3 , 18 Bytes

b'~0my3[_p{'.find

Probieren Sie es online!

Verwendet Little-Endian-Eingaben. Enthält ein \x7FRohbyte.

Python 2 , 27 Bytes

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

Probieren Sie es online!

Wolfram Language (Mathematica) , 41 Bytes

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

Probieren Sie es online!

Verwendet die Little-Endian-Ganzzahlenspalte als Eingabe. Ignorieren Sie die Syntaxwarnung.

Für eine Eingabe X nehmen wir zuerst X mod 41 und dann das Ergebnis mod 11. Die Ergebnisse sind verschiedene mod 11, so dass wir sie aus einer Tabelle extrahieren können. Beispiel: 126 mod 41 mod 11 ist 3. Wenn wir also Position 3 gleich 0 machen, erhalten wir die richtige Antwort für eine Eingabe von 126.

Der Tisch ist 9[,6,0,8,2,3,1,7,5,4]. Teil 0 ist der Kopf, der ist 9. Teil 1 fehlt, also ist es Null, um ein Byte zu speichern: Wir müssen nie Teil 1 nehmen. Dann ist Teil 2 6, Teil 3 0und so weiter, wie üblich.

---

Jonathan Allans Antwort gibt uns 1[4,9,8,6,2,0,5,3,7][[384~Mod~#~Mod~13]]&. Dies ist nicht kürzer, aber es vermeidet die Syntaxwarnung!

---

Wolfram Language (Mathematica) , 27-25 Bytes

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

(Es gibt eine Figur, die hier nicht ganz auftaucht, sorry. Klicken Sie auf den Link unten und Sie werden es sehen.)

Probieren Sie es online!

Hier geht es darum, einige Zeichenketten dazu zu zwingen, nach innen zu gehen, Hashdamit die Hashes am Ende die richtigen Werte für Mod 11 haben. Mehr Brute Forcing kann uns wahrscheinlich zu einer noch kürzeren Lösung führen.

Gelee , 12 Bytes

“0my3[_p¶{‘i

Akzeptiert eine Little-Endian-Ganzzahl.

Probieren Sie es online!

Dies ist die naive Implementierung. Möglicherweise gibt es eine Möglichkeit, einen genaueren Code zu erhalten.

Python 2 , 31 Bytes

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

Probieren Sie es online! Nimmt Eingaben als Little-Endian.

Java (JDK) , 32 Byte

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

Probieren Sie es online!

Credits

• Hafen von Arnauld ‚s JavaScript Antwort , viel kürzer als bei früheren Versuch in der Post - Geschichte.
• -1 Byte dank Jonathan Allan , mit Misha Lawrow ‚s Wolfram Language (Mathematica) Antwort .

JavaScript (Node.js) , 25 Byte

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

Akzeptiert eine Little-Endian-Ganzzahl.

Probieren Sie es online!

---

Ports für 31 Bytes in Python mit lambda n:'1498620537'[384%n%13]

Leerzeichen , 152 Bytes

Obligatorisch "Die S, T und L sind nicht wirklich vorhanden, sondern nur sichtbare Darstellungen der Befehle".

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	

Probieren Sie es online!

Endet mit einem Fehler.

Äquivalente Assembler-ähnliche Syntax:

	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

Nimmt eine Eingabezeichenfolge von acht 0 und 1einschließlich der ersten 0für den Dezimalpunkt.

(wie in der zweiten Spalte der Tabelle in der Post)

Gibt Ziffern von 0 bis 9 aus.

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

Probieren Sie es online!

Algorithmus

Indem wir den Zustand eines bestimmten Segments beobachten, können wir einen Satz möglicher Ziffern in kleinere Teilmengen aufteilen. Unten ist der statische binäre Suchbaum, der in meinem Code verwendet wird. Der linke Unterbaum entspricht dem Segment-EIN-Zustand, der rechte dem Segment-AUS-Zustand.

                                         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

Einige Beobachtungen, die zum Golfen nützlich sind

1. Die Bits C und D sind redundant und können ignoriert werden.
2. Die führende Null (Bit für den Dezimalpunkt) kann (ab) als Wert 48 verwendet werden, der sowohl für das Parsen der Eingabe als auch für das Vorbereiten der Ausgabe wichtig ist.
3. Wenn das Blatt erreicht und die Ziffer gedruckt ist, müssen wir nur alle weiteren Bedingungen überspringen. Bewegen Sie dazu den Datenzeiger weit genug in den Bereich der Nullen, damit er nicht zurückkehren kann.
4. Aus Kompatibilitätsgründen ist es besser, rechts Nullen zu verwenden, da einige BF-Implementierungen keine negativen Datenzeiger unterstützen.
5. Daher ist es besser, den Ausgabewert in der Zelle ganz rechts zu speichern, damit wir den Bereich der Nullen rechts leicht erreichen können.
6. Daher ist es besser, die Bits von links nach rechts zu prüfen: A, B, E, F, G, damit wir die Ausgabezelle leichter erreichen können.
7. Unterschiedliche Ziffern können sich den Ausgabecode teilen. Zum Beispiel befinden sich 5 und 6 im selben Teilbaum. Wir können +++++für beide Werte und dann nur +für sechs tun .
8. Wir können die Anzahl der +Befehle verringern , wenn wir vorab 2 zum Ausgabewert addieren. In diesem Fall müssen wir es für 0und 1nur verringern und Vorteile für andere Ziffern erzielen.

Netzhaut 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

Probieren Sie es online! Vielleicht nicht der beste Weg, aber es ist eine interessante Art, in Retina zu programmieren. Erläuterung:

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

Versucht, die interessanten Fälle zu erfassen. Die positiven Aufnahmen erfassen einfach den Brief, wenn er vorhanden ist. Die Länge des Captures beträgt daher 1, wenn es vorhanden ist, und 0, wenn es nicht vorhanden ist. Die Sonderfälle sind Captures 4 und 6, die nur existieren, wenn D bzw. E fehlen. Diese können nur in dezimal ausgedrückt werden $#4und , $#6aber das ist alles , was wir hier brauchen. Die Captures werden dann zu einer Zeichenfolge zusammengesetzt, deren Länge der gewünschten Zahl entspricht. Wenn wir zum Beispiel schreiben, 6*$1hat dieser String die Länge 6, wenn A vorhanden ist, und 0, wenn es nicht vorhanden ist. Um zwischen verschiedenen Ausdrücken zu wählen, verwenden wir entweder $.(für die positiven Captures) oder $#(für die negativen Captures), die entweder 0 oder 1 ergeben, und dies kann dann mit dem bisherigen String multipliziert werden.

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

Fwird 6-mal und Bzweimal wiederholt (durch Verkettung als Golfspieler). Das Ergebnis wird jedoch ignoriert, sofern nicht beide Eund Gvorhanden sind. Dies behandelt die Fälle von 2, 6und 8.

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

Fwird fünfmal wiederholt, und wenn Bvorhanden, wird es ein sechstes Mal plus eine zusätzliche 3 hinzugefügt (dargestellt durch eine konstante Zeichenfolge mit der Länge 3). Das Ergebnis wird jedoch ignoriert, sofern Des nicht vorhanden ist und nicht vorhanden Eist. Dies behandelt die Fälle von 3, 5und 9.

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

Awird 6-mal Gwiederholt und 3-mal wiederholt und ein zusätzliches 1hinzugefügt (dargestellt durch ein konstantes Zeichen zwischen den beiden, weil es Golfspieler ist). Das Ergebnis wird jedoch ignoriert, es Dsei denn, es fehlt. Dies behandelt die Fälle von 1, 4und 7.

$.(

Die obigen Zeichenfolgen werden dann verkettet und die Länge genommen. Wenn keine der oben genannten Bedingungen zutrifft, wird keine Zeichenfolge generiert und die Länge ist daher gleich 0.

Die resultierenden Zeichenfolgen (bevor die Länge genommen wird) lauten wie folgt:

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

MATL , 14 Bytes

'/lx2Z^o~z'Q&m

Die Eingabe ist eine Zahl, die die Segmente im Little-Endian-Format darstellt.

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Nimmt Little-Endian-Ganzzahlen auf.

Ruby , 29 Bytes

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

Probieren Sie es online!

Japt, 15 Bytes

Nimmt den Big-Endian-Wert als Eingabe.

"~¶ÌÚúþÞ"bUd

Versuch es

---

Erläuterung

Die Zeichenfolge enthält die Zeichen an jedem der Codepunkte der Big-Endian-Werte. UdRuft das Zeichen am Codepunkt der Eingabe ab und bfindet den Index davon in der Zeichenfolge.

Neim , 15 Bytes

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

Erläuterung:

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

Probieren Sie es online!

Stax , 12 Bytes

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

Führen Sie es aus und debuggen Sie es

Die Eingabe ist eine kleine Endian-Ganzzahl.

Es wird dieselbe String-Konstante wie in Luis 'MATL-Lösung verwendet.

TI-BASIC (Serie TI-83 + / 84 +), 15 Byte

int(10fPart(194909642ln(Ans

Verwendet Little-Endian-Eingabe. Hashes sind in TI-BASIC ziemlich verbreitet, deshalb habe ich für solche Fälle eine Hash-Funktion geschrieben .

Wir haben hier ein bisschen Glück, da der Multiplikator 9 Stellen lang ist und nicht die erwarteten 10.

      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 dank @ErikTheOutgolfer .
-1 Byte durch Erstellen eines Ports der Mathematica-Antwort von @MishaLavrov .
-3 Bytes dank @Grimy .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Sehen Sie sich meinen Tipp 05AB1E (Abschnitt Wie komprimiere ich große ganze Zahlen? ) An, um zu verstehen, warum dies so •NŽyf¯•ist 99608231754.

Kohle, 17 Bytes

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

Versuch es!

Port of the Japt antworten .