Introducción

¿Recuerdas los rugientes años 80? Quiero decir, ¿sabes, como hace 30 años? No hay teléfonos celulares, ni internet, ni cajeros automáticos, ropa fluorescente (lo que era eso ?!) y el desplazamiento de marqee ! ¡No no no! No los en línea, sino los reales, con luces LED.

Como estoy de humor nostálgico, me gustaría que crees una marquesina de desplazamiento.

Desafío

Cree un programa donde pueda ingresar una cadena de una línea. Su programa necesita crear una marquesina de desplazamiento de 80 caracteres de ancho, repitiendo el texto si es necesario.

Reglas

• El usuario debe poder ingresar una cadena a su programa como entrada. La cadena puede ser un parámetro de línea de comando o una cadena ingresada mientras se ejecuta el programa.
• Su programa debe imprimir continuamente una cadena de exactamente 80 caracteres (visibles).
• La cadena debe actualizarse cada 0.1 segundo (más o menos; no la sincronizaré), desplazando los caracteres cada iteración una posición hacia la izquierda.
• La cadena "gira". Al final de la cadena proporcionada por el usuario, debe aparecer otra instancia de la cadena.
• El programa debe imprimir su salida en una línea, sin saltos de línea (use un '\ r' en lugar de un '\ n')
• Su programa debe ejecutarse hasta el infinito , hasta que un usuario interrumpa.
• Este es un codegolf, por lo que gana el código más corto en bytes.
• Hay un bono de 10% (redondeado hacia arriba al siguiente entero) para imprimir en color rojo sobre un fondo negro.
• Se aplican lagunas estándar.

Implementación de referencia en Python 2.7

Este programa no es golf, pero proporciona una implementación de referencia (y, por lo tanto, un límite superior para el tamaño).

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

Espera exactamente 100 ms.

Esto solo funcionará con el intérprete oficial de Java , ya que el intérprete en línea solo muestra la salida después de salir del programa.

El texto rojo sobre fondo negro es posible en 40 (o 39) bytes, para una puntuación 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

Cómo 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}

Con la advertencia de que ahora comienza el primer bucle con el segundo personaje; Las reglas no dicen que tiene que comenzar desde el frente de la cadena, y el primero está incluido en general, así que eso está bien para mí. Lo llevaré a 100 caracteres de alguna manera: edite: gracias @ConnorLSW por las ediciones para que sea inferior a 100.

Instrucciones

1. Ejecute PowerShell (consola normal, no funciona en PowerShell ISE)
2. Pegue la versión de una sola línea en PoSH, presione enter
3. Escriba un mensaje, presione enter
4. Ctrl-C para romper

Salida

Notas

Una versión más legible con los nombres de variables y parámetros completados un poco:

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

• Los parámetros solo necesitan ser lo suficientemente largos para ser únicos, por lo que -F R es suficientemente único como para establecer un Red ForegroundColor, por ejemplo.
• 'Negro' tiene que ser 'Bla' para ser único en comparación con 'Azul', pero lo -B 0establece en color Enum valor 0, que se interpreta como Negro.

Alternativa, carpa más "correcta":

El código de referencia no maneja bien las cadenas de más de 80 caracteres, omitiendo cualquier cosa en el mensaje más allá de ~ 160 caracteres, y se reinicia por error cada 99 * caracteres len (cadena). por ejemplo, si el ancho del letrero era de 5 caracteres, hace esto:

   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 versión indexa el módulo de la longitud del texto en lugar del ancho del signo, por lo que se ejecuta a través de toda la cadena. 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: firme qué ciclos como el .gif en la pregunta, 118-10% = 106

Porque se ve mejor.

$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

Lo que creo que es bueno aquí es que puedes tener vectores como índices de matriz. Esto devuelve un vector de las entradas de matriz correspondientes, lo que hace que sea muy fácil agregar la cadena dada independientemente de la longitud.

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

Aquí hay una versión formateada con algunos comentarios:

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

Un par de notas:

• No sé por qué es necesario PRINTel FORciclo posterior .CLSdebe restablecer el cursor a la esquina superior izquierda cada vez. Pero en QB64, al menos, si no pongo el extra PRINT, la marquesina termina en la segunda línea en lugar de la primera. Si alguien tiene QBasic configurado en DosBox o somesuch, me interesaría saber si sucede lo mismo allí o si es un error QB64.
• El código tiene una pequeña falla porque se basa TIMER(número de segundos desde la medianoche) para el retraso. Si el código se ejecuta a medianoche, la marquesina se atascará porque TIMERse restablecerá 0y siempre será menor que a tpartir de entonces.

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

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

Toma su entrada del parámetro de línea de comando.

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

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

+3 bytes para la bandera del 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]}

Una puntuación bastante horrible, pero teniendo en cuenta lo difícil que es hacer algo en este idioma, podría ser peor. La relación de esta respuesta de (bytes utilizados para obtener texto rojo) a (bonificación por tener texto rojo) es realmente buena, toda la salida se vuelve roja con solo elc el comienzo!

El tiempo entre cada marca varía dependiendo de la longitud de la cadena de entrada, pero es de alrededor de 0.1 segundos.

Por cierto, la salida de este programa parece basura total porque el intérprete es muy malo. Cada milisegundo borra la terminal y vuelve a dibujar todo, por lo que se vuelve realmente parpadeante.

Con comentarios:

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

Esto funciona en la versión Matlab R2014b o superior. El resultado se muestra en una ventana 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

En el siguiente ejemplo , el texto se escribe en negrita para una mejor visualización (no se hace en el código anterior porque cuesta unos pocos bytes). Tenga en cuenta también que la velocidad de la animación GIF no corresponde a la pausa requerida de 0.1 s, pero el tiempo es correcto en la figura real que se muestra al ejecutar el programa.

SpecBAS, 130 bytes (-10% = 117)

Multiplica la cadena original para que tenga 80 o más caracteres, luego la corta exactamente a 80.

TEXT es un comando en SpecBAS que funciona de la misma manera que PRINT (en este ejemplo) pero guarda un carácter.

El SCALEcomando agrega algunos caracteres adicionales al código, pero lo hace ver más marquesina.

El programa continúa hasta que presione 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% de bonificación)

No es una solución muy diferente a las demás, pero perdí el tiempo haciéndolo, ¡así que pensé en publicarlo también!

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

Se basa en un terminal compatible con Unix para los códigos ANSI y la llamada a coreutils ' sleep. Los dos \x..caracteres en lo anterior son en realidad un salto de línea literal y un carácter de escape según este volcado 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}

Todavía no soy un experto en rubíes, posiblemente pueda jugar golf.

Con rojo y negro mismo puntaje:

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

Esto toma un argumento de línea de comando que es el texto en la marquesina.

Explicación:

1. Anteponer 80 espacios al texto y almacenar en $_
2. Imprimir retroceso ( \b) y un espacio ( ). Esto elimina el último carácter de la impresión anterior. Luego imprima el retorno de carro y el color.
3. Imprime los 80 caracteres del texto desde la posición $p
4. $p = ($p+1) % length of text
5. Dormir durante 0.1 segundos

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)

Esto solo funcionará en terminales que admitan secuencias de escape ANSI. Si estás en Windows, prueba ansicon .

Hurra por la flushpalabra clave en Python 3, por lo que no tenemos que hacer una sys.stdout.flush()llamada costosa .

C, 293 269 ​​bytes

(Se agregaron nuevas líneas para facilitar la lectura)

Esto toma la entrada de la entrada estándar terminada por EOF; así que es mejor ingresar una cadena, una nueva línea y luego el EOF (por ejemplo, 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);}}}

Sin golf:

#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

Tuve una buena solución gráfica casi terminada cuando me di cuenta de que tenía que desplazar 1 carácter completo a la vez.

Jalea , 20 19 18 bytes

• -1 byte reemplazando el primero 80por ⁹(= 256) porque tiene que multiplicarse por al menos 80
• -1 byte cambiando el bucle infinito a Çß(desde Ç1¿).

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

Con algunos trucos de la respuesta de @Dennis aquí . Jelly es más nuevo que el desafío, pero no está diseñado específicamente para ello. ¡Sugerencias sobre cómo mejorar son bienvenidas! Si su consola está en utf-8, ejecute export LC_ALL=en_USo similar antes de intentarlo.

Ejemplo

Explicación

ẋ⁹ḣ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

Requiere que la entrada esté en un archivo llamado 'tt' en la raíz, por lo tanto, se agregaron 3 bytes adicionales a la puntuación.

Funcionalidad realmente básica, solo en un bucle for de 80 iteraciones, agregue el carácter en el índice de i más el tiempo actual en segundos modulado por la longitud de la cadena actual, dando una cadena larga repetida de 80 caracteres de la entrada, que se desplaza hacia la izquierda Conforme pasé él tiempo.

Usé LOVE2D para las risas.

Sinclair ZX81 / Timex TS1000 / 1500 BASIC, 110 bytes 182 bytes (para el listado)

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

Funciona imprimiendo los primeros 32 80 caracteres de la cadena A$en la posición de pantalla 0,0 en la línea dos, y luego manipulando la cadena desde la posición 2 hasta el final de la picadura en la línea 3 (Sinclair ZX81 BASIC indexa cadenas de 1 y no cero ), por lo tanto, agrega el primer carácter al final y lo devuelve a la A$variable; entonces hay un bucle incondicional de regreso a la línea 2.

Commodore 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 esto requiere 80 caracteres para mostrar, y el C64 por defecto tiene solo 40 caracteres, luego se imprimen 40 caracteres de la voluta en la línea superior del área de la pantalla mientras que los otros 40 se imprimen cerca de la parte inferior.

Para aclarar en qué se {HOME}traducen los símbolos y otros como PETSCII, aquí hay una captura de pantalla tomada de mi emulador:

Haré una versión completa de golf cuando instale CBM PRG Studio (o cuando no esté almorzando en el trabajo).

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;

• Llámalo php -f marquee.php hello\ worldpara marcar la cadena "hello world".
• Por alguna razón, tuve que hacer 160 caracteres para la cadena inicial, de lo contrario, la salida sería algo así hello worlddddddddddddddddddddddddddddddddddddddd, pero solo pasará por 80 caracteres, espero que todavía cuente.

Ha sido un día largo, probablemente hay algo que puedo hacer para mejorarlo.

PHP, 85 bytes

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

toma la entrada del primer argumento de línea de comando; correr con -nr.

Comienza a desplazarse con el segundo personaje. Agregue un byte para comenzar en el primer carácter:
Reemplace =++$i%con %=y ;;con ;;$i++,.