Mein erstes Programmierpuzzlespiel und Codegolf ist das Sieben-Schrägstrich-Display . Hier ist meine erste Challenge, die ebenfalls auf einer 7-Segment-Anzeige basiert.

Ich denke oft neben Zahlen darüber nach, welche Buchstaben ich mit einer einfachen 7-Segment-Anzeige darstellen kann. Es können sehr viele Buchstaben angezeigt werden. Tatsächlich können alle Buchstaben außer K, M, V, W, X mit einer einzigen 7-Segment-Anzeige angezeigt werden. Dies liegt daran, dass Sie entweder Kleinbuchstaben oder Großbuchstaben eines Buchstabens anzeigen können. z.B

"abcdef" kann angezeigt werden als

 _     _     _  _
!_!!_ !   _!!_ !_ 
! !!_!!_ !_!!_ !  

Beachten Sie, dass jedes Zeichen eine 3x3-Matrix aus !und ist _.

Natürlich kann die 7-Segment-Anzeige zur Anzeige von Zahlen und Symbolen verwendet werden:

 _     _  _  _           _  _     _    
  ! _ !_ !_ !      _!  !!_ !_!!  !_!!_!
  !    _!!_ !_!   !_!  ! _!!  !_ ! ! _!

Einige Buchstaben können sowohl Groß- als auch Kleinbuchstaben enthalten:

 _                 _          
!   _ !_!!_   !   ! ! _ ! !   
!_ !_ ! !! !  !  !!_!!_!!_!!_!

Hier sind die vollständigen Zeichen:

 _     _  _     _  _  _  _  _                       _
! !  ! _! _!!_!!_ !_   !!_!!_!    _ !_     _     _  _!
!_!  !!_  _!  ! _!!_!  !!_! _!   !_ ! !  !!_!!_!   !  

 _     _     _  _  _                 _  _  _     _           _ 
!_!!_ !   _!!_ !_ !  !_!  !  !!   _ ! !!_!!_! _ !_ !_ ! !!_! _!
! !!_!!_ !_!!_ !  !_!! !  !!_!!_ ! !!_!!    !!   _!!_ !_! _!!_ 

Achten Sie darauf, dass ein Leerzeichen ( ), ein Bindestrich ( -) und ein Fragezeichen ( ?) vorhanden sind. Der Brief I, Ound Zist die gleiche wie Zahlen 1, 0und 2jeweils.

In dieser Herausforderung schreiben Sie ein Programm oder eine Funktion zum Anzeigen einer Zeichenfolge im obigen 7-Segment-Anzeigeformat.

Regeln

1. Sie können ein Programm oder eine Funktion schreiben

2. Dies ist Code-Golf, der kürzeste Code in Bytes gewinnt

3. Ihr Programm oder Ihre Funktion sollte Eingaben von STDIN oder als Parameter erhalten. Und gibt eine Zeichenfolge an STDOUT oder als Zeichenfolge in 3 Zeilen ohne vorangestelltes Leerzeichen aus, die jedoch mit einem Zeilenumbruch abgeschlossen wird. Behandeln Sie die Groß- / Kleinschreibung CHIOUrichtig.

4. Optional können Sie nachfolgende Leerzeichen drucken

5. Sie müssen das obige Format befolgen. Verwenden Sie Unterstrich _und Ausrufezeichen !, um Ihre 7-Segment-Anzeige zu erstellen.

6. Sie müssen Leerzeichen ( ), Bindestrich ( -) und Fragezeichen ( ?) unterstützen

7. Wenn die Zeichenfolge ein nicht unterstütztes Zeichen (k, m, v, w, x) enthält, wird ein einzelnes Fehlerzeichen (3 Horizontlinien, siehe Beispiel) angezeigt. Neben den 5 nicht unterstützten Zeichen können Sie davon ausgehen, dass die Eingabe nur aus dem unterstützten Zeichensatz besteht.

8. Ich habe mich aus lUnklarheiten dafür entschieden, keinen Buchstaben für Kleinbuchstaben L ( ) zu haben, aber wenn Sie so geneigt sind, können Sie ihn wie einen 1entweder rechts oder links anzeigen .

Beispiele

$./a.out Start
 _     _    
!_ !_ !_! _ !_
 _!!_ ! !!  !_
$./a.out "7-seg dIsplay"
 _     _  _  _           _  _     _ 
  ! _ !_ !_ !      _!  !!_ !_!!  !_!!_!
  !    _!!_ !_!   !_!  ! _!!  !_ ! ! _!
$./a.out "0123456789 chiou-?"
 _     _  _     _  _  _  _  _                       _
! !  ! _! _!!_!!_ !_   !!_!!_!    _ !_     _     _  _!
!_!  !!_  _!  ! _!!_!  !!_! _!   !_ ! !  !!_!!_!   !
$./a.out "ABCDEFGHIJLNOPQRSTUZ"
 _     _     _  _  _                 _  _  _     _        _
!_!!_ !   _!!_ !_ !  !_!  !  !!   _ ! !!_!!_! _ !_ !_ ! ! _!
! !!_!!_ !_!!_ !  !_!! !  !!_!!_ ! !!_!!    !!   _!!_ !_!!_
$./a.out "abcdefghijlnopqrstuz"
 _           _  _  _                    _  _     _        _
!_!!_  _  _!!_ !_ !  !_      !!   _  _ !_!!_! _ !_ !_     _!
! !!_!!_ !_!!_ !  !_!! !  !!_!!_ ! !!_!!    !!   _!!_ !_!!_
$./a.out "Bad Form"
 _
 _
 _
$./a.out "Hello"
    _       
!_!!_ !  !   _
! !!_ !_ !_ !_!
$./a.out "World"
 _
 _
 _

CJam, 123 114 112 110 Bytes

Qq_eu";=KMVWX":T&"@"@?" -chiou"Tereu{i"^A^W^G;^Þ¯     ^Þ^Û9³·^É¿»
^@
^P
^Ü^Ò½7¦^_¶´§=   ^O^V&5^U¯¼¹^T³6/"=i2b9Ue[3/"!_!"f.{S?}.+}/N*

Oben wird die Caret-Notation verwendet, da der Code nicht druckbare Zeichen enthält. Eine davon ist ein Null-Byte ( ^@), was bedeutet, dass dieser Code nur über die Befehlszeile ausgeführt werden kann.

Auf Kosten von nur zwei weiteren Bytes (für insgesamt 112 ) können wir dies beheben.

Qq_eu";=KMVWX":T&"@"@?" -chiou"Tereu{i"AWG{ÞïIÞÛyó÷Éÿû
@
P
ÜÒýwæ_öôç}IOVfuUïüùTóvo"=i448+2b1>3/"!_!"f.{S?}.+}/N*

Dieses Mal können alle Zeichen gedruckt werden. Probieren Sie es online im CJam-Interpreter aus .

Beispiellauf

$ LANG=en_US
$ xxd -ps -r > 7seg.cjam <<< 51715f6575223b3d4b4d565758223a5426224022403f22202d6368696f752254657265757b69220117073b9eaf099e9b39b3b789bfbb0a000a100a9c92bd37a61fb6b4a73d090f16263515afbcb914b3362f223d6932623955655b332f22215f2122662e7b533f7d2e2b7d2f4e2a
$ wc -c 7seg.cjam 
110 7seg.cjam
$ echo -n '0123456789 chiou-?' | cjam 7seg.cjam; echo
 _     _  _     _  _  _  _  _                       _ 
! !  ! _! _!!_!!_ !_   !!_!!_!    _ !_     _     _  _!
!_!  !!_  _!  ! _!!_!  !!_! _!   !_ ! !  !!_!!_!   !  
$ echo -n 'ABCDEFGHIJLNOPQRSTUYZ' | cjam 7seg.cjam; echo
 _     _     _  _  _                 _  _  _     _           _ 
!_!!_ !   _!!_ !_ !  !_!  !  !!   _ ! !!_!!_! _ !_ !_ ! !!_! _!
! !!_!!_ !_!!_ !  !_!! !  !!_!!_ ! !!_!!    !!   _!!_ !_! _!!_ 
$ echo -n 'World' | cjam 7seg.cjam; echo
 _ 
 _ 
 _

Idee (druckbare Version)

Jedes Zeichen kann auf der 9-Segment-Anzeige angezeigt werden

!_!
!_!
!_!

durch Ersetzen einiger seiner Zeichen durch Leerzeichen.

Wir können ein bestimmtes Zeichen in eine ganze Zahl verwandeln, indem wir jedes gezeigte Segment in natürlicher Lesereihenfolge durch eine 1 ersetzen , jedes nicht gezeigte Segment durch eine 0 und die resultierenden Binärziffern berücksichtigen.

Das erste und dritte Segment werden nie gezeigt, daher werden ganze Zahlen in den Bereichen [0,64) und [128,192) erzeugt .

Wir können jede dieser Ganzzahlen als ein einzelnes Byte codieren, aber die Hälfte davon führt zu nicht druckbaren Zeichen. Daher addieren wir vor dem Umwandeln in ein Zeichen 64 zu jeder Ganzzahl, wodurch sichergestellt wird, dass die Codepunkte in den Bereichen [64, 128] und [192, 256 ] liegen .

Das einzige nicht druckbare Zeichen in diesen beiden Bereichen ist DEL (Code-Punkt 127), das der folgenden nicht verwendeten Anzeigekonfiguration entspricht:

!_!
!_!

Wir können die obige Codierung umkehren, indem wir jedem Codepunkt 448 == 512 - 64 hinzufügen , in Basis 2 konvertieren und die erste Binärziffer entfernen.

Alles was noch zu tun ist, um eine effiziente Möglichkeit zu finden, diese codierten Segmenets mit ihren entsprechenden ASCII-Zeichen zu verknüpfen.

Wenn wir die Zeichen von " -chiou"den Zeichen von ";=KMVWX"zuordnen und die gesamte Eingabe in Großbuchstaben umwandeln, können wir einfach die Codierung für alle Zeichen zwischen 0(Codepunkt 48) und Z(Codepunkt 90) speichern und einen Bereich von 43 angeben.

Array Indizierung ist modular in CJam, so dass , wenn Aeine Zeichenfolge mit einer Länge von 43, A86=, A43=und A0=alle die gleichen Ergebnisse liefern. Das Zeichen mit dem Codepunkt 86 ist V, also speichern wir einfach die codierten Segmente von V - Z und 0 - U in der angegebenen Reihenfolge.

Im eigentlichen Code wählen wir das At-Zeichen als "Bad Form" -Zeichen aus, ersetzen die gesamte Eingabe durch die Zeichenfolge, "@"wenn sie einen verbotenen Buchstaben enthält, und kehren die obigen Schritte um.

Code (druckbare Version)

Q            e# Push an empty array for posterior concatenation.
q            e# Read from STDIN.
_eu          e# Copy the input and convert is to uppercase.
";=KMVWX":T& e# Intersect the result with with T := ";=KMVWX".
"@"@?        e# Select "@" if truthy and the input if falsy.
" -chiou"Ter e# Perform transliteration.
eu           e# Convert everything to uppercase.
{            e# For each character in the modified input:
  i          e#   Push its code point.
  "…"=       e#   Select the corresponding character from the string.
  i448+      e#   Push that character's code point and add 448.
  2b1>       e#   Convert to base 2 and discard the first digit.
  3/         e#   Group into triplets of digits (rows).
  "!_!"      e#   Push that string.
  f.{        e#   For each group of digits:
    S?       e#     Select the corresponding char of "!_!" for 1 and " " for 0.
  }          e#
  .+         e#   Concatenate along the rows with the previous results.
}/           e#
N*           e# Join, separating by linefeeds.

Perl, 475 469 424 390 280 272 Bytes

$_=<>;die" -
"x3if/[kmvwx]/i;y/chiou/kmvwx/;$_=lc;while(/(.)/g){$z=ord($1=~y/a-z0-9\-\? /{v\x17nWS7z(.F\x16rb?[yBuV> f&|O?(Omxuw)\x7f}@K\0/r);$i.=$z&1?' _ ':$"x3;$m.=($z&16?'!':$").($z&64?'_':$").($z&8?'!':$");$p.=substr("  !  _!_",$z&6,2).($z&32?'!':$")}print"$i
$m
$p
"

mehrzeilig mit Kommentaren:

$_=<>;   # accept input
die" -   # check for invalid chars
"x3if/[kmvwx]/i;
y/chiou/kmvwx/;$_=lc;   # substitute invalid chars, convert to lowercase
while(/(.)/g)   # loop over each character
    # lookup character from string using transliteration and convert to
    # number using ord() for bit checking:
    {$z=ord($1=~y/a-z0-9\-\? /{v\x17nWS7z(.F\x16rb?[yBuV> f&|O?(Omxuw)\x7f}@K\0/r);
    $i.=$z&1?' _ ':$"x3;    # first row
    $m.=($z&16?'!':$").($z&64?'_':$").($z&8?'!':$");   # second row
    $p.=substr("  !  _!_",$z&6,2).($z&32?'!':$")}    # third row
# print result:
print"$i
$m
$p
"

Die Bitmuster, die die Segmente codieren, werden in einer Zeichenfolge gespeichert (wobei 3 nicht druckbare Zeichen mit \xund ohne \0Leerzeichen ausgegeben werden) und mit dem Perl-Transliterationsoperator auf die Eingabezeichen abgebildet.

Für 5 der 7 Segmente wird ein bitweises und zusammen mit dem ternären Operator verwendet, um ein Leerzeichen oder das Segmentzeichen auszugeben. Für die beiden unteren linken Segmente (codiert durch 2 und 4 im Bitset) wird eine Teilstringsuche in einer 8-Zeichen-Zeichenfolge verwendet, um 2 Bytes zu speichern.

Vielen Dank an Dom Hastings für seine Perl Golftipps.

Alte Version (mit Regexen, um die Muster zu kodieren), 390 Bytes:

$_=<>;if(/[kmvwx]/i){print" -\n"x3;exit}y/chiou/kmvwx/;$_=lc;while(/(.)/g){$z=$1;$i.=($z=~/[acefgopqsz\?0235-9]/?' _ ':'   ');$m.=($z=~/[abce-hlmopqstuy045689]/?'!':' ').($z=~/[abdefhkmnp-twyz\-\?2-689]/?'_':' ').($z=~/[adhijopquyz\?0-4789]/?'!':' ');$p.=($z=~/[a-hj-prtuwxz\?0268]/?'!':' ').($z=~/[b-egjklostuw-z0235689]/?'_':' ').($z=~/[abdg-jmnoqsu-y013-9]/?'!':' ')}print"$i\n$m\n$p\n"

mehrzeilig mit Kommentaren:

$_=<>;   # accept input
if(/[kmvwx]/i){print" -\n"x3;exit}   # check for invalid chars
y/chiou/kmvwx/;$_=lc;   # substitute invalid chars, convert to lowercase
while(/(.)/g)
{$z=$1;$i.=($z=~/[acefgopqsz\?0235-9]/?' _ ':'   '); # first row
$m.=($z=~/[abce-hlmopqstuy045689]/?'!':' ').
($z=~/[abdefhkmnp-twyz\-\?2-689]/?'_':' ').
($z=~/[adhijopquyz\?0-4789]/?'!':' '); # second row
$p.=($z=~/[a-hj-prtuwxz\?0268]/?'!':' ').
($z=~/[b-egjklostuw-z0235689]/?'_':' ').
($z=~/[abdg-jmnoqsu-y013-9]/?'!':' ')} # third row
print"$i\n$m\n$p\n" # print result

Die Zeichenfolge wird eingelesen und mit einem regulären Ausdruck auf ungültige Zeichen überprüft. Anschließend werden die ungültigen Zeichen durch die zulässigen Kleinbuchstaben ersetzt, und die gesamte Zeichenfolge wird in Kleinbuchstaben umgewandelt.

Die Zeilen werden einzeln generiert, wobei 1 Segment pro Buchstabe in der ersten Zeile und 3 in den beiden anderen Segmenten enthalten sind. Für jede Zeile wird die Zeichenfolge einzeln verarbeitet, und das Zeichen wird für jedes Segment mit einem regulären Ausdruck verglichen, um zu überprüfen, ob ein! oder _ sollte angezeigt werden. Die Verwendung einer Regex bedeutet, dass für Zeichen, bei denen das Segment nicht gesetzt ist, für die Kodierung der Einstellung null Bits pro Segment und Zeichen benötigt werden, und für diejenigen, bei denen es sich um ein Regex handelt, im Durchschnitt etwas weniger als 8 Bits, da es sich um Regex-Zeichenbereiche handeln kann benutzt. Das heißt, es gibt ungefähr 3 oder 4 Bits pro Segment pro Zeichen im Satz oder ungefähr 21 bis 24 Bits pro Zeichen.

Zeilenumbrüche werden nicht verarbeitet.

Gemeines Lisp, 488 416

(lambda(z)(dotimes(r 3)(map()(lambda(c)(do((i 0(+ 17 i))n)((or(and(> i 901)(setf n 146))(=(char-code c)(ldb(byte 8 9)(setf n(ldb(byte 17 i)#36RIL884OIVFXJY4DCQ0O8DPH8MOMR2DSLPP3O4ESYHS234A9HEQYSV8IBDBZI6Z3C3MCVR77OYD3QN5G6CX2UQWGL4UY5R9PKYI1JQ5Y6DC27MQQGUZSCGI8Q9JCYP9N1L4YYKRWM1ZNMSVTSB4792UUWV6Z3906VSP981WCCBMDNJ02)))))(loop for v from(* 3 r)for d across"!_!"do(format t"~:[ ~;~A~]"(logbitp v n)d)))))z)(terpri)))

Beispiel

Mit "abcdefg'hijklnopqrstuz", druckt:

 _           _  _  _  _           _           _  _     _        _ 
!_!!_  _  _!!_ !_ !   _ !_   !  ! _ !   _  _ !_!!_! _ !_ !_     _!
! !!_!!_ !_!!_ !  !_! _ ! !  !!_! _ !_ ! !!_!!    !!   _!!_ !_!!_ 

Bemerkungen

Zeichen und ihre Darstellungen sind in dieser Zahl in Basis 36 codiert:

IL884OIVFXJY4DCQ0O8DPH8MOMR2DSLPP3O4ESYHS234A9HEQYSV8IBDBZI6Z3C3MCVR77OYD3QN5G6CX2UQWGL4UY5R9PKYI1JQ5Y6DC27MQQGUZSCGI8Q9JCYP9N1L4YYKRWM1ZNMSVTSB4792UUWV6Z3906VSP981WCCBMDNJ02

Die Binärdarstellung dieser Ziffer ist in 17-Bit-Gruppen unterteilt.

Zum Beispiel ist die letzte Gruppe von 17 Bits 110000111101010, die hier in zwei Teile zerlegt wird:

1. 110000, der Zeichencode des Zeichens 0

2. 111101010, eine Kodierung der Zeichnung, am besten wie folgt dargestellt:

   010 (bits 0-2)         _ 
   101 (bits 3-5)   =>   ! !
   111 (bits 6-8)        !_!
   

   Die Bits in der ersten und letzten "Spalte" stehen für !Zeichen, die in der mittleren Spalte für das _Zeichen. Bei Bedarf werden sowohl Groß- als auch Kleinbuchstaben eines Zeichens gespeichert.

Die Funktion iteriert dreimal über die Eingabezeichenfolge, eine für jede Ausgabezeile, sucht nach einem übereinstimmenden Zeichen in der Tabelle (oder standardmäßig 146, dh drei Balken) und druckt die Darstellung in der aktuellen Zeile.

JavaScript (ES6), 380 352 324 Byte

( Hinweis: Der Code verwendet die Caret-Notation, da er einige nicht druckbare Zeichen enthält. Um den Originalcode zu erhalten, klicken Sie hier und wählen Sie die Rohdaten aus. Und nein, es hhandelt sich nicht um ein CJam-Programm.;)

d=s=>{a=' ',u=n=>r>>n&1?'!':a,v=n=>r>>n&1?'_':a,g='ABCDEFGHIJLNOPQRSTUYZabcdefghijlnopqrstuyz0123456789-? ÿ',h='{vUnWSuz(lTb}[;B7V|>O{vFnWSur lTbf[;B7Vd>O}(O/:7w)^??^BK^0^G',x=y=z='';for(i=0;i<s.length;x+=a+v(0)+a,y+=u(4)+v(1)+u(3),z+=u(6)+v(2)+u(5)){q=g.indexOf(s[i++]);if(q<0)return d`ÿ`;r=h.charCodeAt(q)}return x+`
${y}
`+z}

Genannt als d("7-seg display")oder ähnlich. Funktioniert in Firefox 40, jedoch möglicherweise nicht in anderen Browsern. Aus irgendeinem Grund speichert das HTML / JS-Snippet die nicht druckbaren Dateien nicht, aber Sie können die Rohdaten von hier aus kopieren und einfügen .

Ungolfed:

( Anmerkung: g und hwurde mit Leerzeichen aufgefüllt entsprechen 8, -, ÿund spacemit ihren entsprechenden Unicode - Werten.)

d = function (s) {
  t = function (n) { return Math.floor(n) % 2; };
  g = 'ABCDEFGHIJLNOPQRSTUYZabcdefghijlnopqrstuyz012345679? 8      -      ÿ      space ';
  h = '{vUnWSuz(lTb}[;B7V|>O{vFnWSur lTbf[;B7Vd>O}(O/:7w)?K \u007f \u0002 \u0007 \u0000';
  x = y = z = '';
  for(var i = 0; i < s.length; i++) {
    q = g.indexOf(s.charAt(i));
    if (q < 0)          // if g does not contain the character
      return d('ÿ');    // ÿ is equivalent to the error character, '\u0007'
    r = h.charCodeAt(q);
    x += ' ' + (r % 2 === 1 ? '_' : ' ') + ' ';
    y += (t(r / 16) === 1 ? '!' : ' ') + (t(r / 2) === 1 ? '_' : ' ') + (t(r / 8) === 1 ? '!' : ' ');
    z += (t(r / 64) === 1 ? '!' : ' ') + (t(r / 4) === 1 ? '_' : ' ') + (t(r / 32) === 1 ? '!' : ' ');
  }
  return x + '\n' + y + '\n' + z;
}

Erläuterung:

Ich bemerkte sofort, dass die in 0/ 1bits konvertierten 7 Segmente gut zu den ersten 128 Unicode-Zeichen passen würden. Das Problem bei dieser Idee ist, dass 1/4 dieser Zeichen nicht druckbare Steuerzeichen sind. Wenn ich sie in meinem Code verwende, sieht es unglaublich chaotisch aus (oder unglaublich intelligent; ich habe nicht entschieden, welcher). Um dies zu lösen und gleichzeitig den Rest des Codes einfach zu halten, kam mir folgende Idee:

Mit Ausnahme von -, Raum , und Fehler , keiner der Charaktere waren beide der unteren vertikalen Segmente fehlen. Um sicherzustellen, dass alle diese Zeichen zwischen 0020und bleiben 007f, habe ich einfach die 64- und 32- Bit-Zeichen diesen Segmenten zugeordnet :

     1
    ---
16 |   | 8
  2 ---
64 |   | 32
    ---
     4

Die Zahlen der anderen 5 Segmente sind nicht so wichtig. Sie könnten auch auf andere Weise angeordnet sein und dennoch dieselben Zeichen "in-bounds" haben.

Als Beispiel ist hier die codierte Version von A :

     1
    ---
16 |   | 8
  2 ---
64 |   | 32

Dec: 64 + 32 + 16 + 8 + 2 + 1 = 123
Hex: 40 + 20 + 10 + 8 + 2 + 1 = 7B = u+007B = {

Ich habe dann die codierte Version jedes 7-Seg-Zeichens eingefügt h. Jedoch 8führte 007f(den Lösch - Steuercode; konstant unabhängig davon , wie die Segmente angeordnet sind), Raum in Folge 0000(der Nullcode; konstant), -führte 0002, und Fehler in Folge 0007. Ich das rohe Bytes in die richtige Position kopier klebte für 8, -und Fehler ; Platz war mit leicht zu erreichen \0.

Nach all dieser Kodierung musste ich den String nur noch dekodieren und in einem 7-Segment-lesbaren Format ausgeben. Ich habe eine for- Schleife und drei Variablen ( x, yund z, die jeweils einer Ausgabezeile entsprechen) verwendet, um jedes Zeichen in der Zeichenfolge durchzugehen und seine 7-Seg-Entsprechung zur Ausgabe hinzuzufügen. Ich wählte ÿfür den Fehler Charakter , weil AFAIK, es ist nicht auf jeder Tastatur, und es ist das letzte Zeichen im u+0000-u+00ffBereich. Vielleicht hätte ich Ξstattdessen witzig und auserwählt sein können (griechischer Buchstabe xi) ....;)

Edit 1: Gespeichert ein Bündel von Raum durch Mini-Funktionen zu schaffen , um zu bestimmen , ob !, _oder benötigt wird .

Bearbeiten 2: Mit den Tricks, die ich seit meinem letzten Besuch in diesem Beitrag gelernt habe, hat sich einiges an Platz gespart.

Wie immer sind Vorschläge sehr willkommen!