In der Fernsehserie Knight Rider aus den 80er Jahren wurde ein intelligentes, selbstbewusstes Auto namens KITT vorgestellt. Ein charakteristischer Aspekt des Autos war eine an der Vorderseite angebrachte Scannerleiste, die es KITT ermöglichte, zu "sehen" (und die den Fans einer anderen früheren Fernsehserie verdächtig bekannt vorkam ).

Der Scanner hatte acht Lichter, wie auf diesem Bild zu sehen:

Die Lichter "bewegten" sich wie in diesem animierten Bild gezeigt .

Ihre Aufgabe ist es, wie Sie bereits vermutet haben, die Scannerleiste mit den Moving Lights in ASCII-Kunst nachzubilden.

Die Herausforderung

Geben Sie bei einer bestimmten Ganzzahl tden Status der Scannerleiste zu diesem Zeitpunkt wie folgt aus:

• Der Scanner besteht aus acht Lichtern.
• Zu jedem Zeitpunkt ist eine der Leuchten aktiv und wird als angezeigt #. Die Lichter, die zu bestimmten Zeiten aktiv waren t-1und t-2jetzt abgeblendet sind, werden als angezeigt +. es sei denn, sie stimmen mit der aktuell aktiven überein. Die restlichen Lichter sind aus und werden als angezeigt -.
• Das aktive Licht bewegt sich von links nach rechts und dann von rechts nach links.

Die genaue Ausgabe für jedes tist unten aufgeführt.

0  -->  #++-----   % The leftmost light is active, and it just came from the right.
                   % The two neighbouring lights are dimmed
1  -->  +#------   % The active light has bounced to the right, and it is covering
                   % one of the two lights that should be dimmed. So there is only
                   % one dimmed light
2  -->  ++#-----   % The active light has moved one more step to the right, and the
                   % two trailing dimmed lights are visible
3  -->  -++#----
7  -->  -----++#
8  -->  ------#+   % The active light has bounced to the left
9  -->  -----#++
10 -->  ----#++-
13 -->  -#++----
14 -->  #++-----   % Same as 0
15 -->  +#------   % Same as 1

Bei negativen Werten wird tder Zyklus einfach verlängert:

-1 -->  -#++----   % Same as 13
-2 -->  --#++---   % Same as 12

Zusätzliche Regeln

Sie können ein Programm oder eine Funktion schreiben.

Die Ausgabe kann abschließende Leerzeichen und eine führende Newline enthalten.

Kürzester Code in Bytes gewinnt.

Jelly , 28 22 Bytes

-6 Bytes dank der Hilfe von @Dennis! (Erst upend, dann verketten)

”-ẋ6;“#++”ṙ7Ḷ’¤Ḋ€U;$⁸ị

TryItOnline
Oder führe vier Oszillationen mit einem Bonus- Osterei aus !!

Wie?

”-ẋ6;“#++”ṙ7Ḷ’¤Ḋ€U;$⁸ị - Main link: n
”-   “#++”             - strings "-" and "#++"
  ẋ6                   - repeat six times: "------"
    ;                  - concatenate: "------#++"
              ¤        - nilad followed by atoms as a nilad (ie make a constant)
           7Ḷ’         -     range(7) decremented: [-1,0,1,2,3,4,5]
          ṙ            - rotate left by (makes)-----------> ["+------#+",
               Ḋ€      - Dequeue each                        "------#++",
                   $   - last two atoms as a monad           "-----#++-",
                 U     -     reverse (vectorises)            "----#++--",
                  ;    -     concatenate                     "---#++---",
                    ⁸  - left argument (n)                   "--#++----",
                     ị - index into (1 based and modular)    "-#++-----"])

JavaScript (ES6), 65 bis 67 Byte

BEARBEITEN - Bei negativen Werten korrigiert . Jetzt wird unterstützt N >= -8,000,000,000, was im AUTO CRUISE-Modus eine recht gute längere Betriebszeit bieten sollte. :-)

let f =

n=>[..."------#++-----".substr((n+=8e9)%7,8)].sort(_=>n/7&1).join``

// testing 28 frames
for(var i = -14; i < 14; i++) {
  console.log(f(i));
}

Animierte Version

let f =

n=>[..."------#++-----".substr((n+=8e9)%7,8)].sort(_=>n/7&1).join``

let n = 0;

setInterval(function() { document.getElementById("o").innerHTML = f(n++) }, 90);

<pre id="o"></pre>

JavaScript (ES6), 90 87 Bytes

n=>"01234567".replace(/./g,i=>"-+##"[g=n=>!((+i+n)%14&&(n-i)%14),g(n)*2|g(n-1)|g(n-2)])

"- + ##" wird durch eine Bitmaske indiziert, wobei Bit 1 ein aktives Licht und Bit 0 ein gedimmtes Licht bedeutet. Active / Dimmedness wird jetzt berechnet, indem die aktuelle Position von der gewünschten Position addiert und subtrahiert wird und geprüft wird, ob eines der Ergebnisse durch 14 teilbar ist.

Python, 53 Bytes

lambda n:('-'*5+'++#'+'-'*6)[-n%7:][:8][::-n/7%2*2-1]

Erzeugt den String -----++#------, nimmt je nach Eingangsmodulo 7 ein Länge-8-Fenster ein, kehrt für Eingänge Modulo 14 um, die zwischen 1 und 7 liegen.

> <> , 51 + 3 = 54 Bytes

<v{"------#++"%7&(7%*27:-1
}>:?!\1-$
{~&?r\~
l?!;o>

Die Eingabe wird beim Programmstart auf dem Stack erwartet, also +3 Bytes für das -vFlag.

Probieren Sie es online!

MATL, 34 30 27 Bytes

'++#-'I:7XyY+4LZ)t2&P&viY))

7 Bytes gespart dank @Luis

Probieren Sie es online!

Ein weiteres Beispiel mit den ersten 25 Schritten

Erläuterung

'++#-'      % Push the string literal to the stack
I:          % Create the array [1 2 3]
7Xy         % Create a 7 x 7 identity matrix
Y+          % Perform 2D convolution between the vector and this matrix
4LZ)        % Grab all but the first column. Yields the following matrix
            %
            %    2 3 0 0 0 0 0 0
            %    1 2 3 0 0 0 0 0
            %    0 1 2 3 0 0 0 0
            %    0 0 1 2 3 0 0 0
            %    0 0 0 1 2 3 0 0
            %    0 0 0 0 1 2 3 0
            %    0 0 0 0 0 1 2 3
            %
t2&P&v      % Copy this matrix, flip it horizontally and vertically concatenate
            % it with itself. 
i           % Explicitly grab the input (n)
Y)          % Get the n-th row of the above matrix (and use modular indexing)
)           % Index into the initial string literal to replace 2 with #, 1 and 3 with + 
            % and all 0's with -
            % Implicitly display the result

Pyth, 33 28 Bytes

5 Bytes gespart, indem alle Lichter auf die gleiche Weise berechnet wurden.

X:*8\-@LJ+U7_S7,-Q2tQ\+@JQ\#

Beginnt mit dem Ausschalten der Lichter und schaltet sie einzeln ein.

Probieren Sie es online aus!

JavaScript, 204 Byte

function g(i){var a=(i%16+16)%16
if(!a)return g(2)
if(1==a%14)return(g(2)+'-').substr(1)
if((1<a)&&(a<8))return Array(a-1).join('-')+'++#'+Array(8-a).join('-')
return g(a-7).split("").reverse().join("")}

Prüfung

function g(i){var a=(i%16+16)%16
if(!a)return g(2)
if(1==a%14)return(g(2)+'-').substr(1)
if((1<a)&&(a<8))return Array(a-1).join('-')+'++#'+Array(8-a).join('-')
return g(a-7).split("").reverse().join("")}

for (var i = 0; i < 16; ++i) {
    console.log(i + '-->' + g(i));
}

JavaScript (ES6), 72

t=>`------${(t=(13+t%14)%14)>6?'#++':'++#'}------`.substr(t>6?t%7:7-t,8)

Weniger golfen

t=>(
  pad = '------',
  t = (13+(t%14))%14,
  u = t % 7,
  t > 6 ? (pad + '#++' + pad).substr(u, 8)
        : (pad + '++#' + pad).substr(7 - u, 8)
)

Prüfung

f=
t=>`------${(t=(13+t%14)%14)>6?'#++':'++#'}------`.substr(t>6?t%7:7-t,8)

T=_=>(
  O.textContent=f(++N.textContent),
  setTimeout(T, 150)
)

T()

<input id=I type=number value=0 oninput='N.textContent=this.value'>
<pre id=N>-100</pre>
<pre id=O></pre>

Perl, 65 Bytes

Beinhaltet +1 für -n

Führen Sie mit der Nummer auf STDIN:

for i in 0 `seq 14`; do perl -M5.010 kitt.pl <<< $i; done

kitt.pl:

#!/usr/bin/perl -n
$_="311e".--$_%14+4e16|0;s/.(.{8})/$&|reverse/e;y/013/-+#/;say//

Nicht sehr wettbewerbsfähig, aber verdient einen Beitrag für die seltsame Methode

Perl, 56 55 Bytes

Beinhaltet +3 für -p

Führen Sie mit der Nummer auf STDIN:

for i in 0 `seq 14`; do kitt.pl <<< $i; echo; done

kitt.pl:

#!/usr/bin/perl -p
$_=eval'1x8
|1x(7-abs$_--%14-7).++$^F#'x3;y;1537;-+#

Fügen Sie dies in eine Datei ohne die letzte Zeile ein (fügen ;Sie dem Programm ein Finale hinzu , wenn Sie sich nicht darum kümmern möchten). Leider ^Ffunktioniert ein Literal nicht

Dieses Programm enthält 2 Kommentarzeichen (ignorieren Sie die #!Zeile). Einer von ihnen ist wirklich ein Kommentar und gewinnt tatsächlich ein Byte ....

Implementiert den eigentlichen Nachleuchtalgorithmus

Canvas , 23 Byte

±７％╵-８×#++１╋８ｍ⁸╷³╵％７＜？↔

Probieren Sie es hier aus!