La serie de televisión de los 80 Knight Rider presentó un auto inteligente y consciente de sí mismo llamado KITT. Un aspecto distintivo del automóvil era una barra de escáner frontal que permitía a KITT "ver" (y que parecía sospechosamente familiar para los fanáticos de otra serie de televisión anterior ).

El escáner tenía ocho luces como se ve en esta imagen:

Las luces "se movieron" como se muestra en esta imagen animada .

Su tarea, como ya lo ha adivinado, es recrear la barra del escáner con las luces en movimiento en el arte ASCII.

El reto

Dado un entero t, genera el estado de la barra del escáner en ese instante, definido de la siguiente manera:

• El escáner consta de ocho luces.
• En cualquier instante, una de las luces está activa y se muestra como #. Las luces que estaban activas a veces t-1y t-2ahora están atenuadas , y se muestran como +; a menos que coincidan con el activo actual. El resto de las luces están apagadas y se muestran como -.
• La luz activa se mueve de izquierda a derecha, luego de derecha a izquierda.

El resultado exacto de cada uno tse detalla a continuación.

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

Para valores negativos del tciclo simplemente se extiende:

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

Reglas adicionales

Puedes escribir un programa o función.

La salida puede contener espacios en blanco al final y una nueva línea inicial.

El código más corto en bytes gana.

Jalea , 28 22 bytes

-6 bytes gracias a la ayuda de @Dennis! (invertir primero, luego concatenar)

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

TryItOnline ¡
O realiza cuatro oscilaciones con un huevo de pascua extra !

¿Cómo?

”-ẋ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 bytes

EDITAR - Corregido para valores negativos. Ahora compatible N >= -8,000,000,000, lo que debería proporcionar un tiempo de funcionamiento extendido bastante bueno en modo CRUCERO AUTOMÁTICO. :-)

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

Versión animada

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

"- + ##" está indexado por una máscara de bits, donde el bit 1 significa una luz activa y el bit 0 significa una luz atenuada. La atenuación activa / atenuación ahora se calcula sumando y restando la posición actual de la posición deseada y viendo si alguno de los resultados es divisible por 14.

Python, 53 bytes

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

Crea la cadena -----++#------, toma una ventana de longitud 8 según el módulo de entrada 7, invierte las entradas del módulo 14 que se encuentran entre 1 y 7.

> <> , 51 + 3 = 54 bytes

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

Se espera la entrada en la pila al inicio del programa, por lo que +3 bytes para el -vindicador

Pruébalo en línea!

MATL, 34 30 27 bytes

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

7 bytes guardados gracias a @Luis

Pruébalo en línea!

Otro ejemplo con los primeros 25 pasos.

Explicación

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

Ahorró 5 bytes calculando todas las luces de la misma manera.

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

Comienza con todas las luces apagadas y las enciende de una en una.

¡Pruébelo en línea!

JavaScript, 204 bytes

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

Prueba

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)

Menos golf

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

Prueba

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

Incluye +1 para -n

Ejecutar con el número en 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//

No es muy competitivo, pero merece una publicación por el extraño método.

Perl, 56 55 bytes

Incluye +3 para -p

Ejecutar con el número en 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;-+#

Ponga esto en un archivo sin la nueva línea final (agregue una final ;al programa si no quiere molestarse con eso). Desafortunadamente, usar un literal ^Fno funciona

Este programa contiene 2 caracteres de comentario (ignore la #!línea). Uno de ellos realmente es un comentario y de hecho gana un byte ...

Implementa el algoritmo de resplandor posterior real

Lienzo , 23 bytes.

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

Pruébalo aquí!