Introdução

Lembra dos anos 80? Quero dizer, sabe, há 30 anos atrás? Sem telefones celulares, sem internet, sem caixas eletrônicos, roupas fluorescentes (o que era isso ?!) e marquise de rolagem ! Não não não! Não os online, mas os reais, com luzes LED.

Como estou com um humor nostálgico, gostaria que você criasse uma marca de rolagem.

Desafio

Crie um programa onde você pode inserir uma sequência de uma linha. Seu programa precisa criar uma marca de rolagem com 80 caracteres de largura, repetindo o texto, se necessário.

Regras

• O usuário deve poder inserir uma sequência no seu programa como entrada. A sequência pode ser um parâmetro de linha de comando ou uma sequência inserida durante a execução do programa.
• Seu programa deve imprimir continuamente uma sequência de exatamente 80 caracteres (visíveis).
• A string deve ser atualizada a cada 0,1 segundo (mais ou menos; não vou cronometrar), deslocando os caracteres a cada iteração uma posição para a esquerda.
• A string "gira". No final da sequência fornecida pelo usuário, outra instância da sequência deve aparecer.
• Seu programa deve imprimir sua saída em uma linha, sem feeds de linha (use um '\ r' em vez de um '\ n')
• Seu programa deve executar ad infinitum , até que um usuário seja interrompido.
• Este é um codegolf, então o código mais curto em bytes vence.
• Há um bônus de 10% (arredondado para cima para o próximo inteiro) para impressão no vermelho em um fundo preto.
• Aplicam-se brechas padrão.

Implementação de referência no Python 2.7

Este programa não é um jogo de golfe, mas fornece uma implementação de referência (e, portanto, um limite superior para o tamanho).

import time,sys
s=raw_input()*99
while 1:
    for i in range(80):
        print s[i:i+80]+'\r',
        sys.stdout.flush()
        time.sleep(0.1)

CJam, 31 bytes

l80*{Dco_80<o(+es99+{es1$<}g;}h

Aguarda exatamente 100 ms.

Isso funcionará apenas com o intérprete oficial do Java , uma vez que o intérprete online mostra apenas a saída após a saída do programa.

O texto em vermelho sobre fundo preto é possível em 40 (ou 39) bytes, com uma pontuação de 36:

0000000: 6c 38 30 2a 7b 22 0d 1b 5b 33 31 3b 34 30 6d 22 6f 5f  l80*{"..[31;40m"o_
0000012: 38 30 3c 6f 28 2b 65 73 39 39 2b 7b 65 73 31 24 3c 7d  80<o(+es99+{es1$<}
0000024: 67 3b 7d 68                                            g;}h

Como funciona

l80*                             Read a line and repeat it 80 times.
    {                        }h  Do:
     Dco                           Print the character with code point 13.
        _80<o                      Print the first 80 characters of the string.
             (+                    Rotate the string one charcter to the left.
               es99+               Push the current time (ms) plus 99.
                    {     }g       Do:
                     es1$<           Compare the current time with the sum.
                                     Repeat the loop if 99 or less ms have passed.
                            ;      Discard the time stamp.
                                 Repeat the loop.

PowerShell, 118 113 112 108 102 101 99 96 - 10% = 86

Código

$s=(Read-Host)*180;for(){Write-Host($s.substring(($i=++$i%80),80)+"`r")-N -F R -B 0;sleep -m 99}

Com a ressalva de que agora começa o primeiro loop com o segundo caractere; As regras não dizem que deve começar pela frente da corda, e a primeira é incluída no geral, então tudo bem para mim. Vou consegui-lo de 100 caracteres de alguma forma - edit: obrigado @ConnorLSW pelas edições para obtê-lo abaixo de 100.

Instruções

1. Execute o PowerShell (console normal, ele não funciona no PowerShell ISE)
2. Cole a versão de linha única no PoSH, pressione enter
3. Digite uma mensagem, pressione Enter
4. Ctrl-C para quebrar

Resultado

Notas

Uma versão mais legível com os nomes e parâmetros das variáveis ​​preenchidos um pouco:

$test = (Read-Host) * 180
for () {
    Write-Host ($text.substring(($i=++$i%80), 80)+"`r") -NoNewLine -ForegroundColor Red -BackgroundColor Black
    sleep -Miliseconds 99
}

• Os parâmetros só precisam ser longos o suficiente para serem exclusivos, portanto, -F Rsão únicos o suficiente para definir um Red ForegroundColor, por exemplo.
• 'Preto' deve ser 'Bla' para ser único em comparação com 'Azul', mas o -B 0define para colorir o valor Enum 0, que é interpretado como Preto.

Letreiro alternativo, mais "correto":

O código de referência não lida bem com seqüências de caracteres com mais de 80 caracteres, ignorando qualquer coisa na mensagem além de 160 caracteres e redefine a cada 99 * len (string) caracteres. por exemplo, se a largura do sinal tiver 5 caracteres, isso será feito:

   here is my long test input
 0 |here |            
 1  |ere i|          ^^^^ never shown
 2   |re is|
 3    |e is |
 4     | is m|
 0 |here |
 1  |ere i|
    ...

Esta versão indexa o tamanho do texto em vez da largura do sinal e, portanto, percorre toda a cadeia. 106 - 10% = 95 caracteres.

$l=($s=Read-Host).Length;for(){Write-Host(($s*160).substring(($i=++$i%$l),80)+"`r")-N -F R -B 0;sleep -m 99}

Alternativa: assine quais ciclos como o .gif na pergunta, 118-10% = 106

Porque parece melhor.

$s=' '*80+(read-host)+' '*80;for(){write-host($s.Substring(($i=++$i%($s.length-80)),80)+"`r")-N -F R -B 0;sleep -m 99}

Matlab, 76 bytes

O que eu acho legal aqui é que você pode ter vetores como índices de matriz. Isso retorna um vetor das entradas correspondentes da matriz, o que facilita muito acrescentar a sequência especificada independentemente do comprimento.

a=input('');k=1:80;while 1;pause(.1);clc;k=mod(k+1,nnz(a));disp(a(k+1));end

Resultado:

QBasic, 116 113 bytes - 10% = 105 102

INPUT s$
COLOR 4
1CLS
FOR i=a TO a+79
?MID$(s$,i MOD LEN(s$)+1,1);
NEXT
?
a=a+1
t=TIMER+.1
2ON(TIMER<t)+2GOTO 2,1

Aqui está uma versão formatada com alguns comentários:

INPUT s$
COLOR 4   ' 4 is the color code for red (the background's already black)

1 CLS   ' CLear Screen (and mark this as line number 1)

' The variable a represents an offset from the beginning of the string
' As a numeric variable, it is 0 at the beginning of the program
FOR i = a TO a + 79
    ' Print i'th character mod string length (+ 1 because QBasic strings
    ' are 1-indexed)
    PRINT MID$(s$, i MOD LEN(s$) + 1, 1);
NEXT i
PRINT
a = a + 1

' Do a busy-wait for .1 seconds
' (Unfortunately, QBasic's SLEEP command only takes integer values)
' Set t to the time we want to stop waiting, .1 seconds in the future
t = TIMER + .1
' We want to stay on line number 2 while TIMER < t; once that condition is
' no longer true, we want to goto the top of the outer loop (line number 1)
' Since true is -1 and false is 0 in QBasic, adding 2 to the conditional
' gives 1 for true and 2 for false; we can pass these values to the
' ON ... GOTO statement to branch conditionally
2 ON (TIMER < t) + 2 GOTO 2, 1

Algumas notas:

• Não sei por que PRINTo FORloop posterior é necessário. CLSdeve redefinir o cursor para o canto superior esquerdo de cada vez. Mas no QB64, pelo menos, se eu não colocar o extra PRINT, a marca de seleção acaba na segunda linha, em vez da primeira. Se alguém tiver o QBasic configurado no DosBox ou algo assim, eu estaria interessado em saber se a mesma coisa acontece lá ou se é um bug do QB64.
• O código tem uma pequena falha porque depende de TIMER(número de segundos desde meia-noite) para o atraso. Se o código estiver em execução à meia-noite, a marca de seleção ficará presa porque TIMERserá redefinida 0e sempre será menor que a tpartir de então.

Perl, 99 98 bytes (-10% = 89)

$|=@_=split('',pop);printf("\e[31m\r%.80s",join('',@_)x80)while select($a,$a,$a,.1)|push@_,shift@_

Recebe sua entrada do parâmetro de linha de comando.

perl marquee.pl "Welcome to Programming Puzzles & Code Golf "

pb , ⌈ (216 + 3) * 0,9⌉ = 198

+3 bytes para sinalizador de intérprete d=1

c^w[Y=-1]{w[B!0]{>}t[X]<[X-79]w[X!0]{t[T-1]w[T=-1]{t[0]}<}vw[T=0]{^w[B!0]{t[B]^b[T]>v}<[X]^w[B!0]{t[B]vw[B!0]{>}b[T]<[X]^w[B=0]{>}b[0]>}v}}^w[1=1]{<[X-80]w[X!0]{<t[B]vb[T]^}w[B!0]{t[B]<b[T]>>}<[X]<t[B]w[B!0]{>}<b[T]}

Uma pontuação bastante horrível, mas, considerando o quão difícil é fazer algo nesse idioma, pode ser pior. A proporção desta resposta de (bytes usados ​​para obter texto em vermelho) para (bônus por ter texto em vermelho) é realmente boa, toda a saída fica vermelha com apenas co início!

O tempo entre cada marca varia de acordo com o comprimento da sequência de entrada, mas é de cerca de 0,1 segundos.

A propósito, a saída deste programa parece lixo total porque o intérprete é muito ruim. A cada milissegundo, ele limpa o terminal e redesenha tudo, tornando-o realmente instável.

Com comentários:

c           # Change paint colour to red

^w[Y=-1]{   # While Y=-1 (arbitrary condition we can break later)

    w[B!0]{>}   # Go to end of input

    t[X]        # Save length of input in T

    # SET T TO MAX(T-79, 0)

    <[X-79]     # Go to (79, -1)

    w[X!0]{     # While X is not 0
        t[T-1]      # Subtract 1 from T
        w[T=-1]{    # If T is now negative
            t[0]        # Set it back to 0
        }
        <         # Move left (position doesn't matter except to end the loop eventually)
    }

    # DONE SETTING T TO MAX(T-79, 0)
    # If T == 0, the string needs to be doubled. Otherwise this part of the program is done

    v           # Move down to break the loop unless this is specifically undone
    w[T=0]{     # While T == 0
        ^w[B!0]{    # For each byte of input
            t[B]^b[T] # Copy it up 1 place
            >v        # Go to the next byte
        }
        <[X]^     # First byte of the copy
        w[B!0]{   # For each byte of the copy
            t[B]      # Save the byte's value
            vw[B!0]{>}# Go to the first empty spot after the original
            b[T]      # Write the saved value
            <[X]^w[B=0]{>} # Go back to the first byte of the copy
            b[0]>     # Erase it and go to the next one
        }
        v       # Back to Y=-1 to reset the loop from the very beginning
    }

}

# After ALL OF THAT nonsense, we're now at (0, 0) and the input string is guaranteed to be
# at least 80 characters long

^
w[1=1]{       # While 1=1 (should hold true until mathematics itself breaks down)
    <[X-80]        # Go to the 81st character
    w[X!0]{        # While X!=0
        <t[B]vb[T]^    # Go left and copy that character down
    }

    w[B!0]{      # For each byte in the string
        t[B]<b[T]>>  # Copy that byte left
    }

    <[X]<t[B]    # Go get the first value (copied to (-1, -1))
    w[B!0]{>}<b[T]# Bring it to the end of the string
}

Perl - 120 bytes (-10% = 108)

$|=1;$_=<>;chomp;for(;;){print "\e[31m",substr(" "x80 .$_,$p++,80)," \r";select($z,$z,$z,0.1);if($p>length()+80){$p=0}}

Matlab, ⌈188 * .9⌉ = 170

Isso funciona na versão Matlab R2014b ou superior. O resultado é mostrado em uma janela de figura.

h=text(.1,.1,repmat(' ',1,80),'fontn','courier','ba','k','co','r');set(1,'pos',[90 90 990 90]);axis off
s=input('','s');n=0;while 1
n=n+1;pause(.1)
h.String=s(mod((0:79)+n,numel(s))+1);end

No exemplo a seguir , o texto é digitado em negrito para melhor visualização (não feito no código acima porque custa alguns bytes). Observe também que a velocidade da animação GIF não corresponde à pausa de 0,1 s necessária, mas o tempo está correto na figura real mostrada ao executar o programa.

SpecBAS, 130 bytes (-10% = 117)

Multiplica a sequência original para formar 80 ou mais caracteres e a corta exatamente para 80.

TEXTé um comando no SpecBAS que funciona da mesma maneira que PRINT(neste exemplo), mas salva um caractere.

O SCALEcomando adiciona alguns caracteres extras ao código, mas faz com que pareça mais sofisticado.

O programa continua até você pressionar Esc.

1 INPUT s$: LET s$=s$*CEIL(80/LEN s$)
2 TEXT PAPER 0;INK 2;SCALE 1,2;AT 1,1;s$( TO 80)
3 LET s$=s$(2 TO)+s$(1): PAUSE 5: GO TO 2

Perl, 63 (70 caracteres - 10% para bônus)

Não é uma solução muito diferente das outras, mas eu perdi meu tempo fazendo isso, então pensei em publicá-la também!

$_=<>;s/
/ /;print"\x0d\x1b[91m",substr"$_"x80,$z++%y///c,80 until`sleep .1`

Confia em um terminal compatível com Unix para códigos ANSI e na chamada para coreutils ' sleep. Os dois \x..caracteres acima são, na verdade, um literal de feed de linha e de escape, de acordo com este dump hexadecimal:

0000000: 245f 3d3c 3e3b 732f 0a2f 202f 3b70 7269  $_=<>;s/./ /;pri
0000010: 6e74 220d 1b5b 3931 6d22 2c73 7562 7374  nt"..[91m",subst
0000020: 7222 245f 2278 3830 2c24 7a2b 2b25 792f  r"$_"x80,$z++%y/
0000030: 2f2f 632c 3830 2075 6e74 696c 6073 6c65  //c,80 until`sle
0000040: 6570 202e 3160                           ep .1`

Ruby, 79 76 75 bytes

t,i=gets.chop*81,0
loop{system'cls'
$><<t[(i=(i+1)%80)..i+79]
sleep 0.1}

Ainda não sou um especialista em rubi, possivelmente posso jogar golfe.

Com vermelho e preto com a mesma pontuação:

t,i=gets.chop*81,0
loop{system'cls&color 4'
$><<t[(i=(i+1)%80)..i+79]
sleep 0.1}

Perl, 84 bytes (- 10% = 76)

$_=' 'x80 .pop;$|=print"\b \r\e[31m".substr$_,++$p% length,80until select$z,$z,$z,.1

Isso requer um argumento de linha de comando, que é o texto na marca de seleção.

Explicação:

1. Anexar 80 espaços ao texto e armazenar em $_
2. Imprimir backspace ( \b) e um espaço ( ). Isso remove o último caractere da impressão anterior. Em seguida, imprima o retorno do carro e a cor.
3. Imprimir os 80 caracteres do texto da posição $p
4. $p = ($p+1) % length of text
5. Dormir por 0,1 s

bash, 121 bytes

A=$(printf ' %.s' {1..80})$1
while :; do
printf "%s \r" "${A:((P++)):80}"
if [ $P == ${#A} ];then
 P=0
fi
sleep 0.1
done

Python 3, 96 bytes

import time;s=input()*80
while 1:print("\033[2J",end=s[:80],flush=1);s=s[1:]+s[0];time.sleep(.1)

Isso funcionará apenas em terminais que suportam seqüências de escape ANSI. Se você estiver no Windows, tente o ansicon .

Viva a flushpalavra - chave no Python 3, para que não tenhamos que fazer uma sys.stdout.flush()chamada cara .

C, 293 269 ​​bytes

(Novas linhas adicionadas para facilitar a leitura)

Isso recebe a entrada da entrada padrão finalizada pelo EOF; portanto, é melhor inserir uma string, uma nova linha e o EOF (por exemplo, Ctrl ^ D).

#include<stdio.h>
#include<string.h>
#define Z '\0'
main(){int i=0,j;char m[80],o[80],n[2];
while(~(j=getchar())&&i<80)j-'\n'?m[i++]=j:0;m[i]=Z;
while(1){for(i=0;m[i]-Z;++i){strcpy(o,&m[i]);
for(j=0;j<i;)*n=m[j++],n[1]=Z,strcat(o,n);
printf("\x1b[40;31m%s\x1b[0m\r",o);}}}

Ungolfed:

#include <stdio.h>
#include <string.h>
#define ANSI_COLOR_SET "\x1b[40;31m"
#define ANSI_COLOR_RESET "\x1b[0m"

int main(void)
{
  int i, j, c;
  char msg[80], out[80], next[2];

  for (i = 0; (c = getchar()) != EOF && i < 80; ++i) {
    if (c != '\n') {
      msg[i] = c;
    }
  }
  msg[i - 1] = '\0';

  while (1) {
    for (i = 0; msg[i] != '\0'; ++i) {
      strcpy(out, &msg[i]);
      for (j = 0; j < i; ++j) {
        next[0] = msg[j];
        next[1] = '\0';
        strcat(out, next);
      }
      printf(ANSI_COLOR_SET "%s\r" ANSI_COLOR_RESET, out);
    }
  }
  return(0);
}

SmileBASIC BIG, 79 bytes

COLOR 3INPUT S$@L
CLS
FOR I=0TO 79?S$[(I+O)MOD LEN(S$)];
NEXT
WAIT 6O=O+1GOTO@L

Eu tinha uma boa solução gráfica quase pronta quando percebi que precisava rolar 1 caractere inteiro de cada vez.

Geléia , 20 19 18 bytes

• -1 byte, substituindo o primeiro 80por ⁹(= 256), pois ele deve ser multiplicado por pelo menos 80
• -1 byte, alterando o loop infinito para Çß(de Ç1¿).

ẋ⁹ḣ80ṙ1;”ÆṄœS.1
Çß

Com alguns truques da resposta de @Dennis 'aqui . A geléia é mais recente que o desafio, mas não é exatamente feita para isso. Sugestões sobre como melhorar são bem-vindas! Se seu console estiver em utf-8, execute export LC_ALL=en_USou similar antes de tentar.

Exemplo

Explicação

ẋ⁹ḣ80ṙ1;”ÆṄœS.1         Monadic helper link - Argument: s
ẋ⁹                      Repeat s 256 times.
  ḣ80                   Head. Set {output} to first 80 characters from repeated s.
     ṙ1                 Rotate. Rotates {output} one character to the left.
       ;Ӯ              Concatenate character 0D, the carriage return, to {output}.
          Ṅ             Print and return {output}.
           œS.1         Wait 0.1 seconds before returning {output} from the
                        helper link.

Çß                      Monadic main link - Argument: s
Ç                       Execute helper link with argument s. Replace s by
                        result of helper link.
 ß                      Execute this link with argument s (while true).

LOVE2D Lua, 197-10% = 178 bytes

f=io.open("t.t"):read().."  "love.graphics.setColor(255,0,0)love.window.setMode(640,14)function love.draw()s=""for i=1,80 do n=i+os.clock()s=s..f:sub(n%#f,n%#f) end love.graphics.print(s,0,0)end

Requer que a entrada esteja em um arquivo chamado 'tt' na raiz, portanto, 3 bytes extras foram adicionados à pontuação.

Uma funcionalidade realmente básica, apenas em um loop for de 80 iterações, acrescenta o caractere no índice de i mais o tempo atual em segundos modulado pelo comprimento da string atual, fornecendo uma string repetida de 80 caracteres da entrada, que muda para a esquerda com o passar do tempo.

Eu usei LOVE2D para rir.

Sinclair ZX81 / Timex TS1000 / 1500 BASIC, 110 bytes 182 bytes (para a listagem)

1 LET A$="I LIKE TO SCROLL IT... HELLO MUM, BY DONKEYSOFT... THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG... STILL SCROLLING... "
2 PRINT AT 0,0;A$(1 TO 80)
3 LET A$=A$(2 TO )+A$(1)
4 GOTO 3

Ele funciona imprimindo os primeiros 32 80 caracteres da string A$na posição 0,0 da tela na linha dois e, em seguida, manipulando a string da posição 2 até o final da picada na linha 3 (o Sinclair ZX81 BASIC indexa as strings de 1 e não zero ), portanto, adicionando o primeiro caractere ao final e devolvendo-o à A$variável; então há um loop incondicional de volta à linha 2.

Comodoro 64, 434 bytes

0 A$="I LIKE TO SCROLL IT... SAMPLE SCROLLY ROUTINE FOR CODE-GOLF MADE BY DONKEYS
1 A$=A$+"OFT MMXVII... HELLO MUM... SCROLLING IS FUN, INNIT? GREETZ TO ALL...
2 POKE53280,6:PRINT"{CLEAR}";
3 PRINTLEFT$(A$,40)"{HOME}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}{DOWN}"MID$(A$,41,40)"{HOME}";
4 FORI=0TO99:NEXT:A$=RIGHT$(A$,142)+LEFT$(A$,1):GOTO3

Como isso exige 80 caracteres para mostrar, e o C64, por padrão, tem apenas 40 caracteres, então 40 caracteres do scrolly são impressos na linha superior da área da tela, enquanto os outros 40 são impressos próximo à parte inferior.

Para esclarecer o que os {HOME}outros símbolos traduzem como PETSCII, eis uma captura de tela do meu emulador:

Farei uma versão completa quando eu instalar o CBM PRG Studio (ou quando não estiver almoçando no trabalho).

Ruby, 79 77 caracteres

->(s){t=0;loop{system("clear");puts (s*80)[t..(80+t)];t=(t+1)%80;sleep(0.1)}}

PHP, 136 bytes

<?php
$s="\e[0;31;40m".substr(str_repeat($argv[1],160),0,160);
while(true){for($i=0;$i<=80;$i++){usleep(100000);echo substr($s,$i)."\r";}}die;

• Ligue com php -f marquee.php hello\ world para marcar a string "hello world".
• Por alguma razão, eu tive que fazer 160 caracteres para a string inicial, caso contrário, a saída seria algo como hello worlddddddddddddddddddddddddddddddddddddddd, mas ela passará apenas por 80 caracteres - espero que isso ainda conte.

Foi um longo dia, provavelmente há algo que eu posso fazer para melhorá-lo

PHP, 85 bytes

for(;;usleep(1e5))echo substr(str_repeat($s=$argv[1],80),$i=++$i%strlen($s),80),"\r";

recebe entrada do primeiro argumento da linha de comando; corra com -nr.

Inicia a rolagem com o segundo caractere. Adicione um byte para iniciar o primeiro caractere:
Substitua =++$i%por %=e ;;por ;;$i++,.