Einführung

Erinnerst du dich an die tosenden 80er? Ich meine, wissen Sie, wie vor 30 Jahren? Keine Handys, kein Internet, keine Geldautomaten, fluoreszierende Kleidung (was war das ?!) und Laufschrift ! Nein nein Nein! Nicht die online, sondern echte, mit LED-Leuchten.

Da ich nostalgisch bin, möchte ich, dass Sie einen Laufrahmen erstellen.

Herausforderung

Erstellen Sie ein Programm, in das Sie eine einzeilige Zeichenfolge eingeben können. Ihr Programm muss einen Laufrahmen mit einer Breite von 80 Zeichen erstellen und den Text bei Bedarf wiederholen.

Regeln

• Der Benutzer muss in der Lage sein, eine Zeichenfolge als Eingabe in Ihr Programm einzugeben. Die Zeichenfolge kann ein Befehlszeilenparameter oder eine Zeichenfolge sein, die beim Ausführen des Programms eingegeben wird.
• Ihr Programm muss kontinuierlich eine Zeichenfolge mit genau 80 (sichtbaren) Zeichen drucken.
• Die Zeichenfolge muss alle 0,1 Sekunden aktualisiert werden (mehr oder weniger; ich lege kein Timing fest), wobei die Zeichen bei jeder Iteration um eine Position nach links verschoben werden.
• Die Zeichenfolge "dreht sich". Am Ende der vom Benutzer angegebenen Zeichenfolge muss eine weitere Instanz der Zeichenfolge angezeigt werden.
• Ihr Programm muss die Ausgabe in einer Zeile ohne Zeilenvorschub drucken (verwenden Sie ein '\ r' anstelle eines '\ n')
• Ihr Programm muss unendlich lange ausgeführt werden , bis ein Benutzer die Ausführung unterbricht.
• Dies ist ein Codegolf, also gewinnt der kürzeste Code in Bytes.
• Es gibt einen Bonus von 10% (gerundet bis auf die nächste ganze Zahl) für auf einem schwarzen Hintergrund in Rot gedruckt wird .
• Es gelten Standardlücken.

Referenzimplementierung in Python 2.7

Dieses Programm ist kein Golfspiel, bietet jedoch eine Referenzimplementierung (und damit eine Obergrenze für die Größe).

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

Wartet genau 100 ms.

Dies funktioniert nur mit dem offiziellen Java-Interpreter , da der Online-Interpreter die Ausgabe erst nach dem Beenden des Programms anzeigt.

Roter Text auf schwarzem Hintergrund ist in 40 (oder 39) Bytes bei einer Punktzahl von 36 möglich:

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

Wie es funktioniert

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

Code

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

Mit der Einschränkung, dass jetzt die erste Schleife mit dem zweiten Zeichen beginnt; Die Regeln besagen nicht, dass es von vorne beginnen muss, und die erste ist insgesamt enthalten, also ist das in Ordnung für mich. Ich werde es irgendwie auf 100 Zeichen bringen - edit: danke @ConnorLSW für die Änderungen, um es unter 100 zu bekommen.

Anleitung

1. PowerShell ausführen (normale Konsole, funktioniert in PowerShell ISE nicht)
2. Fügen Sie die einzeilige Version in PoSH ein und drücken Sie die Eingabetaste
3. Geben Sie eine Nachricht ein und drücken Sie die Eingabetaste
4. Strg-C um zu brechen

Ausgabe

Anmerkungen

Eine besser lesbare Version mit etwas ausgefüllten Variablennamen und Parametern:

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

• Die Parameter müssen nur lang genug sein, um eindeutig zu sein. Sie sind also -F Reindeutig genug, um beispielsweise eine rote Vordergrundfarbe festzulegen.
• "Schwarz" muss "Bla" sein, um im Vergleich zu "Blau" eindeutig zu sein, -B 0setzt es jedoch auf den Farbenzählungswert 0, der als "Schwarz" interpretiert wird.

Alternative, mehr "richtige" Laufschrift:

Der Referenzcode verarbeitet keine Zeichenfolgen, die länger als 80 Zeichen sind, überspringt alle Nachrichten, die länger als 160 Zeichen sind, und setzt alle 99 * len (Zeichenfolgen) fehlerhaft zurück. Wenn die Zeichenbreite beispielsweise 5 Zeichen beträgt, geschieht Folgendes:

   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|
    ...

Diese Version indiziert modulo die Textlänge anstelle der Zeichenbreite, sodass die gesamte Zeichenfolge durchlaufen wird. 106-10% = 95 Zeichen.

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

Alternative: Unterschreiben Sie, welche Zyklen der GIF-Datei in der Frage entsprechen, 118-10% = 106

Weil es besser aussieht.

$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

Was ich hier schön finde, ist, dass Sie Vektoren als Array-Indizes haben können. Dies gibt einen Vektor der entsprechenden Array-Einträge zurück, wodurch es sehr einfach ist, die angegebene Zeichenfolge unabhängig von der Länge anzufügen.

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

Ergebnis:

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

Hier ist eine formatierte Version mit einigen Kommentaren:

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

Ein paar Notizen:

• Ich weiß nicht, warum das PRINTnach der FORSchleife notwendig ist. CLSsollte den Cursor jedes Mal in die obere linke Ecke zurücksetzen. Aber zumindest bei QB64 PRINTlandet das Auswahlrechteck in der zweiten Zeile anstelle der ersten , wenn ich das Extra nicht hinzufüge. Wenn jemand QBasic auf DosBox oder ähnlichem installiert hat, würde ich gerne wissen, ob dort dasselbe passiert oder ob es sich um einen QB64-Fehler handelt.
• Der Code weist einen kleinen Fehler auf, da TIMERdie Verzögerung von (Anzahl der Sekunden seit Mitternacht) abhängt. Wenn der Code um Mitternacht ausgeführt wird, bleibt der Auswahlrahmen hängen, da er TIMERauf 0und immer kleiner als tdanach zurückgesetzt wird.

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

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

Übernimmt die Eingabe vom Befehlszeilenparameter.

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

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

+3 Bytes für Interpreter-Flag 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]}

Eine ziemlich schreckliche Punktzahl, aber wenn man bedenkt, wie schwierig es ist, etwas in dieser Sprache zu tun, könnte es schlimmer sein. Das Verhältnis dieser Antwort von (für roten Text verwendete Bytes) zu (Bonus durch roten Text) ist wirklich gut. Die gesamte Ausgabe wird nur cam Anfang rot dargestellt !

Die Zeit zwischen den einzelnen Häkchen variiert je nach Länge der Eingabezeichenfolge, beträgt jedoch ungefähr 0,1 Sekunden.

Übrigens sieht die Ausgabe dieses Programms wie totaler Müll aus, weil der Interpreter so schlecht ist. Jede Millisekunde löscht es das Terminal und zeichnet alles neu, so dass es wirklich flimmert.

Mit Kommentaren:

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 Byte (-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

Dies funktioniert in Matlab Version R2014b oder höher. Das Ergebnis wird in einem Zahlenfenster angezeigt.

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

Im folgenden Beispiel wird der Text zur besseren Visualisierung fett gedruckt (wird im obigen Code nicht verwendet, da er einige Bytes kostet). Beachten Sie auch, dass die Geschwindigkeit der GIF-Animation nicht der erforderlichen Pause von 0,1 s entspricht, aber das Timing in der tatsächlichen Abbildung, die durch Ausführen des Programms angezeigt wird, korrekt ist.

SpecBAS, 130 Byte (-10% = 117)

Multipliziert die ursprüngliche Zeichenfolge, um 80 oder mehr Zeichen zu erhalten, und schneidet sie dann auf genau 80 ab.

TEXTist ein Befehl in SpecBAS, der wie PRINTin diesem Beispiel funktioniert, jedoch ein Zeichen speichert.

Der SCALEBefehl fügt dem Code einige zusätzliche Zeichen hinzu, lässt ihn jedoch markanter aussehen.

Das Programm läuft weiter, bis Sie Esc drücken.

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 Zeichen - 10% Bonus)

Keine andere Lösung als die anderen, aber ich habe meine Zeit damit verschwendet und dachte, ich würde es auch posten!

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

Verlässt sich auf ein Unix-kompatibles Terminal für ANSI-Codes und den Aufruf von coreutils sleep. Die beiden oben genannten \x..Zeichen sind tatsächlich ein Literal-Zeilenvorschub und ein Escape-Zeichen gemäß diesem Hex-Dump:

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}

Ich bin immer noch kein Rubinexperte, möglicherweise kann man Golf spielen.

Bei rot & schwarz gleicher Punktzahl:

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

Dies erfordert ein Befehlszeilenargument, das der Text im Auswahlrahmen ist.

Erläuterung:

1. Stellen Sie dem Text 80 Leerzeichen voran und speichern Sie in $_
2. Rücktaste ( \b) und ein Leerzeichen () drucken ) . Dadurch wird das letzte Zeichen aus dem vorherigen Ausdruck entfernt. Dann drucken Sie den Wagenrücklauf und Farbe.
3. Drucken Sie die 80 Zeichen des Texts ab Position $p
4. $p = ($p+1) % length of text
5. Schlaf für 0,1 Sekunden

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)

Dies funktioniert nur auf Terminals, die ANSI-Escape-Sequenzen unterstützen. Wenn Sie unter Windows arbeiten, versuchen Sie es mit ansicon .

Hurra für das flushSchlüsselwort in Python 3, damit wir keinen teuren sys.stdout.flush()Anruf tätigen müssen .

C 293 269 ​​Bytes

(Zeilenumbrüche zur besseren Lesbarkeit hinzugefügt)

Dies nimmt Eingaben von Standardeingaben entgegen, die durch EOF beendet werden. Geben Sie am besten eine Zeichenfolge, eine neue Zeile und dann die EOF ein (z. B. Strg ^ 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

Ich hatte eine schöne grafische Lösung fast fertig, als mir klar wurde, dass immer nur ein Zeichen gleichzeitig gescrollt werden muss.

Jelly , 20 19 18 Bytes

• -1 Byte durch Ersetzen des ersten 80durch ⁹(= 256), da dieser mit mindestens 80 multipliziert werden muss
• -1 Byte durch Ändern der Endlosschleife in Çß(von Ç1¿).

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

Mit ein paar Tricks von @Dennis 'Antwort hier . Jelly ist neuer als die Herausforderung, aber nicht wirklich speziell darauf zugeschnitten. Verbesserungsvorschläge sind willkommen! Wenn sich Ihre Konsole in utf-8 befindet, führen Sie export LC_ALL=en_USoder ähnliches aus, bevor Sie es versuchen.

Beispiel

Erläuterung

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

Erfordert, dass sich die Eingabe in einer Datei mit dem Namen 'tt' im Stammverzeichnis befindet. Daher wurden der Partitur 3 zusätzliche Bytes hinzugefügt.

Wirklich grundlegend in der Funktionalität, nur in einer for-Schleife mit 80 Iterationen, hängen Sie das Zeichen am Index von i plus der aktuellen Zeit in Sekunden an, die durch die Länge der aktuellen Zeichenfolge moduliert wird, und geben Sie eine wiederholte 80 Zeichen lange Zeichenfolge der Eingabe, die sich nach links verschiebt wie die Zeit vergeht.

Ich habe LOVE2D zum Lachen benutzt.

Sinclair ZX81 / Timex TS1000 / 1500 BASIC, 110 Bytes 182 Bytes (für die Auflistung)

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

Es funktioniert durch Drucken der ersten 32 80 Zeichen der Zeichenfolge A$an der Bildschirmposition 0,0 in Zeile zwei und dann die Zeichenfolge von Position 2 bis zum Ende der Zeichenfolge in Zeile 3 manipuliert wird (Sinclair ZX81 BASIC indiziert Zeichenfolgen von 1 und nicht Null) ), fügt also das erste Zeichen am Ende hinzu und übergibt es an die A$Variable zurück; dann gibt es eine bedingungslose Schleife zurück zu Zeile 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

Da für die Anzeige 80 Zeichen erforderlich sind und der C64 standardmäßig nur 40 Zeichen enthält, werden 40 Zeichen des Scrollys in der oberen Zeile des Bildschirmbereichs gedruckt, während die anderen 40 Zeichen in der Nähe des unteren Bereichs gedruckt werden.

Um zu verdeutlichen, was die {HOME}und andere Symbole als PETSCII übersetzen, ist hier ein Screenshot von meinem Emulator:

Ich werde eine Vollgolf-Version machen, wenn ich CBM PRG Studio installiert bekomme (oder wenn ich nicht zum Mittagessen bei der Arbeit bin).

Ruby, 79 77 Zeichen

->(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;

• Nennen Sie es mit php -f marquee.php hello\ world "Hallo Welt" Zeichenfolge Laufschrift.
• Aus irgendeinem Grund musste ich 160 Zeichen für die anfängliche Zeichenfolge tun, sonst würde die Ausgabe in etwa so aussehen hello worlddddddddddddddddddddddddddddddddddddddd, aber es werden nur 80 Zeichen durchlaufen - ich hoffe, das zählt immer noch.

Es war ein langer Tag, wahrscheinlich kann ich etwas tun, um ihn zu verbessern

PHP, 85 Bytes

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

Nimmt Eingaben vom ersten Befehlszeilenargument entgegen; renn mit-nr .

Beginnt mit dem zweiten Zeichen zu scrollen. Fügen Sie ein Byte hinzu, um mit dem ersten Zeichen zu beginnen:
Ersetzen Sie =++$i%mit %=und ;;mit ;;$i++,.