La série télévisée Knight Rider des années 80 présentait une voiture intelligente et consciente appelée KITT. Un aspect distinctif de la voiture était une barre de scanner montée à l'avant qui permettait à KITT de "voir" (et qui semblait étrangement familier aux fans d'une autre série télévisée antérieure ).

Le scanner avait huit lumières comme le montre cette image:

Les lumières ont "bougé" comme le montre cette image animée .

Votre tâche, comme vous l'avez deviné, consiste à recréer la barre du scanner avec les lumières mobiles dans l'art ASCII.

Le défi

Étant donné un entier t, affichez l'état de la barre du scanner à cet instant, défini comme suit:

• Le scanner se compose de huit lumières.
• À tout instant, l'un des voyants est actif et s'affiche comme #. Les lumières qui étaient actives à certains moments t-1et t-2sont maintenant atténuées , et sont représentées comme +; à moins qu'ils ne coïncident avec l'actuel actif. Les autres voyants sont éteints et sont représentés par -.
• La lumière active se déplace de gauche à droite, puis de droite à gauche.

La sortie exacte pour chacun test détaillée ci-dessous.

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

Pour les valeurs négatives du tcycle est simplement étendu:

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

Règles supplémentaires

Vous pouvez écrire un programme ou une fonction.

La sortie peut contenir des espaces de fin et une nouvelle ligne de début.

Le code le plus court en octets gagne.

Gelée , 28 22 octets

-6 octets grâce à l'aide de @Dennis! (bouleverser d'abord, puis concaténer)

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

TryItOnline
Ou effectuez quatre oscillations avec un œuf de Pâques en prime !!

Comment?

”-ẋ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 67 octets

EDIT - Fixé pour les valeurs négatives. Maintenant en charge N >= -8,000,000,000, ce qui devrait fournir une assez longue durée de fonctionnement prolongée en mode AUTO CRUISE. :-)

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));
}

Version animée

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 octets

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

"- + ##" est indexé par un masque de bits, où le bit 1 signifie une lumière active et le bit 0 signifie une lumière atténuée. L'activation / atténuation est maintenant calculée en ajoutant et en soustrayant la position actuelle de la position souhaitée et en voyant si l'un ou l'autre résultat est divisible par 14.

Python, 53 octets

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

Crée la chaîne -----++#------, prend une fenêtre de longueur 8 en fonction du modulo d'entrée 7, inverse les entrées modulo 14 qui se situent entre 1 et 7.

> <> , 51 + 3 = 54 octets

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

Une entrée est attendue sur la pile au démarrage du programme, donc +3 octets pour l' -vindicateur.

Essayez-le en ligne!

MATL, 34 30 27 octets

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

7 octets économisés grâce à @Luis

Essayez-le en ligne!

Un autre exemple avec les 25 premières étapes

Explication

'++#-'      % 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 octets

Enregistré 5 octets en calculant toutes les lumières de la même manière.

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

Commence avec les lumières éteintes et les allume une à la fois.

Essayez-le en ligne!

JavaScript, 204 octets

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("")}

Tester

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)

Moins golfé

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

Tester

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 octets

Comprend +1 pour -n

Exécutez avec le numéro sur 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//

Pas très compétitif mais mérite un poste pour l'étrange méthode

Perl, 56 55 octets

Comprend +3 pour -p

Exécutez avec le numéro sur 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;-+#

Mettez-le dans un fichier sans la nouvelle ligne finale (ajoutez une finale ;au programme si vous ne voulez pas vous embêter avec ça). Malheureusement, l'utilisation d'un littéral ^Fne fonctionne pas

Ce programme contient 2 caractères de commentaire (ignorez la #!ligne). L'un d'eux est vraiment un commentaire et gagne en fait un octet ...

Implémente l'algorithme de rémanence réelle

Toile , 23 octets

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

Essayez-le ici!