A série de TV dos anos 80 Knight Rider apresentava um carro inteligente e autoconsciente chamado KITT. Um aspecto distintivo do carro era uma barra de scanner montada na frente que permitia ao KITT "ver" (e que parecia suspeitamente familiar aos fãs de outra série de TV anterior ).

O scanner tinha oito luzes, como visto na figura:

As luzes "se moveram", como mostrado nesta imagem animada .

Sua tarefa, como você já adivinhou, é recriar a barra do scanner com as luzes móveis da arte ASCII.

O desafio

Dado um número inteiro t, imprima o estado da barra do scanner naquele instante, definido da seguinte maneira:

• O scanner consiste em oito luzes.
• A qualquer momento, uma das luzes está ativa e é mostrada como #. As luzes que estavam ativas às vezes t-1e t-2agora estão esmaecidas e são mostradas como +; a menos que coincidam com o ativo atual. O restante das luzes estão apagadas e são mostradas como -.
• A luz ativa se move da esquerda para a direita e depois da direita para a esquerda.

A saída exata para cada um té detalhada abaixo.

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 do tciclo é simplesmente estendido:

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

Regras adicionais

Você pode escrever um programa ou função.

A saída pode conter espaços em branco à direita e uma nova linha principal.

O menor código em bytes vence.

Geléia , 28 22 bytes

-6 bytes graças à ajuda de @Dennis! (upend primeiro e concatenar)

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

TryItOnline
Ou faça quatro oscilações com um ovo de páscoa bônus !!

Quão?

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

EDIT - Fixado para valores negativos. Agora suportando N >= -8,000,000,000, o que deve fornecer um tempo de operação estendido bastante bom no modo 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));
}

Versão 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)])

"- + ##" é indexado por uma máscara de bits, onde o bit 1 significa uma luz ativa e o bit 0 significa uma luz esmaecida. O ativo / escurecimento agora é calculado adicionando e subtraindo a posição atual da posição desejada e verificando se um dos resultados é divisível por 14.

Python, 53 bytes

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

Cria a string -----++#------, pega uma janela de comprimento 8, dependendo do módulo de entrada 7, reverte para as entradas do módulo 14 que se situam entre 1 e 7.

> <> , 51 + 3 = 54 bytes

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

A entrada é esperada na pilha no início do programa, portanto, +3 bytes para o -vsinalizador.

Experimente online!

MATL, 34 30 27 bytes

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

7 bytes salvos graças a @Luis

Experimente Online!

Outro exemplo com as primeiras 25 etapas

Explicação

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

Economizou 5 bytes calculando todas as luzes da mesma maneira.

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

Começa com as luzes apagadas e as acende uma de cada vez.

Experimente online!

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

Teste

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 golfe

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

Teste

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

Inclui +1 para -n

Execute com o número em 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//

Não é muito competitivo, mas merece uma publicação pelo método estranho

Perl, 56 55 bytes

Inclui +3 para -p

Execute com o número em 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;-+#

Coloque isso em um arquivo sem a nova linha final (adicione uma final ;ao programa se você não quiser se preocupar com isso). Infelizmente, usar um literal ^Fnão funciona

Este programa contém 2 caracteres de comentário (ignore a #!linha). Um deles é realmente um comentário e ganha um byte ...

Implementa o algoritmo real de pós-brilho

Tela , 23 bytes

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

Experimente aqui!